Skip to content
Python
7.2 KB
Raw Blame
//! One real, disposable OpenShell environment. The current trusted runtime
//! screens remote ToolRunner results; no vendor/model keys or cloud resources.
#![cfg(all(
    feature = "openshell-test",
    feature = "guardrails",
    feature = "compliance",
    not(windows)
))]
use anyhow::{ensure, Result};
use openworker_runtime::{
    environment::{Management, Provider, Registry, Sharing},
    environment_openshell::OpenShell,
    execution::Backend,
    model::Model,
    runtime::Runtime,
    safety::{
        Action, CheckFuture, Config as Safety, Context, Decision, Guardrails, Handler, HandlerRef,
        Hook, HookPhase, Rule, ToolRules,
    },
    sandbox::ExecConnectionConfig,
};
use openworker_store_postgres::{Config, PostgresStore, Tls};
use serde_json::{json, Value};
use std::{path::PathBuf, sync::Arc, time::Duration};
struct Deny;
impl Handler for Deny {
    fn call(&self, _: Context, _: tokio_util::sync::CancellationToken) -> CheckFuture<'_> {
        Box::pin(async { Ok(Decision::block("READ_ONLY")) })
    }
}
async fn run(rt: &Arc<Runtime>, sid: &str, key: &str, calls: Value) -> Result<()> {
    rt.dispatch("turn/start",json!({"session_id":sid,"submission_id":key,"text":format!("TEST_RESOURCE_GRANTS {calls}")})).await?;
    tokio::time::timeout(Duration::from_secs(90), async {
        loop {
            let s = rt.snapshot(sid)?;
            let state = s["turn"]["status"].as_str().unwrap_or("");
            if state == "completed" && !rt.is_busy(sid) {
                return Ok(());
            }
            ensure!(
                !matches!(
                    state,
                    "failed" | "blocked" | "interrupted" | "waiting_safety"
                ),
                "Remote qualification stopped: {state}"
            );
            tokio::time::sleep(Duration::from_millis(50)).await;
        }
    })
    .await?
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "requires isolated OW_PG_TEST_URL and OW_PROBE_ENDPOINT/CERTS/IMAGE/RUNNER"]
async fn remote_read_redaction_and_before_tool_denial_in_bypass() -> Result<()> {
    let provider = Arc::new(OpenShell::new(
        "openshell-k8s".into(),
        "safety-qualification".into(),
        ExecConnectionConfig {
            endpoint: std::env::var("OW_PROBE_ENDPOINT")?,
            certificates: PathBuf::from(std::env::var("OW_PROBE_CERTS")?),
            tls_server_name: std::env::var("OW_PROBE_TLS_NAME").ok(),
            workspace: "default".into(),
        },
        std::env::var("OW_PROBE_IMAGE")?,
    )?);
    let mut config = Config::new(
        std::env::var("OW_PG_TEST_URL")?,
        format!("ow_safety_{}", uuid::Uuid::new_v4().simple()),
    );
    config.tls = Tls::LoopbackPlaintext;
    config.lease_duration = Duration::from_secs(120);
    PostgresStore::migrate(&config)?;
    let store = PostgresStore::open(config.clone())?;
    let (record, _) = store.begin_environment(
        "safety-create",
        "qualification",
        provider.spec(Sharing::Shared, Management::Harness),
    )?;
    eprintln!(
        "Owned safety fixture: schema={} environment={}",
        config.schema, record.id
    );
    let binding = provider.create(record.clone()).await?;
    store.complete_environment(&record.id, record.revision, Some(binding.clone()))?;
    provider.inspect(binding.clone()).await?;
    let mut registry = Registry::default();
    registry.register(provider.clone())?;
    let root = tempfile::tempdir()?;
    let mut rt = Runtime::open_with_store(
        root.path(),
        &PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../examples/assistant"),
        &PathBuf::from(std::env::var("OW_PROBE_RUNNER")?),
        Model::new("fixture".into(), true),
        Backend::Openshell,
        None,
        None,
        Default::default(),
        Some(Box::new(store.clone())),
    )?;
    Runtime::configure_environments(&mut rt, Arc::new(registry))?;
    let reference = HandlerRef {
        name: "read-only".into(),
        version: "1".into(),
    };
    rt.safety_handlers
        .register(reference.clone(), Arc::new(Deny))?;
    let safety = Safety {
        guardrails: Guardrails {
            tool_results: vec![ToolRules {
                tools: vec!["example-tools.read_file".into()],
                rules: vec![Rule::regex("secrets", "SECRET_[A-Z]+", Action::redact())],
            }],
            ..Default::default()
        },
        hooks: vec![Hook {
            name: "read-only".into(),
            version: "1".into(),
            when: HookPhase::BeforeTool,
            tools: vec!["example-tools.write_file".into()],
            handler: reference,
            timeout_ms: 1000,
        }],
        ..Default::default()
    };
    let mut sessions = vec![];
    let result:Result<()>=async {
  for (name,policy) in [("seed",Safety::default()),("screened",safety)] {let s=rt.dispatch("session/create",json!({"name":name,"coworker":"assistant-example","workspace":"/sandbox","environment_id":record.id,"permissions":{"mode":"bypass"},"safety":policy,"compliance":{},"compaction":{"enabled":false}})).await?;sessions.push(s["session"]["id"].as_str().unwrap().to_owned());}
  run(&rt,&sessions[0],"seed-file",json!([{"name":"write_file","arguments":{"path":"protected.txt","content":"SECRET_SENTINEL"}}])).await?;
  run(&rt,&sessions[1],"screen-read",json!([{"name":"read_file","arguments":{"path":"protected.txt"}}])).await?;
  let reader=store.inspect(&sessions[1])?;ensure!(!json!(reader.history).to_string().contains("SECRET_SENTINEL"),"Remote result escaped inspection");ensure!(json!(reader.history).to_string().contains("[redacted]"),"Redacted remote result missing");
  run(&rt,&sessions[1],"deny-write",json!([{"name":"write_file","arguments":{"path":"forbidden.txt","content":"unapproved"}}])).await?;
  let events=rt.dispatch("event/read",json!({"session_id":sessions[1],"after":0})).await?;ensure!(!events.to_string().contains("SECRET_SENTINEL"),"Remote result leaked into events");ensure!(events["events"].as_array().unwrap().iter().any(|e|e["type"]=="tool_started"&&e["data"]["name"]=="read_file"),"No remote read was dispatched");ensure!(!events["events"].as_array().unwrap().iter().any(|e|e["type"]=="tool_started"&&e["data"]["name"]=="write_file"),"Blocked action dispatched");
  let evidence=store.compliance_page(&sessions[1],Default::default())?;ensure!(evidence["activities"].as_array().unwrap().iter().any(|e|e["facts"]["outcome"]=="redacted"),"Missing redaction evidence");ensure!(evidence["activities"].as_array().unwrap().iter().any(|e|e["facts"]["outcome"]=="blocked"),"Missing block evidence");
  Ok(())
 }.await;
    for sid in &sessions {
        rt.dispatch("session/close", json!({"session_id":sid}))
            .await?;
    }
    rt.shutdown().await?;
    let operation = uuid::Uuid::new_v4().to_string();
    let (deleting, _) = store.begin_environment_delete(&record.id, &operation, "qualification")?;
    provider.delete(binding, operation.clone()).await?;
    store.complete_environment_delete(&record.id, &operation, deleting.revision)?;
    tokio::task::block_in_place(|| -> Result<()> {
        let mut db = postgres::Client::connect(&config.connection, postgres::NoTls)?;
        db.batch_execute(&format!("DROP SCHEMA {} CASCADE", config.schema))?;
        Ok(())
    })?;
    result
}