mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
Allow developers to easily build AI apps without worrying about the harness part. Bundles the Rust agent runtime as a SDK (Rust and TypeScript) for building desktop and web applications. Applications can manage a local harness or connect to an authenticated harness service on k8s with separately scaled workers and sandbox execution. The implementation is primarily contained in harness/, with deployment tooling in deploy/, Markdown guides in docs/harness/guides/, and the static documentation site in docs-site/. It does not replace the existing Python harness or migrate OpenWorker Desktop. Co-authored-by: Devika Verma <devikaverma11@gmail.com>
225 lines
8.9 KiB
Rust
225 lines
8.9 KiB
Rust
#![cfg(target_os = "linux")]
|
|
//! Real helper/process transport tests, without external service credentials.
|
|
//! These do not replace live OpenShell proxy/L7 qualification.
|
|
use serde_json::{json, Value};
|
|
use std::{path::Path, process::Stdio};
|
|
use tokio::{
|
|
io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
|
|
process::Command,
|
|
};
|
|
const BIN: &str = env!("CARGO_BIN_EXE_openworker");
|
|
const REF: &str = "openshell:resolve:env:v1_fixture_GITHUB_TOKEN";
|
|
async fn helper(root: &Path, request: &str, token: &str) -> std::process::Output {
|
|
let mut child = Command::new(BIN)
|
|
.args(["git-credential-openshell", "get"])
|
|
.env_clear()
|
|
.env("GITHUB_TOKEN", token)
|
|
.env(
|
|
"OPENWORKER_GIT_SETTINGS",
|
|
r#"{"host":"github.com","repositories":["org/project"]}"#,
|
|
)
|
|
.current_dir(root)
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.kill_on_drop(true)
|
|
.spawn()
|
|
.unwrap();
|
|
child
|
|
.stdin
|
|
.take()
|
|
.unwrap()
|
|
.write_all(request.as_bytes())
|
|
.await
|
|
.unwrap();
|
|
child.wait_with_output().await.unwrap()
|
|
}
|
|
#[tokio::test]
|
|
async fn helper_returns_only_placeholder_for_exact_repo_and_never_persists_a_key() {
|
|
let root = tempfile::tempdir().unwrap();
|
|
let allowed = "protocol=https\nhost=github.com\npath=org/project.git\n\n";
|
|
let out = helper(root.path(), allowed, REF).await;
|
|
assert!(out.status.success());
|
|
assert_eq!(
|
|
String::from_utf8(out.stdout).unwrap(),
|
|
format!("username=x-access-token\npassword={REF}\n\n")
|
|
);
|
|
for request in [
|
|
"protocol=http\nhost=github.com\npath=org/project.git\n\n",
|
|
"protocol=https\nhost=other.test\npath=org/project.git\n\n",
|
|
"protocol=https\nhost=github.com\npath=org/other.git\n\n",
|
|
] {
|
|
let out = helper(root.path(), request, REF).await;
|
|
assert!(out.status.success());
|
|
assert!(out.stdout.is_empty());
|
|
}
|
|
let raw = "synthetic-raw-key-must-not-leak";
|
|
let out = helper(root.path(), allowed, raw).await;
|
|
assert!(!out.status.success() && out.stdout.is_empty());
|
|
assert!(!String::from_utf8_lossy(&out.stderr).contains(raw));
|
|
assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
|
|
}
|
|
async fn rpc(
|
|
child: &mut tokio::process::Child,
|
|
reader: &mut BufReader<tokio::process::ChildStdout>,
|
|
id: u64,
|
|
name: &str,
|
|
args: Value,
|
|
) -> Value {
|
|
let v = json!({"jsonrpc":"2.0","id":id,"method":name,"params":args});
|
|
child
|
|
.stdin
|
|
.as_mut()
|
|
.unwrap()
|
|
.write_all(format!("{v}\n").as_bytes())
|
|
.await
|
|
.unwrap();
|
|
let mut line = String::new();
|
|
tokio::time::timeout(
|
|
std::time::Duration::from_secs(20),
|
|
reader.read_line(&mut line),
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.unwrap();
|
|
let reply: Value = serde_json::from_str(&line).unwrap();
|
|
assert_eq!(reply["id"], id);
|
|
reply
|
|
}
|
|
#[tokio::test]
|
|
#[ignore = "requires OW_TEST_DISPOSABLE_LINUX in a disposable Linux container"]
|
|
async fn default_shell_has_no_git_key_and_opt_in_manager_carries_only_current_reference() {
|
|
assert_eq!(
|
|
std::env::var("OW_TEST_DISPOSABLE_LINUX").as_deref(),
|
|
Ok("true")
|
|
);
|
|
for managed in [false, true] {
|
|
for enabled in [false, true] {
|
|
let root = tempfile::tempdir().unwrap();
|
|
// Reconnect to the SAME workspace/manager with a distinct current
|
|
// reference. A manager that caches its launch environment must fail
|
|
// this assertion, even if an upstream still accepts the old token.
|
|
for reference in [REF, "openshell:resolve:env:v2_refreshed_GITHUB_TOKEN"] {
|
|
let mut cmd = Command::new(BIN);
|
|
cmd.args(["mcp-coding", "--workspace"]).arg(root.path());
|
|
if managed {
|
|
cmd.arg("--environment-processes");
|
|
}
|
|
if enabled {
|
|
cmd.args([
|
|
"--openshell-git",
|
|
"--openshell-git-repository",
|
|
"org/project",
|
|
]);
|
|
}
|
|
let mut child = cmd
|
|
.env("GITHUB_TOKEN", reference)
|
|
.env_remove("GH_TOKEN")
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::null())
|
|
.kill_on_drop(true)
|
|
.spawn()
|
|
.unwrap();
|
|
let mut reader = BufReader::new(child.stdout.take().unwrap());
|
|
let init=rpc(&mut child,&mut reader,1,"initialize",json!({"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"git-test","version":"1"}})).await;
|
|
assert!(init["error"].is_null());
|
|
child
|
|
.stdin
|
|
.as_mut()
|
|
.unwrap()
|
|
.write_all(b"{\"jsonrpc\":\"2.0\",\"method\":\"notifications/initialized\"}\n")
|
|
.await
|
|
.unwrap();
|
|
let command = if enabled {
|
|
format!("test \"$GITHUB_TOKEN\" = '{reference}' && printf 'protocol=https\\nhost=github.com\\npath=org/project.git\\n\\n' | git credential fill | grep -Fxq 'password={reference}' && printf 'scoped helper works'")
|
|
} else {
|
|
"test -z \"$GITHUB_TOKEN\" && test -z \"$GIT_CONFIG_COUNT\" && printf 'no credential inherited'".into()
|
|
};
|
|
let out = rpc(
|
|
&mut child,
|
|
&mut reader,
|
|
2,
|
|
"tools/call",
|
|
json!({"name":"run_shell","arguments":{"command":command,"yield_ms":10000}}),
|
|
)
|
|
.await;
|
|
let data: Value =
|
|
serde_json::from_str(out["result"]["content"][0]["text"].as_str().unwrap())
|
|
.unwrap();
|
|
assert_eq!(
|
|
data["exit_code"], 0,
|
|
"process failed; managed={managed}, enabled={enabled}"
|
|
);
|
|
assert_eq!(
|
|
data["stdout"],
|
|
if enabled {
|
|
"scoped helper works"
|
|
} else {
|
|
"no credential inherited"
|
|
}
|
|
);
|
|
assert!(!data.to_string().contains(REF));
|
|
assert!(!data.to_string().contains(reference));
|
|
child.stdin.take();
|
|
child.wait().await.unwrap();
|
|
// A manager is sandbox-owned, not tool-connection-owned. End only
|
|
// this fixture's idle manager by dropping its process container in
|
|
// the Linux Docker test; no process IDs outside the fixture are used.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[ignore = "requires OW_TEST_DISPOSABLE_LINUX in a disposable Linux container"]
|
|
async fn long_workspace_process_manager_reuses_original_owner_across_tool_connections() {
|
|
assert_eq!(
|
|
std::env::var("OW_TEST_DISPOSABLE_LINUX").as_deref(),
|
|
Ok("true")
|
|
);
|
|
let temp = tempfile::tempdir().unwrap();
|
|
let root = temp.path().join("project".repeat(30));
|
|
std::fs::create_dir(&root).unwrap();
|
|
let mut handle = String::new();
|
|
for connection in 0..2 {
|
|
let mut child = Command::new(BIN)
|
|
.args(["mcp-coding", "--environment-processes", "--workspace"])
|
|
.arg(&root)
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::null())
|
|
.kill_on_drop(true)
|
|
.spawn()
|
|
.unwrap();
|
|
let mut reader = BufReader::new(child.stdout.take().unwrap());
|
|
rpc(&mut child,&mut reader,1,"initialize",json!({"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"fixture","version":"1"}})).await;
|
|
let args = if connection == 0 {
|
|
json!({"name":"process_start","arguments":{"command":"sleep 30"}})
|
|
} else {
|
|
json!({"name":"process_status","arguments":{"process_id":handle}})
|
|
};
|
|
let reply = rpc(&mut child, &mut reader, 2, "tools/call", args).await;
|
|
let data: Value =
|
|
serde_json::from_str(reply["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
|
|
assert_ne!(reply["result"]["isError"], true, "{reply}");
|
|
if connection == 0 {
|
|
handle = data["process_id"].as_str().unwrap().into();
|
|
} else {
|
|
assert_eq!(data["process_id"], handle);
|
|
assert_eq!(data["status"], "running");
|
|
let stopped = rpc(
|
|
&mut child,
|
|
&mut reader,
|
|
3,
|
|
"tools/call",
|
|
json!({"name":"process_stop","arguments":{"process_id":handle}}),
|
|
)
|
|
.await;
|
|
assert_ne!(stopped["result"]["isError"], true, "{stopped}");
|
|
}
|
|
child.stdin.take();
|
|
child.wait().await.unwrap();
|
|
}
|
|
}
|