//! Coding-agent sandboxes (Docker sandbox-templates images) and pi config mirroring. use crate::vm::{Guest, run}; use crate::util::{base, sq}; use crate::Agent; use anyhow::{Context, Result}; use serde_json::Value; use std::fs; use std::path::{Path, PathBuf}; /// Fallback when pi isn't installed on the host (otherwise the host's package + version are mirrored). const PI_PKG: &str = "@earendil-works/pi-coding-agent"; /// User-level pi config worth sharing. Never npm/, bin/ (macOS binaries), sessions/, caches. const PI_CONFIG: &[&str] = &[ "settings.json", "keybindings.json", "models.json", "mcp.json", "AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD", "SYSTEM.md", "APPEND_SYSTEM.md", "extensions", "skills", "prompts", "themes", ]; // No official Docker template for pi: the generic `shell` template has node + npm; pi is installed // (pinned to the host's version) onto the persistent sandbox disk. pub fn pi(h: &Path, mut a: Agent, auth: bool) -> Result<()> { let user_home = PathBuf::from(std::env::var_os("HOME").expect("HOME")); let agent_dir = std::env::var_os("PI_CODING_AGENT_DIR").map(PathBuf::from).unwrap_or_else(|| user_home.join(".pi/agent")); let agents_skills = user_home.join(".agents/skills"); // Agent Skills location pi also reads let mut items = PI_CONFIG.to_vec(); if auth { items.push("auth.json"); } let mut stage: Vec<(PathBuf, String)> = items.iter().map(|i| (agent_dir.join(i), format!("pi/{i}"))).collect(); stage.push((agents_skills.clone(), "agents-skills".into())); stage.retain(|(p, _)| p.exists()); let roots = [&agent_dir, &agents_skills].iter().filter_map(|p| fs::canonicalize(p).ok()).collect(); if let Ok(m) = fs::read(agent_dir.join("models.json")) { let m: Value = serde_json::from_slice(&m).context("models.json")?; for p in m["providers"].as_object().into_iter().flat_map(|p| p.values()) { if let Some(port) = p["baseUrl"].as_str().and_then(local_port) { a.o.host_ports.push(port); } } } let sh = match host_npm_pkg("pi") { Some((pkg, v)) => format!( "[ \"$(pi --version 2>/dev/null)\" = {v} ] || npm install -g --force {}@{v} >&2 || exit 1; exec pi \"$@\"", sq(&pkg) ), None => format!("command -v pi >/dev/null || npm install -g --force {PI_PKG} >&2 || exit 1; exec pi \"$@\""), }; // Link each staged item into the guest's own ~/.pi/agent (which keeps its linux npm/, bin/, sessions/). let setup = r#"PA="$HOME/.pi/agent"; S=/.wsbx/host/stage; $B mkdir -p "$PA" "$HOME/.agents" for l in "$PA"/* "$PA"/.[!.]* "$HOME/.agents/skills"; do [ -L "$l" ] && $B rm -f "$l"; done for f in "$S"/pi/*; do [ -e "$f" ] && $B rm -rf "$PA/${f##*/}" && $B ln -s "$f" "$PA/${f##*/}"; done [ -e "$S/agents-skills" ] && $B rm -rf "$HOME/.agents/skills" && $B ln -s "$S/agents-skills" "$HOME/.agents/skills" [ -z "$WSBX_USER" ] || $B chown "$WSBX_USER" "$HOME/.pi" "$PA" "$HOME/.agents" "#; let cmd = ["bash", "-c", &sh, "pi"].map(String::from).to_vec(); let keys = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "OPENROUTER_API_KEY", "GROQ_API_KEY", "XAI_API_KEY", "MISTRAL_API_KEY", "CEREBRAS_API_KEY", "ZAI_API_KEY"]; agent(h, a, "shell", "pi", cmd, &keys, Guest { stage, roots, setup: setup.into() }) } /// npm package (name, version) behind a host command: follow the bin symlink up to its package.json. fn host_npm_pkg(cmd: &str) -> Option<(String, String)> { let bin = std::env::split_paths(&std::env::var_os("PATH")?).map(|d| d.join(cmd)).find(|p| p.is_file())?; let real = fs::canonicalize(bin).ok()?; let pj = real.ancestors().map(|d| d.join("package.json")).find(|p| p.is_file())?; let v: Value = serde_json::from_slice(&fs::read(pj).ok()?).ok()?; let (name, ver) = (v["name"].as_str()?, v["version"].as_str()?); ver.chars().all(|c| c.is_ascii_alphanumeric() || ".-+".contains(c)).then(|| (name.into(), ver.into())) } /// Port of a URL pointing at the host's loopback, e.g. "http://127.0.0.1:8000/v1" -> 8000. fn local_port(url: &str) -> Option { let (scheme, rest) = url.split_once("://")?; let auth = rest.split('/').next()?; let (host, port) = match auth.rsplit_once(':') { Some((h, p)) if !p.ends_with(']') => (h, p.parse().ok()?), _ => (auth, if scheme == "https" { 443 } else { 80 }), }; ["127.0.0.1", "localhost", "[::1]", "0.0.0.0"].contains(&host).then_some(port) } pub fn agent(h: &Path, a: Agent, template: &str, short: &str, cmd: Vec, keys: &[&str], g: Guest) -> Result<()> { let mut o = a.o; if o.workspace.is_none() { o.workspace = Some(std::env::current_dir()?); } if o.name.is_none() { o.name = Some(format!("{short}-{}", base(o.workspace.as_ref().unwrap()))); } let set: Vec = keys.iter().filter(|k| std::env::var_os(k).is_some()).map(|k| k.to_string()).collect(); if a.keys { o.env.extend(set); } else if !set.is_empty() { eprintln!("wsbx: not forwarding {} (use --keys; code in the VM, e.g. a prompt-injected agent, could read it)", set.join(", ")); } // Docker's sandbox templates: Cmd is the agent (e.g. `claude --dangerously-skip-permissions`) unless overridden run(h, o, &format!("docker/sandbox-templates:{template}"), cmd, &a.args, g) } #[cfg(test)] mod tests { #[test] fn local_port() { use super::local_port as lp; assert_eq!(lp("http://127.0.0.1:8000/v1"), Some(8000)); assert_eq!(lp("http://localhost:11434"), Some(11434)); assert_eq!(lp("http://[::1]:1234/v1"), Some(1234)); assert_eq!(lp("http://localhost/v1"), Some(80)); assert_eq!(lp("http://192.168.1.169:8080/v1"), None); assert_eq!(lp("https://api.openai.com/v1"), None); } }