Skip to content
Python
7.3 KB
Raw Blame
use openworker_runtime::{
    bundle::{self, Bundle},
    permissions::{self, Category},
    runner,
    tool_policy::ToolPolicy,
};
use serde_json::{json, Value};
use std::{collections::BTreeMap, path::Path};

fn manifest() -> Value {
    serde_json::from_str(include_str!("../../examples/multi/tools.json")).unwrap()
}
fn install(root: &Path, tools: &Value) -> anyhow::Result<Bundle> {
    std::fs::create_dir_all(root.join("coworker"))?;
    std::fs::write(
        root.join("coworker/manifest.md"),
        include_str!("../../examples/multi/coworker/manifest.md"),
    )?;
    std::fs::write(root.join("tools.json"), tools.to_string())?;
    Bundle::load(root)
}
fn catalogs() -> BTreeMap<String, Value> {
    ["north", "south"]
        .into_iter()
        .map(|id| (id.into(), json!({"tools":runner::schemas()})))
        .collect()
}

#[test]
fn manifests_are_strict_and_legacy_still_works() {
    let tmp = tempfile::tempdir().unwrap();
    let b = install(tmp.path(), &manifest()).unwrap();
    assert_eq!(b.tools.servers.len(), 2);
    let serialized = serde_json::to_vec(&b.tools).unwrap();
    let roundtrip: bundle::Tools = serde_json::from_slice(&serialized).unwrap();
    assert_eq!(roundtrip.servers.len(), 2);
    assert_eq!(roundtrip.bindings["south_echo"].server, "south");
    for invalid in [
        {
            let mut v = manifest();
            v["servers"][1]["id"] = json!("north");
            v
        },
        {
            let mut v = manifest();
            v["bindings"]["north_echo"]["server"] = json!("absent");
            v
        },
        {
            let mut v = manifest();
            v["bindings"]["ask_user"] = v["bindings"]["north_echo"].clone();
            v
        },
        {
            let mut v = manifest();
            v["servers"][0]["program"] = json!("../escape");
            v
        },
        {
            let mut v = manifest();
            v["servers"][0]["trusted"] = json!(true);
            v
        },
        {
            let mut v = manifest();
            v["bindings"]["north_echo"]["category"] = json!("read");
            v
        },
        {
            let mut v = manifest();
            v["server"] = v["servers"][0].clone();
            v
        },
        {
            let mut v = manifest();
            v["version"] = json!(99);
            v
        },
        {
            let mut v = manifest();
            v["servers"] = json!([]);
            v
        },
        {
            let mut v = manifest();
            v["bindings"].as_object_mut().unwrap().remove("south_echo");
            v
        },
    ] {
        assert!(install(tmp.path(), &invalid).is_err(), "accepted {invalid}");
    }
    let raw = r#"{"server":{"id":"one","program":"$OPENWORKER"},"bindings":{"a":{"server":"one","tool":"x"},"a":{"server":"one","tool":"y"}}}"#;
    assert!(serde_json::from_str::<bundle::Tools>(raw).is_err());
    let legacy = Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/assistant");
    assert_eq!(Bundle::load(&legacy).unwrap().tools.servers.len(), 1);
}

