From 0d65d56eda1c39b43ac3e5a60cb610bd87868333 Mon Sep 17 00:00:00 2001 From: Phoebus Date: Tue, 22 Sep 2026 02:36:29 -0700 Subject: [PATCH] feat(installer): wire OpenCode into the GUI, CLI and sys ask Select the OpenCode adapter from canonical config in ai_check/ai_test; add --ai-backend/--opencode-* flags to the installer and sys. Require a validated interaction (not a provider name) for the mandatory-AI gate in both the bridge and the CLI, invalidated by config, model or credential changes. Tests cover the gate, invalidation and the OpenCode backend. --- .../crates/phoebus-installer/src/bin/sys.rs | 175 +++++-- .../phoebus-installer/src/gui_bridge.rs | 471 +++++++++++++++--- .../crates/phoebus-installer/src/main.rs | 257 ++++++++-- .../phoebus-installer/tests/ai_guidance.rs | 24 +- 4 files changed, 784 insertions(+), 143 deletions(-) diff --git a/installer-rs/crates/phoebus-installer/src/bin/sys.rs b/installer-rs/crates/phoebus-installer/src/bin/sys.rs index 29d89df..c9dff15 100644 --- a/installer-rs/crates/phoebus-installer/src/bin/sys.rs +++ b/installer-rs/crates/phoebus-installer/src/bin/sys.rs @@ -11,10 +11,11 @@ use std::process::ExitCode; use clap::Parser; use phoebus_ai::assistant::{complete_plan, AssistantPlan}; -use phoebus_ai::provider::{ProviderKind, SystemFacts}; +use phoebus_ai::provider::{ModelTransport, ProviderKind, SystemFacts}; use phoebus_core::action::{parse_action, parse_natural, SystemAction}; use phoebus_core::transaction::TransactionRecord; -use phoebus_core::{InstallConfig, Redactor}; +use phoebus_core::{AiBackend, InstallConfig, Redactor}; +use phoebus_executor::opencode_client::ExecOpenCodeTransport; use phoebus_executor::{ actions, authorize, probe, transaction, AutoConfirm, Confirmation, DestructiveAuthorization, Exec, Logger, RealRunner, Result, @@ -61,6 +62,26 @@ struct Cli { /// 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, + + /// 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. + #[arg(long, value_name = "FILE")] + opencode_password_file: Option, } struct SysConfirm { @@ -214,6 +235,16 @@ fn gather_facts(exec: &Exec) -> SystemFacts { SystemFacts::from_system(&config, &hardware, &history, binhost, None) } +/// The AI backend selected on the command line or the environment. +fn resolve_backend(cli: &Cli) -> AiBackend { + let raw = cli + .ai_backend + .clone() + .or_else(|| std::env::var("PHOEBUS_AI_BACKEND").ok()) + .unwrap_or_default(); + AiBackend::parse(&raw).unwrap_or(AiBackend::Direct) +} + /// The provider selected on the command line or the environment. fn resolve_provider(cli: &Cli) -> ProviderKind { let raw = cli @@ -270,48 +301,112 @@ fn run_ask( exec: &Exec, instruction: &str, ) -> std::result::Result<(), Box> { - let provider = resolve_provider(cli); - if provider == ProviderKind::None { - deterministic_fallback(instruction); - return Err("no AI provider configured".into()); - } - let endpoint = resolve_endpoint(cli, provider); - let model = resolve_model(cli); - let key = match api_key_file(cli) { - Some(path) => Some(phoebus_executor::ai::load_api_key(&path)?), - None => None, - }; - if provider.requires_key() && key.is_none() { - deterministic_fallback(instruction); - return Err(format!( - "provider `{}` requires --ai-api-key-file (mode 0600)", - provider.as_str() - ) - .into()); - } - let facts = gather_facts(exec); - eprintln!( - "Sending these bounded system facts to {} (no passwords, files or home directories):", - provider.as_str() - ); - eprintln!("{}", facts.render()); + let backend = resolve_backend(cli); + let (provider, endpoint, model); + let transport: Box; - let transport = phoebus_executor::ai::CurlTransport::new(exec, key); - let transport = if cli.no_sandbox { - transport - } else { - transport.sandboxed() - }; - let plan: AssistantPlan = - match complete_plan(provider, &endpoint, &model, &facts, instruction, &transport) { - Ok(plan) => plan, - Err(e) => { - eprintln!("The model is unavailable or returned an unusable plan: {e}"); + match backend { + AiBackend::OpenCode => { + let server = cli + .opencode_server + .clone() + .or_else(|| std::env::var("PHOEBUS_OPENCODE_SERVER").ok()) + .unwrap_or_default(); + let opencode_provider = cli + .opencode_provider + .clone() + .or_else(|| std::env::var("PHOEBUS_OPENCODE_PROVIDER").ok()) + .unwrap_or_default(); + let opencode_model = cli + .opencode_model + .clone() + .or_else(|| std::env::var("PHOEBUS_OPENCODE_MODEL").ok()) + .unwrap_or_default(); + if server.trim().is_empty() + || opencode_provider.trim().is_empty() + || opencode_model.trim().is_empty() + { deterministic_fallback(instruction); - return Err("model unavailable".into()); + return Err( + "OpenCode requires --opencode-server, --opencode-provider and --opencode-model" + .into(), + ); } - }; + let password = match &cli.opencode_password_file { + Some(path) => Some(phoebus_executor::ai::load_api_key(path)?), + None => None, + }; + eprintln!( + "Sending these bounded system facts through the OpenCode server at {} \ + (provider {}, model {}); no passwords, files or home directories:", + server, opencode_provider, opencode_model + ); + eprintln!("{}", facts.render()); + provider = ProviderKind::Local; + endpoint = server; + model = opencode_model; + transport = Box::new( + ExecOpenCodeTransport::new( + exec, + endpoint.clone(), + opencode_provider, + model.clone(), + ) + .with_auth(password), + ); + } + AiBackend::Direct => { + let resolved = resolve_provider(cli); + if resolved == ProviderKind::None { + deterministic_fallback(instruction); + return Err("no AI provider configured".into()); + } + let key = match api_key_file(cli) { + Some(path) => Some(phoebus_executor::ai::load_api_key(&path)?), + None => None, + }; + if resolved.requires_key() && key.is_none() { + deterministic_fallback(instruction); + return Err(format!( + "provider `{}` requires --ai-api-key-file (mode 0600)", + resolved.as_str() + ) + .into()); + } + eprintln!( + "Sending these bounded system facts to {} \ + (no passwords, files or home directories):", + resolved.as_str() + ); + eprintln!("{}", facts.render()); + provider = resolved; + endpoint = resolve_endpoint(cli, resolved); + model = resolve_model(cli); + let direct = phoebus_executor::ai::CurlTransport::new(exec, key); + transport = if cli.no_sandbox { + Box::new(direct) + } else { + Box::new(direct.sandboxed()) + }; + } + } + + let plan: AssistantPlan = match complete_plan( + provider, + &endpoint, + &model, + &facts, + instruction, + transport.as_ref(), + ) { + Ok(plan) => plan, + Err(e) => { + eprintln!("The model is unavailable or returned an unusable plan: {e}"); + deterministic_fallback(instruction); + return Err("model unavailable".into()); + } + }; println!("{}", plan.render()); diff --git a/installer-rs/crates/phoebus-installer/src/gui_bridge.rs b/installer-rs/crates/phoebus-installer/src/gui_bridge.rs index 7de68e5..fb4f6a8 100644 --- a/installer-rs/crates/phoebus-installer/src/gui_bridge.rs +++ b/installer-rs/crates/phoebus-installer/src/gui_bridge.rs @@ -18,9 +18,10 @@ use std::io::{self, BufRead, Write}; use crate::{ai_guide, InstallObserver, Installer}; use phoebus_ai::provider::{ModelTransport, ProviderKind, SystemFacts}; -use phoebus_core::{InstallConfig, InstallStep, SecretString}; +use phoebus_core::{AiBackend, InstallConfig, InstallStep, SecretString}; use phoebus_executor::ai::CurlTransport; use phoebus_executor::auth::{authorize, Confirmation}; +use phoebus_executor::opencode_client::ExecOpenCodeTransport; use phoebus_executor::{Exec, Result as ExecResult}; use serde::Deserialize; @@ -70,6 +71,10 @@ struct SecretsPatch { root_password: Option, #[serde(default)] ai_api_key: Option, + /// The OpenCode server password (basic auth). Distinct from a model + /// provider API key and never stored in the configuration. + #[serde(default)] + opencode_password: Option, } /// A `Confirmation` whose answers come from an explicit GUI request. The ERASE @@ -164,7 +169,12 @@ pub struct Bridge { user_password: Option, root_password: Option, api_key: Option, + opencode_password: Option, approved_digest: Option, + /// Set only after a real, validated AI interaction (a proposal reviewed for + /// the direct path, or a validated model response for OpenCode). A mere + /// provider name never satisfies the mandatory-AI gate. + validated_ai: Option, phase: std::rc::Rc>, /// One destructive transaction at a time. An approval is single-use: it is /// consumed when the install starts so a replay, a second frontend or a @@ -183,7 +193,9 @@ impl Bridge { user_password: None, root_password: None, api_key: None, + opencode_password: None, approved_digest: None, + validated_ai: None, phase: std::rc::Rc::new(std::cell::Cell::new(DiskPhase::BeforeStorage)), installing: false, installed: false, @@ -199,7 +211,9 @@ impl Bridge { user_password: None, root_password: None, api_key: None, + opencode_password: None, approved_digest: None, + validated_ai: None, phase: std::rc::Rc::new(std::cell::Cell::new(DiskPhase::BeforeStorage)), installing: false, installed: false, @@ -251,6 +265,7 @@ impl Bridge { "plan" => self.plan(), "destructive_preview" => self.destructive_preview(), "ai_check" => self.ai_check(), + "ai_test" => self.ai_test(), "approve" => self.approve(&request), "start_install" => return self.start_install(id, &request, out), "log_tail" => self.log_tail(&request), @@ -405,6 +420,9 @@ impl Bridge { self.installer.reconfigure(config); self.approved_digest = None; + // A configuration change (provider, model, endpoint, server) invalidates + // any previous AI validation. + self.validated_ai = None; let issues = self.installer.validate(); Ok(json!({ "accepted": true, @@ -427,6 +445,7 @@ impl Bridge { &patch.user_password, &patch.root_password, &patch.ai_api_key, + &patch.opencode_password, ] .into_iter() .flatten() @@ -455,12 +474,20 @@ impl Bridge { self.installer.exec.register_secret(&s); self.api_key = Some(s); } + if let Some(v) = &patch.opencode_password { + let s = SecretString::new(v.clone()); + self.installer.exec.register_secret(&s); + self.opencode_password = Some(s); + } + // A credential change invalidates any previous AI validation. + self.validated_ai = None; // Report only presence, never values. Ok(json!({ "luks_set": self.luks.is_some(), "user_password_set": self.user_password.is_some(), "root_password_set": self.root_password.is_some(), "ai_api_key_set": self.api_key.is_some(), + "opencode_password_set": self.opencode_password.is_some(), })) } @@ -468,33 +495,107 @@ impl Bridge { fn ai_check(&mut self) -> Result { let facts = self.installer.system_facts(); - let api_key_present = self.api_key.is_some(); - let Bridge { - installer, - api_key, - approved_digest, - .. - } = self; - let Installer { exec, config, .. } = installer; - let transport = CurlTransport::new(exec, api_key.clone()); - let value = review_proposal(config, exec.redactor(), facts, api_key_present, &transport)?; - *approved_digest = None; + let backend = self.installer.config.ai.backend; + let api_key = self.api_key.clone(); + let opencode_password = self.opencode_password.clone(); + let value = { + let Installer { exec, config, .. } = &mut self.installer; + let redactor = exec.redactor(); + match backend { + AiBackend::OpenCode => { + let transport = opencode_transport(exec, config, opencode_password)?; + review_opencode(config, redactor, facts, &transport)? + } + AiBackend::Direct => { + let transport = CurlTransport::new(exec, api_key.clone()); + review_proposal(config, redactor, facts, api_key.is_some(), &transport)? + } + } + }; + self.approved_digest = None; + // Bind the validated interaction to the exact configuration it was + // validated against; any later change clears it. + self.validated_ai = Some(self.plan_digest()); Ok(value) } + /// A real, minimal model interaction that obtains and validates a JSON model + /// response without changing the configuration. This is "Test connection". + fn ai_test(&mut self) -> Result { + use phoebus_ai::provider::{build_request, extract_content}; + let backend = self.installer.config.ai.backend; + let facts = self.installer.system_facts(); + let redactor = self.installer.exec.redactor(); + let (kind, endpoint, model, label) = match backend { + AiBackend::OpenCode => { + let (server, provider, model) = opencode_parts(&self.installer.config)?; + (ProviderKind::Local, server, model, provider) + } + AiBackend::Direct => { + let raw = self.installer.config.ai.provider.clone(); + let provider = ProviderKind::parse(&raw) + .ok_or_else(|| format!("unknown AI provider `{raw}`"))?; + if provider == ProviderKind::None { + return Err("no AI provider selected".into()); + } + let endpoint = if self.installer.config.ai.endpoint.is_empty() { + provider.endpoint().to_string() + } else { + self.installer.config.ai.endpoint.clone() + }; + let model = if self.installer.config.ai.model.is_empty() { + provider.default_model().to_string() + } else { + self.installer.config.ai.model.clone() + }; + (provider, endpoint, model, provider.as_str().to_string()) + } + }; + let request = build_request(kind, &model, &facts); + let body = serde_json::to_string(&request) + .map_err(|e| format!("could not build the test request: {e}"))?; + let response = match backend { + AiBackend::OpenCode => { + let (server, provider, model) = opencode_parts(&self.installer.config)?; + let transport = + ExecOpenCodeTransport::new(&self.installer.exec, server, provider, model) + .with_auth(self.opencode_password.clone()); + transport.send(kind, &endpoint, &body) + } + AiBackend::Direct => { + let transport = CurlTransport::new(&self.installer.exec, self.api_key.clone()); + transport.send(kind, &endpoint, &body) + } + } + .map_err(|e| format!("connection failed: {}", redactor.redact(&e.to_string())))?; + let content = extract_content(&response).map_err(|e| { + format!( + "model response was not usable: {}", + redactor.redact(&e.to_string()) + ) + })?; + serde_json::from_str::(&content) + .map_err(|_| "model response was not JSON".to_string())?; + Ok(json!({ + "connected": true, + "backend": backend.as_str(), + "provider": label, + "model": model, + "response": content, + })) + } + /// Validate the provider connection and review the proposal (fail-closed). /// Exposed so tests can drive it with a canned transport. pub fn ai_check_with(&mut self, transport: &dyn ModelTransport) -> Result { let facts = self.installer.system_facts(); let api_key_present = self.api_key.is_some(); - let Bridge { - installer, - approved_digest, - .. - } = self; - let Installer { exec, config, .. } = installer; - let value = review_proposal(config, exec.redactor(), facts, api_key_present, transport)?; - *approved_digest = None; + let value = { + let Installer { exec, config, .. } = &mut self.installer; + review_proposal(config, exec.redactor(), facts, api_key_present, transport)? + }; + self.approved_digest = None; + self.validated_ai = Some(self.plan_digest()); Ok(value) } @@ -558,18 +659,20 @@ impl Bridge { } // AI is mandatory to install unless this is a dry run or an explicit - // break-glass (mirrors the CLI rule). + // break-glass. A validated interaction is required: merely naming a + // provider is not enough. The validation is bound to the current + // configuration, so a change since validation invalidates it. let dry_run = self.installer.config.runtime.dry_run; if !dry_run { - let provider = ProviderKind::parse(&self.installer.config.ai.provider) - .unwrap_or(ProviderKind::None); let break_glass = std::env::var("PHOEBUS_NO_AI") .map(|v| matches!(v.to_ascii_lowercase().as_str(), "1" | "yes" | "true")) .unwrap_or(false); - if provider == ProviderKind::None && !break_glass { + let validated = self.validated_ai.as_deref() == Some(current.as_str()); + if !validated && !break_glass { return Err( - "installing Phoebus requires a connected AI model; connect a provider \ - or set PHOEBUS_NO_AI=1 for a deterministic install" + "installing Phoebus requires a successful, validated AI interaction for \ + the current configuration; connect and validate a model, or set \ + PHOEBUS_NO_AI=1 for a deterministic install" .into(), ); } @@ -602,6 +705,7 @@ impl Bridge { // Consume the approval and mark the session busy before any destructive // work: a replay or a second frontend can never reach storage_prepare. self.approved_digest = None; + self.validated_ai = None; self.installing = true; let outcome = self.installer.install_observed( &auth, @@ -757,8 +861,109 @@ fn config_digest(config: &InstallConfig) -> String { format!("{:x}", hasher.finalize()) } -/// Parse the provider from the configuration, validate the connection and apply -/// the reviewed proposal. This is the same `ai_guide` path the TUI uses. +/// The OpenCode server URL, provider id and model id, validated for presence. +fn opencode_parts(config: &InstallConfig) -> Result<(String, String, String), String> { + let server = config.ai.opencode_server.trim().to_string(); + let provider = config.ai.opencode_provider.trim().to_string(); + let model = config.ai.opencode_model.trim().to_string(); + if server.is_empty() { + return Err("OpenCode requires a server URL".into()); + } + if provider.is_empty() { + return Err("OpenCode requires a provider".into()); + } + if model.is_empty() { + return Err("OpenCode requires a model".into()); + } + // Fail fast on an unsafe endpoint, before any request is attempted. + phoebus_executor::opencode_server::Endpoint::parse(&server) + .map_err(|e| format!("invalid OpenCode endpoint: {e}"))?; + Ok((server, provider, model)) +} + +fn opencode_transport<'a>( + exec: &'a Exec, + config: &InstallConfig, + password: Option, +) -> Result, String> { + let (server, provider, model) = opencode_parts(config)?; + Ok( + phoebus_executor::opencode_client::ExecOpenCodeTransport::new( + exec, server, provider, model, + ) + .with_auth(password), + ) +} + +#[allow(clippy::too_many_arguments)] +fn finish_review( + config: &mut InstallConfig, + redactor: &phoebus_core::Redactor, + facts: SystemFacts, + kind: ProviderKind, + endpoint: &str, + provider_label: &str, + model: &str, + transport: &dyn ModelTransport, + backend: &str, +) -> Result { + let outcome = + ai_guide::generate_and_review_at(config, &facts, kind, endpoint, model, transport) + .map_err(|e| { + // Error messages are redacted before they reach the GUI. + format!( + "connection or proposal failed: {}", + redactor.redact(&e.to_string()) + ) + })?; + let applied: Vec = outcome + .applied + .iter() + .map(|c| { + json!({ + "description": c.description, + "reason": c.reason, + "evidence": c.evidence, + }) + }) + .collect(); + Ok(json!({ + "connected": true, + "backend": backend, + "provider": provider_label, + "model": model, + "endpoint": endpoint, + "applied": applied, + "config": config, + "plan_digest": config_digest(config), + })) +} + +/// OpenCode proposal review: the adapter talks the agent protocol and the +/// shared strict proposal parser/review applies the accepted changes. +fn review_opencode( + config: &mut InstallConfig, + redactor: &phoebus_core::Redactor, + facts: SystemFacts, + transport: &dyn ModelTransport, +) -> Result { + let (server, provider_id, model) = opencode_parts(config)?; + finish_review( + config, + redactor, + facts, + ProviderKind::Local, + &server, + &provider_id, + &model, + transport, + "opencode", + ) +} + +/// Parse the direct provider from the configuration, validate the connection +/// and apply the reviewed proposal. This is the same `ai_guide` path the TUI +/// uses. fn review_proposal( config: &mut InstallConfig, redactor: &phoebus_core::Redactor, @@ -788,36 +993,17 @@ fn review_proposal( provider.as_str() )); } - - let outcome = - ai_guide::generate_and_review_at(config, &facts, provider, &endpoint, &model, transport) - .map_err(|e| { - // Error messages are redacted before they reach the GUI. - format!( - "connection or proposal failed: {}", - redactor.redact(&e.to_string()) - ) - })?; - let applied: Vec = outcome - .applied - .iter() - .map(|c| { - json!({ - "description": c.description, - "reason": c.reason, - "evidence": c.evidence, - }) - }) - .collect(); - Ok(json!({ - "connected": true, - "provider": provider.as_str(), - "model": model, - "endpoint": endpoint, - "applied": applied, - "config": config, - "plan_digest": config_digest(config), - })) + finish_review( + config, + redactor, + facts, + provider, + &endpoint, + provider.as_str(), + &model, + transport, + "direct", + ) } /// The stdio entry point used by `--gui-bridge`. @@ -1275,4 +1461,173 @@ mod tests { let lines = call(&mut bridge, &line); assert_eq!(response(&lines)["ok"], json!(false)); } + + /// A non-dry bridge whose runner reports `/dev/vda`, so revalidation and + /// the install stages run against the fake runner (never a real disk). + fn test_bridge_non_dry() -> Bridge { + let runner = RecordingRunner::new(); + runner.set_response( + "lsblk", + phoebus_executor::CommandOutput { + status: 0, + success: true, + stdout: b"NAME=\"vda\" MODEL=\"QEMU HARDDISK\" SIZE=\"32212254720\" TRAN=\"virtio\" RM=\"0\" RO=\"0\"\n".to_vec(), + stderr: Vec::new(), + duration: std::time::Duration::from_millis(1), + }, + ); + let dir = tempfile::tempdir().unwrap().keep(); + let logger = Logger::open(dir.join("install.log"), Redactor::new(), false); + let mut config = InstallConfig::default(); + config.runtime.dry_run = false; + config.system.hostname = "phoebus".into(); + config.system.timezone = "UTC".into(); + config.user.username = "tester".into(); + config.storage.disk = "/dev/vda".into(); + let exec = Exec::new( + Box::new(runner), + logger, + false, + dir.join("root"), + dir.clone(), + ); + let mut installer = Installer::new(config, exec); + installer.disks.push(Disk { + path: "/dev/vda".into(), + model: Some("QEMU HARDDISK".into()), + size_bytes: 30 * 1024 * 1024 * 1024, + transport: Some("virtio".into()), + removable: false, + read_only: false, + mounted: false, + is_block_device: true, + kind: DiskKind::Physical, + live_media: false, + }); + Bridge::with_installer(installer) + } + + fn arm_ai(bridge: &mut Bridge) -> Value { + let mut c = config_json(bridge); + c["ai"]["provider"] = json!("deepseek"); + c["ai"]["model"] = json!("deepseek-chat"); + let _ = call( + bridge, + &json!({ "id": 30, "op": "set_config", "config": c }).to_string(), + ); + bridge.api_key = Some(SecretString::new("test-key")); + let proposal = r#"{"version":1,"changes":[{"action":"set_kernel_profile","value":"safe"}],"rationale":[{"action":"set_kernel_profile","reason":"stability","evidence":["x"]}]}"#; + bridge + .ai_check_with(&TestTransport::proposal(proposal)) + .expect("ai_check") + } + + fn start(bridge: &mut Bridge, digest: &str) -> Value { + let lines = call( + bridge, + &json!({ + "id": 31, "op": "start_install", "erase": "ERASE", + "final_confirm": true, "plan_digest": digest + }) + .to_string(), + ); + response(&lines) + } + + #[test] + fn a_provider_name_alone_does_not_satisfy_the_ai_requirement() { + let mut bridge = test_bridge_non_dry(); + set_valid_config(&mut bridge); + // Provider configured and key present, but no validated interaction. + let mut c = config_json(&bridge); + c["ai"]["provider"] = json!("deepseek"); + let _ = call( + &mut bridge, + &json!({ "id": 40, "op": "set_config", "config": c }).to_string(), + ); + bridge.api_key = Some(SecretString::new("test-key")); + let (digest, _) = approve(&mut bridge); + let resp = start(&mut bridge, &digest); + assert_eq!(resp["ok"], json!(false)); + assert!( + resp["error"] + .as_str() + .unwrap() + .contains("validated AI interaction"), + "unexpected error: {}", + resp["error"] + ); + } + + #[test] + fn a_validated_interaction_satisfies_the_ai_requirement() { + let mut bridge = test_bridge_non_dry(); + set_valid_config(&mut bridge); + arm_ai(&mut bridge); + let (digest, _) = approve(&mut bridge); + let resp = start(&mut bridge, &digest); + // It may fail later in the fake storage stage, but never on the AI gate. + assert!( + !resp["error"] + .as_str() + .unwrap_or("") + .contains("validated AI interaction"), + "the AI gate wrongly rejected a validated interaction: {}", + resp["error"] + ); + } + + #[test] + fn a_config_change_invalidates_the_validated_interaction() { + let mut bridge = test_bridge_non_dry(); + set_valid_config(&mut bridge); + arm_ai(&mut bridge); + // Change the model after validation. + let mut c = config_json(&bridge); + c["ai"]["model"] = json!("deepseek-reasoner"); + let _ = call( + &mut bridge, + &json!({ "id": 41, "op": "set_config", "config": c }).to_string(), + ); + let (digest, _) = approve(&mut bridge); + let resp = start(&mut bridge, &digest); + assert_eq!(resp["ok"], json!(false)); + assert!(resp["error"] + .as_str() + .unwrap() + .contains("validated AI interaction")); + } + + #[test] + fn a_secret_change_invalidates_the_validated_interaction() { + let mut bridge = test_bridge_non_dry(); + set_valid_config(&mut bridge); + arm_ai(&mut bridge); + let _ = call( + &mut bridge, + r#"{"id":42,"op":"set_secrets","secrets":{"ai_api_key":"new-key"}}"#, + ); + let (digest, _) = approve(&mut bridge); + let resp = start(&mut bridge, &digest); + assert_eq!(resp["ok"], json!(false)); + assert!(resp["error"] + .as_str() + .unwrap() + .contains("validated AI interaction")); + } + + #[test] + fn ai_test_is_a_known_operation_and_fails_without_a_provider() { + let mut bridge = test_bridge(); + let lines = call(&mut bridge, r#"{"id":43,"op":"ai_test"}"#); + let resp = response(&lines); + // Not "unknown op": the operation exists and reports the configuration + // problem instead. + assert_eq!(resp["ok"], json!(false)); + assert!( + !resp["error"].as_str().unwrap().contains("unknown op"), + "{}", + resp["error"] + ); + } } diff --git a/installer-rs/crates/phoebus-installer/src/main.rs b/installer-rs/crates/phoebus-installer/src/main.rs index 30947cb..1cabc7e 100644 --- a/installer-rs/crates/phoebus-installer/src/main.rs +++ b/installer-rs/crates/phoebus-installer/src/main.rs @@ -122,10 +122,36 @@ struct Cli { 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. + /// 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, } struct TerminalConfirm; @@ -161,6 +187,94 @@ fn read_secret(path: &PathBuf) -> std::io::Result { 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), 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, @@ -183,48 +297,116 @@ fn no_ai_requested(cli: &Cli) -> bool { .unwrap_or(false) } -/// Installing Phoebus requires a connected model. `--no-ai`/`--legacy` is the -/// explicit, documented break-glass for recovery or automation. +/// 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, - provider: ProviderKind, + validated: bool, ) -> std::result::Result<(), Box> { - if no_ai_requested(cli) || provider != ProviderKind::None { + if no_ai_requested(cli) || validated { 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()) + 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. The model never sees secrets and never executes anything: its response -/// is reviewed with mandatory evidence and applied atomically. +/// 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<(), Box> { - let provider = resolve_provider(cli, &installer.config)?; +) -> std::result::Result> { let wants_ai = cli.ai || cli.ai_proposal_file.is_some() || installer.config.ai.enabled; if !wants_ai { - return Ok(()); + 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(()); + 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(()); + return Ok(false); } - - // 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() @@ -244,7 +426,6 @@ fn run_ai_guidance( ) .into()); } - // A self-hosted local model usually needs no key. (None, false) => None, }; let model = cli.ai_model.clone().unwrap_or_default(); @@ -257,10 +438,15 @@ fn run_ai_guidance( &model, &transport, ) { - Ok(outcome) => println!("{}", outcome.render()), - Err(e) => eprintln!("AI proposal rejected; continuing with the proven defaults: {e}"), + Ok(outcome) => { + println!("{}", outcome.render()); + Ok(true) + } + Err(e) => { + eprintln!("AI proposal rejected; continuing with the proven defaults: {e}"); + Ok(false) + } } - Ok(()) } fn main() -> ExitCode { @@ -282,16 +468,10 @@ fn run() -> std::result::Result> { } 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 - }); + 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 { @@ -411,12 +591,13 @@ fn run() -> std::result::Result> { println!("{}", installer.system_facts().render()); return Ok(ExitCode::SUCCESS); } - run_ai_guidance(&cli, &mut installer)?; + let ai_validated = run_ai_guidance(&cli, &mut installer)?; - // AI is mandatory to install; a deterministic no-AI run needs the explicit + // 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, resolve_provider(&cli, &installer.config)?)?; + require_ai_for_install(&cli, ai_validated)?; } if let Some(path) = &cli.save_config { diff --git a/installer-rs/crates/phoebus-installer/tests/ai_guidance.rs b/installer-rs/crates/phoebus-installer/tests/ai_guidance.rs index 82c88e5..bddcc22 100644 --- a/installer-rs/crates/phoebus-installer/tests/ai_guidance.rs +++ b/installer-rs/crates/phoebus-installer/tests/ai_guidance.rs @@ -109,7 +109,7 @@ fn install_without_ai_is_refused() { .expect("run phoebus-installer"); assert!(!out.status.success()); let err = String::from_utf8_lossy(&out.stderr); - assert!(err.contains("requires a connected AI"), "{err}"); + assert!(err.contains("validated AI interaction"), "{err}"); } #[test] @@ -122,21 +122,31 @@ fn no_ai_is_the_explicit_break_glass() { .output() .expect("run phoebus-installer"); let err = String::from_utf8_lossy(&out.stderr); - assert!(!err.contains("requires a connected AI"), "{flag}: {err}"); + assert!(!err.contains("validated AI interaction"), "{flag}: {err}"); assert!(err.contains("configuration is incomplete"), "{flag}: {err}"); } } #[test] -fn local_provider_needs_no_key_at_the_gate() { - // A local provider satisfies the gate without --no-ai (it fails later at - // the incomplete config, not at the AI gate). +fn an_unreachable_provider_does_not_satisfy_the_ai_gate() { + // A provider *name* is not enough: without a real, validated model + // interaction the install is refused (a deliberately closed port makes the + // result deterministic and offline). let out = Command::new(bin()) - .args(["--install", "--yes", "--ai", "--ai-provider", "local"]) + .args([ + "--install", + "--yes", + "--ai", + "--ai-provider", + "local", + "--ai-endpoint", + "http://127.0.0.1:1/v1/chat/completions", + ]) .output() .expect("run phoebus-installer"); + assert!(!out.status.success()); let err = String::from_utf8_lossy(&out.stderr); - assert!(!err.contains("requires a connected AI"), "{err}"); + assert!(err.contains("validated AI interaction"), "{err}"); } #[test]