//! Phoebus OS installer CLI. //! //! With no mode flags on a terminal, the text UI starts. The deterministic //! backend is available directly with `--plan`, `--dry-run` and `--install`. //! Secrets are supplied through files, never on the command line. use std::io::Write; use std::path::PathBuf; use std::process::ExitCode; use clap::Parser; use phoebus_ai::provider::ProviderKind; use phoebus_core::{InstallConfig, Redactor, SecretString}; use phoebus_executor::{ authorize, AutoConfirm, Confirmation, DestructiveAuthorization, Exec, Logger, RealRunner, Result, }; use phoebus_installer::Installer; use phoebus_tui::TuiOutcome; /// Pinned OpenCode release manifest. Embedded so the static binary needs no /// runtime resources. See `resources/opencode.manifest`. const OPENCODE_MANIFEST: &str = include_str!("../resources/opencode.manifest"); /// Resolve the manifest text. `PHOEBUS_OPENCODE_MANIFEST` overrides the /// embedded copy so a fixture can be verified end to end (tests, mirrors). fn opencode_manifest() -> std::io::Result { match std::env::var("PHOEBUS_OPENCODE_MANIFEST") { Ok(path) if !path.is_empty() => std::fs::read_to_string(path), _ => Ok(OPENCODE_MANIFEST.to_string()), } } #[derive(Parser, Debug)] #[command( name = "phoebus-installer", version, about = "Phoebus OS installer (deterministic backend + TUI)" )] struct Cli { /// Load configuration from a file (TOML or the legacy flat format). #[arg(long)] config: Option, /// Render the installation plan and exit. #[arg(long)] plan: bool, /// Do not execute commands or modify the target. #[arg(long)] dry_run: bool, /// Run the deterministic backend without the TUI. #[arg(long)] install: bool, /// Skip interactive confirmations (for unattended installs). #[arg(long, short = 'y')] yes: bool, /// Read the LUKS passphrase from a 0600 file. #[arg(long)] luks_passphrase_file: Option, /// Read the user password from a 0600 file. #[arg(long)] user_password_file: Option, /// Read the root password from a 0600 file. #[arg(long)] root_password_file: Option, /// Write the effective configuration as TOML and exit. #[arg(long)] save_config: Option, /// Fetch and verify the pinned OpenCode release, then exit. #[arg(long)] bootstrap_opencode: bool, /// Enable AI-assisted optimization (opt-in). The facts sent are shown first. #[arg(long)] ai: bool, /// AI provider: `deepseek`, `openai`/`chatgpt`, or `none`. #[arg(long, value_name = "PROVIDER")] ai_provider: Option, /// Model name override for the selected provider. #[arg(long, value_name = "MODEL")] ai_model: Option, /// Read the provider API key from a mode-0600 file (never stored in config). #[arg(long, value_name = "FILE")] ai_api_key_file: Option, /// Apply a proposal from a file (a chat response or a bare proposal JSON). #[arg(long, value_name = "FILE")] ai_proposal_file: Option, /// Print the system facts that would be sent to the model, then exit. #[arg(long)] ai_facts: bool, /// Override the provider endpoint (self-hosted/local models). #[arg(long, value_name = "URL")] ai_endpoint: Option, /// Install without AI (break-glass for recovery/automation). Also /// `--legacy` or `PHOEBUS_NO_AI=1`. #[arg(long, alias = "legacy")] no_ai: bool, /// Print a named desktop asset (session scripts, config, entries) and exit. /// Used by the live ISO build so it reuses the installer's exact assets. #[arg(long, value_name = "NAME", hide = true)] emit_asset: Option, /// Verify that an assembled live rootfs bundles a complete NVIDIA payload /// (kernel modules for its kernel, userspace, Wayland/EGL/GBM integration /// and firmware), write the version record to /etc/phoebus/nvidia, and exit. /// Fails (nonzero) on any missing or mismatched component. Used by the live /// ISO build, including cached-rootfs builds. #[arg(long, value_name = "ROOTFS", hide = true)] verify_live_nvidia: Option, /// The NVIDIA driver version bundled in the live image (recorded by /// `--verify-live-nvidia`). #[arg(long, value_name = "VERSION", hide = true)] nvidia_version: Option, /// The NVIDIA kernel-module flavor bundled in the live image: /// `proprietary` (default) or `open`. #[arg(long, value_name = "FLAVOR", hide = true)] nvidia_flavor: Option, /// Print the live medium's display-driver decision as stable `key=value` /// lines and exit. Consumed by the live-only `phoebus-nvidia-load` /// service; the decision comes from the actual PCI display devices and the /// bundled branch's capabilities, never from a vendor-name match. #[arg(long, hide = true)] live_gpu_plan: bool, /// Override the sysfs root used by `--live-gpu-plan` (fixtures/testing). #[arg(long, value_name = "PATH", hide = true)] sysfs_root: Option, /// Override the kernel command line used by `--live-gpu-plan`. #[arg(long, value_name = "CMDLINE", hide = true)] kernel_cmdline: Option, /// Speak the typed JSON protocol used by the graphical installer frontend /// (stdin/stdout). Not intended for direct interactive use. #[arg(long, hide = true)] gui_bridge: bool, /// Probe a running OpenCode server (e.g. `http://127.0.0.1:4096`) and print /// its capability as JSON. Read-only; exits nonzero unless a model catalog /// is available. Never prints provider credentials. #[arg(long, value_name = "URL")] opencode_probe: Option, /// Obtain a real model response through an OpenCode server and validate it, /// then exit. This is the acceptance test for inference, not reachability. #[arg(long, value_name = "URL")] opencode_test: Option, /// OpenCode agent server URL, e.g. `http://127.0.0.1:4096`. #[arg(long, value_name = "URL")] opencode_server: Option, /// OpenCode provider id (e.g. `deepseek`). #[arg(long, value_name = "PROVIDER")] opencode_provider: Option, /// OpenCode model id (e.g. `deepseek-chat`). #[arg(long, value_name = "MODEL")] opencode_model: Option, /// Read the OpenCode server password from a mode-0600 file (distinct from a /// model provider API key). #[arg(long, value_name = "FILE")] opencode_password_file: Option, /// AI backend for install guidance: `direct` (default) or `opencode`. #[arg(long, value_name = "BACKEND")] ai_backend: Option, } /// Verify the live rootfs's bundled NVIDIA payload and write its record. This /// is a build-time gate: a missing module, library or firmware file makes the /// live ISO build fail rather than shipping an image that cannot accelerate the /// GPU it advertises. It is independent of any cached-rootfs path. fn verify_live_nvidia_command(cli: &Cli, rootfs: &std::path::Path) -> ExitCode { use phoebus_core::NvidiaModuleFlavor; let version = cli.nvidia_version.clone().unwrap_or_default(); if version.trim().is_empty() { eprintln!("--verify-live-nvidia requires --nvidia-version"); return ExitCode::FAILURE; } let flavor = match cli.nvidia_flavor.as_deref().unwrap_or("proprietary") { "open" => NvidiaModuleFlavor::Open, "proprietary" => NvidiaModuleFlavor::Proprietary, other => { eprintln!("unknown --nvidia-flavor `{other}` (expected `proprietary` or `open`)"); return ExitCode::FAILURE; } }; match phoebus_executor::live_nvidia::verify_live_nvidia(rootfs, &version, flavor) { Ok(payload) => { let dir = rootfs.join("etc/phoebus"); if let Err(e) = std::fs::create_dir_all(&dir) { eprintln!("cannot create {}: {e}", dir.display()); return ExitCode::FAILURE; } if let Err(e) = std::fs::write(dir.join("nvidia"), payload.record()) { eprintln!("cannot write the NVIDIA record: {e}"); return ExitCode::FAILURE; } println!("{}", payload.render()); ExitCode::SUCCESS } Err(e) => { eprintln!("NVIDIA live payload verification failed: {e}"); ExitCode::FAILURE } } } /// Print the live medium's display-driver decision as stable `key=value` lines. /// /// This is the single authority the live-only `phoebus-nvidia-load` service /// consults. It is deterministic, read-only and outside the AI boundary: the /// action follows the actual PCI display devices and the bundled branch, and /// fail-safe graphics (`nomodeset` / `phoebus.nvidia=off`) always wins. fn live_gpu_plan_command(cli: &Cli) -> ExitCode { let sysfs = cli .sysfs_root .clone() .unwrap_or_else(|| PathBuf::from("/sys")); let cmdline = cli .kernel_cmdline .clone() .or_else(|| std::fs::read_to_string("/proc/cmdline").ok()) .unwrap_or_default(); let fail_safe = cmdline .split_whitespace() .any(|tok| tok == "nomodeset" || tok == "phoebus.nvidia=off"); let gpus = phoebus_executor::probe::probe_nvidia_display_devices(&sysfs); let devices: Vec = gpus .iter() .map(phoebus_core::nvidia::NvidiaDevice::from_gpu) .collect(); let plan = phoebus_core::nvidia::live_nvidia_plan(&devices, fail_safe); print!("{}", plan.render()); ExitCode::SUCCESS } struct TerminalConfirm; impl Confirmation for TerminalConfirm { fn confirm_erase(&self, preview: &str) -> Result { println!("\n{preview}"); print!("\nType ERASE to continue: "); std::io::stdout().flush().ok(); let mut line = String::new(); std::io::stdin().read_line(&mut line).map_err(|e| { phoebus_executor::ExecError::operation("confirm", "erase", e.to_string()) })?; Ok(line.trim() == "ERASE") } fn confirm_final(&self, message: &str) -> Result { print!("{message} [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("confirm", "final", e.to_string()) })?; Ok(matches!( line.trim().to_ascii_lowercase().as_str(), "y" | "yes" )) } } fn read_secret(path: &PathBuf) -> std::io::Result { let value = std::fs::read_to_string(path)?; Ok(SecretString::new(value.trim_end_matches(['\n', '\r']))) } /// A lightweight `Exec` for the OpenCode probe/test commands, which do not /// touch the target. fn opencode_exec() -> Exec { let dir = std::env::temp_dir().join("phoebus-opencode-cli"); let _ = std::fs::create_dir_all(&dir); let logger = Logger::open(dir.join("opencode.log"), Redactor::new(), false); Exec::new(Box::new(RealRunner::new()), logger, false, dir.clone(), dir) } /// Probe an OpenCode server (`validate_inference = false`) or obtain and /// validate a real model response (`true`). Exits nonzero unless the requested /// condition is met, so it can be used as an acceptance command. fn run_opencode_probe(cli: &Cli, url: &str, validate_inference: bool) -> ExitCode { use phoebus_executor::opencode_client::{CurlHttpClient, OpenCodeClient}; use phoebus_executor::opencode_server::{probe, ConnectionState, Endpoint, ProbeRequest}; let endpoint = match Endpoint::parse(url) { Ok(endpoint) => endpoint, Err(e) => { eprintln!("invalid OpenCode endpoint `{url}`: {e}"); return ExitCode::FAILURE; } }; let auth = match &cli.opencode_password_file { Some(path) => match read_secret(path) { Ok(secret) => Some(secret), Err(e) => { eprintln!("cannot read OpenCode password file: {e}"); return ExitCode::FAILURE; } }, None => None, }; let provider = cli.opencode_provider.clone().unwrap_or_default(); let model = cli.opencode_model.clone().unwrap_or_default(); let exec = opencode_exec(); let http = CurlHttpClient::new(&exec); if !validate_inference { let mut request = ProbeRequest::new(); request.auth = auth.clone(); request.provider = (!provider.is_empty()).then(|| provider.clone()); request.model = (!model.is_empty()).then(|| model.clone()); let capability = probe(&http, &endpoint, &request); match serde_json::to_string_pretty(&capability) { Ok(json) => println!("{json}"), Err(e) => eprintln!("could not render capability: {e}"), } return if matches!( capability.state, ConnectionState::ModelCatalog | ConnectionState::Ready ) { ExitCode::SUCCESS } else { ExitCode::FAILURE }; } if provider.is_empty() || model.is_empty() { eprintln!("--opencode-test requires --opencode-provider and --opencode-model"); return ExitCode::FAILURE; } let client = OpenCodeClient::new(&http, endpoint.base(), &provider, &model).with_auth(auth); match client.one_shot( "You are a connectivity test. Reply with JSON only.", "Reply with exactly {\"phoebus\":\"ok\"} and nothing else.", ) { Ok(reply) => match serde_json::from_str::(&reply.content) { Ok(value) if value.get("phoebus").and_then(|v| v.as_str()) == Some("ok") => { println!("validated model response: {}", reply.content); ExitCode::SUCCESS } Ok(value) => { println!("model responded, but not as requested: {value}"); ExitCode::FAILURE } Err(_) => { println!("model response was not JSON: {}", reply.content); ExitCode::FAILURE } }, Err(e) => { eprintln!("model validation failed: {e}"); ExitCode::FAILURE } } } /// The provider selected on the command line, or the one the TUI/config chose. fn resolve_provider( cli: &Cli, config: &InstallConfig, ) -> std::result::Result> { let raw = cli .ai_provider .as_deref() .unwrap_or(config.ai.provider.as_str()); ProviderKind::parse(raw).ok_or_else(|| { format!("unknown AI provider `{raw}` (use deepseek, openai, local or none)").into() }) } /// Whether the user explicitly asked for a deterministic, no-AI run. fn no_ai_requested(cli: &Cli) -> bool { cli.no_ai || std::env::var("PHOEBUS_NO_AI") .map(|v| matches!(v.to_ascii_lowercase().as_str(), "1" | "yes" | "true")) .unwrap_or(false) } /// Installing Phoebus requires a **validated** AI interaction, not just a /// non-empty provider name. `--no-ai`/`--legacy` is the explicit, documented /// break-glass for recovery or automation. fn require_ai_for_install( cli: &Cli, validated: bool, ) -> std::result::Result<(), Box> { if no_ai_requested(cli) || validated { return Ok(()); } Err( "installing Phoebus requires a successful, validated AI interaction.\n\ Connect a provider (--ai-backend direct with --ai-provider \ deepseek|openai|local and --ai-api-key-file/--ai-endpoint, or \ --ai-backend opencode with --opencode-server/--opencode-provider/\ --opencode-model) and let it return a valid proposal, or pass --no-ai \ (alias --legacy) for a deterministic install." .into(), ) } /// Apply AI guidance to the configuration before the plan is shown or install /// runs. Returns `true` only when a model interaction produced a valid, /// reviewed proposal. The model never sees secrets and never executes anything. fn run_ai_guidance( cli: &Cli, installer: &mut Installer, ) -> std::result::Result> { let wants_ai = cli.ai || cli.ai_proposal_file.is_some() || installer.config.ai.enabled; if !wants_ai { return Ok(false); } if let Some(path) = &cli.ai_proposal_file { let outcome = phoebus_installer::ai_guide::review_file(&mut installer.config, path)?; println!("{}", outcome.render()); return Ok(true); } let backend = cli .ai_backend .as_deref() .and_then(phoebus_core::AiBackend::parse) .unwrap_or(installer.config.ai.backend); let facts = installer.system_facts(); if backend == phoebus_core::AiBackend::OpenCode { let server = cli .opencode_server .clone() .or_else(|| std::env::var("PHOEBUS_OPENCODE_SERVER").ok()) .unwrap_or_else(|| installer.config.ai.opencode_server.clone()); let provider_id = cli .opencode_provider .clone() .or_else(|| std::env::var("PHOEBUS_OPENCODE_PROVIDER").ok()) .unwrap_or_else(|| installer.config.ai.opencode_provider.clone()); let model = cli .opencode_model .clone() .or_else(|| std::env::var("PHOEBUS_OPENCODE_MODEL").ok()) .unwrap_or_else(|| installer.config.ai.opencode_model.clone()); if server.trim().is_empty() || provider_id.trim().is_empty() || model.trim().is_empty() { eprintln!( "AI assistance is enabled but OpenCode is not fully configured \ (need server, provider and model); continuing without AI." ); return Ok(false); } let password = match &cli.opencode_password_file { Some(path) => Some(phoebus_executor::ai::load_api_key(path)?), None => None, }; eprintln!( "Sending these system facts through the OpenCode server at {} \ (provider {}, no passwords, passphrases or files):", server, provider_id ); eprintln!("{}", facts.render()); let transport = phoebus_executor::opencode_client::ExecOpenCodeTransport::new( &installer.exec, server.clone(), provider_id.clone(), model.clone(), ) .with_auth(password); return match phoebus_installer::ai_guide::generate_and_review_at( &mut installer.config, &facts, ProviderKind::Local, &server, &model, &transport, ) { Ok(outcome) => { println!("{}", outcome.render()); Ok(true) } Err(e) => { eprintln!("OpenCode proposal rejected; continuing with the proven defaults: {e}"); Ok(false) } }; } let provider = resolve_provider(cli, &installer.config)?; if provider == ProviderKind::None { eprintln!("AI assistance is enabled but no provider is selected; continuing without AI."); return Ok(false); } eprintln!( "Sending these system facts to {} (no passwords, passphrases or files):", provider.as_str() ); eprintln!("{}", facts.render()); let endpoint = cli .ai_endpoint .clone() .unwrap_or_else(|| provider.endpoint().to_string()); let api_key = match (&cli.ai_api_key_file, provider.requires_key()) { (Some(path), _) => Some(phoebus_executor::ai::load_api_key(path)?), (None, true) => { return Err(format!( "--ai-api-key-file is required for provider `{}`", provider.as_str() ) .into()); } (None, false) => None, }; let model = cli.ai_model.clone().unwrap_or_default(); let transport = phoebus_executor::ai::CurlTransport::new(&installer.exec, api_key); match phoebus_installer::ai_guide::generate_and_review_at( &mut installer.config, &facts, provider, &endpoint, &model, &transport, ) { Ok(outcome) => { println!("{}", outcome.render()); Ok(true) } Err(e) => { eprintln!("AI proposal rejected; continuing with the proven defaults: {e}"); Ok(false) } } } fn main() -> ExitCode { match run() { Ok(code) => code, Err(e) => { eprintln!("error: {e}"); ExitCode::FAILURE } } } fn run() -> std::result::Result> { let cli = Cli::parse(); if cli.gui_bridge { phoebus_installer::gui_bridge::run_stdio()?; return Ok(ExitCode::SUCCESS); } if let Some(url) = &cli.opencode_probe { return Ok(run_opencode_probe(&cli, url, false)); } if let Some(url) = &cli.opencode_test { return Ok(run_opencode_probe(&cli, url, true)); } if let Some(name) = &cli.emit_asset { return match phoebus_core::system::desktop_asset(name) { Some(text) => { print!("{text}"); Ok(ExitCode::SUCCESS) } None => { eprintln!("unknown desktop asset: {name}"); Ok(ExitCode::FAILURE) } }; } if cli.live_gpu_plan { return Ok(live_gpu_plan_command(&cli)); } if let Some(rootfs) = &cli.verify_live_nvidia { return Ok(verify_live_nvidia_command(&cli, rootfs)); } let mut config = if let Some(path) = &cli.config { InstallConfig::load_from_path(path)? } else { InstallConfig::default() }; if cli.dry_run { config.runtime.dry_run = true; } if cli.yes { config.runtime.assume_yes = true; } // Secrets may come from CLI files or the TUI. let mut luks = cli .luks_passphrase_file .as_ref() .map(read_secret) .transpose()?; let mut user_pw = cli .user_password_file .as_ref() .map(read_secret) .transpose()?; let root_pw = cli .root_password_file .as_ref() .map(read_secret) .transpose()?; let mut tui_confirmed = false; let mut do_install = cli.install; // TUI when no explicit mode and a terminal is present. if !cli.plan && !cli.install && !cli.dry_run && !cli.bootstrap_opencode && phoebus_tui::is_tty() { match phoebus_tui::run(config.clone())? { TuiOutcome::Exit => return Ok(ExitCode::SUCCESS), TuiOutcome::Save(saved) => { let path = cli .config .clone() .unwrap_or_else(|| PathBuf::from("phoebus-install.toml")); std::fs::write(&path, saved.to_toml_string()?)?; println!("wrote {}", path.display()); return Ok(ExitCode::SUCCESS); } TuiOutcome::Install(saved, tui_luks, tui_user) => { config = saved; if luks.is_none() { luks = tui_luks; } if user_pw.is_none() { user_pw = tui_user; } do_install = true; tui_confirmed = true; } } } let mut state_dir = PathBuf::from(&config.runtime.state_dir); if std::fs::create_dir_all(&state_dir).is_err() { state_dir = PathBuf::from("/tmp/phoebus-installer"); std::fs::create_dir_all(&state_dir).ok(); } let log_path = state_dir.join("install.log"); let echo = std::env::var("PHOEBUS_LOG_ECHO") .map(|v| matches!(v.to_ascii_lowercase().as_str(), "yes" | "1" | "true")) .unwrap_or(false); let logger = Logger::open(&log_path, Redactor::new(), echo); let root = if config.runtime.dry_run { let sandbox = state_dir.join("dry-run-root"); std::fs::create_dir_all(&sandbox).ok(); sandbox } else { PathBuf::from(&config.storage.install_root) }; let logger_clone = logger.clone(); let runner = RealRunner::with_sink(std::sync::Arc::new(move |text: &str| { logger_clone.stream_output(text); })); let exec = Exec::new( Box::new(runner), logger, config.runtime.dry_run, root, state_dir.clone(), ); for secret in [&luks, &user_pw, &root_pw].into_iter().flatten() { exec.register_secret(secret); } if cli.bootstrap_opencode { let manifest = phoebus_executor::opencode::Manifest::parse(&opencode_manifest()?); let dest = phoebus_executor::opencode::bin_dir(&state_dir); let installed = phoebus_executor::opencode::ensure(&exec, &manifest, &dest)?; println!("OpenCode ready at {}", installed.display()); return Ok(ExitCode::SUCCESS); } let mut installer = Installer::new(config, exec); if cli.ai_facts { println!("{}", installer.system_facts().render()); return Ok(ExitCode::SUCCESS); } let ai_validated = run_ai_guidance(&cli, &mut installer)?; // CLI parity with the GUI bridge: hold the validated credential in memory // so finalize can persist it when reuse is selected (default). if installer.config.ai.reuse_ai_connection { let api_key = match &cli.ai_api_key_file { Some(p) => phoebus_executor::ai::load_api_key(p).ok(), None => None, }; let opencode_pw = match &cli.opencode_password_file { Some(p) => phoebus_executor::ai::load_api_key(p).ok(), None => None, }; if api_key.is_some() || opencode_pw.is_some() { installer.set_pending_ai_credentials(api_key, opencode_pw); } } // AI is mandatory to install, and a validated interaction (not merely a // provider name) is required; a deterministic no-AI run needs the explicit // break-glass. Dry-run and plan modes are exempt. if do_install && !installer.config.runtime.dry_run { require_ai_for_install(&cli, ai_validated)?; } if let Some(path) = &cli.save_config { std::fs::write(path, installer.config.to_toml_string()?)?; println!("wrote {}", path.display()); } // Plan / default mode. if cli.plan || !do_install { print!("{}", installer.render_plan()); let issues = installer.validate(); println!("\nValidation:"); if issues.is_empty() { println!(" OK"); } else { for issue in &issues { println!(" - {issue}"); } } return Ok(ExitCode::SUCCESS); } // Install mode. let issues = installer.validate(); if !issues.is_empty() { eprintln!("configuration is incomplete:"); for issue in &issues { eprintln!(" - {issue}"); } return Ok(ExitCode::FAILURE); } print!("{}", installer.render_plan()); let auth: DestructiveAuthorization = if tui_confirmed || installer.config.runtime.assume_yes { authorize( &AutoConfirm, &installer.destructive_preview(), "Start installation?", )? } else { let preview = installer.destructive_preview(); authorize( &TerminalConfirm, &preview, "Start the installation now? This can take a long time.", )? }; installer.install(&auth, luks.as_ref(), user_pw.as_ref(), root_pw.as_ref())?; if installer.config.runtime.dry_run { println!( "dry-run complete; log: {}", installer.exec.log_path().display() ); } else { println!( "installation complete; log: {}", installer.exec.log_path().display() ); } Ok(ExitCode::SUCCESS) }