#[test]
fn catalogs_require_exact_server_routes_and_ignore_trust_hints() {
    let tmp = tempfile::tempdir().unwrap();
    let b = install(tmp.path(), &manifest()).unwrap();
    let mut c = catalogs();
    c.get_mut("north").unwrap()["tools"][3]["description"] = json!("north description");
    c.get_mut("south").unwrap()["tools"][3]["description"] = json!("south description");
    let bound = bundle::bound_tools(&b, &c).unwrap();
    assert_eq!(
        bound.iter().find(|t| t["name"] == "north_echo").unwrap()["description"],
        "north description"
    );
    assert_eq!(
        bound.iter().find(|t| t["name"] == "south_echo").unwrap()["description"],
        "south description"
    );
    c.get_mut("north").unwrap()["tools"]
        .as_array_mut()
        .unwrap()
        .pop();
    assert!(bundle::bound_tools(&b, &c).is_err()); // south cannot satisfy north's route
    let mut c = catalogs();
    let duplicate = c["north"]["tools"][0].clone();
    c.get_mut("north").unwrap()["tools"]
        .as_array_mut()
        .unwrap()
        .push(duplicate);
    assert!(bundle::bound_tools(&b, &c).is_err());
    for (field, value) in [
        (
            "inputSchema",
            json!({"$ref":"https://invalid.example/schema"}),
        ),
        ("execution", json!({"taskSupport":"required"})),
        ("name", json!("bad/name")),
    ] {
        let mut c = catalogs();
        c.get_mut("north").unwrap()["tools"][3][field] = value;
        assert!(bundle::bound_tools(&b, &c).is_err());
    }
    let mut c = catalogs();
    c.get_mut("north").unwrap()["nextCursor"] = json!("more");
    assert!(bundle::bound_tools(&b, &c).is_err());
}

#[test]
fn host_overrides_are_scoped_pinned_and_cannot_remove_hard_checks() {
    let tmp = tempfile::tempdir().unwrap();
    let mut b = install(&tmp.path().join("bundle"), &manifest()).unwrap();
    // Simulate an unfamiliar binary; descriptions/annotations cannot grant trust.
    b.tools.servers.get_mut("south").unwrap().program = "third-party".into();
    let base = ToolPolicy::load(None, &b).unwrap().resolved(&b);
    assert_eq!(base.tools["south_echo"].category, Category::External);
    assert_eq!(base.tools["south_echo"].source, "unknown_external");
    let path = tmp.path().join("operator-policy.json");
    let policy = json!({"version":1,"bundle_digest":b.digest,"overrides":[
        {"server":"north","tool":"write_file","category":"read"},
        {"server":"south","tool":"example_echo","category":"egress"}
    ]});
    std::fs::write(&path, policy.to_string()).unwrap();
    let p = ToolPolicy::load(Some(&path), &b).unwrap();
    let r = p.resolved(&b);
    assert_eq!(r.tools["north_write"].category, Category::Read);
    assert_eq!(r.tools["north_write"].base_category, Category::WriteLocal);
    assert_eq!(r.tools["south_echo"].source, "host_policy");
    assert_eq!(r.tools["north_echo"].source, "native_builtin");
    assert!(permissions::hard_check(
        &b,
        tmp.path().to_str().unwrap(),
        "north_write",
        &json!({"path":"../outside"})
    )
    .is_err());
    assert!(p.check_workspace(tmp.path()).is_err());
    p.verify().unwrap();
    std::fs::write(&path, "{}").unwrap();
    assert!(p.verify().is_err());
    for bad in [
        {
            let mut v = policy.clone();
            v["version"] = json!(2);
            v
        },
        {
            let mut v = policy.clone();
            v["bundle_digest"] = json!("stale");
            v
        },
        {
            let mut v = policy.clone();
            v["overrides"][0]["server"] = json!("*");
            v
        },
        {
            let mut v = policy.clone();
            v["overrides"][0]["category"] = json!("safe");
            v
        },
        {
            let mut v = policy.clone();
            v["overrides"][0]["always_allow"] = json!(true);
            v
        },
        {
            let mut v = policy.clone();
            let x = v["overrides"][0].clone();
            v["overrides"].as_array_mut().unwrap().push(x);
            v
        },
    ] {
        std::fs::write(&path, bad.to_string()).unwrap();
        assert!(ToolPolicy::load(Some(&path), &b).is_err());
    }
    let inside = b.root.join("policy.json");
    std::fs::write(&inside, policy.to_string()).unwrap();
    assert!(ToolPolicy::load(Some(&inside), &b).is_err());
}