diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index fcfe9c7..263d112 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -5,6 +5,18 @@ this file is the curated, human-readable summary. ## Unreleased — Fast defaults with user-controlled source builds +- **Cross-lane install comparison (2026-10-03).** A plain install request now + searches the configured Portage, Flatpak, Snap, AppImage, Nix and staged-ebuild + catalogues before the connected model recommends a source. A multiword name + gets a labelled broader search in lanes with no full-name match. The Assistant + shows each lane's results or failure state with the recommended plan, and a + user can select another package result to prepare a fresh, exact-ID and + exact-source approval plan. AppImage catalogue entries remain leads until an + artifact URL and SHA-256 are pinned. Source-constrained requests keep their + constraint. A disposable VM displayed all six lanes for `install chatgpt + desktop` and staged separate Snap and Nix alternatives; the plan was + cancelled without installing a package. + - **Natural install requests find reviewed overlays (2026-10-03).** The Assistant checks for an exact external Portage package when it prepares a non-Portage plan or cannot prepare a local plan. A request such as “install diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 4ec2189..72e5b88 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -3,6 +3,23 @@ Rolling note between work sessions. **Update this file before you finish**, then commit it. It should be short and current; use `git log` for detail. +- **Cross-lane install comparison (2026-10-03):** A plain install now performs + read-only searches across the configured package catalogues before asking + the model to recommend a candidate. The Assistant shows per-lane results, + failures and availability, and selecting another listed source stages a + separate exact-source review through the legacy planner. AppImage catalogue + links remain non-installable leads. `make check`, dynamic and static release + builds passed. In the disposable VM, `install chatgpt desktop` produced a Snap + recommendation and six-lane comparison; the broader search found 17 Nix + results. Reviewing Snap `chatgpt-desktop-client` and Nix `chatgpt` staged + distinct exact-source plans. The final plan was cancelled. No package or + repository was installed. VM preview used the user-local static `sys` + (SHA-256 `d9172c81098ba23b6d37a9480fdb25aecc8fb0c646191fd4be2f30a35ef68f59`) + and Assistant QML override. `sys.new` was renamed to `sys`; a subsequent + `sha256sum sys` in the VM matched that build hash. Privileged alternative + execution remains unverified. + + - **Natural ChatGPT Desktop request (2026-10-03):** The user clarified that the bad result was the Assistant's AppImage fallback for “I want to install chatgpt desktop,” not the Send button. The unavailable install path now looks diff --git a/docs/STATUS.md b/docs/STATUS.md index db55a67..8de0b2f 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -48,6 +48,22 @@ disposable VM; `serial-driver.py recovery` now automates the same check. ## Matrix +Cross-lane Assistant install comparison (2026-10-03): unqualified installs +search every configured package catalogue before AI selection. The result +states are kept distinct, and the desktop card offers exact-source review of +other catalogue matches without running an install. AppImage catalogue leads +cannot be directly selected. **Implemented, unit tested, and visually verified +in the disposable VM.** The user-local static `sys` (SHA-256 +`d9172c81098ba23b6d37a9480fdb25aecc8fb0c646191fd4be2f30a35ef68f59`) +and Assistant QML override returned a Snap recommendation for `install chatgpt +desktop` with six source lanes. The comparison showed 6 Flatpak, 10 Snap, 1 +AppImage lead, and 17 Nix results after the labelled broader search; Portage +was empty. Selecting `chatgpt-desktop-client` from Snap and `chatgpt` from Nix +each staged a plan naming the exact selected source. The final plan was +cancelled; no package or repository was installed. Privileged execution of +these alternatives remains unverified. + + Natural external package discovery (2026-10-03): the Assistant checks GPO for an exact package-name match after a non-Portage plan or an unavailable install and runs the same overlay review as an explicit GPO link. Reviewed repository diff --git a/docs/SYS.md b/docs/SYS.md index 3d8837a..6f6afb4 100644 --- a/docs/SYS.md +++ b/docs/SYS.md @@ -109,6 +109,19 @@ identify -> evidence -> AI investigation -> proposed selection ``` - **Unqualified** installation consults the connected model. The model may + first receive a read-only search across the configured Portage, Flatpak, + Snap, AppImage, Nix and staged-ebuild catalogues. Each source reports actual + matches, no matches, an unavailable backend, or a failed lookup; catalog + results are leads rather than verified artifacts. For a multiword name, an + empty lane also searches the first term and labels those broader results. + The model compares these + findings before recommending a source. The desktop Assistant shows the + source results alongside the recommended plan. Selecting a different result + re-resolves the exact displayed package ID and prepares a new source-specific + plan for approval; it never executes directly. A changed ID is refused. + AppImage catalog leads have no direct install button because acquisition + requires a pinned artifact URL and SHA-256. Source-constrained requests only + investigate the selected lane. The model may request bounded, read-only evidence (`discover_candidates`, `inspect_candidate`, `check_backend`, `inspect_installation`) and may ask one bounded question about your intent. It returns a structured proposal naming a diff --git a/installer-rs/crates/phoebus-ai/src/install.rs b/installer-rs/crates/phoebus-ai/src/install.rs index 68ba40b..b26f239 100644 --- a/installer-rs/crates/phoebus-ai/src/install.rs +++ b/installer-rs/crates/phoebus-ai/src/install.rs @@ -207,7 +207,11 @@ Rules: compare suitable options across lanes; do NOT choose a lane merely becaus application is a desktop app (Flatpak/Snap) or a developer tool (Nix) — base the choice on \ the machine facts, the user's requirement, permissions, confinement, integration, size, \ measured compile time and update behaviour. Never invent a candidate id, version, size, \ -checksum, availability or compatibility: use only what discover_candidates returned. \ +checksum, availability or compatibility: use only IDs returned by read-only discovery. \ +The system may also supply a cross-lane catalogue before this conversation. Its IDs are \ +read-only leads you may inspect, not verified install candidates. If inspection confirms an \ +available candidate and the resolver accepts it, propose the best one with its tradeoffs; \ +reserve unavailable for when no such candidate remains. \ Portage owns the kernel, drivers, systemd, the host graphics/audio stack and boot tooling. \ Prefer an existing installation and the user's saved preference; never migrate or duplicate \ silently. If the user asked for a specific backend, investigate only that lane and honour it. \ @@ -367,6 +371,27 @@ pub fn investigate_install( session: &dyn InstallSession, validate: &dyn Fn(&InstallProposal) -> Result<(), String>, limits: &Limits, +) -> Result { + investigate_install_with_discovery( + provider, endpoint, model, facts, request, transport, session, validate, limits, false, + ) +} + +/// The caller has already supplied a read-only, cross-lane catalogue report +/// in `request`. Count it as candidate discovery when the model concludes that +/// no verified installation is available. +#[allow(clippy::too_many_arguments)] +pub fn investigate_install_with_discovery( + provider: ProviderKind, + endpoint: &str, + model: &str, + facts: &SystemFacts, + request: &str, + transport: &dyn ModelTransport, + session: &dyn InstallSession, + validate: &dyn Fn(&InstallProposal) -> Result<(), String>, + limits: &Limits, + initial_discovery: bool, ) -> Result { if provider == ProviderKind::None { return Err(AiError::ProviderUnavailable( @@ -380,7 +405,7 @@ pub fn investigate_install( let mut repeated: std::collections::BTreeMap = std::collections::BTreeMap::new(); let mut turns = 0usize; let mut malformed_replies = 0usize; - let mut discovered_candidates = false; + let mut discovered_candidates = initial_discovery; let mut inspected = std::collections::BTreeSet::new(); while turns < limits.max_turns { @@ -800,6 +825,22 @@ mod tests { .unwrap_err(); assert!(early_error.to_string().contains("requires read-only")); + let catalogued = crate::provider::ScriptedTransport::new(vec![chat_response(unavailable)]); + let catalogued_error = investigate_install_with_discovery( + ProviderKind::Local, + "http://127.0.0.1:11434/v1/chat/completions", + "m", + &facts(), + "install etcher; cross-lane catalogue: no verified candidates", + &catalogued, + &session, + &|_| panic!("no proposal may be validated"), + &Limits::default(), + true, + ) + .unwrap_err(); + assert!(matches!(catalogued_error, AiError::NoVerifiedCandidate(_))); + let investigated = crate::provider::ScriptedTransport::new(vec![ chat_response( r#"{"version":2,"kind":"investigate","requests":[{"action":"discover_candidates","query":"etcher"}]}"#, diff --git a/installer-rs/crates/phoebus-executor/src/install.rs b/installer-rs/crates/phoebus-executor/src/install.rs index 16ff0ca..c9adcdd 100644 --- a/installer-rs/crates/phoebus-executor/src/install.rs +++ b/installer-rs/crates/phoebus-executor/src/install.rs @@ -18,6 +18,7 @@ use phoebus_ai::install::{Evidence, InstallProposal, InstallSession}; use phoebus_ai::provider::{ModelTransport, ProviderKind, SystemFacts}; use phoebus_ai::AiError; use phoebus_core::action::SystemAction; +use phoebus_core::catalog::CatalogReport; use phoebus_core::effects::{EffectKind, EffectSource, PackageEffect, ResolvedPlan}; use phoebus_core::selection::{Backend, Candidate, Need, PackageKind, Rejected}; @@ -39,6 +40,8 @@ pub struct InstallRequest { pub requirements: Vec, /// An explicit backend constraint (`--flatpak`, `--portage`, ...). pub backend: Option, + /// Read-only cross-lane search gathered by the caller for an unconstrained request. + pub catalog: Option, } impl InstallRequest { @@ -51,6 +54,7 @@ impl InstallRequest { requires_proprietary: false, requirements: Vec::new(), backend: None, + catalog: None, } } @@ -802,7 +806,7 @@ pub fn resolve_with_ai( appimage_discovery_guidance(exec, root, &request.application), )); } - let phrase = format!( + let mut phrase = format!( "install {}{}{}", request.application, if request.gui { @@ -815,6 +819,51 @@ pub fn resolve_with_ai( .map(|backend| format!("; only use the {} backend", backend.as_str())) .unwrap_or_default() ); + if request.backend.is_none() { + if let Some(report) = &request.catalog { + phrase.push_str("\nCross-lane catalogue search (read-only leads; inspect the exact candidate before proposing). Compare every lane's result and explain the recommended source and material tradeoffs:\n"); + for source in &report.sources { + let state = if !source.supported { + "unavailable" + } else if !source.ok { + "failed" + } else if source.entries.is_empty() { + "no results" + } else { + "results" + }; + phrase.push_str(&format!( + "{}: {} — {}\n", + source.backend.as_str(), + state, + source.note.chars().take(200).collect::() + )); + for entry in source.entries.iter().take(8) { + let description = entry.description.as_deref().unwrap_or(""); + let description: String = description.chars().take(100).collect(); + phrase.push_str(&format!( + " {} {} {}\n", + entry.id.chars().take(150).collect::(), + entry + .version + .as_deref() + .unwrap_or("") + .chars() + .take(40) + .collect::(), + description + )); + } + if source.entries.len() > 8 { + phrase.push_str(&format!( + " ... {} more results\n", + source.entries.len() - 8 + )); + } + } + phrase.push_str("AppImage catalogue links are leads only and require a pinned artifact URL and SHA-256 before installation.\n"); + } + } // The validator both checks the proposal against real metadata and stashes // the resolved plan, so we do not resolve twice. let validated: std::cell::RefCell> = std::cell::RefCell::new(None); @@ -828,7 +877,7 @@ pub fn resolve_with_ai( } }; - let outcome = phoebus_ai::install::investigate_install( + let outcome = phoebus_ai::install::investigate_install_with_discovery( ai.provider, &ai.endpoint, &ai.model, @@ -838,6 +887,7 @@ pub fn resolve_with_ai( session, &validator, &ai.limits, + request.backend.is_none() && request.catalog.is_some(), ) .map_err(|error| match error { AiError::NoVerifiedCandidate(_) => ExecError::operation( diff --git a/installer-rs/crates/phoebus-executor/src/query.rs b/installer-rs/crates/phoebus-executor/src/query.rs index 1e299d5..257bce4 100644 --- a/installer-rs/crates/phoebus-executor/src/query.rs +++ b/installer-rs/crates/phoebus-executor/src/query.rs @@ -117,22 +117,44 @@ fn snap_target_usable(exec: &Exec, root: &Path) -> bool { /// Cross-source package search. `filter` constrains the search to one lane. pub fn search(exec: &Exec, root: &Path, query: &str, filter: Option) -> CatalogReport { let mut report = CatalogReport::new(query); + let broader = query + .split_whitespace() + .next() + .filter(|term| *term != query); for lane in selected_lanes(filter) { - let source = match lane { - Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { - search_portage(exec, root, query, lane) + let mut source = search_lane(exec, root, query, lane); + if source.ok && source.entries.is_empty() { + if let Some(term) = broader { + let fallback = search_lane(exec, root, term, lane); + if fallback.ok && !fallback.entries.is_empty() { + source = fallback; + source.note = format!( + "{}; no full-name match, broadened search to `{term}`", + source.note + ); + } else if !fallback.ok { + source.note.push_str("; broader search did not answer"); + } } - Backend::Flatpak => search_flatpak(exec, root, query, lane), - Backend::Snap => search_snap(exec, root, query, lane), - Backend::AppImage => search_appimage(exec, root, query, lane), - Backend::Nix => search_nix(exec, root, query, lane), - Backend::CustomEbuild => search_ebuild(root, query, lane), - }; + } report.push(source); } report } +fn search_lane(exec: &Exec, root: &Path, query: &str, lane: Backend) -> SourceReport { + match lane { + Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { + search_portage(exec, root, query, lane) + } + Backend::Flatpak => search_flatpak(exec, root, query, lane), + Backend::Snap => search_snap(exec, root, query, lane), + Backend::AppImage => search_appimage(exec, root, query, lane), + Backend::Nix => search_nix(exec, root, query, lane), + Backend::CustomEbuild => search_ebuild(root, query, lane), + } +} + fn search_portage(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport { match capture( exec, @@ -360,7 +382,7 @@ fn search_flatpak(exec: &Exec, root: &Path, query: &str, backend: Backend) -> So .into_iter() .filter_map(|cols| { let id = cols.first()?.clone(); - if id.is_empty() { + if !phoebus_core::action::valid_flatpak_app_id(&id) { return None; } let mut entry = CatalogEntry::new(backend, &id).installed(installed.contains(&id)); @@ -2757,6 +2779,51 @@ mod tests { ); } + #[test] + fn flatpak_no_matches_message_is_not_a_catalog_entry() { + let runner = RecordingRunner::new(); + runner.set_response("chroot", ok("No matches found\n")); + let exec = make_exec(runner); + let root = Path::new(&exec.root); + install_fake_tool(root, "flatpak"); + let report = search(&exec, root, "missing-app", Some(Backend::Flatpak)); + assert!(report.sources[0].ok); + assert!(report.sources[0].entries.is_empty()); + } + + #[test] + fn multiword_search_broadens_an_empty_lane_and_labels_the_fallback() { + struct SearchFallbackRunner; + impl crate::command::ProcessRunner for SearchFallbackRunner { + fn execute(&self, spec: &CommandSpec) -> Result { + let output = if spec.args.last().map(String::as_str) == Some("chatgpt desktop") { + "No matches found\n" + } else if spec.args.last().map(String::as_str) == Some("chatgpt") { + "com.example.ChatGPT\t1.0\tChatGPT Desktop\n" + } else { + "" + }; + Ok(ok(output)) + } + } + let path = tempfile::tempdir().unwrap().keep(); + let root = path.join("root"); + install_fake_tool(&root, "flatpak"); + let logger = Logger::open(path.join("l.log"), Redactor::new(), false); + let exec = Exec::new( + Box::new(SearchFallbackRunner), + logger, + false, + root.clone(), + path, + ); + let report = search(&exec, &root, "chatgpt desktop", Some(Backend::Flatpak)); + assert_eq!(report.sources[0].entries[0].id, "com.example.ChatGPT"); + assert!(report.sources[0] + .note + .contains("broadened search to `chatgpt`")); + } + #[test] fn apply_updates_never_runs_host_snap_for_an_alternate_root() { let runner = RecordingRunner::new(); diff --git a/installer-rs/crates/phoebus-installer/src/assistant_bridge.rs b/installer-rs/crates/phoebus-installer/src/assistant_bridge.rs index 1f7bd2f..6ecb100 100644 --- a/installer-rs/crates/phoebus-installer/src/assistant_bridge.rs +++ b/installer-rs/crates/phoebus-installer/src/assistant_bridge.rs @@ -13,6 +13,7 @@ use phoebus_ai::install::{Evidence, InstallSession}; use phoebus_ai::provider::{ModelTransport, ProviderKind, SystemFacts}; use phoebus_ai::AiError; use phoebus_core::action::{parse_natural, OverlayReview, SystemAction}; +use phoebus_core::catalog::CatalogReport; use phoebus_core::selection::Backend; use phoebus_core::{AiBackend, InstallConfig, Preferences}; use phoebus_executor::chooser; @@ -274,6 +275,46 @@ fn plan_response(id: u64, kind: &str, plan: &PreparedPlan) -> BridgeResponse { ) } +/// Keep the review bounded while preserving each lane's actual search state. +/// Catalogue hits are leads; selecting one resolves and checks it afresh. +fn catalog_sources_for_review(report: &CatalogReport) -> Value { + json!(report + .sources + .iter() + .map(|source| { + let mut entries = source.entries.clone(); + let query = report.query.to_ascii_lowercase().replace(' ', "-"); + entries.sort_by_key(|entry| { + let id = entry.id.to_ascii_lowercase(); + let name = id.rsplit('/').next().unwrap_or(&id); + let name = name.rsplit('.').next().unwrap_or(name); + if name == query { + 0 + } else if name.starts_with(&query) { + 1 + } else { + 2 + } + }); + json!({ + "backend": source.backend.as_str(), + "status": if !source.supported { "unavailable" } + else if !source.ok { "failed" } + else if source.entries.is_empty() { "empty" } else { "results" }, + "note": source.note, + "total": source.entries.len(), + "entries": entries.into_iter().take(8).map(|entry| json!({ + "id": entry.id, + "version": entry.version, + "description": entry.description, + "installed": entry.installed, + "selectable": source.backend != Backend::AppImage, + })).collect::>(), + }) + }) + .collect::>()) +} + fn general_response(exec: &Exec, root: &Path, id: u64, plan: &PreparedPlan) -> BridgeResponse { if !plan.actions.iter().any(SystemAction::is_mutating) { let mut answer = plan.summary.clone(); @@ -511,6 +552,28 @@ pub fn handle_request( Err(e) => BridgeResponse::err(id, e.to_string()), } } + "select_catalog_source" => { + let Some(id_text) = req.application else { + return BridgeResponse::err(id, "missing selected package ID"); + }; + let Some(backend) = req.backend.as_deref().and_then(Backend::parse) else { + return BridgeResponse::err(id, "missing selected package source"); + }; + if backend == Backend::AppImage + || !phoebus_core::action::valid_candidate_id(backend, &id_text) + { + return BridgeResponse::err( + id, + "the selected catalogue entry cannot be prepared as an install plan", + ); + } + let mut install_req = InstallRequest::new(&id_text); + install_req.backend = Some(backend); + match service::plan_selected_install(plans, exec, root, &install_req) { + Ok(plan) => plan_response(id, "install", &plan), + Err(e) => BridgeResponse::err(id, e.to_string()), + } + } "legacy_execute" => { let action = if let Some(val) = req.action { match serde_json::from_value::(val) { @@ -733,6 +796,11 @@ fn plan_and_respond_install( } let mut install_req = InstallRequest::new(app); install_req.backend = constrained_backend; + if constrained_backend.is_none() { + let phase = exec.progress_phase("Searching every package lane"); + install_req.catalog = Some(query::search(exec, root, app, None)); + phase.complete(); + } let session = BridgeSession { exec, root }; let result = with_bridge_ai(exec, root, |ai, facts| { @@ -757,6 +825,15 @@ fn plan_and_respond_install( }, ); let mut response = plan_response(id, "install", &plan); + if let (Some(catalog), Some(result)) = ( + install_req.catalog.as_ref(), + response.result.as_mut().and_then(Value::as_object_mut), + ) { + result.insert( + "catalog_sources".into(), + catalog_sources_for_review(catalog), + ); + } if constrained_backend.is_none() && plan .candidate @@ -790,7 +867,18 @@ fn plan_and_respond_install( Ok(Err(phoebus_executor::ExecError::Operation { stage, operation, .. })) if stage == "install" && operation == "plan unavailable" => { - unavailable_install_response(exec, root, id, app, constrained_backend) + let mut response = + unavailable_install_response(exec, root, id, app, constrained_backend); + if let (Some(catalog), Some(result)) = ( + install_req.catalog.as_ref(), + response.result.as_mut().and_then(Value::as_object_mut), + ) { + result.insert( + "catalog_sources".into(), + catalog_sources_for_review(catalog), + ); + } + response } Ok(Err(e)) => BridgeResponse::err(id, e.to_string()), Err(e) => BridgeResponse::err(id, e), @@ -1084,7 +1172,7 @@ fn bridge_request_label(op: &str) -> Option<&'static str> { match op { "ask" => Some("Investigating your request"), "execute" | "legacy_execute" | "undo" => Some("Executing the reviewed action"), - "legacy_install" => Some("Checking the selected package"), + "legacy_install" | "select_catalog_source" => Some("Checking the selected package"), "updates" => Some("Checking package updates"), _ => None, } @@ -1125,6 +1213,7 @@ fn write_protocol_line(lock: &Mutex<()>, line: &str) -> std::io::Result<()> { #[cfg(test)] mod tests { use super::*; + use phoebus_core::catalog::{CatalogEntry, SourceReport}; use phoebus_core::Redactor; use phoebus_executor::command::RecordingRunner; use phoebus_executor::Logger; @@ -1142,6 +1231,31 @@ mod tests { ) } + #[test] + fn cross_lane_review_keeps_failures_and_only_offers_resolvable_lanes() { + let mut report = CatalogReport::new("chatgpt desktop"); + report.push(SourceReport::ok( + Backend::Snap, + "Snap Store search", + vec![ + CatalogEntry::new(Backend::Snap, "unrelated-tool"), + CatalogEntry::new(Backend::Snap, "chatgpt-desktop"), + ], + )); + report.push(SourceReport::failed(Backend::Nix, "registry unavailable")); + report.push(SourceReport::ok( + Backend::AppImage, + "unverified catalog leads", + vec![CatalogEntry::new(Backend::AppImage, "chatgpt-desktop")], + )); + + let review = catalog_sources_for_review(&report); + assert_eq!(review[0]["entries"][0]["id"], "chatgpt-desktop"); + assert_eq!(review[0]["entries"][0]["selectable"], true); + assert_eq!(review[1]["status"], "failed"); + assert_eq!(review[2]["entries"][0]["selectable"], false); + } + fn request(op: &str) -> BridgeRequest { BridgeRequest { id: 1, diff --git a/installer-rs/crates/phoebus-installer/src/service/mod.rs b/installer-rs/crates/phoebus-installer/src/service/mod.rs index 218b4dd..9bb0779 100644 --- a/installer-rs/crates/phoebus-installer/src/service/mod.rs +++ b/installer-rs/crates/phoebus-installer/src/service/mod.rs @@ -342,6 +342,7 @@ pub mod validation; pub use execution::{execute_plan, execute_plan_privileged}; pub use plan::{ build_removal_plan, format_recommendation, plan_general, plan_install, plan_legacy_install, - plan_overlay, plan_removal, plan_removal_with_ai, select_removal_copy, PlanStore, + plan_overlay, plan_removal, plan_removal_with_ai, plan_selected_install, select_removal_copy, + PlanStore, }; pub use validation::{compute_plan_digest, seal_plan, validate_prepared_plan}; diff --git a/installer-rs/crates/phoebus-installer/src/service/plan.rs b/installer-rs/crates/phoebus-installer/src/service/plan.rs index 5f7838a..03ba43b 100644 --- a/installer-rs/crates/phoebus-installer/src/service/plan.rs +++ b/installer-rs/crates/phoebus-installer/src/service/plan.rs @@ -381,7 +381,16 @@ pub fn plan_install( } }; - let resolved = install::resolve_with_ai(exec, root, request, session, ai, facts)?; + let mut request = request.clone(); + if request.backend.is_none() && request.catalog.is_none() { + request.catalog = Some(phoebus_executor::query::search( + exec, + root, + &request.application, + None, + )); + } + let resolved = install::resolve_with_ai(exec, root, &request, session, ai, facts)?; build_install_plan(plans, root, resolved, PlanKind::Install) } @@ -403,6 +412,29 @@ pub fn plan_legacy_install( build_install_plan(plans, root, resolved, PlanKind::LegacyInstall) } +/// Prepare a user-selected catalogue entry. Friendly-name matching may find a +/// different package after a catalogue changes, so require the exact ID that +/// was displayed before exposing an approval plan. +pub fn plan_selected_install( + plans: &PlanStore, + exec: &Exec, + root: &Path, + request: &InstallRequest, +) -> Result { + let resolved = install::resolve_explicit(exec, root, request)?; + if resolved.candidate.id != request.application { + return Err(ExecError::operation( + "service", + "select catalogue candidate", + format!( + "the selected package `{}` now resolves to `{}`; search again before approving", + request.application, resolved.candidate.id + ), + )); + } + build_install_plan(plans, root, resolved, PlanKind::LegacyInstall) +} + fn build_install_plan( plans: &PlanStore, root: &Path, diff --git a/installer-rs/crates/phoebus-installer/src/service/tests.rs b/installer-rs/crates/phoebus-installer/src/service/tests.rs index 8287720..aa4267c 100644 --- a/installer-rs/crates/phoebus-installer/src/service/tests.rs +++ b/installer-rs/crates/phoebus-installer/src/service/tests.rs @@ -568,6 +568,26 @@ fn install_fake_flatpak(root: &Path) { std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap(); } +#[test] +fn selected_catalog_source_refuses_a_different_resolved_id() { + let root = tempdir().unwrap(); + let exec = make_exec_with_runner( + root.path(), + Box::new(FlatpakRunner { + installed: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)), + mark_on_install: false, + }), + ); + install_fake_flatpak(root.path()); + let store = PlanStore::with_dir(tempdir().unwrap().keep()); + let mut request = InstallRequest::new("firefox"); + request.backend = Some(Backend::Flatpak); + let error = plan_selected_install(&store, &exec, root.path(), &request).unwrap_err(); + assert!(error + .to_string() + .contains("now resolves to `org.mozilla.firefox`")); +} + #[test] fn install_verification_failure_finishes_the_transaction_as_failed() { let root = tempdir().unwrap(); diff --git a/installer/live/desktop/phoebus-assistant/AssistantBridge.qml b/installer/live/desktop/phoebus-assistant/AssistantBridge.qml index e01601f..002596f 100644 --- a/installer/live/desktop/phoebus-assistant/AssistantBridge.qml +++ b/installer/live/desktop/phoebus-assistant/AssistantBridge.qml @@ -105,8 +105,12 @@ Singleton { call("execute", { plan_id: planId, digest: digest, yes: yes }, cb, onProgress); } - function legacyInstall(application, backend, cb) { - call("legacy_install", { application: application, backend: backend }, cb); + function legacyInstall(application, backend, cb, onProgress) { + call("legacy_install", { application: application, backend: backend }, cb, onProgress); + } + + function selectCatalogSource(packageId, backend, cb, onProgress) { + call("select_catalog_source", { application: packageId, backend: backend }, cb, onProgress); } function legacyExecute(phrase, action, yes, cb) { diff --git a/installer/live/desktop/phoebus-assistant/shell.qml b/installer/live/desktop/phoebus-assistant/shell.qml index 756db9b..aef1bb9 100644 --- a/installer/live/desktop/phoebus-assistant/shell.qml +++ b/installer/live/desktop/phoebus-assistant/shell.qml @@ -281,6 +281,29 @@ ShellRoot { }, progress => shell.recordActivity(index, progress)); } + function chooseCatalogSource(index, backend, packageId) { + if (shell.busy) + return; + const previous = shell.conversation[index] ? shell.conversation[index].data : null; + shell.busy = true; + shell.statusText = "Checking " + packageId + " from " + backend + "..."; + AssistantBridge.selectCatalogSource(packageId, backend, reply => { + shell.busy = false; + if (!reply.ok) { + shell.statusText = "That source could not be prepared"; + shell.updateMessage(index, { source_error: reply.error || "Source review failed" }); + return; + } + const result = reply.result || {}; + result.user_selected_source = true; + result.catalog_sources = previous ? previous.catalog_sources : []; + result.external_overlay_options = previous ? previous.external_overlay_options : []; + result.external_overlay_atom = previous ? previous.external_overlay_atom : ""; + shell.statusText = "Selected source ready for approval"; + shell.finishMessage(index, result.recommendation || result.summary || "Review this source", result); + }, progress => shell.recordActivity(index, progress)); + } + function cancelPlan(index) { // Cancelling is purely local: nothing reaches the privileged broker. shell.updateMessage(index, { state: "cancelled" }); @@ -675,6 +698,21 @@ ShellRoot { } } + Label { + Layout.fillWidth: true + visible: !!(modelData.data && modelData.data.kind === "install" + && modelData.data.chosen) + text: { + const d = modelData.data || {}; + return (d.user_selected_source ? "Selected source: " : "Recommended source: ") + + (d.source || d.backend || "unknown") + + " • " + (d.chosen ? d.chosen.id : ""); + } + color: Theme.accent + font.bold: true + wrapMode: Text.Wrap + } + Label { Layout.fillWidth: true visible: !!(modelData.data && modelData.data.external_overlay_options @@ -684,6 +722,86 @@ ShellRoot { font.bold: true } + ColumnLayout { + id: catalogChoices + property bool expanded: false + Layout.fillWidth: true + visible: !!(modelData.data && modelData.data.catalog_sources + && modelData.data.catalog_sources.length > 0) + spacing: 5 + + RowLayout { + Layout.fillWidth: true + Label { + Layout.fillWidth: true + text: "Package sources checked: " + + (modelData.data ? modelData.data.catalog_sources.length : 0) + color: Theme.text + font.bold: true + wrapMode: Text.Wrap + } + PhoebusButton { + label: catalogChoices.expanded ? "Hide options" : "Compare options" + onClicked: catalogChoices.expanded = !catalogChoices.expanded + } + } + Repeater { + model: catalogChoices.expanded && modelData.data + ? (modelData.data.catalog_sources || []) : [] + delegate: ColumnLayout { + id: catalogLane + required property var modelData + Layout.fillWidth: true + spacing: 3 + Label { + Layout.fillWidth: true + text: modelData.backend + " • " + (modelData.status === "results" + ? modelData.total + " result(s)" : modelData.status) + color: Theme.text + font.bold: true + wrapMode: Text.Wrap + } + Label { + Layout.fillWidth: true + text: modelData.note || "" + color: Theme.muted + font.pixelSize: 11 + wrapMode: Text.Wrap + } + Repeater { + model: modelData.entries || [] + delegate: RowLayout { + required property var modelData + Layout.fillWidth: true + spacing: 6 + Label { + Layout.fillWidth: true + text: modelData.id + (modelData.version ? " " + modelData.version : "") + + (modelData.description ? " — " + modelData.description : "") + color: Theme.muted + font.pixelSize: 11 + wrapMode: Text.Wrap + } + PhoebusButton { + visible: modelData.selectable + label: "Review" + actionEnabled: !shell.busy + onClicked: shell.chooseCatalogSource(messageCard.messageIndex, + catalogLane.modelData.backend, modelData.id) + } + } + } + } + } + Label { + Layout.fillWidth: true + visible: !!(modelData.data && modelData.data.source_error) + text: modelData.data ? (modelData.data.source_error || "") : "" + color: Theme.warning + wrapMode: Text.Wrap + } + } + Label { Layout.fillWidth: true visible: !!(modelData.data && modelData.data.external_overlay_note)