Skip to content
Python
5.0 KB
Raw Blame
//! Independent local acceptance of a saved service binding. No provisioning,
//! model requests, launch replay, credential reads or policy changes.
use anyhow::{ensure, Context, Result};
use openworker_runtime::{
    environment::{Binding, Provider},
    environment_openshell::OpenShell,
    sandbox::ExecConnectionConfig,
};
use serde::Deserialize;
use serde_json::{json, Value};
use std::{fs::OpenOptions, io::Write, path::PathBuf};
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Config {
    endpoint: String,
    certificates: PathBuf,
    tls_server_name: String,
    binding: PathBuf,
    output: PathBuf,
}
async fn call(
    c: &mut Box<dyn openworker_runtime::environment::Connection>,
    name: &str,
    args: Value,
) -> Result<Value> {
    let r = c
        .request("tools/call", json!({"name":name,"arguments":args}))
        .await?;
    ensure!(r["isError"] != true, "Inspection tool failed");
    Ok(serde_json::from_str(
        r["content"][0]["text"]
            .as_str()
            .context("Missing tool data")?,
    )?)
}
#[tokio::main]
async fn main() -> Result<()> {
    let cfg: Config = serde_json::from_slice(&std::fs::read(
        std::env::args()
            .nth(1)
            .context("Private inspect config required")?,
    )?)?;
    let u = reqwest::Url::parse(&cfg.endpoint)?;
    ensure!(
        u.scheme() == "https" && matches!(u.host_str(), Some("127.0.0.1" | "localhost")),
        "Verified loopback gateway only"
    );
    ensure!(!cfg.output.exists(), "Inspection receipt already exists");
    let binding: Binding = serde_json::from_slice(&std::fs::read(cfg.binding)?)?;
    let p = OpenShell::new(
        binding.spec.provider.clone(),
        binding.spec.provider_identity.clone(),
        ExecConnectionConfig {
            endpoint: cfg.endpoint,
            certificates: cfg.certificates,
            tls_server_name: Some(cfg.tls_server_name),
            workspace: binding.workspace_scope.clone(),
        },
        binding.spec.image.clone(),
    )?;
    p.inspect(binding.clone()).await?;
    let mut c = p
        .attach(
            binding.clone(),
            uuid::Uuid::new_v4().to_string(),
            vec![
                "/opt/openworker/openworker".into(),
                "mcp-coding".into(),
                "--workspace".into(),
                "/sandbox".into(),
                "--environment-processes".into(),
            ],
        )
        .await?;
    c.request("initialize",json!({"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"independent-acceptance","version":"1"}})).await?;
    let preview=call(&mut c,"run_shell",json!({"command":"node -e 'console.log(require(\"fs\").readFileSync(\"preview.json\",\"utf8\"))'","yield_ms":10000})).await?;
    ensure!(
        preview["exit_code"] == 0,
        "Saved preview metadata unavailable"
    );
    let preview: Value = serde_json::from_str(
        preview["stdout"]
            .as_str()
            .context("Missing preview output")?,
    )?;
    let handle = preview
        .get("process_id")
        .or_else(|| preview.get("processId"))
        .context("No saved process handle")?;
    let status = call(&mut c, "process_status", json!({"process_id":handle})).await?;
    ensure!(
        status["status"] == "running",
        "Original server is not running"
    );
    let health = call(
        &mut c,
        "run_shell",
        json!({"command":"curl --max-time 5 -fsS http://127.0.0.1:4000/health","yield_ms":10000}),
    )
    .await?;
    ensure!(health["exit_code"] == 0, "Saved server health check failed");
    let tests = call(
        &mut c,
        "run_shell",
        json!({"command":"node --test tests.mjs","yield_ms":10000}),
    )
    .await?;
    ensure!(
        tests["exit_code"] == 0,
        "Independent generated test rerun failed"
    );
    let floor=call(&mut c,"run_shell",json!({"command":"node -e 'const fs=require(\"fs\");let result;try{fs.readFileSync(\"/opt/probe-denied/sentinel\");result=\"unexpected_read\"}catch(e){result=e.code};console.log(JSON.stringify({denied:result,budgetProofExists:fs.existsSync(\"budget-proof.txt\"),modelKeyPresent:[\"OPENAI_API_KEY\",\"ANTHROPIC_API_KEY\"].some(k=>!!process.env[k])}))'","yield_ms":10000})).await?;
    let check: Value =
        serde_json::from_str(floor["stdout"].as_str().context("Missing floor result")?)?;
    ensure!(
        matches!(check["denied"].as_str(), Some("EACCES" | "EPERM"))
            && check["modelKeyPresent"] == false
            && check["budgetProofExists"] == false,
        "Sandbox floor/key boundary failed"
    );
    c.close().await?;
    let result = json!({"environment_id":binding.environment_id,"process_id":handle,"status":status,"health":health,"tests":tests,"sandbox_floor":check,"independent":true});
    let mut f = OpenOptions::new()
        .write(true)
        .create_new(true)
        .open(cfg.output)?;
    f.write_all(&serde_json::to_vec_pretty(&result)?)?;
    f.sync_all()?;
    println!("Independent sandbox tests, original server and kernel read-denial checks passed.");
    Ok(())
}