#![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, 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(); } }