Skip to content
Python
10.4 KB
Raw Blame
#![cfg(any(windows, target_os = "linux"))]
use openworker_runtime::{execution::Backend, model::Model, runtime::Runtime};
use openworker_tools::{Tool, ToolContext, ToolDescriptor, ToolFuture, ToolOutput, ToolRegistry};
use serde_json::{json, Value};
use std::{
    path::Path,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc,
    },
};
struct Probe(&'static str, Arc<AtomicUsize>, String);
impl Tool for Probe {
    fn descriptor(&self) -> ToolDescriptor {
        ToolDescriptor {
            qualified_name: format!("test.{}", self.0),
            description: "Test counter; no OS effects".into(),
            version: self.2.clone(),
            input_schema: json!({"type":"object","properties":{"action":{"type":"string"}},"required":["action"],"additionalProperties":false}),
        }
    }
    fn call(&self, _: ToolContext, args: Value) -> ToolFuture<'_> {
        Box::pin(async move {
            self.1.fetch_add(1, Ordering::SeqCst);
            Ok(ToolOutput::json(args))
        })
    }
}
struct Setup {
    tmp: tempfile::TempDir,
    calls: Arc<AtomicUsize>,
}
impl Setup {
    fn new() -> Self {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(tmp.path().join("bundle/coworker")).unwrap();
        std::fs::create_dir(tmp.path().join("work")).unwrap();
        std::fs::write(
            tmp.path().join("bundle/coworker/manifest.md"),
            "---\nid: grants\nname: Grants\n---\nUse test tools.",
        )
        .unwrap();
        std::fs::write(
            tmp.path().join("bundle/tools.json"),
            r#"{"version":3,"tools":["test.probe","test.other"]}"#,
        )
        .unwrap();
        Self {
            tmp,
            calls: Default::default(),
        }
    }
    fn open(&self, version: &str) -> Arc<Runtime> {
        let mut r = ToolRegistry::default();
        for n in ["probe", "other"] {
            r.register(Probe(n, self.calls.clone(), version.into()))
                .unwrap();
        }
        Runtime::open_with_registry(
            &self.tmp.path().join("state"),
            &self.tmp.path().join("bundle"),
            Path::new(env!("CARGO_BIN_EXE_openworker")),
            Model::new("fixture".into(), true),
            Backend::Off,
            None,
            None,
            r,
        )
        .unwrap()
    }
    async fn session(&self, r: &Arc<Runtime>) -> String {
        r.dispatch(
            "session/create",
            json!({"name":"Grants","coworker":"grants","workspace":self.tmp.path().join("work")}),
        )
        .await
        .unwrap()["session"]["id"]
            .as_str()
            .unwrap()
            .into()
    }
}
async fn start(r: &Arc<Runtime>, sid: &str, steps: Value) {
    r.dispatch("turn/start",json!({"session_id":sid,"submission_id":uuid::Uuid::new_v4().to_string(),"text":format!("TEST_RESOURCE_GRANTS {steps}")})).await.unwrap();
}
async fn wait(r: &Arc<Runtime>, sid: &str, p: impl Fn(&Value) -> bool) -> Value {
    tokio::time::timeout(std::time::Duration::from_secs(60), async {
        loop {
            let v = r.snapshot(sid).unwrap();
            if p(&v) {
                return v;
            }
            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
        }
    })
    .await
    .unwrap()
}
async fn pending(r: &Arc<Runtime>, sid: &str) -> Value {
    wait(r, sid, |v| {
        !v["interactions"].as_array().unwrap().is_empty()
    })
    .await["interactions"][0]
        .clone()
}
async fn done(r: &Arc<Runtime>, sid: &str) {
    let v = wait(r, sid, |v| {
        matches!(v["turn"]["status"].as_str(), Some("completed" | "failed"))
    })
    .await;
    assert_eq!(v["turn"]["status"], "completed");
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
async fn respond(r: &Arc<Runtime>, sid: &str, i: &Value, d: &str) -> Value {
    loop {
        match r
            .dispatch(
                "interaction/respond",
                json!({"session_id":sid,"interaction_id":i["id"],"decision":d}),
            )
            .await
        {
            Ok(v) => return v,
            Err(e) if e.to_string().contains("checkpointing") => {
                tokio::time::sleep(std::time::Duration::from_millis(20)).await
            }
            Err(e) => panic!("{e:#}"),
        }
    }
}
fn step(name: &str, action: &str) -> Value {
    json!({"name":name,"arguments":{"action":action}})
}
async fn grants(r: &Arc<Runtime>, sid: &str) -> Value {
    r.dispatch("permissions/list", json!({"session_id":sid}))
        .await
        .unwrap()["grants"]
        .clone()
}

#[tokio::test]
async fn session_grants_persist_cover_all_actions_and_remain_scoped_revocable_and_idempotent() {
    let f = Setup::new();
    let r = f.open("1");
    let sid = f.session(&r).await;
    start(
        &r,
        &sid,
        json!([
            step("test__probe", "observe"),
            step("test__probe", "type"),
            step("test__other", "observe")
        ]),
    )
    .await;
    let first = pending(&r, &sid).await;
    respond(&r, &sid, &first, "session").await;
    let other = pending(&r, &sid).await;
    assert_eq!(other["call"]["name"], "test__other");
    assert_eq!(f.calls.load(Ordering::SeqCst), 2);
    respond(&r, &sid, &other, "deny").await;
    done(&r, &sid).await;
    assert_eq!(
        respond(&r, &sid, &first, "session").await["duplicate"],
        true
    );
    let saved = grants(&r, &sid).await;
    assert_eq!(saved.as_array().unwrap().len(), 1);
    let gid = saved[0]["id"].clone();
    r.shutdown().await.unwrap();
    drop(r);
    let r = f.open("1");
    assert_eq!(grants(&r, &sid).await, saved);
    start(&r, &sid, json!([step("test__probe", "another-action")])).await;
    done(&r, &sid).await;
    assert_eq!(f.calls.load(Ordering::SeqCst), 3);
    let other_sid = f.session(&r).await;
    start(&r, &other_sid, json!([step("test__probe", "observe")])).await;
    let i = pending(&r, &other_sid).await;
    assert_eq!(
        r.dispatch(
            "permissions/revoke",
            json!({"session_id":other_sid,"grant_id":gid})
        )
        .await
        .unwrap()["revoked"],
        false
    );
    assert_eq!(grants(&r, &sid).await, saved);
    respond(&r, &other_sid, &i, "deny").await;
    done(&r, &other_sid).await;
    assert_eq!(
        r.dispatch(
            "permissions/revoke",
            json!({"session_id":sid,"grant_id":gid})
        )
        .await
        .unwrap()["revoked"],
        true
    );
    assert_eq!(
        r.dispatch(
            "permissions/revoke",
            json!({"session_id":sid,"grant_id":gid})
        )
        .await
        .unwrap()["already_absent"],
        true
    );
    start(&r, &sid, json!([step("test__probe", "click")])).await;
    let i = pending(&r, &sid).await;
    respond(&r, &sid, &i, "session").await;
    done(&r, &sid).await;
    let gid = grants(&r, &sid).await[0]["id"].clone();
    r.dispatch(
        "permissions/revoke",
        json!({"session_id":sid,"grant_id":gid}),
    )
    .await
    .unwrap();
    assert_eq!(respond(&r, &sid, &i, "session").await["duplicate"], true);
    assert!(grants(&r, &sid).await.as_array().unwrap().is_empty());
    r.shutdown().await.unwrap();
    drop(r);
    let r = f.open("1");
    assert!(grants(&r, &sid).await.as_array().unwrap().is_empty());
    r.shutdown().await.unwrap();
}

#[tokio::test]
async fn changed_native_implementation_cannot_reuse_grants() {
    let f = Setup::new();
    let r = f.open("1");
    let sid = f.session(&r).await;
    start(&r, &sid, json!([step("test__probe", "observe")])).await;
    let i = pending(&r, &sid).await;
    respond(&r, &sid, &i, "session").await;
    done(&r, &sid).await;
    r.shutdown().await.unwrap();
    drop(r);
    let r = f.open("2");
    assert_eq!(grants(&r, &sid).await[0]["active"], false);
    assert!(r
        .dispatch(
            "turn/start",
            json!({"session_id":sid,"submission_id":"changed","text":"test"})
        )
        .await
        .is_err());
    assert_eq!(f.calls.load(Ordering::SeqCst), 1);
    r.shutdown().await.unwrap();
}

#[tokio::test]
async fn failed_commit_cannot_partially_mint_a_session_grant() {
    let f = Setup::new();
    let r = f.open("1");
    let sid = f.session(&r).await;
    start(&r, &sid, json!([step("test__probe", "observe")])).await;
    let i = pending(&r, &sid).await;
    let db = rusqlite::Connection::open(f.tmp.path().join("state/runtime.sqlite3")).unwrap();
    db.execute_batch("CREATE TRIGGER fail_grant BEFORE INSERT ON events WHEN NEW.kind='interaction_resolved' BEGIN SELECT RAISE(ABORT,'injected commit failure'); END;").unwrap();
    assert!(r
        .dispatch(
            "interaction/respond",
            json!({"session_id":sid,"interaction_id":i["id"],"decision":"session"})
        )
        .await
        .is_err());
    assert!(grants(&r, &sid).await.as_array().unwrap().is_empty());
    assert_eq!(pending(&r, &sid).await["id"], i["id"]);
    assert_eq!(f.calls.load(Ordering::SeqCst), 0);
    db.execute_batch("DROP TRIGGER fail_grant").unwrap();
    drop(db);
    respond(&r, &sid, &i, "once").await;
    done(&r, &sid).await;
    assert!(grants(&r, &sid).await.as_array().unwrap().is_empty());
    r.shutdown().await.unwrap();
}

#[tokio::test]
async fn mcp_grants_cover_one_exact_route_but_never_remove_path_guards() {
    let f = Setup::new();
    std::fs::copy(
        Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/assistant/tools.json"),
        f.tmp.path().join("bundle/tools.json"),
    )
    .unwrap();
    let r = f.open("1");
    let sid = f.session(&r).await;
    let write =
        |path: &str| json!({"name":"write_file","arguments":{"path":path,"content":"proof"}});
    start(&r,&sid,json!([write("one.txt"),write("two.txt"),{"name":"read_file","arguments":{"path":"two.txt"}}])).await;
    let i = pending(&r, &sid).await;
    respond(&r, &sid, &i, "session").await;
    let read = pending(&r, &sid).await;
    assert_eq!(read["call"]["name"], "read_file");
    respond(&r, &sid, &read, "once").await;
    done(&r, &sid).await;
    assert_eq!(
        std::fs::read_to_string(f.tmp.path().join("work/two.txt")).unwrap(),
        "proof"
    );
    start(&r, &sid, json!([write("../escape.txt")])).await;
    done(&r, &sid).await;
    assert!(!f.tmp.path().join("escape.txt").exists());
    assert!(r
        .store
        .lock()
        .unwrap()
        .events(&sid, 0)
        .unwrap()
        .iter()
        .any(|e| e.kind == "interaction_resolved" && e.data["origin"] == "hard_policy"));
    r.shutdown().await.unwrap();
}