//! HTTP client and the OpenCode protocol adapter. //! //! OpenCode is an **agent server**, not an OpenAI-compatible model endpoint. //! This module talks its real HTTP API (sessions and messages) over the //! project's established transport (`curl` through [`Exec`]), so we do not //! maintain a second handwritten HTTP parser. A [`HttpClient`] trait keeps the //! protocol logic unit-testable with a fake, and a real TCP server can drive //! the curl path in integration tests. //! //! The server API used here was verified against the shipped //! `opencode 1.18.32`: //! //! * `GET /global/health` → `{healthy, version}` //! * `GET /provider` → provider/model metadata //! * `POST /session` → `{id}` //! * `POST /session/{id}/message` → `{info, parts}` (synchronous reply) //! * `POST /session/{id}/abort`, `DELETE /session/{id}` //! //! Only `TextPart`s of the assistant reply are accepted; tool, reasoning, //! snapshot and user parts are ignored. The `/provider` catalog can contain a //! `key` field upstream, so only ids and model names are ever extracted. use std::collections::BTreeMap; use std::io::Write; use std::net::IpAddr; use std::time::Duration; use phoebus_ai::provider::{ChatRequest, ModelTransport, ProviderKind}; use phoebus_ai::AiError; use phoebus_core::SecretString; use crate::command::CommandSpec; use crate::exec::Exec; /// Which HTTP method a request uses. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Method { Get, Post, Delete, } impl Method { fn as_str(self) -> &'static str { match self { Method::Get => "GET", Method::Post => "POST", Method::Delete => "DELETE", } } } /// A bounded HTTP request. Secrets travel in `auth`/`headers` and are injected /// through curl's stdin configuration, never argv or logs. #[derive(Debug, Clone)] pub struct HttpRequest { pub method: Method, /// The full URL, already policy-checked by the caller. pub url: String, /// Non-secret headers (Content-Type, Accept, ...). pub headers: Vec<(String, String)>, /// Optional basic-auth password. The username is supplied separately. pub auth: Option, pub auth_user: String, /// Request body; written to a 0600 temporary file for POST. pub body: Option, pub timeout: Duration, pub connect_timeout: Duration, pub max_body: u64, /// Pin the connection to a resolved address (`host`, `port`, `ip`) so a /// DNS answer that changes after the policy check cannot move the target. pub resolve: Option<(String, u16, IpAddr)>, } impl HttpRequest { pub fn get(url: impl Into) -> Self { Self::new(Method::Get, url) } pub fn post(url: impl Into, body: impl Into) -> Self { let mut req = Self::new(Method::Post, url); req.body = Some(body.into()); req } pub fn delete(url: impl Into) -> Self { Self::new(Method::Delete, url) } fn new(method: Method, url: impl Into) -> Self { Self { method, url: url.into(), headers: vec![("Accept".into(), "application/json".into())], auth: None, auth_user: "opencode".into(), body: None, timeout: Duration::from_secs(120), connect_timeout: Duration::from_secs(15), max_body: 4 * 1024 * 1024, resolve: None, } } } /// A bounded HTTP response. The body is capped by [`HttpRequest::max_body`]. #[derive(Debug, Clone)] pub struct HttpResponse { pub status: u16, pub body: String, } impl HttpResponse { pub fn is_success(&self) -> bool { (200..300).contains(&self.status) } } /// A pluggable HTTP transport. The production implementation is curl; tests /// supply a fake or a real local server. pub trait HttpClient { fn request(&self, request: &HttpRequest) -> Result; } /// The production transport: curl, driven through [`Exec`] so logging, /// redaction and dry-run all apply. Credentials are written into curl's config /// on **stdin** (hidden from argv and logs); the body travels in a 0600 temp /// file. Redirects are disabled and the protocol is restricted to http/https. pub struct CurlHttpClient<'a> { exec: &'a Exec, sandboxed: bool, } impl<'a> CurlHttpClient<'a> { pub fn new(exec: &'a Exec) -> Self { Self { exec, sandboxed: false, } } /// Run the request inside the OS-level model sandbox (same boundary as the /// direct provider transport). The body is inlined into the curl config on /// stdin because the sandbox has a private `/tmp`. pub fn sandboxed(mut self) -> Self { self.sandboxed = true; self } } const STATUS_MARKER: &str = "__PHOEBUS_STATUS__"; impl HttpClient for CurlHttpClient<'_> { fn request(&self, request: &HttpRequest) -> Result { let mut temp: Option = None; let data_line = if let Some(body) = &request.body { if self.sandboxed { // Inline the body (escaped) into the curl config: the sandbox's // PrivateTmp would hide a temp file created here. let escaped = body.replace('\\', "\\\\").replace('"', "\\\""); format!("data = \"{escaped}\"\n") } else { let mut file = tempfile::Builder::new() .prefix("phoebus-opencode.") .tempfile() .map_err(|e| AiError::Provider(format!("temp file: {e}")))?; file.write_all(body.as_bytes()) .and_then(|_| file.flush()) .map_err(|e| AiError::Provider(format!("temp file: {e}")))?; let line = format!("data = \"@{}\"\n", file.path().display()); temp = Some(file); line } } else { String::new() }; let auth = match (&request.auth, request.auth_user.is_empty()) { (Some(password), false) => { use base64_lite::encode; let token = encode(format!("{}:{}", request.auth_user, password.expose()).as_bytes()); self.exec.register_secret(password); // The derived token is what actually travels, so it must be // redacted too: a server that echoes the Authorization header // would otherwise leak the base64 form into the log. self.exec.register_secret(&SecretString::new(token.clone())); format!("header = \"Authorization: Basic {token}\"\n") } (Some(password), true) => { use base64_lite::encode; let token = encode(password.expose().as_bytes()); self.exec.register_secret(password); self.exec.register_secret(&SecretString::new(token.clone())); format!("header = \"Authorization: Bearer {token}\"\n") } _ => String::new(), }; let mut headers = String::new(); for (name, value) in &request.headers { headers.push_str(&format!( "header = \"{}: {}\"\n", sanitize_header(name), sanitize_header(value) )); } let resolve = match &request.resolve { Some((host, port, ip)) => { let addr = match ip { IpAddr::V4(v4) => v4.to_string(), IpAddr::V6(v6) => format!("[{v6}]"), }; format!("resolve = \"{host}:{port}:{addr}\"\n") } None => String::new(), }; let config = format!( "url = \"{url}\"\n\ request = \"{method}\"\n\ proto = \"=http,https\"\n\ max-redirs = 0\n\ connect-timeout = {connect}\n\ max-time = {total}\n\ max-filesize = {max}\n\ silent\nshow-error\n\ header = \"Expect:\"\n\ {headers}{auth}{resolve}{data_line}\ write-out = \"\\n{marker}%{{http_code}}\"\n", url = request.url, method = request.method.as_str(), connect = request.connect_timeout.as_secs().max(1), total = request.timeout.as_secs().max(1), max = request.max_body, marker = STATUS_MARKER, ); let out = if self.sandboxed { crate::sandbox::run( self.exec, "curl", &["-sS".into(), "-K".into(), "-".into()], config.into_bytes(), ) .map_err(|e| AiError::Provider(format!("transport error: {e}")))? } else { self.exec .run( CommandSpec::new("ai", "OpenCode request", "curl") .args(["-sS", "-K", "-"]) .stdin(config.into_bytes()), ) .map_err(|e| AiError::Provider(format!("transport error: {e}")))? }; drop(temp); let stdout = out.stdout_lossy(); let index = stdout .rfind(STATUS_MARKER) .ok_or_else(|| AiError::Provider("transport response had no status".into()))?; let status: u16 = stdout[index + STATUS_MARKER.len()..] .trim() .parse() .map_err(|_| AiError::Provider("transport response had an invalid status".into()))?; let body = stdout[..index].trim_end_matches(['\n', '\r']).to_string(); Ok(HttpResponse { status, body }) } } fn sanitize_header(value: &str) -> String { value .chars() .filter(|c| !c.is_control() && *c != '"' && *c != '\\') .collect() } /// A base64 encoder for the `Authorization: Basic` header. Kept local and tiny /// rather than adding a dependency for one header. mod base64_lite { const TABLE: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; pub fn encode(input: &[u8]) -> String { let mut out = String::with_capacity(input.len().div_ceil(3) * 4); for chunk in input.chunks(3) { let b = [ chunk[0], *chunk.get(1).unwrap_or(&0), *chunk.get(2).unwrap_or(&0), ]; out.push(TABLE[(b[0] >> 2) as usize] as char); out.push(TABLE[(((b[0] & 0x03) << 4) | (b[1] >> 4)) as usize] as char); if chunk.len() > 1 { out.push(TABLE[(((b[1] & 0x0f) << 2) | (b[2] >> 6)) as usize] as char); } else { out.push('='); } if chunk.len() > 2 { out.push(TABLE[(b[2] & 0x3f) as usize] as char); } else { out.push('='); } } out } } // --------------------------------------------------------------------------- // OpenCode protocol // --------------------------------------------------------------------------- /// A model offered by an OpenCode provider. #[derive(Debug, Clone, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)] pub struct ModelInfo { pub id: String, pub name: String, #[serde(default)] pub variants: Vec, } /// A parsed model catalog entry. Never carries upstream credentials. #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct ProviderEntry { pub id: String, pub name: String, pub models: Vec, pub connected: bool, } /// The provider/model catalog, extracted without ever reading a `key` field. #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct Catalog { pub providers: Vec, } impl Catalog { pub fn model_count(&self) -> usize { self.providers.iter().map(|p| p.models.len()).sum() } pub fn connected_model_count(&self) -> usize { self.providers .iter() .filter(|p| p.connected) .map(|p| p.models.len()) .sum() } pub fn has_model(&self, provider: &str, model: &str) -> bool { self.providers .iter() .any(|p| p.id == provider && p.models.iter().any(|m| m.id == model)) } pub fn default_model(&self, provider: &str) -> Option<&str> { self.providers .iter() .find(|p| p.id == provider) .and_then(|p| p.models.first()) .map(|m| m.id.as_str()) } } #[derive(Debug, serde::Deserialize)] struct ProviderCatalogBody { #[serde(default)] all: Vec, #[serde(default)] connected: Vec, #[serde(default)] default: BTreeMap, } #[derive(Debug, serde::Deserialize)] struct RawProvider { #[serde(default)] id: String, #[serde(default)] name: String, #[serde(default)] models: BTreeMap, } #[derive(Debug, serde::Deserialize, Default)] struct RawModel { #[serde(default)] id: String, #[serde(default)] name: String, #[serde(default)] variants: serde_json::Value, } fn extract_variants(val: &serde_json::Value) -> Vec { if let Some(map) = val.as_object() { map.keys().cloned().collect() } else if let Some(arr) = val.as_array() { arr.iter() .filter_map(|v| v.as_str().map(String::from)) .collect() } else { Vec::new() } } impl ProviderCatalogBody { fn into_catalog(self) -> Catalog { let mut defaults = self.default; let connected: std::collections::BTreeSet = self.connected.into_iter().collect(); let mut providers: Vec = self .all .into_iter() .map(|p| { let models = p .models .into_iter() .map(|(key, raw_val)| { if let Ok(m) = serde_json::from_value::(raw_val) { let id = if m.id.trim().is_empty() { key } else { m.id.trim().to_string() }; let name = if m.name.trim().is_empty() { id.clone() } else { m.name.trim().to_string() }; let mut variants = extract_variants(&m.variants); variants.sort(); ModelInfo { id, name, variants } } else { ModelInfo { id: key.clone(), name: key, variants: Vec::new(), } } }) .collect(); ProviderEntry { connected: connected.contains(&p.id), id: p.id, name: p.name, models, } }) .collect(); for provider in &mut providers { provider.models.sort_by(|a, b| a.id.cmp(&b.id)); if let Some(default) = defaults.remove(&provider.id) { // Bubble the default model to the front so callers can pick a // sensible default without a second request. if let Some(pos) = provider.models.iter().position(|m| m.id == default) { let model = provider.models.remove(pos); provider.models.insert(0, model); } } } Catalog { providers } } } /// Parse the `/provider` metadata body into a catalog without retaining any /// credential-bearing field. A non-JSON or unexpected body is an error, never a /// silently empty catalog. pub fn parse_catalog(body: &str) -> Result { // Require an object with an `all` array. Without this, serde's all-default // struct would happily accept `[]` or another misleading shape and report // an empty catalog instead of an incompatible server. let value: serde_json::Value = serde_json::from_str(body) .map_err(|e| AiError::Provider(format!("provider catalog was not valid JSON: {e}")))?; if !value.is_object() || value.get("all").map(|v| v.is_array()) != Some(true) { return Err(AiError::Provider( "provider catalog was not the expected object".into(), )); } let parsed: ProviderCatalogBody = serde_json::from_value(value) .map_err(|e| AiError::Provider(format!("provider catalog was not usable: {e}")))?; Ok(parsed.into_catalog()) } #[derive(Debug, serde::Deserialize)] struct SessionBody { #[serde(default)] id: String, } #[derive(Debug, serde::Deserialize)] struct MessageBody { #[serde(default)] info: MessageInfo, #[serde(default)] parts: Vec, } #[derive(Debug, serde::Deserialize, Default)] struct MessageInfo { #[serde(default)] role: String, #[serde(default)] error: Option, #[serde(default)] time: Option, } #[derive(Debug, serde::Deserialize, Default)] struct MessageTime { #[serde(default)] completed: Option, } #[derive(Debug, serde::Deserialize, Default)] struct Part { #[serde(rename = "type", default)] kind: String, #[serde(default)] text: Option, #[serde(default)] synthetic: Option, #[serde(default)] ignored: Option, } /// The accepted assistant reply: only the completed assistant text parts. #[derive(Debug, Clone, PartialEq, Eq)] pub struct AssistantReply { pub content: String, pub completed: bool, } impl MessageBody { fn into_reply(self) -> Result { if self.info.role != "assistant" { return Err(AiError::Provider( "the reply was not an assistant message".into(), )); } if let Some(error) = &self.info.error { // The upstream error object can echo provider text; keep only the // error name, never a credential-bearing payload. let name = error .get("name") .and_then(|v| v.as_str()) .unwrap_or("provider error"); return Err(AiError::Provider(format!("model error: {name}"))); } let mut content = String::new(); for part in &self.parts { if part.kind != "text" { continue; } if part.synthetic == Some(true) || part.ignored == Some(true) { continue; } if let Some(text) = &part.text { if !content.is_empty() { content.push('\n'); } content.push_str(text); } } if content.trim().is_empty() { return Err(AiError::Provider( "the assistant returned no usable text".into(), )); } let completed = self.info.time.as_ref().and_then(|t| t.completed).is_some(); Ok(AssistantReply { content, completed }) } } /// A protocol client for one OpenCode server, provider and model. pub struct OpenCodeClient<'a> { http: &'a dyn HttpClient, base: String, auth: Option, provider: String, model: String, variant: Option, timeout: Duration, max_body: u64, resolve: Option<(String, u16, IpAddr)>, } impl<'a> OpenCodeClient<'a> { pub fn new( http: &'a dyn HttpClient, base: impl Into, provider: impl Into, model: impl Into, ) -> Self { Self { http, base: base.into(), auth: None, provider: provider.into(), model: model.into(), variant: None, timeout: Duration::from_secs(120), max_body: 4 * 1024 * 1024, resolve: None, } } pub fn with_auth(mut self, password: Option) -> Self { self.auth = password; self } pub fn with_variant(mut self, variant: impl Into) -> Self { self.variant = Some(variant.into()); self } pub fn with_timeout(mut self, timeout: Duration) -> Self { self.timeout = timeout; self } pub fn with_max_body(mut self, max_body: u64) -> Self { self.max_body = max_body; self } pub fn with_resolve(mut self, resolve: Option<(String, u16, IpAddr)>) -> Self { self.resolve = resolve; self } pub fn provider(&self) -> &str { &self.provider } pub fn model(&self) -> &str { &self.model } fn request(&self, mut request: HttpRequest) -> Result { request.timeout = self.timeout; request.max_body = self.max_body; request.auth = self.auth.clone(); request.resolve = self.resolve.clone(); self.http.request(&request) } fn url(&self, path: &str) -> String { format!("{}{}", self.base.trim_end_matches('/'), path) } fn error_for(&self, action: &str, response: &HttpResponse) -> AiError { let hint = match response.status { 400 => "the server rejected the request (check the model id)".to_string(), 401 => "authentication required".to_string(), 403 => "authentication rejected".to_string(), 404 => "endpoint not found (incompatible server?)".to_string(), 429 => "rate limited".to_string(), 500..=599 => "the server returned an internal error (check that the model \ exists and the provider credentials are valid)" .to_string(), _ => format!("HTTP {}", response.status), }; // Name the provider:model so an invalid selection is obvious. AiError::Provider(format!( "OpenCode {action} failed for {}/{}: {hint}", self.provider, self.model )) } /// Fetch the provider/model catalog. Uses the metadata endpoint only. pub fn catalog(&self) -> Result { let response = self.request(HttpRequest::get(self.url("/provider")))?; if !response.is_success() { return Err(self.error_for("provider catalog", &response)); } parse_catalog(&response.body) } /// Create a fresh session bound to the selected provider/model. A unique /// title makes ownership obvious and avoids reusing an existing session. pub fn create_session(&self, title: &str) -> Result { // Verified against 1.18.32: despite the OpenAPI schema, a `model` field // on session creation is rejected as BadRequest. The model is selected // on the message instead. let body = serde_json::json!({ "title": title }).to_string(); let mut request = HttpRequest::post(self.url("/session"), body); request .headers .push(("Content-Type".into(), "application/json".into())); let response = self.request(request)?; if !response.is_success() { return Err(self.error_for("session creation", &response)); } let parsed: SessionBody = serde_json::from_str(&response.body) .map_err(|e| AiError::Provider(format!("session response was invalid: {e}")))?; if parsed.id.is_empty() { return Err(AiError::Provider("session response had no id".into())); } Ok(parsed.id) } /// Send one message and return only the completed assistant reply. Tools are /// disabled per message as defence in depth; the OS/process isolation of /// the server is documented separately. pub fn send_message( &self, session: &str, system: &str, user: &str, ) -> Result { let mut model_val = serde_json::json!({ "providerID": self.provider, "modelID": self.model, }); if let Some(variant) = &self.variant { let v = variant.trim(); if !v.is_empty() && v != "default" { model_val["variant"] = serde_json::Value::String(v.to_string()); } } let body = serde_json::json!({ "system": system, "model": model_val, "tools": disabled_tools(), "parts": [{ "type": "text", "text": user }], }) .to_string(); let mut request = HttpRequest::post(self.url(&format!("/session/{session}/message")), body); request .headers .push(("Content-Type".into(), "application/json".into())); let response = self.request(request)?; if !response.is_success() { return Err(self.error_for("message", &response)); } let parsed: MessageBody = serde_json::from_str(&response.body) .map_err(|e| AiError::Provider(format!("message response was invalid: {e}")))?; parsed.into_reply() } pub fn abort(&self, session: &str) -> Result<(), AiError> { let response = self.request(HttpRequest::post( self.url(&format!("/session/{session}/abort")), "", ))?; if response.is_success() { Ok(()) } else { Err(self.error_for("abort", &response)) } } /// Best-effort session cleanup. Errors are reported to the caller but are /// not fatal to an otherwise valid result. pub fn delete_session(&self, session: &str) -> Result<(), AiError> { let response = self.request(HttpRequest::delete( self.url(&format!("/session/{session}")), ))?; if response.is_success() { Ok(()) } else { Err(self.error_for("session delete", &response)) } } /// Create a session, send one message, clean up, and return the reply. /// The session is deleted on every path, so installation facts are not /// retained longer than necessary. pub fn one_shot(&self, system: &str, user: &str) -> Result { let session = self.create_session("phoebus assistant (transient)")?; let result = self.send_message(&session, system, user); let _ = self.delete_session(&session); result } } fn disabled_tools() -> serde_json::Value { serde_json::json!({ "bash": false, "edit": false, "write": false, "read": false, "webfetch": false, "grep": false, "glob": false, "list": false, "patch": false, "task": false, "todowrite": false, "todoread": false, }) } /// Adapts the OpenAI-shaped chat request that `complete_proposal` / /// `complete_plan` build to the OpenCode session API. It borrows the caller's /// [`Exec`] so logging, redaction and dry-run all apply, and returns an /// OpenAI-shaped body because the shared `extract_content` consumes it. The /// whole proposal/review pipeline is therefore reused unchanged. pub struct ExecOpenCodeTransport<'a> { exec: &'a Exec, base: String, provider: String, model: String, variant: Option, auth: Option, timeout: Duration, max_body: u64, resolve: Option<(String, u16, IpAddr)>, sandboxed: bool, allow_insecure_http: bool, } impl<'a> ExecOpenCodeTransport<'a> { pub fn new( exec: &'a Exec, base: impl Into, provider: impl Into, model: impl Into, ) -> Self { Self { exec, base: base.into(), provider: provider.into(), model: model.into(), variant: None, auth: None, timeout: Duration::from_secs(120), max_body: 4 * 1024 * 1024, resolve: None, sandboxed: false, allow_insecure_http: false, } } /// Run the OpenCode requests inside the same OS-level sandbox as the direct /// provider transport (DynamicUser/ProtectHome/... via `systemd-run`). pub fn sandboxed(mut self) -> Self { self.sandboxed = true; self } /// Permit plain `http` to a non-loopback OpenCode server (explicit opt-in). pub fn allow_insecure_http(mut self) -> Self { self.allow_insecure_http = true; self } pub fn with_auth(mut self, password: Option) -> Self { self.auth = password; self } pub fn with_variant(mut self, variant: impl Into) -> Self { self.variant = Some(variant.into()); self } pub fn with_resolve(mut self, resolve: Option<(String, u16, IpAddr)>) -> Self { self.resolve = resolve; self } pub fn with_timeout(mut self, timeout: Duration) -> Self { self.timeout = timeout; self } pub fn with_max_body(mut self, max_body: u64) -> Self { self.max_body = max_body; self } } fn openai_reply(content: &str) -> String { serde_json::json!({ "choices": [{ "message": { "content": content } }] }) .to_string() } fn split_chat_request(body: &str) -> Result<(String, String), AiError> { let request: ChatRequest = serde_json::from_str(body) .map_err(|e| AiError::Provider(format!("chat request was invalid: {e}")))?; let system = request .messages .iter() .filter(|m| m.role == "system") .map(|m| m.content.as_str()) .collect::>() .join("\n"); let user = request .messages .iter() .filter(|m| m.role == "user") .map(|m| m.content.as_str()) .collect::>() .join("\n"); if user.trim().is_empty() { return Err(AiError::Provider("chat request had no user content".into())); } Ok((system, user)) } impl ModelTransport for ExecOpenCodeTransport<'_> { fn send(&self, _provider: ProviderKind, _url: &str, body: &str) -> Result { let (system, user) = split_chat_request(body)?; // Enforce the transport policy and pin the connection to the checked // address, so the adapter cannot be pointed at a plain-http remote. let endpoint = crate::opencode_server::Endpoint::parse(&self.base) .map_err(|e| AiError::Rejected(format!("invalid OpenCode endpoint: {e}")))?; let target = endpoint.checked_target_with(self.allow_insecure_http)?; let resolve = self.resolve .clone() .or(Some((endpoint.host.clone(), endpoint.port, target.ip()))); let http = CurlHttpClient::new(self.exec); let http = if self.sandboxed { http.sandboxed() } else { http }; let mut client = OpenCodeClient::new(&http, &self.base, &self.provider, &self.model) .with_auth(self.auth.clone()) .with_timeout(self.timeout) .with_max_body(self.max_body) .with_resolve(resolve); if let Some(variant) = &self.variant { client = client.with_variant(variant.clone()); } let reply = client.one_shot(&system, &user)?; Ok(openai_reply(&reply.content)) } } #[cfg(test)] mod tests { use super::*; use crate::command::{CommandOutput, RecordingRunner}; use phoebus_core::Redactor; use std::sync::Mutex; #[test] fn credentials_are_on_stdin_not_argv_and_are_redacted() { let runner = RecordingRunner::new(); runner.set_response( "curl", CommandOutput { status: 0, success: true, stdout: b"\n__PHOEBUS_STATUS__200".to_vec(), stderr: Vec::new(), duration: std::time::Duration::from_millis(1), }, ); let dir = tempfile::tempdir().unwrap().keep(); let logger = crate::log::Logger::open(dir.join("l.log"), Redactor::new(), false); let exec = crate::exec::Exec::new(Box::new(runner.clone()), logger, false, &dir, &dir); let http = CurlHttpClient::new(&exec); let mut request = HttpRequest::get("http://127.0.0.1:4096/provider"); request.auth = Some(SecretString::new("s3cret-pw")); let response = http.request(&request).unwrap(); assert_eq!(response.status, 200); let spec = &runner.recorded()[0]; assert_eq!(spec.program, "curl"); assert!( !spec.args.iter().any(|a| a.contains("s3cret-pw")), "the password must not be in argv: {:?}", spec.args ); let stdin = String::from_utf8(spec.stdin.clone().unwrap()).unwrap(); assert!(stdin.contains("Authorization: Basic")); assert!(stdin.contains(&base64_lite::encode(b"opencode:s3cret-pw"))); // And it is registered for redaction. assert_eq!(exec.redactor().redact("s3cret-pw"), ""); // The derived base64 token is what actually travels, so an endpoint // that echoes the Authorization header must not leak it either. assert_eq!( exec.redactor() .redact(&base64_lite::encode(b"opencode:s3cret-pw")), "" ); } #[test] fn a_sandboxed_request_runs_curl_under_systemd_run_with_the_body_inlined() { if !crate::sandbox::available() { eprintln!("systemd-run unavailable; sandboxed OpenCode transport not exercised here"); return; } let runner = RecordingRunner::new(); runner.set_response( "systemd-run", CommandOutput { status: 0, success: true, stdout: b"\n__PHOEBUS_STATUS__200".to_vec(), stderr: Vec::new(), duration: std::time::Duration::from_millis(1), }, ); let dir = tempfile::tempdir().unwrap().keep(); let logger = crate::log::Logger::open(dir.join("l.log"), Redactor::new(), false); let exec = crate::exec::Exec::new(Box::new(runner.clone()), logger, false, &dir, &dir); let http = CurlHttpClient::new(&exec).sandboxed(); let request = HttpRequest::post("http://127.0.0.1:4096/session", r#"{"x":"y"}"#); let response = http.request(&request).unwrap(); assert_eq!(response.status, 200); let spec = &runner.recorded()[0]; assert_eq!(spec.program, "systemd-run"); let stdin = String::from_utf8(spec.stdin.clone().unwrap()).unwrap(); assert!( stdin.contains(r#"data = "{\"x\":\"y\"}""#), "the body must be inlined into the config: {stdin}" ); assert!( !stdin.contains("phoebus-opencode."), "no temp file may be used under PrivateTmp: {stdin}" ); } #[test] fn a_bearer_token_is_redacted_too() { let runner = RecordingRunner::new(); runner.set_response( "curl", CommandOutput { status: 0, success: true, stdout: b"\n__PHOEBUS_STATUS__200".to_vec(), stderr: Vec::new(), duration: std::time::Duration::from_millis(1), }, ); let dir = tempfile::tempdir().unwrap().keep(); let logger = crate::log::Logger::open(dir.join("l.log"), Redactor::new(), false); let exec = crate::exec::Exec::new(Box::new(runner), logger, false, &dir, &dir); let http = CurlHttpClient::new(&exec); let mut request = HttpRequest::get("http://127.0.0.1:4096/provider"); request.auth = Some(SecretString::new("s3cret-pw")); request.auth_user = String::new(); http.request(&request).unwrap(); assert_eq!( exec.redactor().redact(&base64_lite::encode(b"s3cret-pw")), "" ); } #[test] fn a_missing_status_marker_is_an_error_not_a_silent_success() { let runner = RecordingRunner::new(); runner.set_response( "curl", CommandOutput { status: 0, success: true, stdout: b"{}".to_vec(), stderr: Vec::new(), duration: std::time::Duration::from_millis(1), }, ); let dir = tempfile::tempdir().unwrap().keep(); let logger = crate::log::Logger::open(dir.join("l.log"), Redactor::new(), false); let exec = crate::exec::Exec::new(Box::new(runner), logger, false, &dir, &dir); let http = CurlHttpClient::new(&exec); assert!(http .request(&HttpRequest::get("http://127.0.0.1:4096/x")) .is_err()); } /// A scripted HTTP client: pops one response per request. struct FakeHttp { responses: Mutex>, requests: Mutex>, } impl FakeHttp { fn new(responses: Vec) -> Self { Self { responses: Mutex::new(responses), requests: Mutex::new(Vec::new()), } } fn json(status: u16, body: impl Into) -> HttpResponse { HttpResponse { status, body: body.into(), } } fn requests(&self) -> Vec { self.requests.lock().unwrap().clone() } } impl HttpClient for FakeHttp { fn request(&self, request: &HttpRequest) -> Result { self.requests.lock().unwrap().push(request.clone()); let mut responses = self.responses.lock().unwrap(); if responses.is_empty() { return Err(AiError::Provider("no scripted response".into())); } Ok(responses.remove(0)) } } fn message_reply(text: &str) -> String { serde_json::json!({ "info": { "role": "assistant", "time": { "created": 1, "completed": 2 } }, "parts": [{ "type": "text", "text": text }], }) .to_string() } #[test] fn base64_matches_known_vectors() { assert_eq!(base64_lite::encode(b"opencode:pw"), "b3BlbmNvZGU6cHc="); assert_eq!(base64_lite::encode(b""), ""); assert_eq!(base64_lite::encode(b"f"), "Zg=="); assert_eq!(base64_lite::encode(b"fo"), "Zm8="); assert_eq!(base64_lite::encode(b"foo"), "Zm9v"); } #[test] fn catalog_never_reads_provider_keys() { // Upstream can include a `key`; the catalog must not surface it. let body = r#"{"all":[ {"id":"deepseek","name":"DeepSeek","key":"sk-SECRET","options":{}, "models":{"b":{},"a":{}}}, {"id":"x","name":"X","models":{}}], "connected":["deepseek"],"default":{"deepseek":"a"}}"#; let catalog = parse_catalog(body).unwrap(); let debug = format!("{catalog:?}"); assert!(!debug.contains("SECRET"), "catalog leaked a key: {debug}"); let ds = catalog .providers .iter() .find(|p| p.id == "deepseek") .unwrap(); assert!(ds.connected); // The default model is bubbled to the front. let ids: Vec<&str> = ds.models.iter().map(|m| m.id.as_str()).collect(); assert_eq!(ids, vec!["a", "b"]); assert!(catalog.has_model("deepseek", "a")); assert!(!catalog.has_model("deepseek", "zzz")); } #[test] fn catalog_rejects_a_misleading_body() { assert!(parse_catalog("not json").is_err()); assert!(parse_catalog("[]").is_err()); } #[test] fn one_shot_accepts_only_the_assistant_text_and_cleans_up() { let http = FakeHttp::new(vec![ FakeHttp::json(200, r#"{"id":"ses_1"}"#), // A user part, a tool part, a reasoning part and the assistant text. FakeHttp::json( 200, r#"{"info":{"role":"assistant","time":{"created":1,"completed":2}}, "parts":[ {"type":"text","text":"user echo","synthetic":true}, {"type":"tool","tool":"bash"}, {"type":"reasoning","text":"thinking"}, {"type":"text","text":"{\"version\":1}"}]}"#, ), FakeHttp::json(200, "true"), ]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); let reply = client.one_shot("sys", "user").unwrap(); assert_eq!(reply.content, "{\"version\":1}"); assert!(reply.completed); let requests = http.requests(); assert_eq!(requests.len(), 3); assert_eq!(requests[0].method, Method::Post); assert_eq!(requests[2].method, Method::Delete); assert!(requests[2].url.ends_with("/session/ses_1")); } #[test] fn one_shot_rejects_a_non_assistant_or_errored_reply() { let http = FakeHttp::new(vec![ FakeHttp::json(200, r#"{"id":"ses_1"}"#), FakeHttp::json( 200, r#"{"info":{"role":"user"},"parts":[{"type":"text","text":"hi"}]}"#, ), FakeHttp::json(200, "true"), ]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); assert!(client.one_shot("s", "u").is_err()); let http = FakeHttp::new(vec![ FakeHttp::json(200, r#"{"id":"ses_1"}"#), FakeHttp::json( 200, r#"{"info":{"role":"assistant","error":{"name":"ProviderAuthError","data":{"message":"bad sk-SECRET"}}},"parts":[]}"#, ), FakeHttp::json(200, "true"), ]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); let err = client.one_shot("s", "u").unwrap_err().to_string(); assert!(err.contains("ProviderAuthError"), "{err}"); assert!( !err.contains("sk-SECRET"), "error leaked a credential: {err}" ); } #[test] fn failed_inference_is_reported_not_hidden() { let http = FakeHttp::new(vec![ FakeHttp::json(200, r#"{"id":"ses_1"}"#), FakeHttp::json(200, r#"{"info":{"role":"assistant"},"parts":[]}"#), ]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); assert!(client.one_shot("s", "u").is_err()); } #[test] fn http_errors_are_distinguished() { for (status, needle) in [ (401u16, "authentication required"), (403, "authentication rejected"), (404, "not found"), (500, "internal error"), ] { let http = FakeHttp::new(vec![FakeHttp::json(status, "{}")]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); let err = client.catalog().unwrap_err().to_string(); assert!(err.contains(needle), "status {status}: {err}"); } } #[test] fn session_creation_failure_is_reported() { let http = FakeHttp::new(vec![FakeHttp::json(500, "boom")]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); assert!(client.create_session("t").is_err()); // A success body with no id is also refused. let http = FakeHttp::new(vec![FakeHttp::json(200, "{}")]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "p", "m"); assert!(client.create_session("t").is_err()); } #[test] fn transport_adapts_openai_request_shape() { let http = FakeHttp::new(vec![ FakeHttp::json(200, r#"{"id":"ses_1"}"#), FakeHttp::json(200, message_reply("{\"version\":1}")), FakeHttp::json(200, "true"), ]); let client = OpenCodeClient::new(&http, "http://127.0.0.1:4096", "prov", "mod"); let reply = client.one_shot("system prompt", "user prompt").unwrap(); assert_eq!(reply.content, "{\"version\":1}"); let requests = http.requests(); // requests[0] = session, requests[1] = message, requests[2] = delete let body: serde_json::Value = serde_json::from_str(requests[1].body.as_deref().unwrap()).unwrap(); assert_eq!(body["model"]["providerID"], "prov"); assert_eq!(body["model"]["modelID"], "mod"); assert_eq!(body["system"], "system prompt"); assert_eq!(body["tools"]["bash"], false); assert_eq!(body["parts"][0]["type"], "text"); assert_eq!(body["parts"][0]["text"], "user prompt"); } }