Files
woiken-sandboxes/src/agents.rs
T

111 lines
5.7 KiB
Rust

//! 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<u16> {
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<String>, 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<String> = 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);
}
}