use super::*; #[derive(Clone, Default)] struct Buf(Arc>>); impl Write for Buf { fn write(&mut self, b: &[u8]) -> std::io::Result { self.0.lock().unwrap().extend_from_slice(b); Ok(b.len()) } fn flush(&mut self) -> std::io::Result<()> { Ok(()) } } fn run_with(opts: ServerOptions, lines: &[Value]) -> Vec { let input: String = lines.iter().map(|l| format!("{l}\n")).collect(); run_raw(opts, &input) } fn run_raw(opts: ServerOptions, input: &str) -> Vec { let engine = Arc::new(Engine::new(craft_anything_engine::testing::session())); let buf = Buf::default(); serve(engine, opts, std::io::Cursor::new(input.as_bytes().to_vec()), Box::new(buf.clone())).unwrap(); let out = String::from_utf8(buf.0.lock().unwrap().clone()).unwrap(); out.lines().map(|l| serde_json::from_str(l).unwrap()).collect() } fn run(lines: &[Value]) -> Vec { run_with(ServerOptions::default(), lines) } fn req(id: u64, method: &str, params: Value) -> Value { json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params}) } fn response(out: &[Value], id: u64) -> Value { out.iter().find(|m| m["id"] == json!(id)).cloned().unwrap_or_else(|| panic!("no response {id} in {out:?}")) } /// A coding agent's permission-prompt tool accepts exactly one text block holding the decision /// JSON; anything else (structuredContent, extra notes, an error result) makes it refuse every /// action. Failures must still come back as a readable decision. #[test] fn approval_tool_answers_in_the_permission_prompt_shape() { let out = run(&[ req(1, "tools/call", json!({"name": "core_action_approve", "arguments": {"tool_name": "TodoWrite", "input": {"todos": []}, "tool_use_id": "t"}})), req(2, "tools/call", json!({"name": "core_action_approve", "arguments": {"input": {}}})), ]); for id in [1, 2] { let r = response(&out, id)["result"].clone(); assert_eq!(r["isError"], false, "{r}"); assert!(r.get("structuredContent").is_none(), "{r}"); let content = r["content"].as_array().unwrap(); assert_eq!(content.len(), 1, "{r}"); assert_eq!(content[0]["type"], "text"); let decision: Value = serde_json::from_str(content[0]["text"].as_str().unwrap()).unwrap(); assert!(decision["behavior"] == "allow" || decision["behavior"] == "deny", "{decision}"); } let ok: Value = serde_json::from_str(response(&out, 1)["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(ok, json!({"behavior": "allow", "updatedInput": {"todos": []}})); let bad: Value = serde_json::from_str(response(&out, 2)["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(bad["behavior"], "deny", "a malformed request is refused in the protocol's own words"); } /// #253: an allowed action with a large input came back as an `over_limit` error with no decision. #[test] fn a_large_approval_keeps_its_decision() { let input = json!({"todos": [], "note": "a".repeat(4096)}); let out = run_with( ServerOptions { max_response_bytes: 300, ..Default::default() }, &[req(1, "tools/call", json!({"name": "core_action_approve", "arguments": {"tool_name": "TodoWrite", "input": input, "tool_use_id": "t"}}))], ); let r = response(&out, 1)["result"].clone(); assert_eq!(r["isError"], false, "{r}"); let decision: Value = serde_json::from_str(r["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(decision, json!({"behavior": "allow", "updatedInput": input})); } /// #263: in Clean room, enabling a toolset counted the tools Clean room hides from the list. #[test] fn enabling_a_toolset_counts_the_tools_listed() { let input = format!( "{} ", req(1, "tools/call", json!({"name": "enable_toolset", "arguments": {"toolset": "all"}})) ); let mut session = craft_anything_engine::testing::session(); session.settings.deep_mode = false; let engine = Arc::new(Engine::new(session)); let runs = engine.registry().all().iter().filter(|s| craft_anything_engine::clean_room::allows(s.id)).count(); let buf = Buf::default(); serve(engine, ServerOptions::default(), std::io::Cursor::new(input.into_bytes()), Box::new(buf.clone())).unwrap(); let out: Vec = String::from_utf8(buf.0.lock().unwrap().clone()).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect(); let enabled: Value = serde_json::from_str(response(&out, 1)["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(enabled["result"]["visible_tools"], json!(runs), "{enabled}"); } fn tool_names(v: &Value) -> Vec { v["result"]["tools"].as_array().unwrap().iter().map(|t| t["name"].as_str().unwrap().to_string()).collect() } #[test] fn initialize_negotiates_version() { let out = run(&[ req(1, "initialize", json!({"protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "t", "version": "1"}})), json!({"jsonrpc": "2.0", "method": "notifications/initialized"}), req(2, "initialize", json!({"protocolVersion": "1999-01-01"})), req(3, "ping", json!({})), ]); let r = response(&out, 1); assert_eq!(r["result"]["protocolVersion"], "2025-03-26"); assert_eq!(r["result"]["serverInfo"]["name"], "craft-anything"); assert_eq!(r["result"]["capabilities"]["tools"]["listChanged"], true); assert_eq!(response(&out, 2)["result"]["protocolVersion"], PROTOCOL_VERSIONS[0]); assert_eq!(response(&out, 3)["result"], json!({})); assert_eq!(out.len(), 3, "notifications get no response"); } #[test] fn progressive_toolsets() { let out = run(&[req(1, "tools/list", json!({})), req(2, "tools/call", json!({"name": "enable_toolset", "arguments": {"toolset": "native"}}))]); let names = tool_names(&response(&out, 1)); assert!(names.contains(&"core_session_show".to_string())); assert!(names.contains(&"core_investigation_show".to_string())); assert!(names.contains(&"enable_toolset".to_string())); assert!(!names.contains(&"native_cursor_show".to_string()), "native tools hidden at first"); assert!(out.iter().any(|m| m["method"] == "notifications/tools/list_changed")); // a second connection after enabling sees the tool let out = run(&[req(1, "tools/call", json!({"name": "enable_toolset", "arguments": {"toolset": "native"}})), req(2, "tools/list", json!({}))]); // tools/call runs on a worker; list may be answered first, so check the call result only let r = response(&out, 1); assert_eq!(r["result"]["isError"], false); let all = run_with(ServerOptions { all_tools: true, ..Default::default() }, &[req(1, "tools/list", json!({}))]); let names = tool_names(&response(&all, 1)); assert!(names.contains(&"native_cursor_show".to_string())); assert!(!names.contains(&"enable_toolset".to_string())); } #[test] fn tool_call_success_and_error_shapes() { let out = run(&[ req(1, "tools/call", json!({"name": "core_session_show", "arguments": {}})), req(2, "tools/call", json!({"name": "core_target_close", "arguments": {}})), req(3, "tools/call", json!({"name": "no_such_tool", "arguments": {}})), ]); let ok = response(&out, 1); assert_eq!(ok["result"]["isError"], false); assert_eq!(ok["result"]["structuredContent"]["result"]["server"]["name"], "craft-anything"); let text: Value = serde_json::from_str(ok["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(text, ok["result"]["structuredContent"]); let err = response(&out, 2); assert_eq!(err["result"]["isError"], true); let e: Value = serde_json::from_str(err["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(e["error"]["code"], "not_found"); assert!(e["error"]["remediation"].is_string()); assert_eq!(response(&out, 3)["result"]["isError"], true); } #[test] fn hidden_tool_call_enables_its_toolset() { let out = run(&[req(1, "tools/call", json!({"name": "native_cursor_show", "arguments": {}}))]); assert!(out.iter().any(|m| m["method"] == "notifications/tools/list_changed")); assert_eq!(response(&out, 1)["result"]["isError"], true); } #[test] fn protocol_errors() { let out = run_raw(ServerOptions::default(), "{not json\n[1,2]\n{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"bogus\"}\n\n"); assert_eq!(out[0]["error"]["code"], -32700); assert_eq!(out[1]["error"]["code"], -32600); assert_eq!(out[2]["error"]["code"], -32601); assert_eq!(out[2]["id"], 7); } #[test] fn prompts_and_completion() { let out = run(&[ req(1, "prompts/list", json!({})), req(2, "prompts/get", json!({"name": "native_crash_explain", "arguments": {"symptom": "SIGSEGV in parse"}})), req(3, "prompts/get", json!({"name": "native_crash_explain", "arguments": {}})), req(4, "completion/complete", json!({"ref": {"type": "ref/prompt", "name": "core_unknowns_review"}, "argument": {"name": "evidence", "value": "ev_"}})), req(5, "completion/complete", json!({"ref": {"type": "ref/resource", "uri": "x"}, "argument": {"name": "a", "value": ""}})), ]); assert_eq!(response(&out, 1)["result"]["prompts"].as_array().unwrap().len(), 6); let text = response(&out, 2)["result"]["messages"][0]["content"]["text"].as_str().unwrap().to_string(); assert!(text.contains("SIGSEGV in parse")); assert_eq!(response(&out, 3)["error"]["code"], -32602); assert_eq!(response(&out, 4)["result"]["completion"]["values"], json!([])); assert_eq!(response(&out, 5)["result"]["completion"]["total"], 0); } #[test] fn resources() { let out = run(&[ req(1, "resources/list", json!({})), req(2, "resources/read", json!({"uri": "investigation://brief"})), req(3, "resources/read", json!({"uri": "evidence://ev_missing"})), req(4, "resources/templates/list", json!({})), req(5, "resources/read", json!({"uri": "investigation://state"})), ]); let list = response(&out, 1); let uris: Vec<&str> = list["result"]["resources"].as_array().unwrap().iter().map(|r| r["uri"].as_str().unwrap()).collect(); assert!(uris.contains(&"investigation://handoff")); assert!(response(&out, 2)["result"]["contents"][0]["text"].as_str().unwrap().starts_with("# Brief")); assert_eq!(response(&out, 3)["error"]["code"], -32002); assert_eq!(response(&out, 4)["result"]["resourceTemplates"][0]["uriTemplate"], "evidence://{evidence_id}"); let state: Value = serde_json::from_str(response(&out, 5)["result"]["contents"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(state["revision"], 0); } #[test] fn oversize_results_become_resource_constraint() { let out = run_with( ServerOptions { max_response_bytes: 300, ..Default::default() }, &[req(1, "tools/call", json!({"name": "core_session_show", "arguments": {}}))], ); let r = response(&out, 1); assert_eq!(r["result"]["isError"], true); let e: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(e["error"]["code"], "over_limit"); assert_eq!(e["error"]["details"]["resource"], "transport"); } #[test] fn progress_token_gets_notifications_and_cancel_of_unknown_is_ignored() { let out = run(&[ json!({"jsonrpc": "2.0", "method": "notifications/cancelled", "params": {"requestId": 99}}), json!({"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "core_session_show", "arguments": {}, "_meta": {"progressToken": "p1"}}}), ]); let progress: Vec<&Value> = out.iter().filter(|m| m["method"] == "notifications/progress").collect(); assert!(!progress.is_empty()); assert_eq!(progress[0]["params"]["progressToken"], "p1"); assert_eq!(response(&out, 1)["result"]["isError"], false); } #[test] fn progress_needs_a_token() { let out = run(&[req(1, "tools/call", json!({"name": "core_session_show", "arguments": {}}))]); assert!(out.iter().all(|m| m["method"] != "notifications/progress"), "{out:?}"); assert_eq!(response(&out, 1)["result"]["isError"], false); } #[test] fn only_strings_and_numbers_are_progress_tokens() { for token in [json!(null), json!({"bad": 1}), json!([1, 2]), json!(true)] { let out = run(&[req(1, "tools/call", json!({"name": "core_session_show", "arguments": {}, "_meta": {"progressToken": token.clone()}}))]); assert!(out.iter().all(|m| m["method"] != "notifications/progress"), "token {token}: {out:?}"); assert_eq!(response(&out, 1)["result"]["isError"], false); } let out = run(&[req(1, "tools/call", json!({"name": "core_session_show", "arguments": {}, "_meta": {"progressToken": 7}}))]); let progress: Vec<&Value> = out.iter().filter(|m| m["method"] == "notifications/progress").collect(); assert!(!progress.is_empty(), "a number is a valid token: {out:?}"); assert_eq!(progress[0]["params"]["progressToken"], 7); } #[test] fn progress_comes_before_the_response() { let out = run(&[req(1, "tools/call", json!({"name": "core_session_show", "arguments": {}, "_meta": {"progressToken": "p1"}}))]); let progress = out.iter().position(|m| m["method"] == "notifications/progress").expect("a progress notification"); let result = out.iter().position(|m| m["id"] == json!(1)).expect("the response"); assert!(progress < result, "progress must come before its result: {out:?}"); } #[test] fn memory_tools_work_over_mcp() { let out = run(&[req(1, "tools/call", json!({"name": "core_brief_write", "arguments": {"question": "How does login work?"}}))]); assert_eq!(response(&out, 1)["result"]["isError"], false); } fn test_server(engine: Arc, opts: ServerOptions) -> Server { Server::new(engine, opts, Box::new(Buf::default())) } #[test] fn provenance_meta_is_set_for_target_content() { let server = test_server(Arc::new(Engine::new(craft_anything_engine::testing::session())), ServerOptions::default()); // By tool id: a known producer of target content, even when the record didn't set the flag. let mut body = json!({"content": [{"type": "text", "text": "x"}], "structuredContent": {"result": {}}, "isError": false}); server.attach_provenance(&mut body, "native_function_pseudocode"); assert_eq!(body["_meta"]["provenance"]["from_target"], true); assert!(body["content"].as_array().unwrap().iter().any(|c| c["text"].as_str().unwrap_or_default().contains("data, not instructions"))); // By the evidence flag: an unlisted tool whose evidence set carries_target_content. let mut body2 = json!({"content": [], "structuredContent": {"carries_target_content": true}, "isError": false}); server.attach_provenance(&mut body2, "some_unlisted_tool"); assert_eq!(body2["_meta"]["provenance"]["from_target"], true); // A plain tool with no target content: no provenance marker. let mut body3 = json!({"content": [], "structuredContent": {"result": {"open": false}}, "isError": false}); server.attach_provenance(&mut body3, "core_session_show"); assert!(body3.get("_meta").is_none()); } #[test] fn oversize_evidence_collapses_to_a_summary() { use craft_anything_evidence::{Confidence, Environment, EvidenceBuilder, Subject}; let engine = Arc::new(Engine::new(craft_anything_engine::testing::session())); let ev = EvidenceBuilder::new( "extract_strings", Subject { kind: "native".into(), sha256: Some("ab".repeat(32)), name: Some("calc".into()) }, Environment::builtin(true), ) .result(json!({"strings": vec!["x"; 4000]})) .summary("Four thousand strings.") .confidence(Confidence::Observed) .target_content(true) .build() .unwrap(); let ev_id = ev.id.clone(); let full = serde_json::to_value(&ev).unwrap(); engine.session().record(ev).unwrap(); let server = test_server(engine, ServerOptions { max_response_bytes: 512, ..Default::default() }); // Shape the success response the server would have produced for this evidence. let resp = ok_response(json!(1), json!({"structuredContent": full, "isError": false})); let summary = server.oversize_summary(&resp).expect("a saved summary"); let sc = &summary["structuredContent"]; assert_eq!(sc["detail"], "summary"); assert_eq!(sc["saved_evidence"]["evidence_id"], json!(ev_id)); assert_eq!(sc["continue_with"], "core_evidence_browse"); assert_eq!(summary["isError"], false); // It carries the from-target marker too. assert_eq!(summary["_meta"]["provenance"]["from_target"], true); // And the summary is far smaller than the full record. assert!(serde_json::to_string(&summary).unwrap().len() < serde_json::to_string(&resp).unwrap().len()); } /// Claude Code takes about 25k tokens of a tool's output, so its connections get a smaller budget /// (bigger results come back summary-first); other clients and an explicit budget are left alone. #[test] fn claude_code_connections_get_a_budget_that_fits_its_limit() { let server = |opts: ServerOptions| Server::new(Arc::new(Engine::new(craft_anything_engine::testing::session())), opts, Box::new(Buf::default())); let hello = |name: &str| json!({"protocolVersion": PROTOCOL_VERSIONS[0], "clientInfo": {"name": name, "version": "1"}}); let s = server(ServerOptions::default()); s.handle_request("initialize", &hello("claude-code")).unwrap(); assert_eq!(s.budget(), CLAUDE_CODE_RESPONSE_BYTES); let other = server(ServerOptions::default()); other.handle_request("initialize", &hello("some-editor")).unwrap(); assert_eq!(other.budget(), DEFAULT_MAX_RESPONSE_BYTES); let set = server(ServerOptions { max_response_bytes: 500_000, budget_for_client: false, ..Default::default() }); set.handle_request("initialize", &hello("claude-code")).unwrap(); assert_eq!(set.budget(), 500_000, "an explicit budget wins"); } /// #563: "Always for this project" on a consent card was dropped, so the same tool was asked about /// every time. It is remembered in the project, and a tool it was said for isn't asked again. #[test] fn always_for_this_project_on_a_consent_card_is_remembered() { use craft_anything_engine::inbox::{Answer, Inbox, InboxDir}; use craft_anything_engine::workspace::{TargetRef, Workspace}; let dir = tempfile::tempdir().unwrap(); let ws = Workspace::create(dir.path(), "t", "r", TargetRef::None).unwrap(); let engine = Arc::new(Engine::new(craft_anything_engine::testing::session())); engine.session().ext.insert(Arc::new(InboxDir(ws.inbox_dir()))); let server = Server::new(engine, ServerOptions::default(), Box::new(Buf::default())); let inbox = Inbox::new(ws.inbox_dir()); // Allowed once: this call goes through, and nothing is remembered. let root = ws.inbox_dir(); let answerer = |always: bool| { let inbox = Inbox::new(root.clone()); std::thread::spawn(move || { for _ in 0..400 { if let Some(r) = inbox.pending().first() { inbox.answer(&r.id, &Answer { allow: Some(true), always, ..Default::default() }).unwrap(); return; } std::thread::sleep(Duration::from_millis(10)); } }) }; let once = answerer(false); assert_eq!(server.ask_consent("web_session_run", "why", &CancelToken::default()), Some(true)); once.join().unwrap(); assert!(Workspace::open(&ws.root).unwrap().manifest.allowed_actions.is_empty()); // Always: remembered as `tool:`, and the next call isn't asked (the token is already // cancelled, so asking would be refused, not waited on). let always = answerer(true); assert_eq!(server.ask_consent("web_session_run", "why", &CancelToken::default()), Some(true)); always.join().unwrap(); assert_eq!(Workspace::open(&ws.root).unwrap().manifest.allowed_actions, vec!["tool:web_session_run".to_string()]); let cancelled = CancelToken::default(); cancelled.cancel(); assert_eq!(server.ask_consent("web_session_run", "why", &cancelled), Some(true), "not asked again"); assert!(inbox.pending().is_empty()); // Another tool is still asked about. assert_eq!(server.ask_consent("browser_other", "why", &cancelled), Some(false)); } /// #855, #856: In restricted mode, tools that act on the machine (build_command_run, plugins_add, /// engines_install, adb_*) and web/capture tools (web_site_open, web_site_capture, /// web_page_states_capture) are omitted from tools/list even when --all-tools is set. #[test] fn restricted_mode_omits_machine_and_web_tools() { let opts = ServerOptions { restricted: true, all_tools: true, ..Default::default() }; let out = run_with(opts, &[req(1, "tools/list", json!({}))]); let names = tool_names(&response(&out, 1)); // Machine-acting tools (#855) are absent assert!(!names.contains(&"build_command_run".to_string())); assert!(!names.contains(&"plugins_add".to_string())); assert!(!names.contains(&"engines_install".to_string())); assert!(!names.iter().any(|n| n.starts_with("adb_"))); // Web and capture tools (#856) are absent by default assert!(!names.contains(&"web_site_open".to_string())); assert!(!names.contains(&"web_site_capture".to_string())); assert!(!names.contains(&"web_page_states_capture".to_string())); // Tools no list named: what each declares keeps them off too. for id in ["project_play", "web_browser_connect", "web_page_screenshot_take", "web_standin_start", "native_cutter_command_run"] { assert!(!names.contains(&id.to_string()), "{id}"); } // Safe core tools remain available assert!(names.contains(&"core_session_show".to_string())); assert!(names.contains(&"core_investigation_show".to_string())); } /// #855, #856: Calling turned-off tools in restricted mode returns a refusal stating they are off. #[test] fn restricted_mode_refuses_calling_turned_off_tools() { let opts = ServerOptions { restricted: true, ..Default::default() }; let out = run_with( opts, &[ req(1, "tools/call", json!({"name": "web_site_open", "arguments": {"url": "https://example.com"}})), req(2, "tools/call", json!({"name": "web_site_capture", "arguments": {}})), req(3, "tools/call", json!({"name": "web_page_states_capture", "arguments": {}})), req(4, "tools/call", json!({"name": "build_command_run", "arguments": {"command": "cargo build"}})), req(5, "tools/call", json!({"name": "plugins_add", "arguments": {}})), req(6, "tools/call", json!({"name": "engines_install", "arguments": {}})), req(7, "tools/call", json!({"name": "adb_device_show", "arguments": {}})), req(8, "tools/call", json!({"name": "mcp__craft-anything__web_site_open", "arguments": {}})), req(9, "tools/call", json!({"name": "web-site-open", "arguments": {}})), ], ); for (id, tool_name) in [ (1, "web_site_open"), (2, "web_site_capture"), (3, "web_page_states_capture"), (4, "build_command_run"), (5, "plugins_add"), (6, "engines_install"), (7, "adb_device_show"), (8, "web_site_open"), (9, "web_site_open"), ] { let r = response(&out, id); assert_eq!(r["result"]["isError"], true, "id {id} ({tool_name}) should be error"); let e: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(e["error"]["code"], "feature_missing"); let msg = e["error"]["message"].as_str().unwrap(); assert!(msg.contains("turned off in restricted mode"), "{msg}"); assert_eq!(e["error"]["details"]["reason"], "restricted_mode"); assert_eq!(e["error"]["details"]["tool"], tool_name); } } /// #856: When the operator allows web or capture tools in restricted mode, they are visible and /// callable, while machine-acting tools remain off. #[test] fn restricted_mode_allows_web_and_capture_tools_when_operator_permits() { // With allow_web let opts = ServerOptions { restricted: true, all_tools: true, allow_web: true, ..Default::default() }; let out = run_with(opts, &[req(1, "tools/list", json!({}))]); let names = tool_names(&response(&out, 1)); assert!(names.contains(&"web_site_open".to_string())); assert!(!names.contains(&"web_site_capture".to_string()), "--allow-web is only for web tools"); assert!(!names.contains(&"web_page_states_capture".to_string())); assert!(!names.contains(&"build_command_run".to_string())); assert!(!names.iter().any(|n| n.starts_with("adb_"))); // Signing in opens a window on the host's desktop: never with --restricted. assert!(!names.contains(&"web_site_sign_in".to_string()) && !names.contains(&"web_site_sign_out".to_string())); // With allow_capture let opts_cap = ServerOptions { restricted: true, all_tools: true, allow_capture: true, ..Default::default() }; let out_cap = run_with(opts_cap, &[req(1, "tools/list", json!({}))]); let names_cap = tool_names(&response(&out_cap, 1)); assert!(!names_cap.contains(&"web_site_open".to_string()), "--allow-capture is only for capture tools"); assert!(names_cap.contains(&"web_site_capture".to_string())); assert!(names_cap.contains(&"web_page_states_capture".to_string())); assert!(!names_cap.contains(&"build_command_run".to_string())); assert!(!names_cap.iter().any(|n| n.starts_with("adb_"))); } /// Review of #1459: --allow-web (with --allow-run) must not let a restricted client open the /// desktop person's saved account; sign-in is hidden there, so reusing one would bypass that. #[test] fn restricted_web_opens_never_use_a_saved_sign_in() { use craft_anything_engine::tools::site_sign_in; let session = craft_anything_engine::testing::session(); // A saved sign-in for the site, as web_site_sign_in leaves it. let key = site_sign_in::site_key("https://example.com").unwrap(); let dir = site_sign_in::sign_ins_dir(&session).join(&key); std::fs::create_dir_all(dir.join("profile/Default")).unwrap(); std::fs::write(dir.join("profile/Default/Cookies"), b"fake-cookie-db").unwrap(); std::fs::write(dir.join("sign-in.json"), json!({"version": 1, "site": key, "saved_at": 1}).to_string()).unwrap(); assert!(site_sign_in::saved(&session, &key).is_some(), "the fixture must look like a saved sign-in"); let engine = Arc::new(Engine::new(session)); let opts = ServerOptions { restricted: true, allow_web: true, allow_run: true, ..Default::default() }; let input: String = [ req(1, "tools/call", json!({"name": "web_site_open", "arguments": {"url": "https://example.com", "signed_in": true}})), req(2, "tools/call", json!({"name": "mcp__craft-anything__web_site_open", "arguments": {"url": "https://example.com", "signed_in": "yes"}})), ] .iter() .map(|l| format!("{l}\n")) .collect(); let buf = Buf::default(); serve(engine.clone(), opts.clone(), std::io::Cursor::new(input.into_bytes()), Box::new(buf.clone())).unwrap(); let out: Vec = String::from_utf8(buf.0.lock().unwrap().clone()).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect(); for id in [1, 2] { let r = response(&out, id); assert_eq!(r["result"]["isError"], true, "id {id}"); let e: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); assert_eq!(e["error"]["details"]["reason"], "restricted_mode", "id {id}: {e}"); assert_eq!(e["error"]["details"]["param"], "signed_in", "id {id}: {e}"); } // Omitted (which would pick the saved sign-in) and explicit false both reach the tool as false. let server = Server::new(engine.clone(), opts, Box::new(Buf::default())); for args in [ json!({"url": "https://example.com"}), json!({"url": "https://example.com", "signed_in": false}), json!({"url": "https://example.com", "signed_in": null}), ] { assert_eq!(server.restricted_args("web_site_open", args).unwrap()["signed_in"], false); } // Other tools and unrestricted servers are left alone. assert_eq!(server.restricted_args("core_session_show", json!({})).unwrap(), json!({})); let open = Server::new(engine, ServerOptions::default(), Box::new(Buf::default())); assert_eq!(open.restricted_args("web_site_open", json!({"url": "https://example.com"})).unwrap(), json!({"url": "https://example.com"})); } #[test] fn restricted_mode_server_options_from_env() { let map = [("CRAFT_ANYTHING_MCP_RESTRICTED", "1"), ("CRAFT_ANYTHING_MCP_ALLOW_WEB", "true"), ("CRAFT_ANYTHING_MCP_ALLOW_CAPTURE", "1")] .into_iter() .collect::>(); let opts = ServerOptions::from_env_vars(|k| map.get(k).map(|s| s.to_string())); assert!(opts.restricted); assert!(opts.allow_web); assert!(opts.allow_capture); } /// A client config that adds `--allow-run` must not remove the approval boundary silently. #[test] fn allow_run_says_what_it_turns_off_on_startup() { assert_eq!(startup_notice(&ServerOptions::default()), None, "the default server keeps the approval step"); let notice = startup_notice(&ServerOptions { allow_run: true, ..Default::default() }).expect("--allow-run is worth a line"); assert!(notice.contains("--allow-run"), "{notice}"); assert!(notice.contains("without asking"), "say what it turns off: {notice}"); }