//! 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, /// 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 is /// available. Never prints provider credentials. #[arg(long, value_name = "URL")] opencode_probe: Option, } 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']))) } /// 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 connected model. `--no-ai`/`--legacy` is the /// explicit, documented break-glass for recovery or automation. fn require_ai_for_install( cli: &Cli, provider: ProviderKind, ) -> std::result::Result<(), Box> { if no_ai_requested(cli) || provider != ProviderKind::None { return Ok(()); } Err("installing Phoebus requires a connected AI model.\n\ Connect a provider (--ai-provider deepseek|openai|local, with \ --ai-api-key-file and/or --ai-endpoint), 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. The model never sees secrets and never executes anything: its response /// is reviewed with mandatory evidence and applied atomically. fn run_ai_guidance( cli: &Cli, installer: &mut Installer, ) -> std::result::Result<(), Box> { let provider = resolve_provider(cli, &installer.config)?; let wants_ai = cli.ai || cli.ai_proposal_file.is_some() || installer.config.ai.enabled; if !wants_ai { return Ok(()); } 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(()); } if provider == ProviderKind::None { eprintln!("AI assistance is enabled but no provider is selected; continuing without AI."); return Ok(()); } // Opt-in: show exactly what leaves the machine before sending it. let facts = installer.system_facts(); 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()); } // A self-hosted local model usually needs no key. (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()), Err(e) => eprintln!("AI proposal rejected; continuing with the proven defaults: {e}"), } Ok(()) } 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 { use phoebus_executor::opencode_server::{probe, ConnectionState, Endpoint}; let endpoint = Endpoint::parse(url).map_err(|e| format!("invalid OpenCode endpoint `{url}`: {e}"))?; let capability = probe(&endpoint, std::time::Duration::from_secs(5)); println!("{}", serde_json::to_string_pretty(&capability)?); return Ok(if capability.state == ConnectionState::Ready { ExitCode::SUCCESS } else { ExitCode::FAILURE }); } 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) } }; } 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 exec = Exec::new( Box::new(RealRunner), 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); } run_ai_guidance(&cli, &mut installer)?; // AI is mandatory to install; 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, resolve_provider(&cli, &installer.config)?)?; } 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) }