From 58e0f708790ce1bd2a82255d2c48096332105e95 Mon Sep 17 00:00:00 2001 From: Phoebus Date: Fri, 25 Sep 2026 03:51:02 -0700 Subject: [PATCH] fix(sys): close host/target, revalidation, update-effect and inspection defects in the package catalogue --- .../crates/phoebus-core/src/action.rs | 16 +- .../crates/phoebus-core/src/effects.rs | 49 ++ .../crates/phoebus-executor/src/actions.rs | 607 +++++++++++-- .../crates/phoebus-executor/src/chooser.rs | 358 +++++--- .../crates/phoebus-executor/src/exec.rs | 22 + .../crates/phoebus-executor/src/install.rs | 72 +- .../crates/phoebus-executor/src/nix.rs | 335 +++++++ .../crates/phoebus-executor/src/portage.rs | 128 +++ .../crates/phoebus-executor/src/query.rs | 817 ++++++++++++++---- .../crates/phoebus-executor/src/update.rs | 287 +++--- .../crates/phoebus-installer/src/service.rs | 166 +++- installer/tests/vm/sys-acceptance.sh | 19 + 12 files changed, 2346 insertions(+), 530 deletions(-) diff --git a/installer-rs/crates/phoebus-core/src/action.rs b/installer-rs/crates/phoebus-core/src/action.rs index 105be14..e00de58 100644 --- a/installer-rs/crates/phoebus-core/src/action.rs +++ b/installer-rs/crates/phoebus-core/src/action.rs @@ -600,9 +600,19 @@ impl SystemAction { | SystemAction::DiscoverCandidates { backend, .. } => *backend, SystemAction::InspectCandidate { backend, .. } => Some(*backend), SystemAction::CheckBackend { backend } => Some(*backend), - SystemAction::InstallPackage { .. } | SystemAction::InspectPackage { .. } => { - Some(Backend::PortageSource) - } + // Portage-only actions. These must be classified so a request + // constrained to another lane can never reach them through the + // `backend() == None` loophole (UpdateSystem, RemovePackage, + // Depclean, PrepareUpdates, ownership and dependency inspection). + SystemAction::InstallPackage { .. } + | SystemAction::InspectPackage { .. } + | SystemAction::RemovePackage { .. } + | SystemAction::UpdateSystem + | SystemAction::PrepareUpdates + | SystemAction::InspectUpdates + | SystemAction::PackageOwners { .. } + | SystemAction::PackageDependencies { .. } + | SystemAction::Depclean => Some(Backend::PortageSource), SystemAction::FlatpakInstall { .. } | SystemAction::FlatpakRemove { .. } | SystemAction::FlatpakList => Some(Backend::Flatpak), diff --git a/installer-rs/crates/phoebus-core/src/effects.rs b/installer-rs/crates/phoebus-core/src/effects.rs index 7d80a70..6a46d4c 100644 --- a/installer-rs/crates/phoebus-core/src/effects.rs +++ b/installer-rs/crates/phoebus-core/src/effects.rs @@ -47,11 +47,29 @@ pub struct PackageEffect { pub source: EffectSource, } +/// One destructive cache-cleanup intent, bound to approval. +/// +/// A cleaner is only ever run after its exact dry-run item list has been +/// reviewed. `unavailable` distinguishes a missing tool from a tool that ran +/// and reported nothing to remove, so an unavailable cleaner is never presented +/// as a completed cleanup. +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct CleanupEffect { + /// The cleaner (e.g. `eclean-dist`, `eclean-pkg`, `nix-store --gc`). + pub cleaner: String, + /// The exact items/paths the non-destructive dry run reported. + pub items: Vec, + /// The tool is not present in the target. + pub unavailable: bool, +} + /// A fully resolved, human-reviewable plan. #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] pub struct ResolvedPlan { pub effects: Vec, + /// Destructive cache-cleanup intents, each bound to its reviewed dry run. + pub cleanup: Vec, pub download_bytes: Option, /// A recovery point that will exist before the change (snapshot id). pub recovery_point: Option, @@ -126,6 +144,20 @@ impl ResolvedPlan { } hasher.update(b"\n"); } + // Cleanup intents are part of the approved material change: a cleaner + // that would now delete a different item set must invalidate approval. + for cleanup in &self.cleanup { + hasher.update(b"cleanup\0"); + hasher.update(cleanup.cleaner.as_bytes()); + hasher.update(b"\0"); + hasher.update([cleanup.unavailable as u8]); + hasher.update(b"\0"); + for item in &cleanup.items { + hasher.update(item.as_bytes()); + hasher.update(b"\n"); + } + hasher.update(b"\0"); + } self.digest = format!("{:x}", hasher.finalize()); } @@ -165,6 +197,23 @@ impl ResolvedPlan { self.source_builds(), self.binary_packages() )); + for cleanup in &self.cleanup { + if cleanup.unavailable { + out.push_str(&format!( + " [cleanup] {} is not available in the target\n", + cleanup.cleaner + )); + } else { + out.push_str(&format!( + " [cleanup] {} would remove {} item(s)\n", + cleanup.cleaner, + cleanup.items.len() + )); + for item in &cleanup.items { + out.push_str(&format!(" - {item}\n")); + } + } + } if let Some(bytes) = self.download_bytes { out.push_str(&format!(" download: {} MiB\n", bytes / (1024 * 1024))); } diff --git a/installer-rs/crates/phoebus-executor/src/actions.rs b/installer-rs/crates/phoebus-executor/src/actions.rs index 921ba18..4300e74 100644 --- a/installer-rs/crates/phoebus-executor/src/actions.rs +++ b/installer-rs/crates/phoebus-executor/src/actions.rs @@ -6,8 +6,11 @@ use std::path::Path; use phoebus_core::action::SystemAction; -use phoebus_core::effects::{changed_materially, parse_emerge_pretend, ResolvedPlan}; -use phoebus_core::selection::Need; +use phoebus_core::effects::{ + changed_materially, parse_emerge_pretend, CleanupEffect, EffectKind, EffectSource, + PackageEffect, ResolvedPlan, +}; +use phoebus_core::selection::{Backend, Need}; use phoebus_core::transaction::TransactionOutcome; use crate::auth::DestructiveAuthorization; @@ -68,7 +71,7 @@ pub(crate) fn is_host_root(root: &Path) -> bool { /// root, or inside the target chroot for an alternate root. This is the single /// place package, service and Flatpak commands are rooted, so preview and /// execution always target the same system. -fn target_spec( +pub(crate) fn target_spec( root: &Path, stage: &str, operation: &str, @@ -176,81 +179,37 @@ fn pretend_args(action: &SystemAction) -> Option> { } } -/// Whether [`resolve_effects`] produces a real, comparable package plan for an -/// action. Only Portage transactions have `emerge --pretend` effects; other -/// lanes' effects are resolved by the install layer. Callers that compare a -/// re-resolution against a reviewed plan must use this to avoid treating a -/// "no comparable package plan" result as a material change. +/// Whether [`resolve_effects`] produces a real, comparable plan for an action. +/// +/// Portage transactions resolve from `emerge --pretend`; the maintenance +/// actions (depclean, per-source updates, cache cleanup) resolve a structured, +/// digest-bound plan too. Callers that compare a re-resolution against a +/// reviewed plan must use this to avoid treating a "no comparable plan" result +/// as material drift. pub fn resolves_effects(action: &SystemAction) -> bool { pretend_args(action).is_some() + || matches!( + action, + SystemAction::Depclean + | SystemAction::ApplyUpdates { .. } + | SystemAction::CleanCache { .. } + ) } -/// Resolve exactly what a package action will do. Non-Portage actions yield an -/// empty plan. A plan's digest can be bound to an approval. +/// Resolve exactly what a package or maintenance action will do. A plan's +/// digest is bound to the approval and re-checked immediately before execution. pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Result { action .validate() .map_err(|e| ExecError::operation("sys", "validate action", e))?; - // Destructive maintenance and Portage updates are previewed from a real - // `--pretend`, so approval binds to exactly what will happen. Other lanes - // resolve their effects in the install layer. match action { - SystemAction::Depclean => { - let spec = target_spec( - root, - "sys", - "resolve depclean", - "emerge", - &["--pretend".into(), "--depclean".into(), "--color=n".into()], - ); - let out = exec.run_capture(spec)?; - let mut plan = ResolvedPlan::default(); - plan.established = true; - plan.consequences.push(format!( - "depclean would remove:\n{}", - out.stdout_lossy().trim() - )); - plan.recompute_digest(); - return Ok(plan); + SystemAction::Depclean => return resolve_depclean_effects(exec, root), + SystemAction::ApplyUpdates { backend } => { + return resolve_update_effects(exec, root, *backend); } - SystemAction::ApplyUpdates { backend } - if backend.map(|b| b.is_portage()).unwrap_or(true) => - { - let spec = target_spec( - root, - "sys", - "resolve updates", - "emerge", - &[ - "--pretend".into(), - "--update".into(), - "--deep".into(), - "--newuse".into(), - "--color=n".into(), - "--".into(), - "@world".into(), - ], - ); - let out = exec.run_capture(spec)?; - let mut plan = parse_emerge_pretend(&out.stdout_lossy()); - if !plan.established { - return Err(ExecError::operation( - "sys", - "resolve updates", - "could not establish the update plan from emerge --pretend; \ - refusing to proceed unreviewed", - )); - } - if backend.is_none() { - plan.consequences.push( - "Flatpak/Snap/AppImage/Nix updates are applied per source and are not \ - predicted in this Portage preview" - .into(), - ); - } - plan.recompute_digest(); - return Ok(plan); + SystemAction::CleanCache { backend } => { + return resolve_cleanup_effects(exec, root, *backend); } _ => {} } @@ -279,7 +238,7 @@ pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Resul if plan .effects .iter() - .any(|e| e.source == phoebus_core::effects::EffectSource::Source) + .any(|e| e.source == EffectSource::Source) { return Err(ExecError::operation( "sys", @@ -296,6 +255,419 @@ pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Resul Ok(plan) } +/// Depclean removals are parsed into structured effects, not only prose, so a +/// changed removal set changes the approved digest and is caught before +/// execution. +fn resolve_depclean_effects(exec: &Exec, root: &Path) -> Result { + let spec = target_spec( + root, + "sys", + "resolve depclean", + "emerge", + &["--pretend".into(), "--depclean".into(), "--color=n".into()], + ); + let out = exec.run_capture(spec)?; + let mut plan = parse_emerge_pretend(&out.stdout_lossy()); + if !plan.established { + return Err(ExecError::operation( + "sys", + "resolve depclean", + "could not establish the depclean selection from emerge --pretend; \ + refusing to proceed unreviewed", + )); + } + if root.join(snapshot::SNAPSHOT_DIR).is_dir() { + plan.recovery_point = Some("a protective snapshot before the change".into()); + } + plan.recompute_digest(); + Ok(plan) +} + +pub(crate) fn update_limitation(backend: Backend) -> &'static str { + match backend { + Backend::Nix => { + "Nix packages are declarative/pinned; update them in their project or profile" + } + Backend::AppImage => { + "managed AppImages have no update repository; re-acquire with a pinned URL + SHA-256" + } + Backend::CustomEbuild => "rebuild the staged ebuild through Portage explicitly", + _ => "this source has no system-level update transaction", + } +} + +/// The flatpak client must answer in the intended target. +fn flatpak_available(exec: &Exec, root: &Path) -> bool { + crate::query::flatpak_available(exec, root) +} + +/// Exact per-application Flatpak update effects. Each affected application is +/// an identity plus its planned new version, so approval cannot authorize an +/// unrestricted update-all. +fn flatpak_update_effects(exec: &Exec, root: &Path) -> Result> { + if !flatpak_available(exec, root) { + return Err(ExecError::operation( + "sys", + "resolve flatpak updates", + "the Flatpak client is not available in the target", + )); + } + let updates = exec + .runner + .execute(&target_spec( + root, + "sys", + "resolve flatpak updates", + "flatpak", + &[ + "remote-ls".into(), + "--updates".into(), + "--columns=application,version,branch".into(), + ], + )) + .map_err(|e| { + ExecError::operation( + "sys", + "resolve flatpak updates", + format!("flatpak remote-ls could not run: {e}"), + ) + })?; + if !updates.success { + return Err(ExecError::operation( + "sys", + "resolve flatpak updates", + format!( + "flatpak remote-ls failed: {}", + updates.stderr_lossy().trim() + ), + )); + } + let mut current = std::collections::BTreeMap::new(); + if let Ok(list) = exec.runner.execute(&target_spec( + root, + "sys", + "resolve flatpak updates", + "flatpak", + &[ + "list".into(), + "--app".into(), + "--columns=application,version".into(), + ], + )) { + if list.success { + for line in list.stdout_lossy().lines() { + let mut parts = line.split_whitespace(); + if let (Some(id), Some(version)) = (parts.next(), parts.next()) { + current.insert(id.to_string(), version.to_string()); + } + } + } + } + let mut effects = Vec::new(); + for line in updates.stdout_lossy().lines() { + let mut parts = line.split_whitespace(); + let (Some(id), Some(new_version)) = (parts.next(), parts.next()) else { + continue; + }; + if id.is_empty() || new_version.is_empty() { + continue; + } + effects.push(PackageEffect { + target: format!("{id}-{new_version}"), + previous: current.get(id).cloned(), + kind: EffectKind::Upgrade, + source: EffectSource::Binary, + }); + } + Ok(effects) +} + +/// Exact per-snap update effects. Snaps act on the running daemon, so an +/// alternate root is refused before any command is issued. +fn snap_update_effects(exec: &Exec, root: &Path) -> Result> { + if !is_host_root(root) { + return Err(ExecError::operation( + "sys", + "resolve snap updates", + "Snap acts on the running daemon and cannot be redirected to an alternate root; \ + refusing to touch the host", + )); + } + let status = snap::status(exec)?; + if !status.usable() { + return Err(ExecError::operation( + "sys", + "resolve snap updates", + "snapd is not installed or active", + )); + } + let updates = exec.runner.execute( + &CommandSpec::new("sys", "resolve snap updates", "snap").args(["refresh", "--list"]), + )?; + if !updates.success { + return Err(ExecError::operation( + "sys", + "resolve snap updates", + format!( + "snap refresh --list failed: {}", + updates.stderr_lossy().trim() + ), + )); + } + let mut current = std::collections::BTreeMap::new(); + if let Ok(entries) = snap::list(exec) { + for entry in entries { + current.insert(entry.name, entry.version); + } + } + let mut effects = Vec::new(); + for line in updates.stdout_lossy().lines().skip(1) { + let mut parts = line.split_whitespace(); + let (Some(name), Some(new_version)) = (parts.next(), parts.next()) else { + continue; + }; + if name.is_empty() || new_version.is_empty() { + continue; + } + effects.push(PackageEffect { + target: format!("{name}-{new_version}"), + previous: current.get(name).cloned(), + kind: EffectKind::Upgrade, + source: EffectSource::Binary, + }); + } + Ok(effects) +} + +/// Resolve a reviewable, per-source update plan. Each lane contributes exact +/// affected identities (and versions where the backend reports them). A lane +/// that cannot be updated deterministically is refused when explicitly +/// requested, never silently skipped. +fn resolve_update_effects( + exec: &Exec, + root: &Path, + backend: Option, +) -> Result { + let lanes: Vec = match backend { + Some(backend) => vec![backend], + None => vec![Backend::PortageSource, Backend::Flatpak, Backend::Snap], + }; + let mut plan = ResolvedPlan { + established: true, + ..Default::default() + }; + for lane in lanes { + if lane.is_portage() { + let spec = target_spec( + root, + "sys", + "resolve updates", + "emerge", + &[ + "--pretend".into(), + "--update".into(), + "--deep".into(), + "--newuse".into(), + "--color=n".into(), + "--".into(), + "@world".into(), + ], + ); + let out = exec.run_capture(spec)?; + let parsed = parse_emerge_pretend(&out.stdout_lossy()); + if !parsed.established { + return Err(ExecError::operation( + "sys", + "resolve updates", + "could not establish the update plan from emerge --pretend; \ + refusing to proceed unreviewed", + )); + } + plan.effects.extend(parsed.effects); + if let Some(bytes) = parsed.download_bytes { + *plan.download_bytes.get_or_insert(0) += bytes; + } + plan.consequences.extend(parsed.consequences); + } else if lane == Backend::Flatpak { + match flatpak_update_effects(exec, root) { + Ok(effects) => plan.effects.extend(effects), + Err(e) if backend.is_none() => plan + .consequences + .push(format!("[flatpak] updates could not be resolved: {e}")), + Err(e) => return Err(e), + } + } else if lane == Backend::Snap { + match snap_update_effects(exec, root) { + Ok(effects) => plan.effects.extend(effects), + Err(e) if backend.is_none() => plan + .consequences + .push(format!("[snap] updates could not be resolved: {e}")), + Err(e) => return Err(e), + } + } else { + // Not in the default set; only reachable when explicitly requested. + return Err(ExecError::operation( + "sys", + "resolve updates", + format!( + "{} updates cannot be applied safely by `sys`: {}", + lane.as_str(), + update_limitation(lane) + ), + )); + } + } + if backend.is_none() { + plan.consequences.push( + "Nix, managed AppImages and custom ebuilds are project- or format-specific and are \ + not part of this update transaction" + .into(), + ); + } + if plan.effects.is_empty() { + plan.consequences.push("no updates are available".into()); + } + if root.join(snapshot::SNAPSHOT_DIR).is_dir() { + plan.recovery_point = Some("a protective snapshot before the change".into()); + } + plan.recompute_digest(); + Ok(plan) +} + +/// The cache cleaners for a lane, as `(cleaner, dry-run args, destructive args)`. +pub(crate) fn portage_cleaners(root: &Path) -> Vec<(&'static str, Vec, Vec)> { + let mut cleaners = Vec::new(); + if crate::exec::tool_in_target(root, "eclean-dist") { + cleaners.push(("eclean-dist", vec![], vec!["-d".to_string()])); + } + if crate::exec::tool_in_target(root, "eclean-pkg") { + cleaners.push(("eclean-pkg", vec![], vec!["-d".to_string()])); + } + cleaners +} + +/// Resolve a reviewable cache-cleanup plan from non-destructive dry runs. A +/// cleaner that cannot run is recorded as unavailable, distinct from one that +/// ran and found nothing. +fn resolve_cleanup_effects( + exec: &Exec, + root: &Path, + backend: Option, +) -> Result { + let lanes: Vec = match backend { + Some(backend) => vec![backend], + None => vec![Backend::PortageSource, Backend::Nix], + }; + let mut plan = ResolvedPlan { + established: true, + ..Default::default() + }; + for lane in lanes { + if lane.is_portage() { + for (cleaner, dry_args, _) in portage_cleaners(root) { + let out = exec.runner.execute(&target_spec( + root, + "sys", + "resolve cache cleanup", + cleaner, + &dry_args, + )); + match out { + Ok(output) if output.success => { + let items = output + .stdout_lossy() + .lines() + .map(str::trim) + .filter(|l| !l.is_empty()) + .map(str::to_string) + .collect(); + plan.cleanup.push(CleanupEffect { + cleaner: cleaner.to_string(), + items, + unavailable: false, + }); + } + Ok(output) => { + return Err(ExecError::operation( + "sys", + "resolve cache cleanup", + format!("{cleaner} dry run failed: {}", output.stderr_lossy().trim()), + )); + } + Err(e) => { + return Err(ExecError::operation( + "sys", + "resolve cache cleanup", + format!("{cleaner} dry run could not run: {e}"), + )); + } + } + } + } else if lane == Backend::Nix { + if !crate::nix::installed(root) { + plan.cleanup.push(CleanupEffect { + cleaner: "nix-store --gc".into(), + items: Vec::new(), + unavailable: true, + }); + } else { + let out = exec.runner.execute(&target_spec( + root, + "sys", + "resolve cache cleanup", + "/nix/var/nix/profiles/default/bin/nix-store", + &["--gc".into(), "--dry-run".into()], + )); + match out { + Ok(output) if output.success => { + let items = output + .stdout_lossy() + .lines() + .map(str::trim) + .filter(|l| !l.is_empty()) + .map(str::to_string) + .collect(); + plan.cleanup.push(CleanupEffect { + cleaner: "nix-store --gc".into(), + items, + unavailable: false, + }); + } + Ok(output) => { + return Err(ExecError::operation( + "sys", + "resolve cache cleanup", + format!("nix-store --gc failed: {}", output.stderr_lossy().trim()), + )); + } + Err(e) => { + return Err(ExecError::operation( + "sys", + "resolve cache cleanup", + format!("nix-store --gc could not run: {e}"), + )); + } + } + } + } else { + return Err(ExecError::operation( + "sys", + "resolve cache cleanup", + format!( + "the {} lane has no package cache to clean; refusing", + lane.as_str() + ), + )); + } + } + if plan.cleanup.is_empty() { + plan.consequences + .push("no cache cleaner is available in the target".into()); + } + plan.recompute_digest(); + Ok(plan) +} + /// Execute an action after re-resolving it against the approved digest. If the /// plan changed materially since review, execution is refused. pub fn execute_checked( @@ -1475,15 +1847,17 @@ Total: 1 package (1 new), Size of downloads: 512 KiB } #[test] - fn depclean_is_previewed_from_pretend_at_review() { + fn depclean_is_previewed_as_structured_removals_at_review() { let runner = RecordingRunner::new(); runner.set_response( "emerge", CommandOutput { status: 0, success: true, - stdout: b">>> These are the packages that would be unmerged:\n\ - app-misc/unused-1.0\n\n0 packages selected\n" + stdout: b">>> These are the packages that would be unmerged:\n\n \ + app-misc/unused\n selected: 1.0\n\n\ + All selected packages: app-misc/unused-1.0\n\n\ + >>> 'Selected' packages are slated for removal.\n" .to_vec(), stderr: Vec::new(), duration: std::time::Duration::from_millis(1), @@ -1492,11 +1866,98 @@ Total: 1 package (1 new), Size of downloads: 512 KiB let exec = make_exec(runner); let plan = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap(); assert!(plan.established); + // Removals are structured effects, so changing them changes the digest + // and is caught before execution. + assert_eq!(plan.removals(), 1); + assert_eq!(plan.effects[0].target, "app-misc/unused-1.0"); assert!(plan .consequences .iter() - .any(|c| c.contains("depclean would remove"))); - assert!(plan.render().contains("depclean would remove")); + .any(|c| c.contains("will be removed"))); + assert!(plan.render().contains("app-misc/unused-1.0")); + } + + #[test] + fn depclean_effect_digest_detects_a_changed_removal_set() { + let runner = RecordingRunner::new(); + runner.set_response( + "emerge", + CommandOutput { + status: 0, + success: true, + stdout: b"All selected packages: app-misc/unused-1.0\n".to_vec(), + stderr: Vec::new(), + duration: std::time::Duration::from_millis(1), + }, + ); + let exec = make_exec(runner.clone()); + let approved = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap(); + // The next preview selects a different package entirely. + runner.set_response( + "emerge", + CommandOutput { + status: 0, + success: true, + stdout: b"All selected packages: app-misc/other-2.0\n".to_vec(), + stderr: Vec::new(), + duration: std::time::Duration::from_millis(1), + }, + ); + let current = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap(); + assert_ne!(approved.digest, current.digest); + assert!(phoebus_core::effects::changed_materially( + &approved, ¤t + )); + assert!(!phoebus_core::effects::approval_holds( + &approved, + ¤t, + &[] + )); + } + + #[test] + fn maintenance_actions_have_comparable_effects() { + assert!(resolves_effects(&SystemAction::Depclean)); + assert!(resolves_effects(&SystemAction::ApplyUpdates { + backend: None + })); + assert!(resolves_effects(&SystemAction::ApplyUpdates { + backend: Some(phoebus_core::selection::Backend::Flatpak), + })); + assert!(resolves_effects(&SystemAction::CleanCache { + backend: None + })); + } + + #[test] + fn execute_checked_refuses_depclean_drift_before_any_mutation() { + let approved_runner = RecordingRunner::new(); + approved_runner.set_response( + "emerge", + response("All selected packages: app-misc/old-1.0\n"), + ); + let approved_exec = make_exec(approved_runner); + let approved = + resolve_effects(&approved_exec, &SystemAction::Depclean, Path::new("/")).unwrap(); + + let runner = RecordingRunner::new(); + runner.set_response( + "emerge", + response("All selected packages: app-misc/new-2.0\n"), + ); + let exec = make_exec(runner.clone()); + let auth = auth(); + let err = execute_checked( + &exec, + &SystemAction::Depclean, + Some(&auth), + Path::new("/"), + Some(&approved), + ) + .unwrap_err(); + assert!(err.to_string().contains("plan changed"), "{err}"); + // Only the re-resolution preview ran; the destructive depclean did not. + assert_eq!(runner.recorded().len(), 1, "{:?}", runner.recorded()); } #[test] diff --git a/installer-rs/crates/phoebus-executor/src/chooser.rs b/installer-rs/crates/phoebus-executor/src/chooser.rs index be82a4a..398d3f2 100644 --- a/installer-rs/crates/phoebus-executor/src/chooser.rs +++ b/installer-rs/crates/phoebus-executor/src/chooser.rs @@ -109,6 +109,18 @@ pub fn save_preferences(exec: &Exec, root: &Path, prefs: &Preferences) -> Result save_system_preferences(exec, root, prefs) } +/// Build a command rooted at the intended target: directly for the running +/// root, or inside the target chroot for an alternate root. +fn rooted(root: &Path, stage: &str, operation: &str, program: &str, args: &[&str]) -> CommandSpec { + let owned: Vec = args.iter().map(|s| s.to_string()).collect(); + crate::actions::target_spec(root, stage, operation, program, &owned) +} + +/// Snap acts on the running daemon and cannot be redirected to a target. +fn snap_on_host(root: &Path) -> bool { + root == Path::new("/") +} + /// Read free storage for the filesystem containing `root` using `df -Pk`. fn free_mib(exec: &Exec, root: &Path) -> u64 { let path = if root.exists() { @@ -166,13 +178,10 @@ pub fn hardware_facts(exec: &Exec, root: &Path) -> HardwareFacts { if crate::nix::installed(root) { available_backends.insert(Backend::Nix); } - if crate::exec::find_in_path("flatpak").is_some() { + if crate::exec::tool_in_target(root, "flatpak") { available_backends.insert(Backend::Flatpak); } - if matches!( - crate::snap::status(exec), - Ok(status) if status.usable() - ) { + if snap_on_host(root) && matches!(crate::snap::status(exec), Ok(status) if status.usable()) { available_backends.insert(Backend::Snap); } @@ -283,11 +292,13 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec { let text = resolved.stdout_lossy(); @@ -296,11 +307,20 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec { let out = res.stdout_lossy(); @@ -351,7 +371,7 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec Vec { c.verified = true; @@ -387,7 +406,7 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec Option match backend { Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { - if let Ok(out) = exec.runner.execute( - &CommandSpec::new("sys", "inspect candidate dependencies", "emerge") - .args(["--pretend", "--quiet", "--color=n", "--"]) - .arg(id), - ) { - if out.success { - let plan = phoebus_core::effects::parse_emerge_pretend(&out.stdout_lossy()); - dependencies = plan.effects.into_iter().map(|e| e.target).collect(); + // Declared dependencies come from authoritative metadata: the VDB + // when installed, otherwise `qdepends` (portage-utils). An + // `emerge --pretend` merge plan is deliberately not used, because it + // describes pending merges rather than the dependency graph. + if let Some(record) = crate::portage::installed_packages(root) + .into_iter() + .find(|p| p.atom == id || p.atom.ends_with(&format!("/{id}"))) + { + for text in [&record.depend, &record.rdepend, &record.bdepend] + .into_iter() + .flatten() + { + dependencies.extend( + crate::portage::parse_dependencies(text) + .into_iter() + .map(|d| d.raw), + ); + } + dependencies.sort(); + dependencies.dedup(); + } else if crate::exec::tool_in_target(root, "qdepends") { + if let Ok(out) = exec.runner.execute(&rooted( + root, + "sys", + "inspect candidate dependencies", + "qdepends", + &["-Q", "--", id], + )) { + if out.success { + dependencies = crate::portage::parse_dependencies(&out.stdout_lossy()) + .into_iter() + .map(|d| d.raw) + .collect(); + } } } } Backend::Snap => { - if let Ok(out) = exec.runner.execute( + if !snap_on_host(root) { + // Snap has no alternate-root scope. + } else if let Ok(out) = exec.runner.execute( &CommandSpec::new("sys", "inspect snap candidate", "snap").args([ "info", id, @@ -687,15 +736,14 @@ pub fn resolve_for_backend( match backend { Backend::Flatpak => { - if crate::exec::find_in_path("flatpak").is_some() { - if let Ok(out) = exec.runner.execute( - &CommandSpec::new("sys", "resolve flatpak name", "flatpak").args([ - "search", - "--columns=application,version", - "--", - application, - ]), - ) { + if crate::exec::tool_in_target(root, "flatpak") { + if let Ok(out) = exec.runner.execute(&rooted( + root, + "sys", + "resolve flatpak name", + "flatpak", + &["search", "--columns=application,version", "--", application], + )) { if out.success { let mut matches: Vec<(String, String)> = Vec::new(); for line in out.stdout_lossy().lines() { @@ -738,7 +786,7 @@ pub fn resolve_for_backend( } } Backend::Snap => { - if matches!(crate::snap::status(exec), Ok(s) if s.usable()) { + if snap_on_host(root) && matches!(crate::snap::status(exec), Ok(s) if s.usable()) { if let Ok(out) = exec.runner.execute( &CommandSpec::new("sys", "resolve snap name", "snap").args([ "find", @@ -771,21 +819,32 @@ pub fn resolve_for_backend( } Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { // Portage resolves bare names itself; confirm the atom is real. - if let Ok(out) = exec.runner.execute( - &CommandSpec::new("sys", "resolve portage name", "emerge") - .args(["--pretend", "--quiet", "--color=n", "--"]) - .arg(application), - ) { + if let Ok(out) = exec.runner.execute(&rooted( + root, + "sys", + "resolve portage name", + "emerge", + &["--pretend", "--quiet", "--color=n", "--", application], + )) { if out.success { let (atom, version) = parse_pretend_version(&out.stdout_lossy()) .map(|v| split_atom_version(&v)) .unwrap_or_else(|| (application.to_string(), None)); if backend == Backend::PortageBinary { - let bin_check = exec.runner.execute( - &CommandSpec::new("sys", "check Portage binpkg", "emerge") - .args(["--pretend", "--quiet", "--color=n", "--usepkgonly", "--"]) - .arg(application), - ); + let bin_check = exec.runner.execute(&rooted( + root, + "sys", + "check Portage binpkg", + "emerge", + &[ + "--pretend", + "--quiet", + "--color=n", + "--usepkgonly", + "--", + application, + ], + )); let bin_available = match bin_check { Ok(res) if res.success => { let out = res.stdout_lossy(); @@ -887,10 +946,10 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat let available = facts.backend_available(backend); let detail = match backend { Backend::PortageSource | Backend::PortageVendor => { - if crate::exec::find_in_path("emerge").is_some() { + if crate::exec::tool_in_target(root, "emerge") { "Portage (emerge) is present".into() } else { - "emerge is not in PATH".into() + "emerge is not available in the target".into() } } Backend::PortageBinary => { @@ -908,21 +967,27 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat } } Backend::Flatpak => { - if crate::exec::find_in_path("flatpak").is_some() { - "the flatpak client is present".into() + if crate::exec::tool_in_target(root, "flatpak") { + "the flatpak client is present in the target".into() } else { - "flatpak is not installed".into() + "flatpak is not available in the target".into() + } + } + Backend::Snap => { + if !snap_on_host(root) { + "Snap cannot be inspected for an alternate root".into() + } else { + match crate::snap::status(exec) { + Ok(s) => format!( + "snap client present: {}, daemon active: {}, confinement: {}", + s.client_present, + s.daemon_ready, + s.confinement.as_str() + ), + Err(_) => "snapd state could not be determined".into(), + } } } - Backend::Snap => match crate::snap::status(exec) { - Ok(s) => format!( - "snap client present: {}, daemon active: {}, confinement: {}", - s.client_present, - s.daemon_ready, - s.confinement.as_str() - ), - Err(_) => "snapd state could not be determined".into(), - }, Backend::AppImage => "AppImages can be imported or downloaded locally".into(), Backend::CustomEbuild => { if crate::ebuild::list(root).is_empty() { @@ -939,20 +1004,39 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat } } +/// Whether a lane is covered by an optional source filter. +fn lane_selected(filter: Option, lane: Backend) -> bool { + match filter { + Some(f) => f == lane || (f.is_portage() && lane.is_portage()), + None => true, + } +} + /// Inspect what is already installed for an application across lanes. Never /// invents a copy; every entry comes from a real backend inventory. pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> InstallationInspection { + installed_copies_filtered(exec, root, application, None) +} + +/// Like [`installed_copies`], but an explicit lane filter skips querying every +/// other backend, so a source-constrained request never probes a foreign lane. +pub fn installed_copies_filtered( + exec: &Exec, + root: &Path, + application: &str, + filter: Option, +) -> InstallationInspection { let mut copies = Vec::new(); - // Flatpak. - if crate::exec::find_in_path("flatpak").is_some() { - if let Ok(out) = exec.runner.execute( - &CommandSpec::new("sys", "inspect installed flatpaks", "flatpak").args([ - "list", - "--app", - "--columns=application,name,version", - ]), - ) { + // Flatpak (in the intended target). + if lane_selected(filter, Backend::Flatpak) && crate::exec::tool_in_target(root, "flatpak") { + if let Ok(out) = exec.runner.execute(&rooted( + root, + "sys", + "inspect installed flatpaks", + "flatpak", + &["list", "--app", "--columns=application,name,version"], + )) { if out.success { let app_lower = application.to_ascii_lowercase(); for line in out.stdout_lossy().lines() { @@ -992,45 +1076,51 @@ pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> Installa } } - // Snap. - if let Ok(entries) = crate::snap::list(exec) { - for entry in entries { - if entry.name.eq_ignore_ascii_case(application) { - copies.push(InstalledCopy { - backend: Backend::Snap.as_str().into(), - id: entry.name, - version: entry.version, - }); + // Snap (host only). + if lane_selected(filter, Backend::Snap) && snap_on_host(root) { + if let Ok(entries) = crate::snap::list(exec) { + for entry in entries { + if entry.name.eq_ignore_ascii_case(application) { + copies.push(InstalledCopy { + backend: Backend::Snap.as_str().into(), + id: entry.name, + version: entry.version, + }); + } } } } // AppImage (managed record). - if let Ok(records) = crate::appimage::list(root) { - for record in records { - if record.name.eq_ignore_ascii_case(application) { - copies.push(InstalledCopy { - backend: Backend::AppImage.as_str().into(), - id: record.name, - version: record.version, - }); + if lane_selected(filter, Backend::AppImage) { + if let Ok(records) = crate::appimage::list(root) { + for record in records { + if record.name.eq_ignore_ascii_case(application) { + copies.push(InstalledCopy { + backend: Backend::AppImage.as_str().into(), + id: record.name, + version: record.version, + }); + } } + } else if let Ok(record) = crate::appimage::info(root, application) { + copies.push(InstalledCopy { + backend: Backend::AppImage.as_str().into(), + id: record.name, + version: record.version, + }); } - } else if let Ok(record) = crate::appimage::info(root, application) { - copies.push(InstalledCopy { - backend: Backend::AppImage.as_str().into(), - id: record.name, - version: record.version, - }); } // Portage (VDB). - if let Some((atom, version)) = portage_installed_atom_and_version(root, application) { - copies.push(InstalledCopy { - backend: Backend::PortageSource.as_str().into(), - id: atom, - version, - }); + if lane_selected(filter, Backend::PortageSource) { + if let Some((atom, version)) = portage_installed_atom_and_version(root, application) { + copies.push(InstalledCopy { + backend: Backend::PortageSource.as_str().into(), + id: atom, + version, + }); + } } // De-duplicate any multiple matches within the same backend @@ -1161,11 +1251,13 @@ mod tests { #[test] fn portage_candidate_keeps_a_valid_install_atom() { let runner = RecordingRunner::new(); + // An alternate root runs Portage inside the target chroot; the mock + // runner therefore answers the `chroot` wrapper. runner.set_response( - "emerge", + "chroot", ok("Calculating dependencies... done!\n[ebuild N ] app-misc/hello-2.12.3 USE=\"nls\"\n"), ); - let exec = make_exec(runner); + let exec = make_exec(runner.clone()); let root = tempfile::tempdir().unwrap(); let need = Need::new("app-misc/hello"); let candidates = resolve_candidates(&exec, root.path(), &need); @@ -1177,6 +1269,13 @@ mod tests { assert_eq!(portage.version.as_deref(), Some("2.12.3")); // And the id is a valid package spec that emerge accepts. assert!(phoebus_core::action::valid_package_spec(&portage.id)); + // The query must have been rooted in the target, never the host. + let recorded = runner.recorded(); + let emerge = recorded + .iter() + .find(|s| s.program == "chroot" && s.args.iter().any(|a| a == "emerge")) + .expect("a chrooted emerge"); + assert_eq!(emerge.args[0], root.path().to_string_lossy()); } #[test] @@ -1255,7 +1354,7 @@ mod tests { fn resolve_includes_a_portage_candidate_from_real_metadata() { let runner = RecordingRunner::new(); runner.set_response( - "emerge", + "chroot", ok("Calculating dependencies... done!\n[ebuild N ] app-editors/vim-9.1.0\n"), ); let exec = make_exec(runner); @@ -1270,7 +1369,7 @@ mod tests { #[test] fn unresolved_portage_candidate_is_marked_unavailable() { let runner = RecordingRunner::new(); - runner.fail("emerge", "no such package"); + runner.fail("chroot", "no such package"); let exec = make_exec(runner); let root = tempfile::tempdir().unwrap(); let need = Need::new("not-a-real-package"); @@ -1313,13 +1412,22 @@ mod tests { #[test] fn installed_copies_reports_duplication_and_versions() { + use std::os::unix::fs::PermissionsExt; let runner = RecordingRunner::new(); - runner.set_response("flatpak", ok("org.mozilla.firefox 128\n")); - let exec = make_exec(runner); + runner.set_response("chroot", ok("org.mozilla.firefox\tFirefox\t128\n")); + let exec = make_exec(runner.clone()); let root = tempfile::tempdir().unwrap(); + // A Flatpak present only in the target must be discovered there. + let bin = root.path().join("usr/bin"); + std::fs::create_dir_all(&bin).unwrap(); + let flatpak = bin.join("flatpak"); + std::fs::write(&flatpak, "#!/bin/sh\n").unwrap(); + std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap(); let inspection = installed_copies(&exec, root.path(), "org.mozilla.firefox"); assert_eq!(inspection.copies.len(), 1); assert_eq!(inspection.copies[0].version, "128"); assert!(!inspection.duplicate); + // The target Flatpak, not the host's, was queried. + assert_eq!(runner.recorded()[0].program, "chroot"); } } diff --git a/installer-rs/crates/phoebus-executor/src/exec.rs b/installer-rs/crates/phoebus-executor/src/exec.rs index d7a0501..2ffc447 100644 --- a/installer-rs/crates/phoebus-executor/src/exec.rs +++ b/installer-rs/crates/phoebus-executor/src/exec.rs @@ -181,6 +181,28 @@ impl Exec { } } +/// Whether a tool is present in the intended target. +/// +/// For the running root this is the host `PATH`. For an alternate root a query +/// runs inside the target chroot, so availability must be resolved from the +/// target's own binary directories rather than the host's, where a host tool +/// would otherwise leak into (or bypass) target operations. +pub fn tool_in_target(root: &Path, program: &str) -> bool { + if program.contains('/') { + let candidate = root.join(program.trim_start_matches('/')); + return is_executable(&candidate); + } + if root == Path::new("/") { + return find_in_path(program).is_some(); + } + for dir in ["usr/bin", "usr/sbin", "usr/local/bin", "bin", "sbin"] { + if is_executable(&root.join(dir).join(program)) { + return true; + } + } + false +} + pub fn find_in_path(program: &str) -> Option { if program.contains('/') { let p = PathBuf::from(program); diff --git a/installer-rs/crates/phoebus-executor/src/install.rs b/installer-rs/crates/phoebus-executor/src/install.rs index dbfc0f6..9897a87 100644 --- a/installer-rs/crates/phoebus-executor/src/install.rs +++ b/installer-rs/crates/phoebus-executor/src/install.rs @@ -903,13 +903,19 @@ mod tests { #[test] fn validation_detects_an_ambiguous_friendly_name() { + use std::os::unix::fs::PermissionsExt; let runner = RecordingRunner::new(); runner.set_response( - "flatpak", + "chroot", ok("org.mozilla.firefox 128 stable\norg.mozilla.firefoxpwa 1.0 stable\n"), ); let exec = make_exec(runner); let root = tempfile::tempdir().unwrap(); + let bin = root.path().join("usr/bin"); + std::fs::create_dir_all(&bin).unwrap(); + let flatpak = bin.join("flatpak"); + std::fs::write(&flatpak, "#!/bin/sh\n").unwrap(); + std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap(); let request = InstallRequest::new("firefox"); let proposal = InstallProposal { application: "firefox".into(), @@ -972,23 +978,33 @@ mod tests { duration: Duration::from_millis(1), }; let version = self.version.load(std::sync::atomic::Ordering::SeqCst); - match spec.program.as_str() { - "flatpak" if spec.args.iter().any(|a| a == "search") => { - Ok(ok(format!("org.mozilla.firefox {version}\n"))) - } - "flatpak" if spec.args.iter().any(|a| a == "list") => Ok(ok(if self.installed { + let is_flatpak = spec.program == "flatpak" || spec.args.iter().any(|a| a == "flatpak"); + let is_emerge = spec.program == "emerge" || spec.args.iter().any(|a| a == "emerge"); + if is_flatpak && spec.args.iter().any(|a| a == "search") { + Ok(ok(format!("org.mozilla.firefox {version}\n"))) + } else if is_flatpak && spec.args.iter().any(|a| a == "list") { + Ok(ok(if self.installed { format!("org.mozilla.firefox {version}\n") } else { String::new() - })), - "emerge" => Ok(fail()), - _ => Ok(ok(String::new())), + })) + } else if is_emerge { + Ok(fail()) + } else { + Ok(ok(String::new())) } } } fn arg_exec(version: std::sync::Arc, installed: bool) -> Exec { + use std::os::unix::fs::PermissionsExt; let path = tempfile::tempdir().unwrap().keep(); + // A Flatpak must be present in the *target* for the lane to resolve. + let bin = path.join("root/usr/bin"); + std::fs::create_dir_all(&bin).unwrap(); + let flatpak = bin.join("flatpak"); + std::fs::write(&flatpak, "#!/bin/sh\n").unwrap(); + std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap(); let logger = Logger::open(path.join("l.log"), Redactor::new(), false); Exec::new( Box::new(ArgRunner::new(version, installed)), @@ -1044,19 +1060,12 @@ mod tests { fn ai_unqualified_install_is_confirmed_by_the_resolver() { let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128)); let exec = arg_exec(version, false); - let root = tempfile::tempdir().unwrap(); + let root = Path::new(&exec.root); let request = InstallRequest::new("firefox"); let transport = phoebus_ai::provider::ScriptedTransport::new(vec![proposal("org.mozilla.firefox")]); - let resolved = resolve_with_ai( - &exec, - root.path(), - &request, - &NoAsk, - &ai(&transport), - &facts(), - ) - .unwrap(); + let resolved = + resolve_with_ai(&exec, root, &request, &NoAsk, &ai(&transport), &facts()).unwrap(); assert_eq!(resolved.candidate.id, "org.mozilla.firefox"); assert_eq!(resolved.source, InstallSource::AiRecommendation); assert!(matches!( @@ -1069,21 +1078,14 @@ mod tests { fn a_fabricated_candidate_is_rejected_and_the_model_revises() { let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128)); let exec = arg_exec(version, false); - let root = tempfile::tempdir().unwrap(); + let root = Path::new(&exec.root); let request = InstallRequest::new("firefox"); let transport = phoebus_ai::provider::ScriptedTransport::new(vec![ proposal("org.evil.Firefox"), proposal("org.mozilla.firefox"), ]); - let resolved = resolve_with_ai( - &exec, - root.path(), - &request, - &NoAsk, - &ai(&transport), - &facts(), - ) - .unwrap(); + let resolved = + resolve_with_ai(&exec, root, &request, &NoAsk, &ai(&transport), &facts()).unwrap(); assert_eq!(resolved.candidate.id, "org.mozilla.firefox"); // The second request carries the resolver's finding. assert!(transport.requests()[1].contains("no available")); @@ -1093,19 +1095,19 @@ mod tests { fn a_changed_candidate_version_invalidates_the_review() { let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128)); let exec = arg_exec(version.clone(), false); - let root = tempfile::tempdir().unwrap(); + let root = Path::new(&exec.root); let mut request = InstallRequest::new("firefox"); request.backend = Some(Backend::Flatpak); - let resolved = resolve_explicit(&exec, root.path(), &request).unwrap(); + let resolved = resolve_explicit(&exec, root, &request).unwrap(); assert_eq!(resolved.candidate.version.as_deref(), Some("128")); // Same metadata -> the reviewed digest revalidates. assert_eq!( - revalidate(&exec, root.path(), &resolved).unwrap(), + revalidate(&exec, root, &resolved).unwrap(), resolved.approval_digest() ); // The remote publishes a new version: the approval is invalidated. version.store(129, std::sync::atomic::Ordering::SeqCst); - let err = revalidate(&exec, root.path(), &resolved).unwrap_err(); + let err = revalidate(&exec, root, &resolved).unwrap_err(); assert!(err.to_string().contains("version changed"), "{err}"); } @@ -1113,10 +1115,10 @@ mod tests { fn an_already_installed_app_in_the_same_lane_is_not_reinstalled() { let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128)); let exec = arg_exec(version, true); - let root = tempfile::tempdir().unwrap(); + let root = Path::new(&exec.root); let mut request = InstallRequest::new("org.mozilla.firefox"); request.backend = Some(Backend::Flatpak); - let err = resolve_explicit(&exec, root.path(), &request).unwrap_err(); + let err = resolve_explicit(&exec, root, &request).unwrap_err(); assert!(err.to_string().contains("already installed"), "{err}"); } diff --git a/installer-rs/crates/phoebus-executor/src/nix.rs b/installer-rs/crates/phoebus-executor/src/nix.rs index d9f9b27..0323426 100644 --- a/installer-rs/crates/phoebus-executor/src/nix.rs +++ b/installer-rs/crates/phoebus-executor/src/nix.rs @@ -304,6 +304,242 @@ pub fn profiles(root: &Path) -> Vec { out } +/// One package installed in an active Nix profile. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct NixInstalledPackage { + /// The nixpkgs attribute path when the manifest records one (e.g. + /// `legacyPackages.x86_64-linux.nodejs`), otherwise the store name. + pub path: String, + /// The package identity (the last attribute component, or the store name). + pub name: String, + pub version: Option, + pub store_path: String, + /// Human label for the profile: `default`, `profile`, or `per-user:`. + pub profile: String, + pub user: Option, +} + +/// The result of reading active Nix profiles. `notes` records unsupported +/// profile formats and base profiles so an incomplete enumeration is never +/// presented as complete. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct NixProfileInventory { + pub packages: Vec, + pub notes: Vec, +} + +/// The active (current-generation) profile links in the target. +/// +/// Only the `default` and `profile` links are current: the historical +/// `profile-N-link` generations are deliberately not counted as installed +/// packages. +fn active_profile_links(root: &Path) -> Vec<(String, Option, PathBuf)> { + let base = target_path(root, "nix/var/nix/profiles"); + let mut out = Vec::new(); + for name in ["default", "profile"] { + let path = base.join(name); + if path.symlink_metadata().is_ok() { + out.push((name.to_string(), None, path)); + } + } + let per_user = base.join("per-user"); + if let Ok(users) = std::fs::read_dir(&per_user) { + for user in users.flatten() { + if !user.file_type().map(|t| t.is_dir()).unwrap_or(false) { + continue; + } + let user_name = user.file_name().to_string_lossy().to_string(); + let path = user.path().join("profile"); + if path.symlink_metadata().is_ok() { + out.push((format!("per-user:{user_name}"), Some(user_name), path)); + } + } + } + out.sort_by(|a, b| a.0.cmp(&b.0)); + out +} + +/// Extract `(name, version)` from a store basename like +/// `abc123-nodejs-22.11.0` or `abc123-nodejs`. +fn store_name_parts(basename: &str) -> (String, Option) { + let rest = basename + .split_once('-') + .map(|(_, rest)| rest) + .unwrap_or(basename) + .to_string(); + let Some(idx) = rest + .char_indices() + .filter(|(i, c)| *c == '-' && rest[i + 1..].starts_with(|d: char| d.is_ascii_digit())) + .map(|(i, _)| i) + .next_back() + else { + return (rest, None); + }; + let (name, version) = rest.split_at(idx); + ( + name.to_string(), + Some(version.trim_start_matches('-').to_string()), + ) +} + +/// Parse a `nix profile` `manifest.json`. Returns an error string for an +/// unsupported/undecodable format so the caller can say so explicitly. +pub fn parse_manifest( + profile: &str, + user: Option<&str>, + text: &str, +) -> std::result::Result, String> { + let value: serde_json::Value = + serde_json::from_str(text).map_err(|e| format!("manifest is not JSON: {e}"))?; + let version = value.get("version").and_then(|v| v.as_u64()); + let Some(elements) = value.get("elements") else { + return Err("manifest has no `elements`".to_string()); + }; + let mut out = Vec::new(); + let mut push = |element: &serde_json::Value| { + if element.get("active").and_then(|v| v.as_bool()) == Some(false) { + return; + } + let attr = element + .get("attrPath") + .and_then(|v| v.as_str()) + .map(str::to_string); + let store_paths: Vec = element + .get("storePaths") + .and_then(|v| v.as_array()) + .map(|a| { + a.iter() + .filter_map(|v| v.as_str()) + .map(str::to_string) + .collect() + }) + .or_else(|| { + element + .get("storePath") + .and_then(|v| v.as_str()) + .map(|s| vec![s.to_string()]) + }) + .unwrap_or_default(); + let store_path = store_paths.first().cloned().unwrap_or_default(); + let basename = store_path.rsplit('/').next().unwrap_or("").to_string(); + let (store_name, version) = store_name_parts(&basename); + let name = attr + .as_deref() + .and_then(|a| a.rsplit('.').next()) + .map(str::to_string) + .filter(|n| !n.is_empty()) + .unwrap_or_else(|| store_name.clone()); + let path = attr.unwrap_or_else(|| name.clone()); + out.push(NixInstalledPackage { + path, + name, + version, + store_path, + profile: profile.to_string(), + user: user.map(str::to_string), + }); + }; + match elements { + serde_json::Value::Array(items) => { + for element in items { + push(element); + } + } + serde_json::Value::Object(map) => { + for element in map.values() { + push(element); + } + } + _ => { + return Err(format!( + "unsupported manifest element container (version {})", + version.map(|v| v.to_string()).unwrap_or_else(|| "?".into()) + )) + } + } + if out.is_empty() && version.is_some_and(|v| v > 3) { + return Err(format!( + "manifest version {} is newer than supported", + version.unwrap() + )); + } + Ok(out) +} + +/// Enumerate the packages installed in the active Nix profiles of the target. +/// +/// Historical generations and bare store paths are not packages: generations +/// are noted, and `store_path_count` reports realised store contents +/// separately. A profile whose manifest is missing or an unsupported format is +/// reported in `notes` rather than silently omitted. +pub fn installed_packages(root: &Path) -> NixProfileInventory { + let mut inventory = NixProfileInventory::default(); + for (label, user, link) in active_profile_links(root) { + let Ok(resolved) = std::fs::canonicalize(&link) else { + inventory.notes.push(format!( + "profile `{label}` is a dangling link; not enumerated" + )); + continue; + }; + let resolved = resolved.to_string_lossy().to_string(); + // Never follow a profile outside the target. + if !resolved.starts_with(&root.to_string_lossy().to_string()) { + inventory.notes.push(format!( + "profile `{label}` resolves outside the target; not enumerated" + )); + continue; + } + let manifest = Path::new(&resolved).join("manifest.json"); + match std::fs::read_to_string(&manifest) { + Ok(text) => match parse_manifest(&label, user.as_deref(), &text) { + Ok(mut packages) => inventory.packages.append(&mut packages), + Err(e) => inventory.notes.push(format!( + "profile `{label}` uses an unsupported manifest format ({e}); not enumerated" + )), + }, + Err(_) => inventory.notes.push(format!( + "profile `{label}` has no package manifest (base/system profile); \ + its packages are not listed" + )), + } + } + // Historical generations are explicitly not current packages. + let generations = historical_generation_count(root); + if generations > 0 { + inventory.notes.push(format!( + "{generations} historical profile generation(s) exist and are not counted as \ + installed packages" + )); + } + inventory + .packages + .sort_by(|a, b| a.name.cmp(&b.name).then(a.profile.cmp(&b.profile))); + inventory +} + +fn historical_generation_count(root: &Path) -> usize { + let base = target_path(root, "nix/var/nix/profiles"); + let mut count = 0; + let mut visit = |dir: &Path| { + if let Ok(entries) = std::fs::read_dir(dir) { + for entry in entries.flatten() { + let name = entry.file_name().to_string_lossy().to_string(); + if name.starts_with("profile-") && name.ends_with("-link") { + count += 1; + } + } + } + }; + visit(&base); + let per_user = base.join("per-user"); + if let Ok(users) = std::fs::read_dir(&per_user) { + for user in users.flatten() { + visit(&user.path()); + } + } + count +} + /// Number of realised store paths, if the store exists. `None` means the store /// is absent (Nix is not installed). pub fn store_path_count(root: &Path) -> Option { @@ -467,6 +703,105 @@ mod tests { assert!(!valid_nix_attribute("a b")); } + fn profile_manifest_v3() -> &'static str { + r#"{ + "version": 3, + "elements": [ + { + "active": true, + "attrPath": "legacyPackages.x86_64-linux.nodejs", + "storePaths": ["/nix/store/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-nodejs-22.11.0"], + "originalUrl": "flake:nixpkgs" + }, + { + "active": false, + "attrPath": "legacyPackages.x86_64-linux.gcc", + "storePaths": ["/nix/store/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb-gcc-13.2.0"] + } + ] +}"# + } + + #[test] + fn installed_packages_enumerates_supported_profiles_and_skips_inactive() { + let runner = RecordingRunner::new(); + let exec = make_exec(runner, false); + let root = Path::new(&exec.root); + let store = root.join("nix/store/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-nodejs-22.11.0"); + std::fs::create_dir_all(&store).unwrap(); + std::fs::write(store.join("manifest.json"), profile_manifest_v3()).unwrap(); + let profiles = root.join("nix/var/nix/profiles"); + std::fs::create_dir_all(&profiles).unwrap(); + std::os::unix::fs::symlink(&store, profiles.join("default")).unwrap(); + // A historical generation must not be counted as current. + std::os::unix::fs::symlink(&store, profiles.join("profile-1-link")).unwrap(); + + let inventory = installed_packages(root); + assert_eq!(inventory.packages.len(), 1, "{:?}", inventory); + let pkg = &inventory.packages[0]; + assert_eq!(pkg.name, "nodejs"); + assert_eq!(pkg.version.as_deref(), Some("22.11.0")); + assert_eq!(pkg.profile, "default"); + assert!(pkg.path.contains("nodejs")); + assert!(inventory + .notes + .iter() + .any(|n| n.contains("historical profile generation"))); + } + + #[test] + fn installed_packages_reports_unsupported_manifest_formats_explicitly() { + let runner = RecordingRunner::new(); + let exec = make_exec(runner, false); + let root = Path::new(&exec.root); + let store = root.join("nix/store/cccccccccccccccccccccccccccccccc-future-1.0"); + std::fs::create_dir_all(&store).unwrap(); + std::fs::write( + store.join("manifest.json"), + r#"{"version": 99, "elements": []}"#, + ) + .unwrap(); + let profiles = root.join("nix/var/nix/profiles"); + std::fs::create_dir_all(&profiles).unwrap(); + std::os::unix::fs::symlink(&store, profiles.join("profile")).unwrap(); + + let inventory = installed_packages(root); + assert!(inventory.packages.is_empty()); + assert!( + inventory + .notes + .iter() + .any(|n| n.contains("newer than supported")), + "{:?}", + inventory.notes + ); + // A profile with no manifest is a base profile, reported distinctly. + std::fs::create_dir_all(root.join("nix/var/nix/profiles")).unwrap(); + std::os::unix::fs::symlink(root.join("nix/store"), profiles.join("default")).unwrap(); + let second = installed_packages(root); + assert!( + second + .notes + .iter() + .any(|n| n.contains("no package manifest")), + "{:?}", + second.notes + ); + } + + #[test] + fn parse_manifest_v1_store_path_is_supported() { + let text = r#"{ + "version": 1, + "elements": [ + {"active": true, "uri": "nixpkgs", "storePath": "/nix/store/dddd-vim-9.1.0"} + ] +}"#; + let parsed = parse_manifest("default", None, text).unwrap(); + assert_eq!(parsed.len(), 1); + assert_eq!(parsed[0].name, "vim"); + } + #[test] fn remove_unlinks_units_and_optionally_purges() { let runner = RecordingRunner::new(); diff --git a/installer-rs/crates/phoebus-executor/src/portage.rs b/installer-rs/crates/phoebus-executor/src/portage.rs index 34b9407..50dde0c 100644 --- a/installer-rs/crates/phoebus-executor/src/portage.rs +++ b/installer-rs/crates/phoebus-executor/src/portage.rs @@ -466,6 +466,7 @@ pub struct InstalledPortage { pub repository: Option, pub depend: Option, pub rdepend: Option, + pub bdepend: Option, } /// Split `category/pkgname-1.2.3-r1` into `(category/pkgname, "1.2.3-r1")`. @@ -532,6 +533,7 @@ pub fn installed_packages(root: &Path) -> Vec { repository: read_vdb_field(&dir, "repository"), depend: read_vdb_field(&dir, "DEPEND"), rdepend: read_vdb_field(&dir, "RDEPEND"), + bdepend: read_vdb_field(&dir, "BDEPEND"), }); } } @@ -602,6 +604,108 @@ fn nonempty(value: &str) -> Option { } } +/// One declared dependency, preserving its version/conditional context. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DeclaredDependency { + /// The raw token, e.g. `>=dev-libs/glib-2.0` or `cat/pkg:1`. + pub raw: String, + /// The package atom with operators, version, slot and USE stripped. + pub atom: String, + /// The USE flag/group this dependency is conditional on, if any. + pub condition: Option, + /// A blocker (`!cat/pkg`). + pub negative: bool, +} + +/// Tokenize a dependency string, keeping parentheses as separate tokens. +fn tokenize_depends(text: &str) -> Vec { + let mut tokens = Vec::new(); + let mut current = String::new(); + for c in text.chars() { + match c { + '(' | ')' => { + if !current.is_empty() { + tokens.push(std::mem::take(&mut current)); + } + tokens.push(c.to_string()); + } + c if c.is_whitespace() => { + if !current.is_empty() { + tokens.push(std::mem::take(&mut current)); + } + } + c => current.push(c), + } + } + if !current.is_empty() { + tokens.push(current); + } + tokens +} + +/// Normalize a dependency token to a bare `category/name` atom. +pub fn normalize_dep_atom(token: &str) -> String { + let mut t = token.trim_start_matches(['!', '?']).to_string(); + // USE dependency / slot / version: keep only `category/name`. + if let Some(idx) = t.find('[') { + t.truncate(idx); + } + if let Some(idx) = t.find(':') { + t.truncate(idx); + } + for op in ["~", ">=", "<=", "=", ">", "<"] { + t = t.trim_start_matches(op).to_string(); + } + if let Some((atom, _)) = split_pkgver(&t) { + atom + } else { + t + } +} + +/// Parse a declared dependency string into atoms, preserving conditionals and +/// version operators. Dependencies inside a USE-conditional or any-of group +/// keep that context so the report is honest about when they apply. +pub fn parse_dependencies(text: &str) -> Vec { + let mut out = Vec::new(); + let mut conditions: Vec = Vec::new(); + let mut pending: Option = None; + for token in tokenize_depends(text) { + match token.as_str() { + "(" => { + let context = pending.take().unwrap_or_else(|| "group".to_string()); + conditions.push(context); + } + ")" => { + conditions.pop(); + } + "||" => { + pending = Some("any-of".to_string()); + } + "??" => { + pending = Some("any-of".to_string()); + } + t if t.ends_with('?') => { + pending = Some(format!("{}?", t.trim_end_matches('?'))); + } + t if t.contains('/') => { + let negative = t.starts_with('!'); + let atom = normalize_dep_atom(t); + if atom.contains('/') { + out.push(DeclaredDependency { + raw: t.to_string(), + atom, + condition: conditions.last().cloned(), + negative, + }); + } + } + _ => {} + } + } + out +} + #[cfg(test)] mod tests { use super::*; @@ -799,6 +903,30 @@ mod tests { assert!(installed_packages(Path::new(&exec.root)).is_empty()); } + #[test] + fn dependency_parser_preserves_conditions_versions_and_blockers() { + let deps = parse_dependencies( + ">=dev-libs/glib-2.0 python? ( dev-lang/python ) !app-misc/old || ( a/b c/d )", + ); + let by_atom = |atom: &str| { + deps.iter() + .find(|d| d.atom == atom) + .unwrap_or_else(|| panic!("missing {atom} in {deps:?}")) + }; + assert_eq!(by_atom("dev-libs/glib").raw, ">=dev-libs/glib-2.0"); + assert_eq!( + by_atom("dev-lang/python").condition.as_deref(), + Some("python?") + ); + assert!(by_atom("app-misc/old").negative); + assert_eq!(by_atom("a/b").condition.as_deref(), Some("any-of")); + // self-atom normalization strips operators, slot and USE. + assert_eq!( + normalize_dep_atom(">=dev-lang/python-3.12:3.12[ssl]"), + "dev-lang/python" + ); + } + #[test] fn normalize_config_permissions_makes_read_only_queries_possible() { use std::os::unix::fs::PermissionsExt; diff --git a/installer-rs/crates/phoebus-executor/src/query.rs b/installer-rs/crates/phoebus-executor/src/query.rs index cb1cf1f..5cc4db1 100644 --- a/installer-rs/crates/phoebus-executor/src/query.rs +++ b/installer-rs/crates/phoebus-executor/src/query.rs @@ -89,11 +89,19 @@ fn stderr_tail(text: &str) -> String { } } -/// Whether the Flatpak client answers in the target. -fn flatpak_available(exec: &Exec, root: &Path) -> bool { +/// Whether the Flatpak client answers in the intended target. For an alternate +/// root the check runs inside the target chroot, never against the host. +pub(crate) fn flatpak_available(exec: &Exec, root: &Path) -> bool { matches!(capture(exec, root, "flatpak", &["--version"]), Ok(o) if o.success) } +/// Snap operations act on the running daemon and cannot be redirected into an +/// alternate root. Availability must therefore refer to the running system; +/// pretending a target lane is usable would mutate the host. +fn snap_target_usable(exec: &Exec, root: &Path) -> bool { + crate::actions::is_host_root(root) && matches!(snap::status(exec), Ok(s) if s.usable()) +} + // --------------------------------------------------------------------------- // Search // --------------------------------------------------------------------------- @@ -244,8 +252,13 @@ fn search_flatpak(exec: &Exec, root: &Path, query: &str, backend: Backend) -> So } fn search_snap(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport { - let usable = matches!(snap::status(exec), Ok(s) if s.usable()); - if !usable { + if !crate::actions::is_host_root(root) { + return SourceReport::unsupported( + backend, + "Snap cannot be queried for an alternate root; it acts on the running daemon", + ); + } + if !snap_target_usable(exec, root) { return SourceReport::unsupported(backend, "snapd is not installed or active"); } let out = match capture(exec, root, "snap", &["find", query, "--color=never"]) { @@ -454,9 +467,14 @@ fn inventory_flatpak(exec: &Exec, root: &Path, backend: Backend) -> SourceReport SourceReport::ok(backend, "installed Flatpak applications", entries) } -fn inventory_snap(exec: &Exec, _root: &Path, backend: Backend) -> SourceReport { - let usable = matches!(snap::status(exec), Ok(s) if s.usable()); - if !usable { +fn inventory_snap(exec: &Exec, root: &Path, backend: Backend) -> SourceReport { + if !crate::actions::is_host_root(root) { + return SourceReport::unsupported( + backend, + "Snap cannot be inspected for an alternate root; it acts on the running daemon", + ); + } + if !snap_target_usable(exec, root) { return SourceReport::unsupported(backend, "snapd is not installed or active"); } match snap::list(exec) { @@ -498,23 +516,29 @@ fn inventory_nix(root: &Path, backend: Backend) -> SourceReport { let Some(store_paths) = nix::store_path_count(root) else { return SourceReport::unsupported(backend, "Nix is not installed"); }; - let profiles = nix::profiles(root); - let entries = profiles + let inventory = nix::installed_packages(root); + let entries = inventory + .packages .into_iter() .map(|p| { - let mut entry = CatalogEntry::new(backend, p.name) - .scope("profile") + let mut entry = CatalogEntry::new(backend, p.path) + .scope(p.profile) .installed(true); - if !p.target.is_empty() { - entry = entry.description(p.target); + if let Some(version) = p.version { + entry = entry.version(version); } + entry = entry.description(format!("Nix package `{}` ({})", p.name, p.store_path)); entry }) .collect(); - let note = format!( - "{store_paths} store path(s) realised but not installed profiles; \ - Nix is a per-project/developer lane, so store contents are not listed as packages" + let mut note = format!( + "active Nix profiles; {store_paths} additional store path(s) are realised \ + dependencies, not installed packages" ); + for additional in inventory.notes { + note.push_str("; "); + note.push_str(&additional); + } SourceReport::ok(backend, note, entries) } @@ -531,8 +555,14 @@ pub fn package_info( filter: Option, ) -> PackageInfoReport { let lanes = selected_lanes(filter); - let installed = chooser::installed_copies(exec, root, package); - let installed_portage = portage::installed_packages(root); + // The filter is applied before any backend is queried, so a + // source-constrained request never probes (or reports) another lane. + let installed = chooser::installed_copies_filtered(exec, root, package, filter); + let installed_portage = if filter.map(is_portage).unwrap_or(true) { + portage::installed_packages(root) + } else { + Vec::new() + }; let mut matches: Vec = Vec::new(); let mut notes: Vec = Vec::new(); @@ -705,8 +735,9 @@ fn split_depend(value: &str) -> Vec { /// Which installed package owns a file path (Portage). pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result { - // Prefer `qfile` (portage-utils), then `equery belongs` (gentoolkit). - if crate::exec::find_in_path("qfile").is_some() { + // Prefer `qfile` (portage-utils), then `equery belongs` (gentoolkit). The + // tool must be present in the intended target, not merely on the host. + if crate::exec::tool_in_target(root, "qfile") { let out = capture(exec, root, "qfile", &[path])?; if !out.success { return Ok(format!("no installed package owns {path}")); @@ -716,7 +747,7 @@ pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result { out.stdout_lossy().trim() )); } - if crate::exec::find_in_path("equery").is_some() { + if crate::exec::tool_in_target(root, "equery") { let out = capture(exec, root, "equery", &["belongs", path])?; if !out.success { return Ok(format!("no installed package owns {path}")); @@ -734,53 +765,142 @@ pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result { )) } +/// The declared dependency fields of an installed VDB record. +fn declared_dependencies(record: &portage::InstalledPortage) -> Vec { + let mut deps = Vec::new(); + for text in [&record.depend, &record.rdepend, &record.bdepend] + .into_iter() + .flatten() + { + deps.extend(portage::parse_dependencies(text)); + } + deps +} + +/// Whether `atom` (a `category/name`) matches a requested package (bare name, +/// full atom, or atom-with-version). +fn atom_matches(atom: &str, package: &str) -> bool { + let wanted = portage::normalize_dep_atom(package); + atom == wanted + || wanted.ends_with(&format!("/{package}")) + || atom.ends_with(&format!("/{package}")) +} + /// Forward or reverse dependencies of an installed Portage package. +/// +/// Dependencies come from the authoritative installed metadata (the VDB +/// `DEPEND`/`RDEPEND`/`BDEPEND` fields), so already-satisfied dependencies are +/// included and conditional/versioned dependencies keep their context. An +/// install plan from `emerge --pretend` is deliberately not used: it describes +/// pending merges, not the full dependency graph. For a package that is not +/// installed, `qdepends` (portage-utils) is used when present, else the query is +/// refused with a clear limitation rather than guessing. pub fn package_dependencies( exec: &Exec, root: &Path, package: &str, reverse: bool, ) -> Result { - if reverse { - if crate::exec::find_in_path("equery").is_none() { - return Err(ExecError::operation( - "sys", - "reverse dependencies", - "reverse-dependency inspection requires app-portage/gentoolkit (equery depends)", - )); - } - let out = capture(exec, root, "equery", &["depends", package])?; - if !out.success { - return Ok(format!("no installed package depends on {package}")); - } - return Ok(out.stdout_lossy().trim().to_string()); - } + let installed = portage::installed_packages(root); + let installed_atoms: std::collections::BTreeSet = + installed.iter().map(|p| p.atom.clone()).collect(); + let self_atom = installed + .iter() + .find(|p| atom_matches(&p.atom, package)) + .map(|p| p.atom.clone()); - match capture( - exec, - root, - "emerge", - &["--pretend", "--quiet", "--color=n", "--", package], - ) { - Ok(out) if out.success => { - let plan = phoebus_core::effects::parse_emerge_pretend(&out.stdout_lossy()); - let deps: Vec = plan.effects.iter().map(|e| e.target.clone()).collect(); - if deps.is_empty() { - Ok(format!("{package} has no resolved dependencies")) - } else { - Ok(format!("{package} depends on:\n {}", deps.join("\n "))) + let mut lines: Vec = Vec::new(); + if reverse { + for record in &installed { + for dep in declared_dependencies(record) { + if atom_matches(&dep.atom, package) && Some(&dep.atom) != self_atom.as_ref() { + let conditional = dep + .condition + .as_deref() + .map(|c| format!("[{c}] ")) + .unwrap_or_default(); + lines.push(format!("{conditional}{} (from {})", dep.raw, record.atom)); + } } } - Ok(out) => Ok(format!( - "could not resolve dependencies for {package}: {}", - stderr_tail(&out.stderr_lossy()) - )), - Err(e) => Err(ExecError::operation( - "sys", - "dependencies", - format!("could not resolve dependencies for {package}: {e}"), - )), + lines.sort(); + lines.dedup(); + if lines.is_empty() { + return Ok(format!( + "no installed package depends on {package}\n (installed metadata is authoritative \ + for reverse dependencies; nothing references it)" + )); + } + return Ok(format!( + "installed packages depending on {package}:\n {}", + lines.join("\n ") + )); } + + // Forward: prefer the installed metadata; fall back to the tree via + // qdepends only when the package is not installed. + let deps: Vec<(String, Option, bool)> = + if let Some(record) = installed.iter().find(|p| atom_matches(&p.atom, package)) { + declared_dependencies(record) + .into_iter() + .filter(|d| Some(&d.atom) != self_atom.as_ref()) + .map(|d| (d.raw, d.condition, d.negative)) + .collect() + } else if crate::exec::tool_in_target(root, "qdepends") { + let out = capture(exec, root, "qdepends", &["-Q", "--", package])?; + if !out.success { + return Err(ExecError::operation( + "sys", + "dependencies", + format!( + "qdepends could not resolve dependencies for {package}: {}", + stderr_tail(&out.stderr_lossy()) + ), + )); + } + portage::parse_dependencies(&out.stdout_lossy()) + .into_iter() + .map(|d| (d.raw, d.condition, d.negative)) + .collect() + } else { + return Err(ExecError::operation( + "sys", + "dependencies", + format!( + "{package} is not installed, and no dependency inspection tool is available; \ + install app-portage/portage-utils (qdepends) or inspect it through Portage" + ), + )); + }; + + if deps.is_empty() { + return Ok(format!( + "{package} has no declared dependencies in the installed metadata" + )); + } + let mut rendered = Vec::new(); + for (raw, condition, negative) in deps { + let atom = portage::normalize_dep_atom(&raw); + let satisfied = if negative { + "blocker" + } else if installed_atoms.contains(&atom) { + "installed" + } else { + "not installed" + }; + let conditional = condition + .as_deref() + .map(|c| format!("[{c}] ")) + .unwrap_or_default(); + rendered.push(format!("{conditional}{raw} ({satisfied})")); + } + rendered.sort(); + rendered.dedup(); + Ok(format!( + "{package} declares {} dependency token(s):\n {}", + rendered.len(), + rendered.join("\n ") + )) } /// Remove packages no longer required by any installed package (Portage). @@ -825,6 +945,11 @@ pub fn depclean(exec: &Exec, root: &Path) -> Result { /// Remove unreferenced package caches / store paths. Never removes an /// installed package. +/// +/// Every cleaner's outcome is preserved: a cleaner that ran and failed makes +/// the whole action fail (with the partial successes still reported), and a +/// missing cleaner is distinguished from one that ran and found nothing. A +/// cleanup that could not run at all is a failure, not a silent success. pub fn clean_cache(exec: &Exec, root: &Path, filter: Option) -> Result { let lanes: Vec = match filter { Some(backend) => vec![backend], @@ -832,139 +957,307 @@ pub fn clean_cache(exec: &Exec, root: &Path, filter: Option) -> Result< }; let mut report = String::new(); report.push_str("cache cleanup (installed packages are never removed)\n"); + let mut completed = 0usize; + let mut failed = false; + for lane in lanes { - match lane { - Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { - report.push_str(&clean_portage_cache(exec, root)); - } - Backend::Nix => { - if !nix::installed(root) { - report.push_str(" [nix] unavailable: Nix is not installed\n"); - } else { - nix::gc(exec, root)?; - report - .push_str(" [nix] unreferenced store paths collected (nix-store --gc)\n"); + if lane.is_portage() { + let mut attempted = false; + for (cleaner, _, destructive_args) in crate::actions::portage_cleaners(root) { + attempted = true; + match run_mut( + exec, + root, + cleaner, + &destructive_args + .iter() + .map(|s| s.as_str()) + .collect::>(), + ) { + Ok(()) => { + completed += 1; + report.push_str(&format!(" [portage] {cleaner} completed\n")); + } + Err(e) => { + failed = true; + report.push_str(&format!(" [portage] {cleaner} failed: {e}\n")); + } } } - other => report.push_str(&format!( - " [{}] unsupported: this lane has no package cache to clean\n", - other.as_str() - )), + if !attempted { + report.push_str( + " [portage] unavailable: no cleaner in the target (install \ + app-portage/gentoolkit for eclean-dist / eclean-pkg)\n", + ); + } + } else if lane == Backend::Nix { + if !nix::installed(root) { + report.push_str(" [nix] unavailable: Nix is not installed\n"); + } else { + match nix::gc(exec, root) { + Ok(()) => { + completed += 1; + report.push_str( + " [nix] unreferenced store paths collected (nix-store --gc)\n", + ); + } + Err(e) => { + failed = true; + report.push_str(&format!(" [nix] cleanup failed: {e}\n")); + } + } + } + } else { + return Err(ExecError::operation( + "sys", + "clean cache", + format!( + "the {} lane has no package cache to clean; refusing", + lane.as_str() + ), + )); } } + + if failed { + return Err(ExecError::operation("sys", "clean cache", report)); + } + if completed == 0 { + return Err(ExecError::operation( + "sys", + "clean cache", + format!("{report}no cleaner ran"), + )); + } Ok(report) } -fn clean_portage_cache(exec: &Exec, root: &Path) -> String { - let mut out = String::new(); - let mut cleaned = false; - if crate::exec::find_in_path("eclean-dist").is_some() { - match run_mut(exec, root, "eclean-dist", &["-d"]) { - Ok(()) => { - out.push_str(" [portage] distfiles cleaned (eclean-dist -d)\n"); - cleaned = true; - } - Err(e) => out.push_str(&format!(" [portage] distfile cleanup failed: {e}\n")), - } - } - if crate::exec::find_in_path("eclean-pkg").is_some() { - match run_mut(exec, root, "eclean-pkg", &["-d"]) { - Ok(()) => { - out.push_str(" [portage] binary package cache cleaned (eclean-pkg -d)\n"); - cleaned = true; - } - Err(e) => out.push_str(&format!(" [portage] package cache cleanup failed: {e}\n")), - } - } - if !cleaned { - out.push_str( - " [portage] unsupported: install app-portage/gentoolkit (eclean-dist / eclean-pkg)\n", - ); - } - out -} - // --------------------------------------------------------------------------- // Updates // --------------------------------------------------------------------------- /// Check for updates across the supported lanes, optionally restricted to one. pub fn check_updates(exec: &Exec, root: &Path, filter: Option) -> UnifiedUpdateOverview { - let mut overview = crate::update::check_unified_updates(exec, root); - if let Some(filter) = filter { - overview.sources.retain(|s| lane_matches(s.backend, filter)); + // The filter is applied before any backend is queried, not merely to the + // displayed results. + crate::update::check_unified_updates_filtered(exec, root, filter) +} + +/// The exact Flatpak applications with an available update. Each is updated by +/// ref so execution can never become an unrestricted update-all. +fn flatpak_update_ids(exec: &Exec, root: &Path) -> Result> { + let out = capture( + exec, + root, + "flatpak", + &[ + "remote-ls", + "--updates", + "--columns=application,version,branch", + ], + )?; + if !out.success { + return Err(ExecError::operation( + "sys", + "apply flatpak updates", + format!( + "flatpak remote-ls failed: {}", + stderr_tail(&out.stderr_lossy()) + ), + )); } - overview + let mut ids = Vec::new(); + for line in out.stdout_lossy().lines() { + if let Some(id) = line.split_whitespace().next() { + if !id.is_empty() { + ids.push(id.to_string()); + } + } + } + ids.sort(); + ids.dedup(); + Ok(ids) +} + +/// The exact snaps with an available update. +fn snap_update_names(exec: &Exec) -> Result> { + let out = exec.runner.execute( + &CommandSpec::new("sys", "apply snap updates", "snap").args(["refresh", "--list"]), + )?; + if !out.success { + return Err(ExecError::operation( + "sys", + "apply snap updates", + format!( + "snap refresh --list failed: {}", + stderr_tail(&out.stderr_lossy()) + ), + )); + } + let mut names = Vec::new(); + for line in out.stdout_lossy().lines().skip(1) { + if let Some(name) = line.split_whitespace().next() { + if !name.is_empty() { + names.push(name.to_string()); + } + } + } + names.sort(); + names.dedup(); + Ok(names) } /// Apply updates across the supported lanes and report a truthful per-source -/// outcome. Sources that require manual or project-specific updates are -/// explained, never reported as updated. If any attempted source fails, the -/// whole action fails with the per-source report. +/// outcome. Each per-source update is constrained to the exact identities +/// resolved immediately before execution; a source that ran and failed is +/// reported as failed (with partial success preserved), and the whole action +/// then fails. Sources with no safe system-level transaction are refused. pub fn apply_updates(exec: &Exec, root: &Path, filter: Option) -> Result { let lanes: Vec = match filter { Some(backend) => vec![backend], - None => all_lanes(), + None => vec![Backend::PortageSource, Backend::Flatpak, Backend::Snap], }; let mut report = String::new(); report.push_str("update application (per-source outcome)\n"); let mut failed = false; + let mut completed = 0usize; for lane in lanes { - match lane { - Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => { - match crate::actions::portage_world_update(exec, root) { - Ok(()) => report.push_str(" [portage] updated (emerge -uDN @world)\n"), - Err(e) => { - failed = true; - report.push_str(&format!(" [portage] failed: {e}\n")); - } + if lane.is_portage() { + match crate::actions::portage_world_update(exec, root) { + Ok(()) => { + completed += 1; + report.push_str(" [portage] updated (emerge -uDN @world)\n"); + } + Err(e) => { + failed = true; + report.push_str(&format!(" [portage] failed: {e}\n")); } } - Backend::Flatpak => { - if !flatpak_available(exec, root) { + } else if lane == Backend::Flatpak { + if !flatpak_available(exec, root) { + if filter.is_some() { + failed = true; + report.push_str( + " [flatpak] failed: the Flatpak client is not available in the target\n", + ); + } else { report.push_str(" [flatpak] unavailable: the Flatpak client is not present\n"); - } else { - match run_mut(exec, root, "flatpak", &["update", "-y"]) { - Ok(()) => report.push_str(" [flatpak] updated (flatpak update -y)\n"), - Err(e) => { - failed = true; - report.push_str(&format!(" [flatpak] failed: {e}\n")); + } + continue; + } + match flatpak_update_ids(exec, root) { + Ok(ids) if ids.is_empty() => { + completed += 1; + report.push_str(" [flatpak] no updates available\n"); + } + Ok(ids) => { + let mut lane_failed = false; + for id in &ids { + match run_mut(exec, root, "flatpak", &["update", "-y", "--", id]) { + Ok(()) => {} + Err(e) => { + lane_failed = true; + report.push_str(&format!(" [flatpak] {id} failed: {e}\n")); + } } } + if lane_failed { + failed = true; + } else { + completed += 1; + report.push_str(&format!( + " [flatpak] updated {} reviewed application(s): {}\n", + ids.len(), + ids.join(", ") + )); + } + } + Err(e) => { + failed = true; + report.push_str(&format!(" [flatpak] failed: {e}\n")); } } - Backend::Snap => { - let usable = matches!(snap::status(exec), Ok(s) if s.usable()); - if !usable { + } else if lane == Backend::Snap { + if !crate::actions::is_host_root(root) { + failed = true; + report + .push_str(" [snap] refused: Snap cannot be redirected to an alternate root\n"); + continue; + } + let usable = matches!(snap::status(exec), Ok(s) if s.usable()); + if !usable { + if filter.is_some() { + failed = true; + report.push_str(" [snap] failed: snapd is not installed or active\n"); + } else { report.push_str(" [snap] unavailable: snapd is not installed or active\n"); - } else { - match snap::refresh(exec, None) { - Ok(_) => report.push_str(" [snap] refreshed (snap refresh)\n"), - Err(e) => { - failed = true; - report.push_str(&format!(" [snap] failed: {e}\n")); + } + continue; + } + match snap_update_names(exec) { + Ok(names) if names.is_empty() => { + completed += 1; + report.push_str(" [snap] no updates available\n"); + } + Ok(names) => { + let mut lane_failed = false; + for name in &names { + match snap::refresh(exec, Some(name)) { + Ok(_) => {} + Err(e) => { + lane_failed = true; + report.push_str(&format!(" [snap] {name} failed: {e}\n")); + } } } + if lane_failed { + failed = true; + } else { + completed += 1; + report.push_str(&format!( + " [snap] refreshed {} reviewed snap(s): {}\n", + names.len(), + names.join(", ") + )); + } + } + Err(e) => { + failed = true; + report.push_str(&format!(" [snap] failed: {e}\n")); } } - Backend::AppImage => report.push_str( - " [appimage] manual: managed AppImages have no update repository; \ - re-acquire with a pinned URL + SHA-256 (appimage_update)\n", - ), - Backend::Nix => report.push_str( - " [nix] project-specific: Nix packages are declarative/pinned; \ - update them in their project or profile, not from the system\n", - ), - Backend::CustomEbuild => report.push_str( - " [custom-ebuild] project-specific: rebuild a staged ebuild through Portage\n", - ), + } else if filter.is_some() { + // An explicit request for a lane with no safe system-level update + // transaction is refused, not silently reported as "updated". + return Err(ExecError::operation( + "sys", + "apply updates", + format!( + "{} updates cannot be applied safely by `sys` from the system; {}", + lane.as_str(), + crate::actions::update_limitation(lane) + ), + )); + } else { + report.push_str(&format!( + " [{}] not applied: {}\n", + lane.as_str(), + crate::actions::update_limitation(lane) + )); } } if failed { return Err(ExecError::operation("sys", "apply updates", report)); } + if completed == 0 { + return Err(ExecError::operation( + "sys", + "apply updates", + format!("{report}no source was updated"), + )); + } Ok(report) } @@ -1184,23 +1477,90 @@ mod tests { assert_eq!(runner2.recorded().len(), 2); } - #[test] - fn clean_cache_reports_unsupported_without_a_cleaner() { - // A temp dir with neither eclean-dist nor eclean-pkg on PATH. - let runner = RecordingRunner::new(); - let exec = make_exec(runner); - let out = clean_cache(&exec, Path::new(&exec.root), Some(Backend::PortageSource)).unwrap(); - assert!(out.contains("installed packages are never removed")); - assert!(out.contains("unsupported") || out.contains("cleaned")); + fn install_fake_tool(root: &Path, name: &str) { + use std::os::unix::fs::PermissionsExt; + let bin = root.join("usr/bin"); + std::fs::create_dir_all(&bin).unwrap(); + let tool = bin.join(name); + std::fs::write(&tool, "#!/bin/sh\n").unwrap(); + std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap(); } #[test] - fn apply_updates_reports_manual_and_project_lanes_without_claiming_success() { + fn clean_cache_without_a_cleaner_is_a_failure_not_a_silent_success() { + // A temp dir with neither eclean-dist nor eclean-pkg in the target. let runner = RecordingRunner::new(); let exec = make_exec(runner); - let out = apply_updates(&exec, Path::new(&exec.root), Some(Backend::AppImage)).unwrap(); - assert!(out.contains("manual")); - assert!(!out.contains("updated")); + let err = + clean_cache(&exec, Path::new(&exec.root), Some(Backend::PortageSource)).unwrap_err(); + let text = err.to_string(); + assert!(text.contains("no cleaner ran"), "{text}"); + // The unavailable tool is named distinctly from a failed tool. + assert!(text.contains("unavailable"), "{text}"); + } + + #[test] + fn clean_cache_propagates_a_failed_cleaner_and_preserves_partial_success() { + let runner = RecordingRunner::new(); + let exec = make_exec(runner.clone()); + let root = Path::new(&exec.root); + install_fake_tool(root, "eclean-dist"); + install_fake_tool(root, "eclean-pkg"); + // The first cleaner runs; the second fails. Execution is rooted in the + // target (chroot), so both are the `chroot` wrapper; fail the second. + let chroot_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)); + struct FailSecond(std::sync::Arc); + impl crate::command::ProcessRunner for FailSecond { + fn execute(&self, _spec: &crate::command::CommandSpec) -> Result { + let n = self.0.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + if n == 0 { + Ok(CommandOutput { + status: 0, + success: true, + stdout: Vec::new(), + stderr: Vec::new(), + duration: std::time::Duration::from_millis(1), + }) + } else { + Ok(CommandOutput { + status: 1, + success: false, + stdout: Vec::new(), + stderr: b"eclean boom".to_vec(), + duration: std::time::Duration::from_millis(1), + }) + } + } + } + let logger_path = tempfile::tempdir().unwrap().keep(); + let logger = crate::log::Logger::open( + logger_path.join("l.log"), + phoebus_core::Redactor::new(), + false, + ); + let exec2 = Exec::new( + Box::new(FailSecond(chroot_calls)), + logger, + false, + root, + logger_path, + ); + let err = clean_cache(&exec2, root, Some(Backend::PortageSource)).unwrap_err(); + let text = err.to_string(); + assert!(text.contains("eclean-dist completed"), "{text}"); + assert!(text.contains("eclean-pkg failed"), "{text}"); + // The runner was consulted, and no host command was issued. + assert!(runner.recorded().is_empty()); + } + + #[test] + fn apply_updates_refuses_a_lane_without_a_safe_transaction() { + let runner = RecordingRunner::new(); + let exec = make_exec(runner); + let err = apply_updates(&exec, Path::new(&exec.root), Some(Backend::AppImage)).unwrap_err(); + let text = err.to_string(); + assert!(text.contains("cannot be applied safely"), "{text}"); + assert!(text.contains("pinned URL"), "{text}"); } #[test] @@ -1213,6 +1573,91 @@ mod tests { assert!(err.to_string().contains("[portage] failed")); } + #[test] + fn flatpak_update_plan_is_refused_when_the_target_has_no_client() { + let runner = RecordingRunner::new(); + runner.fail("chroot", "flatpak: not found"); + let exec = make_exec(runner); + let root = Path::new(&exec.root); + let plan = crate::actions::resolve_effects( + &exec, + &phoebus_core::action::SystemAction::ApplyUpdates { + backend: Some(Backend::Flatpak), + }, + root, + ); + // No flatpak in the target, so the plan is refused rather than silently + // reporting success. + assert!(plan.is_err()); + } + + #[test] + fn flatpak_update_effects_bind_exact_identities_and_versions() { + use crate::command::{CommandOutput, CommandSpec, ProcessRunner}; + struct Fp; + impl ProcessRunner for Fp { + fn execute(&self, spec: &CommandSpec) -> Result { + let ok = |s: &str| CommandOutput { + status: 0, + success: true, + stdout: s.as_bytes().to_vec(), + stderr: Vec::new(), + duration: std::time::Duration::from_millis(1), + }; + let flatpak = spec.args.iter().any(|a| a == "flatpak"); + if flatpak && spec.args.iter().any(|a| a == "--version") { + return Ok(ok("Flatpak 1.18\n")); + } + if flatpak && spec.args.iter().any(|a| a == "remote-ls") { + return Ok(ok( + "org.mozilla.firefox 129 stable\norg.gnome.Calc 46 stable\n", + )); + } + if flatpak && spec.args.iter().any(|a| a == "list") { + return Ok(ok("org.mozilla.firefox 128\norg.gnome.Calc 45\n")); + } + Ok(ok("")) + } + } + let path = tempfile::tempdir().unwrap().keep(); + let logger = + crate::log::Logger::open(path.join("l.log"), phoebus_core::Redactor::new(), false); + let exec = Exec::new(Box::new(Fp), logger, false, path.join("root"), path); + let plan = crate::actions::resolve_effects( + &exec, + &phoebus_core::action::SystemAction::ApplyUpdates { + backend: Some(Backend::Flatpak), + }, + &exec.root, + ) + .unwrap(); + assert!(plan.established); + assert!( + plan.effects + .iter() + .any(|e| e.target == "org.mozilla.firefox-129" + && e.previous.as_deref() == Some("128")) + ); + assert!(plan + .effects + .iter() + .any(|e| e.target == "org.gnome.Calc-46" && e.previous.as_deref() == Some("45"))); + } + + #[test] + fn apply_updates_never_runs_host_snap_for_an_alternate_root() { + let runner = RecordingRunner::new(); + let exec = make_exec(runner.clone()); + let err = apply_updates(&exec, Path::new(&exec.root), Some(Backend::Snap)).unwrap_err(); + assert!(err.to_string().contains("alternate root"), "{err}"); + // Crucially, no host `snap` command was attempted. + assert!( + !runner.recorded().iter().any(|s| s.program == "snap"), + "alternate-root snap must not touch the host: {:?}", + runner.programs() + ); + } + #[test] fn parse_flatpak_lines_handles_tabs_and_spaces() { let rows = @@ -1232,15 +1677,59 @@ mod tests { } #[test] - fn package_dependencies_reports_forward_deps() { + fn package_dependencies_uses_installed_metadata_not_an_install_plan() { let runner = RecordingRunner::new(); - runner.set_response( - "emerge", - ok("Calculating dependencies... done!\n[ebuild N ] app-editors/vim-core-9.1.0\n\nTotal: 1 package\n"), - ); let exec = make_exec(runner); - let out = package_dependencies(&exec, Path::new("/"), "vim", false).unwrap(); - assert!(out.contains("app-editors/vim-core-9.1.0"), "{out}"); + let root = Path::new(&exec.root); + // `vim` depends on an already-installed runtime library, a conditional + // dependency and a blocker; `vim-core` is already installed. + for (atom, version) in [ + ("app-editors/vim", "9.1.0"), + ("app-editors/vim-core", "9.1.0"), + ] { + let dir = root.join(format!("var/db/pkg/{atom}-{version}")); + std::fs::create_dir_all(&dir).unwrap(); + } + std::fs::write( + root.join("var/db/pkg/app-editors/vim-9.1.0/RDEPEND"), + "app-editors/vim-core python? ( dev-lang/python ) !app-editors/vim-minimal", + ) + .unwrap(); + + let out = package_dependencies(&exec, root, "app-editors/vim", false).unwrap(); + assert!(out.contains("app-editors/vim-core"), "{out}"); + assert!( + out.contains("(installed)"), + "satisfied deps included: {out}" + ); + assert!(out.contains("dev-lang/python"), "{out}"); + assert!( + out.contains("python?"), + "conditional context preserved: {out}" + ); + assert!(out.contains("blocker"), "{out}"); + // The requested package is never reported as its own dependency. + assert!( + !out.contains("app-editors/vim (") && !out.contains("app-editors/vim-9.1.0"), + "{out}" + ); + } + + #[test] + fn package_dependencies_reverse_finds_installed_dependants() { + let runner = RecordingRunner::new(); + let exec = make_exec(runner); + let root = Path::new(&exec.root); + let dir = root.join("var/db/pkg/app-misc/tool-1.0"); + std::fs::create_dir_all(&dir).unwrap(); + std::fs::write(dir.join("RDEPEND"), ">=dev-libs/glib-2.0").unwrap(); + + let out = package_dependencies(&exec, root, "dev-libs/glib", true).unwrap(); + assert!(out.contains("app-misc/tool"), "{out}"); + + // A genuinely empty reverse set is distinct from a failed query. + let empty = package_dependencies(&exec, root, "dev-libs/nothing", true).unwrap(); + assert!(empty.contains("no installed package depends on"), "{empty}"); } #[test] diff --git a/installer-rs/crates/phoebus-executor/src/update.rs b/installer-rs/crates/phoebus-executor/src/update.rs index ac07cac..e52cdb6 100644 --- a/installer-rs/crates/phoebus-executor/src/update.rs +++ b/installer-rs/crates/phoebus-executor/src/update.rs @@ -166,147 +166,204 @@ use phoebus_core::update::{PackageUpdateItem, SourceUpdateOverview, UnifiedUpdat /// Check updates across all supported package sources (Portage, Flatpak, Snap, AppImage, Nix) /// and report a unified, truthful overview. pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview { + check_unified_updates_filtered(exec, root, None) +} + +/// Whether a lane is covered by an optional source filter. +fn lane_selected(filter: Option, lane: Backend) -> bool { + match filter { + Some(f) => f == lane || (f.is_portage() && lane.is_portage()), + None => true, + } +} + +/// Like [`check_unified_updates`], but a lane filter prevents querying any +/// other backend at all, so a constrained check never probes a foreign lane. +pub fn check_unified_updates_filtered( + exec: &Exec, + root: &Path, + filter: Option, +) -> UnifiedUpdateOverview { let mut sources = Vec::new(); - // 1. Portage - let mut portage_items = Vec::new(); - let portage_res = exec.runner.execute( - &crate::command::CommandSpec::new("sys", "check portage updates", "emerge").args([ + // 1. Portage. The check runs against the intended target: directly for the + // running root, or inside the target chroot for an alternate root. + if lane_selected(filter, Backend::PortageSource) { + let mut portage_items = Vec::new(); + let portage_args: Vec = [ "--pretend", "--update", "--deep", "--newuse", "--color=n", "@world", - ]), - ); - let mut portage_note = "native OS packages".to_string(); - if let Ok(res) = portage_res { - if res.success { - let plan = phoebus_core::effects::parse_emerge_pretend(&res.stdout_lossy()); - for effect in plan.effects { - if effect.kind == phoebus_core::effects::EffectKind::Upgrade - || effect.kind == phoebus_core::effects::EffectKind::New - { - portage_items.push(PackageUpdateItem { - name: effect.target.clone(), - current_version: effect.previous.clone(), - new_version: effect.target, - source: "Portage @world".into(), - }); - } - } - } else { - portage_note = "emerge check failed or offline".into(); - } - } - sources.push(SourceUpdateOverview { - backend: Backend::PortageSource, - updates: portage_items, - supported: true, - note: portage_note, - }); - - // 2. Flatpak - let mut flatpak_items = Vec::new(); - let flatpak_supported = crate::exec::find_in_path("flatpak").is_some(); - let mut flatpak_note = "sandboxed desktop applications".to_string(); - if flatpak_supported { - let fp_res = - exec.runner.execute( - &crate::command::CommandSpec::new("sys", "check flatpak updates", "flatpak") - .args(["remote-ls", "--updates", "--columns=application,version"]), - ); - if let Ok(res) = fp_res { + ] + .iter() + .map(|s| s.to_string()) + .collect(); + let portage_res = exec.runner.execute(&crate::actions::target_spec( + root, + "sys", + "check portage updates", + "emerge", + &portage_args, + )); + let mut portage_note = "native OS packages".to_string(); + if let Ok(res) = portage_res { if res.success { - for line in res.stdout_lossy().lines() { - let mut parts = line.split_whitespace(); - if let (Some(id), Some(ver)) = (parts.next(), parts.next()) { - flatpak_items.push(PackageUpdateItem { - name: id.to_string(), - current_version: None, - new_version: ver.to_string(), - source: "flathub".into(), + let plan = phoebus_core::effects::parse_emerge_pretend(&res.stdout_lossy()); + for effect in plan.effects { + if effect.kind == phoebus_core::effects::EffectKind::Upgrade + || effect.kind == phoebus_core::effects::EffectKind::New + { + portage_items.push(PackageUpdateItem { + name: effect.target.clone(), + current_version: effect.previous.clone(), + new_version: effect.target, + source: "Portage @world".into(), }); } } } else { - flatpak_note = "flatpak remote check failed or offline".into(); + portage_note = "emerge check failed or offline".into(); } } + sources.push(SourceUpdateOverview { + backend: Backend::PortageSource, + updates: portage_items, + supported: true, + note: portage_note, + }); } - sources.push(SourceUpdateOverview { - backend: Backend::Flatpak, - updates: flatpak_items, - supported: flatpak_supported, - note: if flatpak_supported { - flatpak_note - } else { - "flatpak is not installed".into() - }, - }); - // 3. Snap - let mut snap_items = Vec::new(); - let snap_status = crate::snap::status(exec); - let snap_supported = matches!(snap_status, Ok(ref s) if s.usable()); - let snap_note = "snapd automatic refresh lane".to_string(); - if snap_supported { - let snap_res = exec.runner.execute( - &crate::command::CommandSpec::new("sys", "check snap updates", "snap") - .args(["refresh", "--list"]), - ); - if let Ok(res) = snap_res { - if res.success { - for line in res.stdout_lossy().lines().skip(1) { - let mut parts = line.split_whitespace(); - if let (Some(name), Some(ver)) = (parts.next(), parts.next()) { - snap_items.push(PackageUpdateItem { - name: name.to_string(), - current_version: None, - new_version: ver.to_string(), - source: "Snap Store".into(), - }); + // 2. Flatpak. Availability and the query refer to the target, so an + // alternate-root check never consults a host Flatpak installation. + if lane_selected(filter, Backend::Flatpak) { + let mut flatpak_items = Vec::new(); + let flatpak_supported = crate::exec::tool_in_target(root, "flatpak"); + let mut flatpak_note = "sandboxed desktop applications".to_string(); + if flatpak_supported { + let fp_args: Vec = [ + "remote-ls", + "--updates", + "--columns=application,version,branch", + ] + .iter() + .map(|s| s.to_string()) + .collect(); + let fp_res = exec.runner.execute(&crate::actions::target_spec( + root, + "sys", + "check flatpak updates", + "flatpak", + &fp_args, + )); + if let Ok(res) = fp_res { + if res.success { + for line in res.stdout_lossy().lines() { + let mut parts = line.split_whitespace(); + if let (Some(id), Some(ver)) = (parts.next(), parts.next()) { + flatpak_items.push(PackageUpdateItem { + name: id.to_string(), + current_version: None, + new_version: ver.to_string(), + source: "flathub".into(), + }); + } + } + } else { + flatpak_note = "flatpak remote check failed or offline".into(); + } + } + } + sources.push(SourceUpdateOverview { + backend: Backend::Flatpak, + updates: flatpak_items, + supported: flatpak_supported, + note: if flatpak_supported { + flatpak_note + } else { + "flatpak is not installed".into() + }, + }); + } + + // 3. Snap. Snap acts on the running daemon; an alternate-root check must + // not consult (or claim) the host's snaps. + if lane_selected(filter, Backend::Snap) { + let mut snap_items = Vec::new(); + let snap_status = if root == Path::new("/") { + crate::snap::status(exec) + } else { + Ok(crate::snap::SnapdStatus { + client_present: false, + daemon_ready: false, + confinement: crate::snap::Confinement::None, + }) + }; + let snap_supported = matches!(snap_status, Ok(ref s) if s.usable()); + let snap_note = "snapd automatic refresh lane".to_string(); + if snap_supported { + let snap_res = exec.runner.execute( + &crate::command::CommandSpec::new("sys", "check snap updates", "snap") + .args(["refresh", "--list"]), + ); + if let Ok(res) = snap_res { + if res.success { + for line in res.stdout_lossy().lines().skip(1) { + let mut parts = line.split_whitespace(); + if let (Some(name), Some(ver)) = (parts.next(), parts.next()) { + snap_items.push(PackageUpdateItem { + name: name.to_string(), + current_version: None, + new_version: ver.to_string(), + source: "Snap Store".into(), + }); + } } } } } + sources.push(SourceUpdateOverview { + backend: Backend::Snap, + updates: snap_items, + supported: snap_supported, + note: if snap_supported { + snap_note + } else { + "snapd is not installed or active".into() + }, + }); } - sources.push(SourceUpdateOverview { - backend: Backend::Snap, - updates: snap_items, - supported: snap_supported, - note: if snap_supported { - snap_note - } else { - "snapd is not installed or active".into() - }, - }); // 4. AppImage - let appimages = crate::appimage::list(root).unwrap_or_default(); - sources.push(SourceUpdateOverview { - backend: Backend::AppImage, - updates: Vec::new(), - supported: false, - note: format!( - "{} managed AppImage(s); automatic repository updates are not supported by the format (manual update required)", - appimages.len() - ), - }); + if lane_selected(filter, Backend::AppImage) { + let appimages = crate::appimage::list(root).unwrap_or_default(); + sources.push(SourceUpdateOverview { + backend: Backend::AppImage, + updates: Vec::new(), + supported: false, + note: format!( + "{} managed AppImage(s); automatic repository updates are not supported by the format (manual update required)", + appimages.len() + ), + }); + } // 5. Nix - let nix_installed = crate::nix::installed(root); - sources.push(SourceUpdateOverview { - backend: Backend::Nix, - updates: Vec::new(), - supported: nix_installed, - note: if nix_installed { - "Nix dev packages are declarative/pinned; updates are managed per-project or via profile updates".into() - } else { - "Nix is not installed".into() - }, - }); + if lane_selected(filter, Backend::Nix) { + let nix_installed = crate::nix::installed(root); + sources.push(SourceUpdateOverview { + backend: Backend::Nix, + updates: Vec::new(), + supported: nix_installed, + note: if nix_installed { + "Nix dev packages are declarative/pinned; updates are managed per-project or via profile updates".into() + } else { + "Nix is not installed".into() + }, + }); + } // Reboot check: check /var/run/reboot-required let reboot_required = root.join("var/run/reboot-required").exists(); diff --git a/installer-rs/crates/phoebus-installer/src/service.rs b/installer-rs/crates/phoebus-installer/src/service.rs index ae19e9b..1955c20 100644 --- a/installer-rs/crates/phoebus-installer/src/service.rs +++ b/installer-rs/crates/phoebus-installer/src/service.rs @@ -1152,6 +1152,45 @@ fn constrain_action( SystemAction::CleanCache { .. } => SystemAction::CleanCache { backend: Some(constraint), }, + // Optional-backend discovery and selection requests must be *rewritten* + // to the constraint, not merely filtered afterwards: otherwise the + // resolver would still query every lane before the results are + // discarded. + SystemAction::DiscoverCandidates { + query, + kind, + gui, + requires_sandbox, + .. + } => SystemAction::DiscoverCandidates { + query, + kind, + backend: Some(constraint), + gui, + requires_sandbox, + }, + SystemAction::ChoosePackage { + name, + kind, + gui, + requires_sandbox, + .. + } => SystemAction::ChoosePackage { + name, + kind, + backend: Some(constraint), + gui, + requires_sandbox, + }, + // `InspectInstallation` has no lane field but probes every lane; under + // an explicit constraint it is refused rather than leaking other lanes. + SystemAction::InspectInstallation { .. } => { + return Err(format!( + "inspect_installation spans every package lane, but this request was constrained \ + to {}; use a lane-specific inventory instead", + constraint.as_str() + )); + } other => { if let Some(own) = other.backend() { let matches = own == constraint || (own.is_portage() && constraint.is_portage()); @@ -2472,23 +2511,22 @@ mod tests { return Ok(ok("installed\n".into())); } let installed = self.installed.load(std::sync::atomic::Ordering::SeqCst); - match spec.program.as_str() { - "flatpak" if spec.args.iter().any(|a| a == "search") => { - Ok(ok("org.mozilla.firefox 128\n".into())) + let is_flatpak = spec.program == "flatpak" || spec.args.iter().any(|a| a == "flatpak"); + if is_flatpak && spec.args.iter().any(|a| a == "search") { + Ok(ok("org.mozilla.firefox 128\n".into())) + } else if is_flatpak && spec.args.iter().any(|a| a == "list") { + if !installed { + return Ok(ok(String::new())); } - "flatpak" if spec.args.iter().any(|a| a == "list") => { - if !installed { - return Ok(ok(String::new())); - } - // `--columns=application` (verification) vs the richer - // `application,name,version` (discovery). - if spec.args.iter().any(|a| a == "--columns=application") { - Ok(ok("org.mozilla.firefox\n".into())) - } else { - Ok(ok("org.mozilla.firefox Firefox 128\n".into())) - } + // `--columns=application` (verification) vs the richer + // `application,name,version` (discovery). + if spec.args.iter().any(|a| a == "--columns=application") { + Ok(ok("org.mozilla.firefox\n".into())) + } else { + Ok(ok("org.mozilla.firefox Firefox 128\n".into())) } - _ => Ok(ok(String::new())), + } else { + Ok(ok(String::new())) } } } @@ -2502,6 +2540,17 @@ mod tests { Exec::new(runner, logger, false, root.to_path_buf(), temp) } + /// A target that actually has a Flatpak client, so lane availability + /// resolves from the target rather than the host. + fn install_fake_flatpak(root: &Path) { + use std::os::unix::fs::PermissionsExt; + let bin = root.join("usr/bin"); + std::fs::create_dir_all(&bin).unwrap(); + let flatpak = bin.join("flatpak"); + std::fs::write(&flatpak, "#!/bin/sh\n").unwrap(); + std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap(); + } + #[test] fn install_verification_failure_finishes_the_transaction_as_failed() { let root = tempdir().unwrap(); @@ -2515,6 +2564,7 @@ mod tests { ); let store = PlanStore::with_dir(tempdir().unwrap().keep()); let approvals = ApprovalLedger::with_dir(tempdir().unwrap().keep()); + install_fake_flatpak(root.path()); let mut request = InstallRequest::new("firefox"); request.backend = Some(Backend::Flatpak); @@ -2573,6 +2623,7 @@ mod tests { ); let store = PlanStore::with_dir(tempdir().unwrap().keep()); let approvals = ApprovalLedger::with_dir(tempdir().unwrap().keep()); + install_fake_flatpak(root.path()); let mut request = InstallRequest::new("firefox"); request.backend = Some(Backend::Flatpak); let plan = plan_legacy_install(&store, &exec, root.path(), &request).unwrap(); @@ -4005,4 +4056,89 @@ mod tests { }] ); } + + #[test] + fn constrain_action_rewrites_optional_backend_discovery_before_querying() { + let discover = constrain_action( + SystemAction::DiscoverCandidates { + query: "chrome".into(), + kind: None, + backend: None, + gui: false, + requires_sandbox: false, + }, + Backend::Flatpak, + ) + .unwrap(); + assert_eq!(discover.backend(), Some(Backend::Flatpak)); + + let choose = constrain_action( + SystemAction::ChoosePackage { + name: "chrome".into(), + kind: None, + backend: None, + gui: false, + requires_sandbox: false, + }, + Backend::Flatpak, + ) + .unwrap(); + assert_eq!(choose.backend(), Some(Backend::Flatpak)); + } + + #[test] + fn constrain_action_refuses_portage_only_actions_under_another_lane() { + for action in [ + SystemAction::RemovePackage { + atom: "www-client/firefox".into(), + }, + SystemAction::UpdateSystem, + SystemAction::Depclean, + SystemAction::PackageOwners { + path: "/usr/bin/vim".into(), + }, + SystemAction::PackageDependencies { + package: "vim".into(), + reverse: false, + }, + SystemAction::InstallPackage { + atom: "vim".into(), + binary: None, + }, + SystemAction::InspectPackage { atom: "vim".into() }, + ] { + let err = constrain_action(action.clone(), Backend::Flatpak).unwrap_err(); + assert!( + err.contains("constrained") || err.contains("targets the"), + "{action:?} -> {err}" + ); + } + } + + #[test] + fn constrain_action_refuses_cross_lane_installation_inspection() { + let err = constrain_action( + SystemAction::InspectInstallation { + application: "firefox".into(), + }, + Backend::Flatpak, + ) + .unwrap_err(); + assert!(err.contains("spans every package lane"), "{err}"); + } + + #[test] + fn constrain_action_allows_spanning_non_package_actions() { + for action in [ + SystemAction::History, + SystemAction::RollbackStatus, + SystemAction::EnableService { + name: "sshd".into(), + }, + ] { + assert!(constrain_action(action, Backend::Flatpak).is_ok()); + } + // A Portage-only action is allowed when the constraint is Portage. + assert!(constrain_action(SystemAction::UpdateSystem, Backend::PortageSource).is_ok()); + } } diff --git a/installer/tests/vm/sys-acceptance.sh b/installer/tests/vm/sys-acceptance.sh index 4e98e7c..01c6c43 100755 --- a/installer/tests/vm/sys-acceptance.sh +++ b/installer/tests/vm/sys-acceptance.sh @@ -167,6 +167,25 @@ run_expect_zero_contains info-legacy "Package information" --legacy info bash run_expect_zero_contains updates-legacy "Unified Update Overview" --legacy updates run_expect_zero_contains json-search-legacy "Package catalogue" --legacy --action '{"action":"search_packages","query":"firefox"}' +# Regression: an alternate root must never be answered by the host's Snap lane. +AltRoot="$WORK/altroot" +mkdir -p "$AltRoot" +run_expect_zero_contains snap-alternate-root "alternate root" \ + --root "$AltRoot" --legacy search firefox --snap +# Regression: Nix inventory enumerates active profiles, never host commands. +run_expect_zero_contains list-nix-legacy "[nix]" --legacy list --nix +# Regression: dependency inspection uses declared metadata, not a merge plan. +"$SYS" --legacy --action \ + '{"action":"package_dependencies","package":"bash","reverse":false}' \ + >"$WORK/deps.out" 2>"$WORK/deps.err" +if grep -qE "declares|dependency token|has no declared dependencies" "$WORK/deps.out"; then + report deps-legacy PASS "$(head -c 160 "$WORK/deps.out" | tr '\n' ' ')" +elif grep -qi "app-portage/portage-utils\|qdepends\|not installed" "$WORK/deps.err" "$WORK/deps.out"; then + report deps-legacy PASS "honest limitation: $(head -c 120 "$WORK/deps.err" | tr '\n' ' ')" +else + report deps-legacy FAIL "rc=$? $(head -c 200 "$WORK/deps.err" | tr '\n' ' ')" +fi + # A recognizable catalogue command without --legacy must enter the AI workflow # and must not run deterministically when no model is available. if ! PHOEBUS_AI_PROVIDER="" PHOEBUS_AI_BACKEND=direct \