111 lines
5.7 KiB
Rust
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);
|
|
}
|
|
}
|