phoebus_os/installer-rs/crates/phoebus-installer/src/bin/sys.rs
2026-09-24 19:14:16 -07:00

1035 lines
36 KiB
Rust

//! `sys <instruction>` - Phoebus unified system interface.
//!
//! Natural language is the default interaction: a connected model investigates
//! the request, recommends a validated plan, and explains it.
//! Deterministic operation without a model is explicitly selected with `--legacy`.
//! All operations execute typed, validated actions through the privileged broker;
//! the model never receives a shell or privilege.
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::ExitCode;
use clap::Parser;
use phoebus_ai::provider::SystemFacts;
use phoebus_core::action::{parse_action, parse_natural, SystemAction};
use phoebus_core::selection::Backend;
use phoebus_core::transaction::{TransactionOutcome, TransactionRecord};
use phoebus_core::{AiBackend, InstallConfig, Redactor};
use phoebus_executor::install::{AiInstall, ExecutorSession, InstallRequest};
use phoebus_executor::{
actions, authorize, chooser, probe, transaction, AutoConfirm, Confirmation,
DestructiveAuthorization, Exec, Logger, RealRunner, Result,
};
use phoebus_installer::approval;
use phoebus_installer::conversation::{self, ConversationTurn, FollowupResolution};
use phoebus_installer::service::{self, PreparedPlan};
#[derive(Parser, Debug)]
#[command(
name = "sys",
about = "Phoebus system interface",
version,
group(clap::ArgGroup::new("backend").args([
"portage", "flatpak", "nix", "snap", "appimage", "ebuild"
]).multiple(false))
)]
struct Cli {
/// Natural-language instruction, e.g. `enable sshd` or `install firefox`.
text: Vec<String>,
/// Explicit deterministic administration without contacting a model.
#[arg(long)]
legacy: bool,
/// Internal broker invocation by Phoebus OS application layer.
#[arg(long)]
broker: bool,
/// Start the desktop assistant JSON-RPC bridge on stdio.
#[arg(long)]
assistant_bridge: bool,
/// A typed action as JSON, e.g. '{"action":"enable_service","name":"sshd"}'.
#[arg(long)]
action: Option<String>,
/// Read a typed action from a JSON file (used by the AI path or internal broker).
#[arg(long)]
action_file: Option<PathBuf>,
/// Execute a prepared plan by identifier (internal broker invocation).
#[arg(long, value_name = "PLAN_ID")]
execute_plan: Option<String>,
/// The uid that reviewed and approved the plan (internal broker only).
#[arg(long, value_name = "UID")]
plan_uid: Option<u32>,
/// The independently preserved approval digest shown to the user at review
/// (internal broker only). The broker binds execution to this exact plan.
#[arg(long, value_name = "SHA256")]
approval_digest: Option<String>,
/// Auto-approve (unattended); still requires root.
#[arg(long, short = 'y')]
yes: bool,
/// Root directory of the target system.
#[arg(long, default_value = "/")]
root: PathBuf,
/// Constrain to Portage (or in --legacy mode, install through Portage).
#[arg(long)]
portage: bool,
/// Constrain to Flatpak (or in --legacy mode, install from Flatpak).
#[arg(long)]
flatpak: bool,
/// Constrain to Nix (or in --legacy mode, install from Nix).
#[arg(long)]
nix: bool,
/// Constrain to Snap (or in --legacy mode, install from Snap).
#[arg(long)]
snap: bool,
/// Constrain to AppImage (or in --legacy mode, install managed AppImage).
#[arg(long)]
appimage: bool,
/// Constrain to staged custom ebuild (or in --legacy mode, build staged ebuild).
#[arg(long)]
ebuild: bool,
/// AI provider for `sys ask`: deepseek, openai, or local.
#[arg(long, value_name = "PROVIDER")]
ai_provider: Option<String>,
/// Model override for the assistant.
#[arg(long, value_name = "MODEL")]
ai_model: Option<String>,
/// Provider endpoint override (local models).
#[arg(long, value_name = "URL")]
ai_endpoint: Option<String>,
/// Read the provider API key from a mode-0600 file.
#[arg(long, value_name = "FILE")]
ai_api_key_file: Option<PathBuf>,
/// Run the assistant without the OS-level sandbox (development only).
#[arg(long)]
no_sandbox: bool,
/// AI backend for `sys ask`: `direct` (default) or `opencode`.
#[arg(long, value_name = "BACKEND")]
ai_backend: Option<String>,
/// OpenCode agent server URL, e.g. `http://127.0.0.1:4096`.
#[arg(long, value_name = "URL")]
opencode_server: Option<String>,
/// OpenCode provider id (e.g. `deepseek`).
#[arg(long, value_name = "PROVIDER")]
opencode_provider: Option<String>,
/// OpenCode model id (e.g. `deepseek-chat`).
#[arg(long, value_name = "MODEL")]
opencode_model: Option<String>,
/// Read the OpenCode server password from a mode-0600 file.
#[arg(long, value_name = "FILE")]
opencode_password_file: Option<PathBuf>,
}
struct SysConfirm {
action: SystemAction,
assume_yes: bool,
}
impl Confirmation for SysConfirm {
fn confirm_erase(&self, preview: &str) -> Result<bool> {
if self.assume_yes {
println!("{preview}");
return Ok(true);
}
println!("\n{preview}");
print!("\nProceed? [y/N] ");
std::io::stdout().flush().ok();
let mut line = String::new();
std::io::stdin()
.read_line(&mut line)
.map_err(|e| phoebus_executor::ExecError::operation("sys", "confirm", e.to_string()))?;
Ok(matches!(
line.trim().to_ascii_lowercase().as_str(),
"y" | "yes"
))
}
fn confirm_final(&self, _message: &str) -> Result<bool> {
let _ = &self.action;
Ok(true)
}
}
fn now_unix() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
}
fn record_transaction(
exec: &Exec,
root: &Path,
record: TransactionRecord,
) -> std::result::Result<(), Box<dyn std::error::Error>> {
transaction::append(exec, root, record).map_err(|e| {
format!("the action completed but its transaction could not be recorded: {e}").into()
})
}
fn effective_uid() -> u32 {
std::process::Command::new("id")
.arg("-u")
.output()
.ok()
.and_then(|o| String::from_utf8_lossy(&o.stdout).trim().parse().ok())
.unwrap_or(1)
}
/// Persist a minimized conversation turn with the process redactor, surfacing a
/// storage failure instead of silently losing it.
fn record_turn(exec: &Exec, path: &Path, turn: ConversationTurn) {
if let Err(e) = conversation::save_turn(path, exec.redactor(), turn) {
eprintln!("sys: warning: could not persist conversation context: {e}");
}
}
fn main() -> ExitCode {
match run() {
Ok(()) => ExitCode::SUCCESS,
Err(e) => {
eprintln!("sys: {e}");
ExitCode::FAILURE
}
}
}
fn run() -> std::result::Result<(), Box<dyn std::error::Error>> {
let cli = Cli::parse();
let mut state_dir = PathBuf::from("/run/phoebus-installer");
if std::fs::create_dir_all(&state_dir).is_err() {
state_dir = std::env::temp_dir().join("phoebus-installer");
std::fs::create_dir_all(&state_dir).ok();
}
let logger = Logger::open(state_dir.join("sys.log"), Redactor::new(), false);
let exec = Exec::new(
Box::new(RealRunner::new()),
logger,
false,
cli.root.clone(),
state_dir,
);
let plans = service::PlanStore::for_current_user();
// 1. Assistant Bridge
if cli.assistant_bridge {
return phoebus_installer::assistant_bridge::run_stdio(&exec, &cli.root);
}
// 2. Broker execute plan
if let Some(plan_id) = &cli.execute_plan {
if !cli.broker {
return Err("--execute-plan requires --broker for privileged invocation".into());
}
if effective_uid() != 0 {
return Err("privileged plan execution requires root".into());
}
// The initiating identity comes from the authenticated caller context
// (PKEXEC_UID), never from an untrusted --plan-uid alone.
let initiator_uid = approval::broker_initiator_uid(cli.plan_uid, effective_uid())?;
let expected_digest = cli
.approval_digest
.ok_or("--execute-plan requires --approval-digest (the digest the user approved)")?;
// Root-owned ledger: a crash leaves a terminal 'interrupted' record and
// a replay cannot proceed after the user deletes their own plan files.
let approvals = approval::ApprovalLedger::for_broker();
let reconciled = approvals.reconcile_interrupted().unwrap_or(0);
if reconciled > 0 {
eprintln!("sys: recorded {reconciled} interrupted operation(s) from a previous run");
}
// The broker resolves storage from the initiating uid, never from an
// arbitrary path, and repeats the full validation itself.
let plans = service::PlanStore::for_uid(initiator_uid);
let outcome = service::execute_plan_privileged(
&exec,
&cli.root,
&plans,
&approvals,
plan_id,
&expected_digest,
initiator_uid,
true,
)?;
println!("{}", serde_json::to_string(&outcome)?);
return Ok(());
}
// 3. Audit JSON/action-file entry points
if cli.action.is_some() || cli.action_file.is_some() {
if !cli.legacy && !cli.broker {
return Err(
"typed actions via --action/--action-file require --legacy for deterministic \
administration or --broker for internal broker invocation"
.into(),
);
}
let action = if let Some(json) = &cli.action {
parse_action(json)?
} else if let Some(path) = &cli.action_file {
let text = std::fs::read_to_string(path)?;
parse_action(&text)?
} else {
unreachable!();
};
return execute_action(&cli, &exec, action);
}
let backend = backend_flag(&cli);
let full_phrase = cli.text.join(" ");
// 4. Explicit legacy mode (--legacy)
if cli.legacy {
if let Some(application) = parse_install_text(&full_phrase) {
if let Some(b) = backend {
let mut request = InstallRequest::new(&application);
request.backend = Some(b);
let plan = service::plan_legacy_install(&plans, &exec, &cli.root, &request)?;
return render_and_execute_plan(&cli, &exec, &plans, plan);
} else {
eprintln!("sys: legacy install requires an explicit package source flag.");
eprintln!("Specify one of:");
eprintln!(" sys install {application} --legacy --flatpak");
eprintln!(" sys install {application} --legacy --portage");
eprintln!(" sys install {application} --legacy --nix");
eprintln!(" sys install {application} --legacy --snap");
eprintln!(" sys install {application} --legacy --appimage");
eprintln!(" sys install {application} --legacy --ebuild");
return Err("legacy install requires an explicit package source flag (--flatpak, --portage, --nix, --snap, --appimage, --ebuild)".into());
}
}
if let Some(application) = parse_removal_text(&full_phrase) {
let plan = service::plan_removal(&plans, &exec, &cli.root, &application, backend)?;
return render_and_execute_plan(&cli, &exec, &plans, plan);
}
if backend.is_some() {
return Err(
"--portage/--flatpak/--nix/--snap/--appimage/--ebuild only apply to \
`sys install <application>` or `sys remove <application>`"
.into(),
);
}
if full_phrase.trim().is_empty() {
return Err("usage: sys <instruction> --legacy".into());
}
return match parse_natural(&full_phrase) {
Some(action) => execute_action(&cli, &exec, action),
None => {
eprintln!("sys: could not parse `{full_phrase}` in legacy mode.");
eprintln!(
"Legacy mode grammar: sys install <app> --legacy --<source> | \
sys remove <app> --legacy [--<source>] | \
sys history --legacy | sys undo --legacy | sys enable <service> --legacy | \
sys disable <service> --legacy | sys choose <app> --legacy"
);
Err("unsupported instruction in legacy mode".into())
}
};
}
// 5. Default AI mode (natural language)
if cli.text.is_empty() {
eprintln!("sys: no instruction provided.");
eprintln!("Natural language administration is the default:");
eprintln!(" sys install <application>");
eprintln!(" sys please install <application>");
eprintln!(" sys remove <application>");
eprintln!(" sys ask \"<request>\"");
eprintln!("Or select deterministic legacy administration:");
eprintln!(" sys install <application> --legacy --<source>");
eprintln!(" sys remove <application> --legacy [--<source>]");
eprintln!(" sys history --legacy");
eprintln!(" sys undo --legacy");
return Err("missing instruction".into());
}
// Conversational `sys ask <request>`
if cli.text.first().map(String::as_str) == Some("ask") {
let instruction = cli.text[1..].join(" ");
if instruction.trim().is_empty() {
return Err("usage: sys ask <request>".into());
}
return run_ask(&cli, &exec, &plans, &instruction, backend);
}
// Natural `sys install <app>` / `sys please install <app>`
if let Some(application) = parse_install_text(&full_phrase) {
return run_install(&cli, &exec, &plans, &application, backend);
}
// Natural `sys remove <app>` / `sys please remove <app>`
if let Some(application) = parse_removal_text(&full_phrase) {
return run_remove(&cli, &exec, &plans, &application, backend);
}
if backend.is_some() {
return Err(
"--portage/--flatpak/--nix/--snap/--appimage/--ebuild only apply to \
`sys install <application>` or `sys remove <application>`"
.into(),
);
}
// Other natural language instructions enter the AI workflow by default
run_ask(&cli, &exec, &plans, &full_phrase, None)
}
fn execute_action(
cli: &Cli,
exec: &Exec,
action: SystemAction,
) -> std::result::Result<(), Box<dyn std::error::Error>> {
println!("{}", actions::preview(&action));
let approved = match actions::resolve_effects(exec, &action, &cli.root) {
Ok(plan) if !plan.effects.is_empty() => {
println!("{}", plan.render());
Some(plan)
}
Ok(_) => None,
Err(e) => {
eprintln!("sys: could not resolve effects ({e}); refusing to proceed unreviewed");
return Err("effect resolution failed".into());
}
};
// Only genuinely privileged actions require root. A personal package
// preference is mutable user state and is written by the invoking account.
if action.requires_root() && effective_uid() != 0 {
return Err("mutating actions require root; run `sudo sys ...`".into());
}
let auth: Option<DestructiveAuthorization> = if action.requires_root() {
let confirmation = SysConfirm {
action: action.clone(),
assume_yes: cli.yes,
};
Some(authorize(
&confirmation,
&actions::preview(&action),
"execute",
)?)
} else {
None
};
let outcome =
actions::execute_checked(exec, &action, auth.as_ref(), &cli.root, approved.as_ref())?;
if let Some(id) = &outcome.snapshot {
println!("protective snapshot: {id}");
}
println!("{}", outcome.output);
if action.is_mutating() {
let described = action.describe();
let record = TransactionRecord {
id: 0,
created_unix: now_unix(),
origin: "sys-legacy".into(),
summary: described.clone(),
actions: vec![described.clone()],
result: "ok".into(),
snapshot: outcome.snapshot.clone(),
digest: approved.as_ref().map(|p| p.digest.clone()),
outcomes: vec![TransactionOutcome::completed(described)],
};
record_transaction(exec, &cli.root, record)?;
}
Ok(())
}
/// A caller-provided question/answer function for the AI install loop.
type AskFn = dyn Fn(&str) -> Option<String>;
/// Map the explicit backend flags to a lane. The clap arg group forbids more
/// than one, so at most one is set.
fn backend_flag(cli: &Cli) -> Option<Backend> {
if cli.portage {
Some(Backend::PortageSource)
} else if cli.flatpak {
Some(Backend::Flatpak)
} else if cli.nix {
Some(Backend::Nix)
} else if cli.snap {
Some(Backend::Snap)
} else if cli.appimage {
Some(Backend::AppImage)
} else if cli.ebuild {
Some(Backend::CustomEbuild)
} else {
None
}
}
fn backend_flag_name(backend: Backend) -> &'static str {
match backend {
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => "portage",
Backend::Flatpak => "flatpak",
Backend::Nix => "nix",
Backend::Snap => "snap",
Backend::AppImage => "appimage",
Backend::CustomEbuild => "ebuild",
}
}
/// Parse `install <application>` / `add <application>` / `please install <application>`.
fn parse_install_text(text: &str) -> Option<String> {
let mut trimmed = text.trim();
for prefix in ["please ", "Please "] {
if let Some(rest) = trimmed.strip_prefix(prefix) {
trimmed = rest.trim();
break;
}
}
let lower = trimmed.to_ascii_lowercase();
for prefix in ["install ", "add "] {
if lower.starts_with(prefix) {
let app = trimmed[prefix.len()..].trim();
if !app.is_empty() && !app.contains(char::is_whitespace) && !app.starts_with('-') {
return Some(app.to_string());
}
}
}
None
}
/// Parse `remove <application>` / `uninstall <application>` / `delete <application>` / `please remove <application>`.
fn parse_removal_text(text: &str) -> Option<String> {
let mut trimmed = text.trim();
for prefix in ["please ", "Please "] {
if let Some(rest) = trimmed.strip_prefix(prefix) {
trimmed = rest.trim();
break;
}
}
let lower = trimmed.to_ascii_lowercase();
for prefix in ["remove ", "uninstall ", "delete "] {
if lower.starts_with(prefix) {
let app = trimmed[prefix.len()..].trim();
if !app.is_empty() && !app.contains(char::is_whitespace) && !app.starts_with('-') {
return Some(app.to_string());
}
}
}
None
}
/// Load the installed system's configuration instead of assuming defaults.
fn load_installed_config(root: &Path) -> InstallConfig {
let path = root.join("etc/phoebus/install.toml");
std::fs::read_to_string(&path)
.ok()
.and_then(|text| InstallConfig::from_toml(&text).ok())
.unwrap_or_default()
}
fn install_asker(cli: &Cli) -> Option<Box<AskFn>> {
use std::io::IsTerminal;
if cli.yes || !std::io::stdin().is_terminal() {
return None;
}
Some(Box::new(|question: &str| {
println!("\nThe assistant needs to know: {question}");
eprint!("> ");
use std::io::Write;
std::io::stdout().flush().ok();
let mut line = String::new();
match std::io::stdin().read_line(&mut line) {
Ok(n) if n > 0 => {
let t = line.trim();
if t.is_empty() {
None
} else {
Some(t.to_string())
}
}
_ => None,
}
}))
}
/// Explain that an unqualified install needs a model, and show the
/// deterministic candidate selection without installing it.
fn print_install_offer(cli: &Cli, exec: &Exec, application: &str) {
let need = InstallRequest::new(application).need();
match chooser::choose(exec, &cli.root, &need) {
Ok(selection) => println!("{}", selection.render()),
Err(e) => eprintln!("sys: the deterministic selector also found no candidate: {e}"),
}
eprintln!();
eprintln!("No connected model is available for an unqualified install, so Phoebus will");
eprintln!("not choose a lane for you. Install explicitly with legacy mode, for example:");
eprintln!(" sys install {application} --legacy --flatpak");
eprintln!(" sys install {application} --legacy --portage");
eprintln!(" sys install {application} --legacy --nix");
eprintln!(" sys install {application} --legacy --snap");
eprintln!(" sys install {application} --legacy --appimage");
eprintln!(" sys install {application} --legacy --ebuild");
}
/// `sys install <application>`: the shared installation workflow.
fn run_install(
cli: &Cli,
exec: &Exec,
plans: &service::PlanStore,
application: &str,
backend: Option<Backend>,
) -> std::result::Result<(), Box<dyn std::error::Error>> {
let mut request = InstallRequest::new(application);
request.backend = backend;
let resolved = resolve_ai(cli);
let facts = gather_facts(exec);
if !resolved.is_configured() {
if let Some(b) = backend {
eprintln!("sys: no AI model is configured for this request.");
eprintln!("Run deterministically without a model using legacy mode:");
eprintln!(
" sys install {application} --legacy --{}",
backend_flag_name(b)
);
} else {
print_install_offer(cli, exec, application);
}
return Err("no AI provider configured".into());
}
let transport = match resolved.transport(exec) {
Ok(t) => t,
Err(e) => {
if let Some(b) = backend {
eprintln!("sys: {e}");
eprintln!("Run deterministically without a model using legacy mode:");
eprintln!(
" sys install {application} --legacy --{}",
backend_flag_name(b)
);
} else {
print_install_offer(cli, exec, application);
}
return Err(e.to_string().into());
}
};
let provider = resolved.provider;
let endpoint = if resolved.backend == AiBackend::OpenCode {
resolved.opencode_server.clone()
} else {
resolved.endpoint.clone()
};
let model = if resolved.backend == AiBackend::OpenCode {
resolved.opencode_model.clone()
} else {
resolved.model.clone()
};
if let Some(b) = backend {
eprintln!(
"Investigating `{application}` (constrained to {}) with {} (bounded, read-only evidence only)...",
b.as_str(),
provider.as_str()
);
} else {
eprintln!(
"Investigating `{application}` with {} (bounded, read-only evidence only)...",
provider.as_str()
);
}
let ai = AiInstall {
provider,
endpoint,
model,
transport: transport.as_ref(),
limits: phoebus_ai::install::Limits::default(),
};
let asker = install_asker(cli);
let session = ExecutorSession {
exec,
root: &cli.root,
ask: asker.as_deref(),
};
let plan = match service::plan_install(
plans,
exec,
&cli.root,
&request,
&session,
Some(&ai),
&facts,
) {
Ok(plan) => plan,
Err(e) => {
// The model failed: offer the actionable legacy alternative and stop;
// do not install through any backend.
if let Some(b) = backend {
eprintln!("sys: the AI investigation did not produce a plan ({e}).");
eprintln!("Run deterministically without a model using legacy mode:");
eprintln!(
" sys install {application} --legacy --{}",
backend_flag_name(b)
);
} else {
print_install_offer(cli, exec, application);
}
return Err(format!("the AI investigation did not produce a plan: {e}").into());
}
};
let conv_path = conversation::history_path();
record_turn(
exec,
&conv_path,
ConversationTurn {
timestamp_unix: now_unix(),
query: format!("install {application}"),
response_kind: "install".into(),
application: Some(application.to_string()),
chosen_candidate: plan.candidate.clone(),
alternatives: plan.alternatives.clone(),
plan_id: Some(plan.id.clone()),
plan_digest: Some(plan.digest.clone()),
rationale: plan.rationale.clone(),
},
);
render_and_execute_plan(cli, exec, plans, plan)
}
/// `sys remove <application>`: the shared AI-first removal workflow. Default
/// removal goes through the connected model; only `--legacy` bypasses it. The
/// deterministic ownership discovery and policy validation run underneath in
/// both modes.
fn run_remove(
cli: &Cli,
exec: &Exec,
plans: &service::PlanStore,
application: &str,
backend: Option<Backend>,
) -> std::result::Result<(), Box<dyn std::error::Error>> {
let plan = match run_remove_plan(cli, exec, plans, application, backend) {
Ok(plan) => plan,
Err(e) => {
// The model failed: offer the actionable legacy alternative and
// stop; do not silently remove deterministically.
eprintln!("sys: the AI-assisted removal did not produce a plan ({e}).");
eprintln!("Run deterministically without a model using legacy mode:");
let lane = backend
.map(|b| format!(" --{}", backend_flag_name(b)))
.unwrap_or_default();
eprintln!(" sys remove {application} --legacy{lane}");
return Err(format!("the AI-assisted removal did not produce a plan: {e}").into());
}
};
let conv_path = conversation::history_path();
record_turn(
exec,
&conv_path,
ConversationTurn {
timestamp_unix: now_unix(),
query: format!("remove {application}"),
response_kind: "removal".into(),
application: Some(application.to_string()),
chosen_candidate: None,
alternatives: Vec::new(),
plan_id: Some(plan.id.clone()),
plan_digest: Some(plan.digest.clone()),
rationale: plan.rationale.clone(),
},
);
render_and_execute_plan(cli, exec, plans, plan)
}
/// Build a removal plan through the connected model (default) or the
/// deterministic selector (legacy). The model only chooses/confirms among
/// copies the deterministic discovery already found.
fn run_remove_plan(
cli: &Cli,
exec: &Exec,
plans: &service::PlanStore,
application: &str,
backend: Option<Backend>,
) -> std::result::Result<PreparedPlan, Box<dyn std::error::Error>> {
if cli.legacy {
return Ok(service::plan_removal(
plans,
exec,
&cli.root,
application,
backend,
)?);
}
let resolved = resolve_ai(cli);
if !resolved.is_configured() {
return Err("no AI provider configured".into());
}
let transport = resolved.transport(exec).map_err(|e| e.to_string())?;
let ai = AiInstall {
provider: resolved.provider,
endpoint: if resolved.backend == AiBackend::OpenCode {
resolved.opencode_server.clone()
} else {
resolved.endpoint.clone()
},
model: if resolved.backend == AiBackend::OpenCode {
resolved.opencode_model.clone()
} else {
resolved.model.clone()
},
transport: transport.as_ref(),
limits: phoebus_ai::install::Limits::default(),
};
let facts = gather_facts(exec);
service::plan_removal_with_ai(plans, exec, &cli.root, application, backend, &ai, &facts)
.map_err(Into::into)
}
fn render_and_execute_plan(
cli: &Cli,
exec: &Exec,
plans: &service::PlanStore,
plan: PreparedPlan,
) -> std::result::Result<(), Box<dyn std::error::Error>> {
println!("{}", plan.render());
if plan.requires_root && effective_uid() != 0 {
return Err("mutating actions require root; run `sudo sys ...`".into());
}
if plan.requires_root && !cli.yes {
let confirmation = SysConfirm {
action: plan
.actions
.first()
.cloned()
.unwrap_or(SystemAction::History),
assume_yes: false,
};
authorize(&confirmation, &plan.summary, "execute")?;
}
let outcome = service::execute_plan(exec, &cli.root, plans, &plan.id, &plan.digest, true)?;
if let Some(snapshot) = outcome.snapshot {
println!("protective snapshot: {snapshot}");
}
for line in &outcome.output {
if !line.trim().is_empty() {
println!("{line}");
}
}
if !outcome.verification.is_empty() {
println!("{}", outcome.verification);
}
Ok(())
}
/// Bounded system facts for the assistant: hardware, selected profile and
/// measured compile times. No personal files, credentials or command history.
fn gather_facts(exec: &Exec) -> SystemFacts {
let config = load_installed_config(&exec.root);
let hardware = probe::probe_hardware(exec.runner.as_ref());
let history = phoebus_core::load_history(&exec.root.join("var/lib/phoebus/compile-times.tsv"));
let binhost = exec.root.join("etc/portage/binrepos.conf").exists();
let mut facts = SystemFacts::from_system(&config, &hardware, &history, binhost, None);
let hw = chooser::hardware_facts(exec, &exec.root);
facts.storage_free_mib = hw.storage_free_mib;
facts.wayland = hw.wayland;
facts.available_backends = hw
.available_backends
.iter()
.map(|b| b.as_str().to_string())
.collect();
let prefs = chooser::load_preferences(&exec.root);
facts.saved_preferences = prefs
.per_app
.iter()
.map(|(app, backend)| (app.clone(), backend.as_str().to_string()))
.collect();
facts.recovery_snapshots = exec
.root
.join(phoebus_executor::snapshot::SNAPSHOT_DIR)
.is_dir();
facts
}
fn load_installed_ai_config(root: &Path) -> Option<phoebus_core::AiConfig> {
let conf_path = root.join("etc/phoebus/assistant.conf");
let text = std::fs::read_to_string(&conf_path).ok()?;
toml::from_str(&text).ok()
}
/// Resolve provider configuration and credential references through the shared
/// setup module, so the CLI and the GUI cannot diverge.
fn resolve_ai(cli: &Cli) -> phoebus_installer::ai_setup::ResolvedAi {
let conf = load_installed_ai_config(&cli.root);
let overrides = phoebus_installer::ai_setup::AiOverrides {
backend: cli.ai_backend.clone(),
provider: cli.ai_provider.clone(),
model: cli.ai_model.clone(),
endpoint: cli.ai_endpoint.clone(),
api_key_file: cli.ai_api_key_file.clone(),
opencode_server: cli.opencode_server.clone(),
opencode_provider: cli.opencode_provider.clone(),
opencode_model: cli.opencode_model.clone(),
opencode_password_file: cli.opencode_password_file.clone(),
no_sandbox: cli.no_sandbox,
use_environment: true,
};
phoebus_installer::ai_setup::resolve(&cli.root, &overrides, conf.as_ref())
}
fn deterministic_fallback(instruction: &str) {
eprintln!("No connected model is available. The deterministic legacy interface still works:");
match parse_natural(instruction) {
Some(action) => {
eprintln!(" sys {} --legacy", action.describe());
eprintln!("Run it as: sys {} --legacy", instruction.trim());
}
None => {
eprintln!(
" Examples: sys enable sshd --legacy | sys install vim --legacy --<source> | \
sys history --legacy | sys undo --legacy"
);
eprintln!(" A model only makes this easier; it is never required.");
}
}
}
/// The assistant loop: gather facts -> propose validated actions -> show
/// effects -> approve/authenticate -> execute deterministically -> record.
fn run_ask(
cli: &Cli,
exec: &Exec,
plans: &service::PlanStore,
instruction: &str,
backend: Option<Backend>,
) -> std::result::Result<(), Box<dyn std::error::Error>> {
// An explicit application reference takes precedence over any inferred
// conversational reference: "install vlc using flatpak" concerns VLC even
// right after a conversation about Firefox.
if let Some((application, source)) = conversation::parse_explicit_install(instruction) {
return run_install(cli, exec, plans, &application, source.or(backend));
}
if let Some(application) = parse_removal_text(instruction) {
return run_remove(cli, exec, plans, &application, backend);
}
let conv_path = conversation::history_path();
let history = conversation::load_history(&conv_path);
if let Some(followup) = conversation::resolve_followup(instruction, &history) {
match followup {
FollowupResolution::Comparison { explanation, .. } => {
println!("{explanation}");
return Ok(());
}
FollowupResolution::SwitchBackend {
application,
target_backend,
} => {
return run_install(cli, exec, plans, &application, Some(target_backend));
}
FollowupResolution::ConfirmPlan { plan_id, digest } => {
// Conversational confirmation never bypasses normal plan
// validation or authentication: it references a reviewed plan
// and goes through the same execution boundary.
let plan = plans.load(&plan_id)?;
if plan.digest != digest {
return Err("plan digest mismatch".into());
}
return render_and_execute_plan(cli, exec, plans, plan);
}
}
}
let resolved = resolve_ai(cli);
if !resolved.is_configured() {
deterministic_fallback(instruction);
return Err("no AI provider configured".into());
}
let transport = match resolved.transport(exec) {
Ok(t) => t,
Err(e) => {
deterministic_fallback(instruction);
return Err(e.to_string().into());
}
};
let facts = gather_facts(exec);
let provider = resolved.provider;
let endpoint = if resolved.backend == AiBackend::OpenCode {
resolved.opencode_server.clone()
} else {
resolved.endpoint.clone()
};
let model = if resolved.backend == AiBackend::OpenCode {
resolved.opencode_model.clone()
} else {
resolved.model.clone()
};
let ai = AiInstall {
provider,
endpoint,
model,
transport: transport.as_ref(),
limits: phoebus_ai::install::Limits::default(),
};
let plan = match service::plan_general(plans, exec, &cli.root, instruction, &facts, &ai) {
Ok(plan) => plan,
Err(e) => {
eprintln!("The model is unavailable or returned an unusable plan: {e}");
deterministic_fallback(instruction);
return Err("model unavailable".into());
}
};
record_turn(
exec,
&conv_path,
ConversationTurn {
timestamp_unix: now_unix(),
// Persist the plan's own summary, not the raw request: structured
// context is sufficient for follow-ups and minimizes exposure.
query: plan.summary.clone(),
response_kind: "plan".into(),
application: None,
chosen_candidate: None,
alternatives: Vec::new(),
plan_id: Some(plan.id.clone()),
plan_digest: Some(plan.digest.clone()),
rationale: plan.rationale.clone(),
},
);
render_and_execute_plan(cli, exec, plans, plan)
}
#[allow(dead_code)]
fn _auto() -> AutoConfirm {
AutoConfirm
}