//! `mcp --connect` to a port where no app listens yet (#270): the server still starts, its tools //! say how to start the app, and once the app runs they reach it with that launch's token. use std::io::{BufRead, BufReader, Write}; use std::net::TcpListener; use std::process::{Command, Stdio}; use serde_json::{Value, json}; #[test] fn mcp_connect_serves_before_the_app_runs_and_reaches_it_once_it_does() { // This test needs the port closed until its second phase. A port obtained // with bind(:0) and released can immediately be reused by another parallel // test's mock server. Stay below the usual ephemeral ranges, // with a process-specific starting point, and skip any occupied ports. let port = (0..512u32) .find_map(|offset| { let port = 16000 + (std::process::id() + offset) % 16000; TcpListener::bind(("127.0.0.1", port as u16)).ok().map(|listener| listener.local_addr().unwrap().port()) }) .expect("an unused non-ephemeral test port"); let addr = format!("127.0.0.1:{port}"); let control_dir = std::env::temp_dir().join(format!("solidcraft-mcp-connect-{}-{port}", std::process::id())); std::fs::create_dir_all(&control_dir).unwrap(); let mut child = Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")) .args(["mcp", "--connect", &addr, "--allow-any-path"]) .env("SOLIDCRAFT_CONTROL_DIR", &control_dir) .env_remove("SOLIDCRAFT_CONTROL_TOKEN") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::null()) .spawn() .unwrap(); let mut stdin = child.stdin.take().unwrap(); let mut stdout = BufReader::new(child.stdout.take().unwrap()); let mut ask = |id: u64, method: &str, params: Value| -> Value { writeln!(stdin, "{}", json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params})).unwrap(); let mut line = String::new(); stdout.read_line(&mut line).unwrap(); serde_json::from_str(&line).unwrap_or_else(|e| panic!("{e}: {line:?}")) }; let measure = json!({"name": "measure", "arguments": {}}); let text = |r: &Value| r["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string(); // The server answers without the app, and its instructions say the app isn't running. let init = ask(1, "initialize", json!({"protocolVersion": "2025-06-18"})); let instructions = init["result"]["instructions"].as_str().unwrap_or_default(); assert!(instructions.contains("not running") && instructions.contains(&format!("--control {port}")), "{instructions}"); let tools = ask(2, "tools/list", json!({})); assert!(tools["result"]["tools"].as_array().is_some_and(|t| !t.is_empty()), "{tools}"); // A tool call says the app is not running and how to start it. let r = ask(3, "tools/call", measure.clone()); assert_eq!(r["result"]["isError"], true, "{r}"); assert!(text(&r).contains("not running") && text(&r).contains(&format!("solidcraft --control {port}")), "{r}"); // The app starts: a token file for this launch, and its control port. let token = "0123456789abcdef".repeat(4); std::fs::write(control_dir.join(format!("{port}.token")), &token).unwrap(); let listener = TcpListener::bind(&addr).unwrap(); let app = std::thread::spawn(move || { let (stream, _) = listener.accept().unwrap(); let mut line = String::new(); BufReader::new(stream.try_clone().unwrap()).read_line(&mut line).unwrap(); let req: Value = serde_json::from_str(&line).unwrap(); let reply = if req["token"] == json!(token) { json!({"id": req["id"], "ok": true, "result": {"bodies": [], "method": req["method"]}}) } else { json!({"id": req["id"], "ok": false, "error": format!("unauthorized: token {}", req["token"])}) }; writeln!(&stream, "{reply}").unwrap(); }); let r = ask(4, "tools/call", measure); assert_ne!(r["result"]["isError"], true, "{r}"); assert!(text(&r).contains("engine.execute"), "{r}"); app.join().unwrap(); drop(stdin); assert!(child.wait().unwrap().success()); std::fs::remove_dir_all(&control_dir).ok(); } #[test] fn mcp_connect_without_a_port_is_refused_at_start() { for addr in ["localhost", "127.0.0.1:0"] { let output = Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")).args(["mcp", "--connect", addr]).stdin(Stdio::null()).output().unwrap(); let stderr = String::from_utf8_lossy(&output.stderr); assert!(!output.status.success(), "{addr}: {stderr}"); assert!(stderr.contains("HOST:PORT"), "{addr}: {stderr}"); } } /// `mcp` with no arguments finds the running app through the discovery file and uses that /// launch's token; with no app behind the file it stays a headless session. #[test] fn mcp_without_arguments_finds_the_running_app() { let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let port = listener.local_addr().unwrap().port(); let control_dir = std::env::temp_dir().join(format!("solidcraft-mcp-discover-{}-{port}", std::process::id())); std::fs::create_dir_all(&control_dir).unwrap(); let token = "fedcba9876543210".repeat(4); std::fs::write(control_dir.join(format!("{port}.token")), &token).unwrap(); std::fs::write(control_dir.join("current.port"), format!("{port}\n")).unwrap(); let app = std::thread::spawn(move || { // The discovery probe connects and leaves without a request; the tool call follows. let (stream, line) = loop { let (stream, _) = listener.accept().unwrap(); let mut line = String::new(); BufReader::new(stream.try_clone().unwrap()).read_line(&mut line).unwrap(); if !line.is_empty() { break (stream, line); } }; let req: Value = serde_json::from_str(&line).unwrap(); let ok = req["token"] == json!(token); let reply = json!({"id": req["id"], "ok": ok, "result": {"bodies": [], "method": req["method"]}, "error": "unauthorized"}); writeln!(&stream, "{reply}").unwrap(); }); let mut child = Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")) .args(["mcp", "--allow-any-path"]) .env("SOLIDCRAFT_CONTROL_DIR", &control_dir) .env_remove("SOLIDCRAFT_CONTROL_TOKEN") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) .spawn() .unwrap(); let mut stdin = child.stdin.take().unwrap(); let mut stdout = BufReader::new(child.stdout.take().unwrap()); writeln!(stdin, "{}", json!({"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "measure", "arguments": {}}})).unwrap(); let mut line = String::new(); stdout.read_line(&mut line).unwrap(); let r: Value = serde_json::from_str(&line).unwrap_or_else(|e| panic!("{e}: {line:?}")); assert_ne!(r["result"]["isError"], true, "{r}"); assert!(r["result"]["content"][0]["text"].as_str().unwrap_or_default().contains("engine.execute"), "{r}"); app.join().unwrap(); drop(stdin); assert!(child.wait().unwrap().success()); // The file names a port nothing listens on (the app crashed): a headless session instead. let closed = TcpListener::bind("127.0.0.1:0").unwrap(); let dead = closed.local_addr().unwrap().port(); drop(closed); std::fs::write(control_dir.join("current.port"), format!("{dead}\n")).unwrap(); let out = Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")) .args(["mcp", "--allow-any-path"]) .env("SOLIDCRAFT_CONTROL_DIR", &control_dir) .stdin(Stdio::null()) .output() .unwrap(); assert!(!String::from_utf8_lossy(&out.stderr).contains("bridged to the running app"), "{}", String::from_utf8_lossy(&out.stderr)); std::fs::remove_dir_all(&control_dir).ok(); } /// `mcp setup` against a temporary home: the client folders it finds are the only ones it writes. mod setup { use serde_json::{Value, json}; use std::path::{Path, PathBuf}; use std::process::Command; fn home(name: &str) -> PathBuf { let h = std::env::temp_dir().join(format!("solidcraft-mcp-setup-{name}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&h); std::fs::create_dir_all(&h).unwrap(); h } fn run(home: &Path, args: &[&str]) -> std::process::Output { Command::new(env!("CARGO_BIN_EXE_solidcraft-cli")) .args(["mcp", "setup"]) .args(args) .env_clear() .env("HOME", home) .env("USERPROFILE", home) .env("APPDATA", home.join("AppData/Roaming")) .env("LOCALAPPDATA", home.join("AppData/Local")) .env("XDG_CONFIG_HOME", home.join(".config")) .env("PATH", "") .output() .unwrap() } fn json_of(p: &Path) -> Value { serde_json::from_str(&std::fs::read_to_string(p).unwrap()).unwrap() } fn exe() -> String { let p = Path::new(env!("CARGO_BIN_EXE_solidcraft-cli")).canonicalize().unwrap(); p.to_string_lossy().trim_start_matches(r"\\?\").to_owned() } #[test] fn merges_into_opencode_and_cursor_keeping_other_servers() { let h = home("merge"); let oc = h.join(".config/opencode"); std::fs::create_dir_all(&oc).unwrap(); let old = json!({"$schema": "https://opencode.ai/config.json", "theme": "x", "mcp": {"other": {"type": "local", "command": ["o"]}}}); std::fs::write(oc.join("opencode.json"), old.to_string()).unwrap(); std::fs::create_dir_all(h.join(".cursor")).unwrap(); std::fs::write(h.join(".cursor/mcp.json"), r#"{"mcpServers": {"other": {"command": "o"}}}"#).unwrap(); let out = run(&h, &["--live"]); assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); let v = json_of(&oc.join("opencode.json")); assert_eq!(v["theme"], "x"); assert_eq!(v["mcp"]["other"], old["mcp"]["other"]); assert_eq!(v["mcp"]["solidcraft"], json!({"type": "local", "command": [exe(), "mcp"], "enabled": true})); assert_eq!(v["mcp"]["solidcraft-live"]["command"], json!([exe(), "mcp", "--connect", "127.0.0.1:7878"])); assert_eq!(json_of(&oc.join("opencode.json.bak")), old); let c = json_of(&h.join(".cursor/mcp.json")); assert_eq!(c["mcpServers"]["other"], json!({"command": "o"})); assert_eq!(c["mcpServers"]["solidcraft"], json!({"command": exe(), "args": ["mcp"]})); // Codex (TOML) and Claude Code (a big file the CLI owns) are edited in place too. std::fs::create_dir_all(h.join(".codex")).unwrap(); std::fs::write(h.join(".codex/config.toml"), "# mine\nmodel = \"x\"\n").unwrap(); let cc = "{\n \"numStartups\": 3,\n \"projects\": {}\n}\n"; std::fs::write(h.join(".claude.json"), cc).unwrap(); assert!(run(&h, &[]).status.success()); let toml = std::fs::read_to_string(h.join(".codex/config.toml")).unwrap(); assert!(toml.starts_with("# mine\nmodel = \"x\"\n") && toml.contains("[mcp_servers.solidcraft]"), "{toml}"); let c = json_of(&h.join(".claude.json")); assert_eq!(c["numStartups"], 3); assert_eq!(c["mcpServers"]["solidcraft"], json!({"type": "stdio", "command": exe(), "args": ["mcp"]})); assert_eq!(std::fs::read_to_string(h.join(".claude.json.bak")).unwrap(), cc); // Running again updates the same entries and leaves one of each. assert!(run(&h, &[]).status.success()); assert_eq!(json_of(&h.join(".cursor/mcp.json"))["mcpServers"].as_object().unwrap().len(), 3); } #[test] fn dry_run_writes_nothing_and_missing_clients_are_skipped() { let h = home("dry"); std::fs::create_dir_all(h.join(".cursor")).unwrap(); let out = run(&h, &["--dry-run"]); assert!(out.status.success()); let text = String::from_utf8_lossy(&out.stdout); assert!(text.contains("would write") && text.contains("solidcraft"), "{text}"); assert!(!h.join(".cursor/mcp.json").exists()); assert!(!h.join(".config/opencode").exists(), "OpenCode was not installed, so nothing is created for it"); let out = run(&h, &["--client", "claude-desktop"]); assert!(String::from_utf8_lossy(&out.stdout).contains("not found")); } #[test] fn a_file_that_is_not_json_is_left_alone() { let h = home("bad"); std::fs::create_dir_all(h.join(".cursor")).unwrap(); std::fs::write(h.join(".cursor/mcp.json"), "{ // comment").unwrap(); let out = run(&h, &[]); assert!(!out.status.success()); assert_eq!(std::fs::read_to_string(h.join(".cursor/mcp.json")).unwrap(), "{ // comment"); } #[test] fn claude_desktop_msix_folder_is_found() { let h = home("msix"); let pkg = h.join("AppData/Local/Packages/Claude_abc/LocalCache/Roaming/Claude"); std::fs::create_dir_all(&pkg).unwrap(); // The MSIX folder is only read through LOCALAPPDATA, set for every platform here. assert!(run(&h, &["--client", "claude-desktop"]).status.success()); assert!(json_of(&pkg.join("claude_desktop_config.json"))["mcpServers"]["solidcraft"].is_object()); } }