pub mod account;
pub mod lookup;
pub mod mode;
pub mod prompts;
pub mod protocol;
pub mod resources;
pub mod server;
pub mod tools;
pub use mode::DeploymentMode;
pub use server::{AccountTools, McpServer};
#[cfg(test)]
mod tests {
use super::*;
use offline_registry::Registry;
use serde_json::{json, Value};
fn server() -> McpServer {
McpServer::new(Registry::load_embedded().unwrap())
}
fn call(server: &McpServer, msg: Value) -> Value {
let raw = server
.handle_message(&msg.to_string())
.expect("expected a response");
serde_json::from_str(&raw).unwrap()
}
#[test]
fn initialize_negotiates_version() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
"params": {"protocolVersion": "2025-03-26", "capabilities": {}}}),
);
assert_eq!(resp["result"]["protocolVersion"], "2025-03-26");
assert_eq!(resp["result"]["serverInfo"]["name"], "offline-protocol");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 2, "method": "initialize",
"params": {"protocolVersion": "1999-01-01"}}),
);
assert_eq!(resp["result"]["protocolVersion"], "2025-06-18");
}
#[test]
fn notifications_get_no_response() {
let s = server();
assert!(s
.handle_message(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#)
.is_none());
}
#[test]
fn hosted_mode_omits_write_tools() {
use crate::mode::DeploymentMode;
use crate::tools::{call_tool_for, tool_definitions_for};
let registry = Registry::load_embedded().unwrap();
let tools = tool_definitions_for(DeploymentMode::Hosted);
let names: Vec<&str> = tools.iter().map(|t| t["name"].as_str().unwrap()).collect();
for blocked in ["scaffold_project", "integrate_packages", "init_project"] {
assert!(
!names.contains(&blocked),
"hosted tools/list must not include {blocked}"
);
}
assert!(names.contains(&"preview_scaffold"));
assert!(names.contains(&"generate_architecture"));
let err = call_tool_for(
®istry,
"scaffold_project",
&json!({"name": "x", "platform": "nextjs"}),
DeploymentMode::Hosted,
)
.unwrap_err();
assert!(err.contains("hosted MCP"));
}
#[test]
fn hosted_server_tools_list_via_rpc() {
let registry = Registry::load_embedded().unwrap();
let s = McpServer::with_mode(registry, DeploymentMode::Hosted);
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 1, "method": "tools/list"}),
);
let names: Vec<&str> = resp["result"]["tools"]
.as_array()
.unwrap()
.iter()
.map(|t| t["name"].as_str().unwrap())
.collect();
assert!(!names.contains(&"scaffold_project"));
}
#[test]
fn tools_list_and_call_roundtrip() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 1, "method": "tools/list"}),
);
let tools = resp["result"]["tools"].as_array().unwrap();
assert!(tools.len() >= 16);
let names: Vec<&str> = tools.iter().map(|t| t["name"].as_str().unwrap()).collect();
for required in [
"list_packages",
"get_package",
"search_packages",
"search_capabilities",
"search_workflows",
"search_skills",
"search_examples",
"resolve_packages",
"get_template",
"generate_architecture",
"get_skill",
"preview_scaffold",
"scaffold_project",
"integrate_packages",
"init_project",
] {
assert!(names.contains(&required), "missing tool {required}");
}
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 2, "method": "tools/call",
"params": {"name": "get_package",
"arguments": {"name": "@offline-protocol/mesh-sdk"}}}),
);
assert_eq!(resp["result"]["isError"], false);
let text = resp["result"]["content"][0]["text"].as_str().unwrap();
assert!(text.contains("mesh-networking"));
}
#[test]
fn generate_architecture_tool_plans_social_app() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 3, "method": "tools/call",
"params": {"name": "generate_architecture",
"arguments": {"prompt": "Build an offline social network"}}}),
);
assert_eq!(resp["result"]["isError"], false);
let text = resp["result"]["content"][0]["text"].as_str().unwrap();
let parsed: Value = serde_json::from_str(text).unwrap();
assert_eq!(parsed["plan"]["workflow"], "offline-social-network");
assert!(parsed["documents"]["architecture.md"]
.as_str()
.unwrap()
.contains("# Architecture"));
assert!(!parsed["nextActions"].as_array().unwrap().is_empty());
assert_eq!(
parsed["nextActions"][0]["tool"].as_str().unwrap(),
"scaffold_project"
);
}
#[test]
fn preview_and_scaffold_project() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("pulse-social");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 20, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {
"prompt": "Build an offline social network",
"platform": "nextjs",
"name": "pulse-social",
"dir": target.to_string_lossy()
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let preview: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(preview["dryRun"], true);
assert_eq!(preview["template"], "nextjs-social");
assert!(!target.exists() || !target.join("package.json").exists());
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 21, "method": "tools/call",
"params": {"name": "scaffold_project",
"arguments": {
"prompt": "Build an offline social network",
"platform": "nextjs",
"name": "pulse-social",
"dir": target.to_string_lossy(),
"projectId": "proj_test"
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let created: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(created["dryRun"], false);
assert!(target.join("package.json").exists());
assert!(target.join("architecture.md").exists());
let mcp: Value =
serde_json::from_str(&std::fs::read_to_string(target.join(".mcp.json")).unwrap())
.unwrap();
assert_eq!(mcp["mcpServers"]["offline-protocol"]["command"], "npx");
assert_eq!(
mcp["mcpServers"]["offline-protocol"]["args"][1],
format!("@offline-protocol/cli@{}", offline_registry::CLI_VERSION)
);
let providers = std::fs::read_to_string(target.join("src/app/providers.tsx")).unwrap();
assert!(providers.contains("<OfflineAppProvider appId={APP_ID}>"));
}
#[test]
fn scaffold_react_native_mesh_app() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("mesh-test-app");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 30, "method": "tools/call",
"params": {"name": "scaffold_project",
"arguments": {
"template": "react-native-mesh-app",
"platform": "react-native",
"name": "mesh-test-app",
"dir": target.to_string_lossy(),
"appId": "mesh-test-app",
"enableMesh": true
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let created: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(created["dryRun"], false);
assert_eq!(created["template"], "react-native-mesh-app");
assert_eq!(created["meshEnabled"], true);
assert!(target.join("package.json").exists());
assert!(target.join("src/context/ProtocolContext.tsx").exists());
assert!(target.join("src/constants.ts").exists());
assert!(target.join("android").is_dir());
assert!(target.join("ios").is_dir());
let protocol_ctx =
std::fs::read_to_string(target.join("src/context/ProtocolContext.tsx")).unwrap();
assert!(
protocol_ctx.contains("mlsGetOrCreateKeyPackage"),
"scaffolded mesh app must attach MLS key packages on connection requests"
);
assert!(
protocol_ctx.contains("connection_request_undeliverable"),
"scaffolded mesh app must handle connection_request_undeliverable"
);
assert!(
protocol_ctx.contains("localAddressRef"),
"scaffolded mesh app must wait for local off1 address before sending connection requests"
);
assert!(
protocol_ctx.contains("BLE_DESTROY_SETTLE_MS"),
"scaffolded mesh app must pause after native destroy before recreate (iOS BLE settle)"
);
let people = std::fs::read_to_string(target.join("src/screens/PeopleScreen.tsx")).unwrap();
assert!(
people.contains("PROTOCOL_CONFIG.appId"),
"People screen must remind users both devices need the same appId"
);
let manifest =
std::fs::read_to_string(target.join("android/app/src/main/AndroidManifest.xml"))
.unwrap();
assert!(manifest.contains("BLUETOOTH_SCAN"));
let podfile = std::fs::read_to_string(target.join("ios/Podfile")).unwrap();
assert!(
!podfile.contains("pod 'MeshSdk'"),
"scaffolded Podfile must not add a manual MeshSdk pod (autolinking uses package-root podspec)"
);
assert!(
podfile.contains("FMT_USE_CONSTEVAL"),
"scaffolded iOS Podfile must include Xcode 26 fmt build patch"
);
}
#[test]
fn scaffold_offline_id_mesh_chat_routes_to_social_with_mesh() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("id-mesh-chat-app");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 31, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {
"prompt": "Create a React Native mesh chat app using Offline ID",
"platform": "react-native",
"name": "id-mesh-chat-app",
"dir": target.to_string_lossy(),
"projectId": "proj_test"
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let preview: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(preview["template"], "react-native-social");
assert_eq!(preview["meshEnabled"], true);
assert_eq!(preview["offlineIdEnabled"], true);
let skills = preview["skills"].as_array().unwrap();
assert!(
skills
.iter()
.any(|s| s.as_str() == Some("offline-id-mesh-integration")),
"offline-id mesh scaffolds must recommend offline-id-mesh-integration skill first"
);
}
#[test]
fn entrance_prompts_plan_and_scaffold_their_workflows() {
let s = server();
let cases = [
("Durable equipment handoff between field engineers, with persistence and backend reconciliation", "local-handoff", "react-native-mesh-handoff"),
("Retain sensor telemetry during outages and deliver it to a backend with explicit acceptance", "backend-delivery", "react-native-mesh-event-delivery"),
("Discover and invoke an authorised nearby service from an existing application", "nearby-service", "react-native-mesh-service"),
];
for (i, (prompt, workflow, template)) in cases.into_iter().enumerate() {
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 80 + i, "method": "tools/call",
"params": {"name": "generate_architecture", "arguments": {"prompt": prompt}}}),
);
assert_eq!(resp["result"]["isError"], false, "{prompt}");
let parsed: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap())
.unwrap();
assert_eq!(parsed["plan"]["workflow"], workflow);
assert_eq!(parsed["plan"]["template"], template);
let actions = parsed["nextActions"].as_array().unwrap();
let first = actions[0]["tool"].as_str().unwrap();
if workflow == "nearby-service" {
assert_eq!(first, "integrate_packages");
assert_eq!(actions[1]["tool"], "init_project");
} else {
assert_eq!(first, "scaffold_project");
}
let preview = call(
&s,
json!({"jsonrpc": "2.0", "id": 90 + i, "method": "tools/call",
"params": {"name": "preview_scaffold", "arguments": {"prompt": prompt, "name": "field-app"}}}),
);
assert_eq!(preview["result"]["isError"], false, "{prompt}");
let preview: Value =
serde_json::from_str(preview["result"]["content"][0]["text"].as_str().unwrap())
.unwrap();
assert_eq!(preview["template"], template);
assert_eq!(preview["meshEnabled"], true);
let skills: Vec<&str> = preview["skills"]
.as_array()
.unwrap()
.iter()
.filter_map(Value::as_str)
.collect();
assert_eq!(skills[0], workflow, "{skills:?}");
assert!(!skills.contains(&"groups"), "{skills:?}");
}
}
#[test]
fn workflow_templates_always_enable_mesh() {
let s = server();
for (id, template) in [
(60, "react-native-mesh-handoff"),
(61, "react-native-mesh-event-delivery"),
(62, "react-native-mesh-service"),
] {
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": id, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {"template": template, "name": "field-app"}}}),
);
assert_eq!(resp["result"]["isError"], false, "{template}");
let preview: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap())
.unwrap();
assert_eq!(preview["template"], template);
assert_eq!(preview["meshEnabled"], true, "{template}");
assert_eq!(preview["offlineIdEnabled"], false, "{template}");
let refused = call(
&s,
json!({"jsonrpc": "2.0", "id": id + 10, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {"template": template, "name": "field-app", "enableMesh": false}}}),
);
assert_eq!(refused["result"]["isError"], true, "{template}");
}
}
#[test]
fn scaffold_mesh_with_offline_id_switches_template() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("mesh-id-switch");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 32, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {
"template": "react-native-mesh-app",
"platform": "react-native",
"name": "mesh-id-switch",
"dir": target.to_string_lossy(),
"enableOfflineId": true,
"projectId": "proj_test"
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let preview: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(preview["template"], "react-native-social");
assert_eq!(preview["offlineIdEnabled"], true);
}
#[test]
fn scaffold_mesh_without_offline_id_routes_to_mesh_app() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("mesh-no-id");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 33, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {
"workflow": "offline-id-mesh-chat",
"platform": "react-native",
"name": "mesh-no-id",
"dir": target.to_string_lossy(),
"enableOfflineId": false,
"enableMesh": true
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let preview: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(preview["template"], "react-native-mesh-app");
assert_eq!(preview["offlineIdEnabled"], false);
}
#[test]
fn integrate_and_init_existing_project() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let pkg = json!({
"name": "existing-app",
"dependencies": {"next": "14.0.0", "react": "18.0.0"}
});
std::fs::write(
dir.path().join("package.json"),
serde_json::to_string_pretty(&pkg).unwrap(),
)
.unwrap();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 22, "method": "tools/call",
"params": {"name": "integrate_packages",
"arguments": {
"packages": ["id-react"],
"dir": dir.path().to_string_lossy()
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let integrated: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert!(!integrated["added"].as_array().unwrap().is_empty());
let pkg_after: Value = serde_json::from_str(
&std::fs::read_to_string(dir.path().join("package.json")).unwrap(),
)
.unwrap();
assert!(pkg_after["dependencies"]["@offline-protocol/id-react"].is_string());
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 23, "method": "tools/call",
"params": {"name": "init_project",
"arguments": {
"dir": dir.path().to_string_lossy(),
"projectId": "proj_abc"
}}}),
);
assert_eq!(resp["result"]["isError"], false);
assert!(dir.path().join(".mcp.json").exists());
assert!(dir.path().join("offline.config.json").exists());
assert!(dir.path().join("AGENTS.md").exists());
}
fn tool_text(resp: &Value) -> String {
resp["result"]["content"][0]["text"]
.as_str()
.unwrap()
.to_string()
}
#[test]
fn every_tool_declares_annotations_matching_side_effects() {
use crate::tools::tool_definitions_for;
let local = tool_definitions_for(DeploymentMode::Local);
assert_eq!(local.len(), 18);
for tool in &local {
let name = tool["name"].as_str().unwrap();
let a = &tool["annotations"];
for hint in [
"readOnlyHint",
"destructiveHint",
"idempotentHint",
"openWorldHint",
] {
assert!(a[hint].is_boolean(), "{name} lacks {hint}");
}
assert!(
!a["title"].as_str().unwrap().is_empty(),
"{name} lacks title"
);
let writes = ["scaffold_project", "integrate_packages", "init_project"].contains(&name);
assert_eq!(a["readOnlyHint"], !writes, "{name} readOnlyHint");
assert_eq!(a["destructiveHint"], false, "{name} destructiveHint");
}
let scaffold = local
.iter()
.find(|t| t["name"] == "scaffold_project")
.unwrap();
assert_eq!(scaffold["annotations"]["openWorldHint"], true);
assert_eq!(scaffold["annotations"]["idempotentHint"], false);
let hosted = tool_definitions_for(DeploymentMode::Hosted);
assert_eq!(hosted.len(), 15);
assert!(hosted
.iter()
.all(|t| t["annotations"]["readOnlyHint"] == true));
}
#[test]
fn unsupported_framework_prompt_returns_limitation_not_react_native_plan() {
let s = server();
for (id, prompt, framework) in [
(60, "Build a Flutter app that hands off kitchen orders between two Android tablets over Bluetooth", "Flutter"),
(61, "Native Android Kotlin app that sends files between phones over Wi-Fi Direct", "Kotlin"),
(62, "A SwiftUI iPhone app for nearby chat", "SwiftUI"),
] {
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": id, "method": "tools/call",
"params": {"name": "generate_architecture", "arguments": {"prompt": prompt}}}),
);
assert_eq!(resp["result"]["isError"], false, "{prompt}");
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["supported"], false, "{out}");
assert_eq!(out["planGenerated"], false, "{out}");
assert!(out.get("plan").is_none(), "{out}");
assert_eq!(out["framework"], framework);
let reason = out["reason"].as_str().unwrap();
assert!(reason.starts_with("no plan generated"), "{reason}");
assert!(reason.contains("platform \"react-native\""), "{reason}");
assert_eq!(out["alternatives"][0]["arguments"]["platform"], "react-native");
assert!(out["supportedPlatforms"]
.as_array()
.unwrap()
.contains(&json!("react-native")));
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": id + 10, "method": "tools/call",
"params": {"name": "preview_scaffold",
"arguments": {"prompt": prompt, "name": "orders"}}}),
);
assert_eq!(resp["result"]["isError"], false, "preview: {prompt}");
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["supported"], false, "{out}");
assert_eq!(out["planGenerated"], false, "{out}");
assert!(out.get("template").is_none(), "{out}");
}
for tool in [
"generate_architecture",
"resolve_packages",
"preview_scaffold",
] {
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 65, "method": "tools/call",
"params": {"name": tool,
"arguments": {"prompt": "nearby chat", "name": "x",
"platform": "flutter", "workflow": "nearby-chat"}}}),
);
assert_eq!(resp["result"]["isError"], false, "{tool}");
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["supported"], false, "{tool}: {out}");
assert_eq!(out["requestedPlatform"], "flutter");
assert!(
out["reason"]
.as_str()
.unwrap()
.to_lowercase()
.contains("flutter"),
"{tool}: {out}"
);
}
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 70, "method": "tools/call",
"params": {"name": "generate_architecture",
"arguments": {"prompt": "Port our Flutter kitchen app: hand off orders over Bluetooth",
"platform": "react-native"}}}),
);
assert_eq!(resp["result"]["isError"], false);
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["plan"]["platform"], "react-native");
assert!(out["plan"]["resolution"]["warnings"][0]
.as_str()
.unwrap()
.contains("Flutter"));
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 71, "method": "tools/call",
"params": {"name": "generate_architecture",
"arguments": {"prompt": "React Native nearby chat app with a Kotlin native module"}}}),
);
assert_eq!(resp["result"]["isError"], false);
}
#[test]
fn platform_errors_use_the_callers_platform_name() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 80, "method": "tools/call",
"params": {"name": "resolve_packages",
"arguments": {"platform": "web", "packages": ["@offline-protocol/mesh-sdk"]}}}),
);
assert_eq!(resp["result"]["isError"], false);
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["supported"], false);
let reason = out["reason"].as_str().unwrap();
assert!(reason.contains("not `web`"), "{reason}");
assert!(
reason.contains("supports platforms [react-native]"),
"{reason}"
);
assert!(out["alternatives"]
.as_array()
.unwrap()
.iter()
.any(|a| a["arguments"]["platform"] == "react-native"));
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 81, "method": "tools/call",
"params": {"name": "generate_architecture",
"arguments": {"prompt": "Browser web app that discovers nearby phones over Bluetooth and chats offline",
"platform": "web"}}}),
);
assert_eq!(resp["result"]["isError"], false);
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["supported"], false);
assert_eq!(out["planGenerated"], false);
assert!(out.get("plan").is_none());
let reason = out["reason"].as_str().unwrap();
assert!(reason.starts_with("no plan generated: "), "{reason}");
assert!(reason.contains("not `web`"), "{reason}");
assert_eq!(
out["alternatives"][0]["arguments"]["platform"],
"react-native"
);
}
#[test]
fn integrate_packages_preserves_package_json_layout() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let original = "{\n \"name\": \"kitchen\",\n \"private\": true,\n \"scripts\": {\n \"dev\": \"vite\"\n },\n \"dependencies\": {\n \"react\": \"^19.0.0\",\n \"react-dom\": \"^19.0.0\"\n },\n \"devDependencies\": {\n \"vite\": \"^7.0.0\"\n }\n}\n";
std::fs::write(dir.path().join("package.json"), original).unwrap();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 90, "method": "tools/call",
"params": {"name": "integrate_packages",
"arguments": {"packages": ["id-react"], "dir": dir.path().to_string_lossy()}}}),
);
assert_eq!(resp["result"]["isError"], false);
let after = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
let core = offline_registry::Registry::load_embedded()
.unwrap()
.package("@offline-protocol/core")
.unwrap()
.version
.clone();
let id_react = offline_registry::Registry::load_embedded()
.unwrap()
.package("@offline-protocol/id-react")
.unwrap()
.version
.clone();
let expected = original.replace(
" \"dependencies\": {\n",
&format!(
" \"dependencies\": {{\n \"@offline-protocol/core\": \"^{core}\",\n \"@offline-protocol/id-react\": \"^{id_react}\",\n"
),
);
assert_eq!(after, expected);
}
#[test]
fn init_project_respects_existing_mcp_json() {
let s = server();
let dir = tempfile::tempdir().unwrap();
std::fs::write(
dir.path().join("package.json"),
r#"{"name":"x","dependencies":{"react":"^19.0.0"}}"#,
)
.unwrap();
let existing_mcp = r#"{"mcpServers":{"github":{"command":"npx","args":["-y","@modelcontextprotocol/server-github"]}}}"#;
std::fs::write(dir.path().join(".mcp.json"), existing_mcp).unwrap();
std::fs::write(dir.path().join("AGENTS.md"), "# Team rules\n").unwrap();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 100, "method": "tools/call",
"params": {"name": "init_project", "arguments": {"dir": dir.path().to_string_lossy()}}}),
);
assert_eq!(resp["result"]["isError"], false);
let out: Value = serde_json::from_str(&tool_text(&resp)).unwrap();
assert_eq!(out["mcpServer"]["registered"], false);
assert_eq!(
std::fs::read_to_string(dir.path().join(".mcp.json")).unwrap(),
existing_mcp
);
let agents = std::fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
assert!(agents.starts_with("# Team rules\n"));
assert!(agents.contains("does not register the Offline Protocol MCP"));
assert!(!agents.contains("is registered in `.mcp.json`"));
call(
&s,
json!({"jsonrpc": "2.0", "id": 101, "method": "tools/call",
"params": {"name": "init_project", "arguments": {"dir": dir.path().to_string_lossy()}}}),
);
assert_eq!(
std::fs::read_to_string(dir.path().join("AGENTS.md")).unwrap(),
agents
);
}
#[test]
fn init_project_writes_npx_mcp_json() {
let s = server();
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("package.json"), r#"{"name":"x"}"#).unwrap();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 110, "method": "tools/call",
"params": {"name": "init_project", "arguments": {"dir": dir.path().to_string_lossy()}}}),
);
assert_eq!(resp["result"]["isError"], false);
let mcp: Value =
serde_json::from_str(&std::fs::read_to_string(dir.path().join(".mcp.json")).unwrap())
.unwrap();
let server = &mcp["mcpServers"]["offline-protocol"];
assert_eq!(server["command"], "npx");
assert_eq!(
server["args"][1],
format!("@offline-protocol/cli@{}", offline_registry::CLI_VERSION)
);
let agents = std::fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
assert!(agents.contains("is registered in `.mcp.json`"));
}
#[test]
fn init_project_wires_a_python_project() {
let s = server();
let dir = tempfile::tempdir().unwrap();
std::fs::write(
dir.path().join("pyproject.toml"),
"[project]\nname = \"gateway\"\n",
)
.unwrap();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 111, "method": "tools/call",
"params": {"name": "init_project", "arguments": {"dir": dir.path().to_string_lossy()}}}),
);
assert_eq!(resp["result"]["isError"], false);
let config: Value = serde_json::from_str(
&std::fs::read_to_string(dir.path().join("offline.config.json")).unwrap(),
)
.unwrap();
assert_eq!(config["platform"], "python");
assert_eq!(config["projectName"], "gateway");
let text = resp["result"]["content"][0]["text"].as_str().unwrap();
assert!(text.contains("pip install offline-protocol-sdk=="));
assert!(text.contains("mesh-sdk/python"));
}
#[test]
fn init_project_names_supported_manifests_in_an_empty_dir() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 112, "method": "tools/call",
"params": {"name": "init_project", "arguments": {"dir": dir.path().to_string_lossy()}}}),
);
assert_eq!(resp["result"]["isError"], true);
let text = resp["result"]["content"][0]["text"].as_str().unwrap();
assert!(text.contains("Package.swift"));
assert!(text.contains("scaffold_project"));
}
#[test]
fn unknown_tool_reports_is_error_not_rpc_error() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 4, "method": "tools/call",
"params": {"name": "nope", "arguments": {}}}),
);
assert!(resp["error"].is_null());
assert_eq!(resp["result"]["isError"], true);
}
#[test]
fn resources_list_and_read() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 5, "method": "resources/list"}),
);
let resources = resp["result"]["resources"].as_array().unwrap();
assert!(resources.len() > 15);
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 6, "method": "resources/read",
"params": {"uri": "offline://skills/mesh-networking"}}),
);
let text = resp["result"]["contents"][0]["text"].as_str().unwrap();
assert!(text.contains("OfflineProtocol"));
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 7, "method": "resources/read",
"params": {"uri": "offline://llms.txt"}}),
);
let text = resp["result"]["contents"][0]["text"].as_str().unwrap();
assert!(text.contains("# Offline Protocol"));
}
#[test]
fn prompts_list_and_get() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 8, "method": "prompts/list"}),
);
assert_eq!(resp["result"]["prompts"].as_array().unwrap().len(), 3);
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 9, "method": "prompts/get",
"params": {"name": "plan-app",
"arguments": {"description": "nearby chat for festivals"}}}),
);
let text = resp["result"]["messages"][0]["content"]["text"]
.as_str()
.unwrap();
assert!(text.contains("generate_architecture"));
}
#[test]
fn generate_architecture_custom_p2p_game() {
let s = server();
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 40, "method": "tools/call",
"params": {"name": "generate_architecture",
"arguments": {"prompt": "tic tac toe game over BLE for two phones"}}}),
);
assert_eq!(resp["result"]["isError"], false);
let parsed: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(parsed["plan"]["workflow"], "custom-p2p-app");
assert!(parsed["plan"]["p2pProfile"]["syncModel"]
.as_str()
.unwrap()
.contains("host-authority"));
assert!(parsed["documents"]["architecture.md"]
.as_str()
.unwrap()
.contains("## P2P profile"));
}
#[test]
fn scaffold_custom_p2p_app() {
let s = server();
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("p2p-game");
let resp = call(
&s,
json!({"jsonrpc": "2.0", "id": 41, "method": "tools/call",
"params": {"name": "scaffold_project",
"arguments": {
"prompt": "offline Ludo game for two phones over BLE",
"workflow": "custom-p2p-app",
"platform": "react-native",
"name": "p2p-game",
"dir": target.to_string_lossy()
}}}),
);
assert_eq!(resp["result"]["isError"], false);
let created: Value =
serde_json::from_str(resp["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
assert_eq!(created["template"], "react-native-mesh-custom-app");
assert!(target.join("src/domain/index.ts").exists());
assert!(target.join("src/wire.ts").exists());
assert!(target.join("src/session.ts").exists());
assert!(target.join("src/mesh.ts").exists());
assert!(target.join("src/meshEstablishment.ts").exists());
assert!(target.join("__tests__/mesh.test.ts").exists());
assert!(target.join("src/debug.ts").exists());
assert!(target.join("src/ui/PeerDiscovery.tsx").exists());
assert!(target.join("AGENTS.md").exists());
let arch = std::fs::read_to_string(target.join("architecture.md")).unwrap();
assert!(arch.contains("P2P profile"));
let mesh = std::fs::read_to_string(target.join("src/mesh.ts")).unwrap();
assert!(
mesh.contains("waitForLocalAddress"),
"custom P2P scaffold must wait for off1 identity before joining"
);
assert!(
mesh.contains("keyPackage"),
"custom P2P scaffold must attach MLS key packages on connection requests"
);
assert!(
mesh.contains("beginJoin"),
"custom P2P scaffold must use beginJoin before connection requests"
);
assert!(
mesh.contains("maybeInferHostFromNeighbors"),
"custom P2P scaffold must infer host when service discovery is slow"
);
assert!(
mesh.contains("TRANSPORT_IDENTITY_MISMATCH"),
"custom P2P scaffold must handle BLE identity mismatch"
);
assert!(
mesh.contains("connection_request_undeliverable"),
"custom P2P scaffold must handle connection_request_undeliverable"
);
assert!(
mesh.contains("requireEncryption: false"),
"custom P2P scaffold must not require MLS for app-level traffic"
);
}
fn tool_call(s: &McpServer, tool: &str, args: Value) -> (bool, Value) {
let resp = call(
s,
json!({"jsonrpc": "2.0", "id": 500, "method": "tools/call",
"params": {"name": tool, "arguments": args}}),
);
assert!(resp["error"].is_null(), "{resp}");
let is_error = resp["result"]["isError"].as_bool().unwrap();
let text = tool_text(&resp);
let value = serde_json::from_str(&text).unwrap_or(Value::String(text));
(is_error, value)
}
#[test]
fn exact_names_answer_exactly_as_before() {
let s = server();
let r = Registry::load_embedded().unwrap();
for skill in r.skills() {
let (err, v) = tool_call(&s, "get_skill", json!({"name": skill.name}));
assert!(!err);
assert_eq!(v, json!(skill), "{}", skill.name);
}
for p in r.packages() {
let (err, v) = tool_call(&s, "get_package", json!({"name": p.name}));
assert!(!err);
assert_eq!(v, json!(p), "{}", p.name);
}
for w in r.workflows() {
let (err, v) = tool_call(&s, "get_workflow", json!({"name": w.name}));
assert!(!err);
assert_eq!(v, json!(w), "{}", w.name);
for platform in w.packages.keys() {
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"workflow": w.name, "platform": platform}),
);
assert!(!err);
assert_eq!(v, json!(r.resolve_workflow(&w.name, platform).unwrap()));
}
}
for t in r.templates() {
let (err, v) = tool_call(&s, "get_template", json!({"name": t.name}));
assert!(!err);
assert_eq!(v["meta"], json!(t));
assert!(v.get("note").is_none());
}
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "web", "packages": ["@offline-protocol/id-react"]}),
);
assert!(!err);
assert_eq!(
v,
json!(r
.resolve_packages(&["@offline-protocol/id-react".to_string()], "nextjs")
.unwrap())
);
let (err, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "Plan a nearby chat app", "platform": "react-native"}),
);
assert!(!err);
assert!(v.get("note").is_none());
let (err, v) = tool_call(
&s,
"preview_scaffold",
json!({"prompt": "Plan a nearby chat app", "name": "fieldchat"}),
);
assert!(!err);
assert_eq!(v["project"], "fieldchat");
assert_eq!(v["notes"].as_array().unwrap().len(), 2, "{v}");
}
#[test]
fn near_miss_names_resolve_with_a_note() {
let s = server();
for (tool, input, expected) in [
("get_skill", "offline-messaging", "messaging"),
("get_skill", "Mesh Networking", "mesh-networking"),
("get_package", "mesh-sdk", "@offline-protocol/mesh-sdk"),
("get_package", "id-react", "@offline-protocol/id-react"),
("get_workflow", "nearby chat", "nearby-chat"),
("get_workflow", "NEARBY_CHAT", "nearby-chat"),
("get_template", "nextjs", "nextjs-social"),
] {
let (err, v) = tool_call(&s, tool, json!({"name": input}));
assert!(!err, "{tool} {input}: {v}");
let name = if tool == "get_template" {
&v["meta"]["name"]
} else {
&v["name"]
};
assert_eq!(name, expected, "{tool} {input}");
let note = v["note"].as_str().unwrap();
assert!(
note.starts_with(&format!("resolved `{input}` to `{expected}`")),
"{note}"
);
}
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "react-native", "packages": ["mesh-sdk"]}),
);
assert!(!err);
assert_eq!(v["packages"][0]["name"], "@offline-protocol/mesh-sdk");
assert!(v["note"].as_str().unwrap().contains("mesh-sdk"));
let (err, v) = tool_call(
&s,
"preview_scaffold",
json!({"template": "mesh handoff", "name": "x"}),
);
assert!(!err, "{v}");
assert_eq!(v["template"], "react-native-mesh-handoff");
assert!(v["notes"]
.as_array()
.unwrap()
.iter()
.any(|n| n.as_str().unwrap().starts_with("resolved `mesh handoff`")));
}
#[test]
fn ambiguous_and_unknown_names_are_answers_not_errors() {
let s = server();
let (err, v) = tool_call(&s, "get_template", json!({"name": "react-native"}));
assert!(!err);
assert_eq!(v["found"], false);
assert!(v["message"]
.as_str()
.unwrap()
.starts_with("Several matches:"));
let names: Vec<&str> = v["matches"]
.as_array()
.unwrap()
.iter()
.map(|m| m["name"].as_str().unwrap())
.collect();
assert!(names.contains(&"react-native-mesh-app"));
assert!(names.contains(&"react-native-mesh-handoff"));
assert!(!names.contains(&"nextjs-social"));
for (tool, input, noun) in [
("get_skill", "quantum-teleport", "skill"),
("get_package", "@offline-protocol/flutter-sdk", "package"),
("get_workflow", "space-elevator", "workflow"),
("get_template", "flutter-starter", "template"),
] {
let (err, v) = tool_call(&s, tool, json!({"name": input}));
assert!(!err, "{tool} {input}");
assert_eq!(v["found"], false);
let message = v["message"].as_str().unwrap();
assert!(
message.starts_with(&format!(
"There is no Offline Protocol {noun} named `{input}`."
)),
"{message}"
);
assert!(!v["validNames"].as_array().unwrap().is_empty());
assert!(v["closestMatches"].is_array());
}
let (err, v) = tool_call(&s, "get_skill", json!({"name": "mesh-netwrking"}));
assert!(!err);
assert_eq!(v["closestMatches"][0]["name"], "mesh-networking", "{v}");
let (err, v) = tool_call(&s, "get_package", json!({"name": "@offline-protocol/cli"}));
assert!(!err);
assert_eq!(v["supported"], false);
assert_eq!(v["cli"]["package"], "@offline-protocol/cli");
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "react-native", "packages": ["nope-sdk"]}),
);
assert!(!err);
assert_eq!(v["found"], false);
}
#[test]
fn sdk_0_29_http_front_questions_get_correct_answers() {
let s = server();
for query in ["http", "curl", "http front", "docker"] {
let (err, v) = tool_call(&s, "search_capabilities", json!({"query": query}));
assert!(!err);
assert_eq!(v[0]["name"], "http-front", "{query}: {v}");
}
let (err, v) = tool_call(&s, "get_skill", json!({"name": "http-front"}));
assert!(!err, "{v}");
let body = v.to_string();
assert!(body.contains("X-Offline-Protocol-Sender"), "{body}");
assert!(body.contains("does not authorize"), "{body}");
}
#[test]
fn sdk_0_30_bindings_get_correct_answers() {
let s = server();
for (query, first) in [
("flutter", "native-mobile"),
("java", "server-runtime"),
("cgo", "server-runtime"),
] {
let (err, v) = tool_call(&s, "search_capabilities", json!({"query": query}));
assert!(!err);
assert_eq!(v[0]["name"], first, "{query}: {v}");
}
for (platform, package, expected) in [
(
"java",
"java",
"implementation(\"com.offlineprotocol:offline-protocol-java:0.34.0\")",
),
(
"jvm",
"offline-protocol-java",
"offline-protocol-java:0.34.0",
),
("c", "offline-protocol-c", "releases/tag/v0.34.0"),
("flutter", "flutter", "bindings/flutter/offline_protocol"),
("dart", "offline-protocol-flutter", "v0.34.0"),
] {
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": platform, "packages": [package]}),
);
assert!(!err, "{platform}: {v}");
let commands = v["installCommands"]
.as_array()
.unwrap_or_else(|| panic!("{platform}: {v}"))
.iter()
.map(|c| c.as_str().unwrap())
.collect::<Vec<_>>()
.join("\n");
assert!(commands.contains(expected), "{platform}: {commands}");
assert!(!commands.contains("npm install"), "{platform}: {commands}");
}
let (_, v) = tool_call(&s, "get_package", json!({"name": "flutter"}));
assert_eq!(v["name"], "offline-protocol-flutter", "{v}");
assert_eq!(v["registry"], "source", "{v}");
assert_eq!(v["status"], "preview", "{v}");
let (_, v) = tool_call(&s, "get_package", json!({"name": "offline_protocol.h"}));
assert_eq!(v["name"], "offline-protocol-c", "{v}");
for (prompt, needle) in [
(
"Build a Flutter app for nearby chat",
"offline-protocol-flutter 0.34.0",
),
(
"A Java service that relays messages between laptops",
"com.offlineprotocol:offline-protocol-java",
),
] {
let (err, v) = tool_call(&s, "generate_architecture", json!({"prompt": prompt}));
assert!(!err);
assert_eq!(v["planGenerated"], false, "{v}");
let reason = v["reason"].as_str().unwrap();
assert!(reason.contains(needle), "{reason}");
}
}
#[test]
fn sdk_0_31_bindings_get_correct_answers() {
let s = server();
for (query, first) in [("ruby", "server-runtime"), ("webrtc", "browser-node")] {
let (err, v) = tool_call(&s, "search_capabilities", json!({"query": query}));
assert!(!err);
assert_eq!(v[0]["name"], first, "{query}: {v}");
}
for (platform, package, expected) in [
("ruby", "ruby", "gem \"offline_protocol\", \"~> 0.34.0\""),
("rb", "offline-protocol-ruby", "releases/tag/v0.34.0"),
(
"web",
"offline-protocol-web",
"cargo add offline-protocol-web@0.34.0",
),
] {
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": platform, "packages": [package]}),
);
assert!(!err, "{platform}: {v}");
let commands = v["installCommands"]
.as_array()
.unwrap_or_else(|| panic!("{platform}: {v}"))
.iter()
.map(|c| c.as_str().unwrap())
.collect::<Vec<_>>()
.join("\n");
assert!(commands.contains(expected), "{platform}: {commands}");
assert!(!commands.contains("npm install"), "{platform}: {commands}");
}
let (_, v) = tool_call(&s, "get_package", json!({"name": "ruby"}));
assert_eq!(v["name"], "offline-protocol-ruby", "{v}");
assert_eq!(v["registry"], "rubygems", "{v}");
let (_, v) = tool_call(&s, "get_package", json!({"name": "offline-protocol-web"}));
assert_eq!(v["status"], "experimental", "{v}");
let (err, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "A Ruby service that relays messages between laptops"}),
);
assert!(!err);
assert_eq!(v["planGenerated"], false, "{v}");
assert!(
v["reason"]
.as_str()
.unwrap()
.contains("offline_protocol gem"),
"{v}"
);
let (err, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "Browser web app that discovers nearby phones over Bluetooth and chats offline",
"platform": "web"}),
);
assert!(!err);
assert_eq!(v["planGenerated"], false, "{v}");
assert!(
v["alternatives"]
.as_array()
.unwrap()
.iter()
.any(|a| a["arguments"]["packages"][0] == "offline-protocol-web"),
"{v}"
);
}
#[test]
fn sdk_0_32_answers() {
let s = server();
for (query, first) in [
("subscribe to a service topic", "service-subscriptions"),
("csharp", "server-runtime"),
] {
let (err, v) = tool_call(&s, "search_capabilities", json!({"query": query}));
assert!(!err);
assert_eq!(v[0]["name"], first, "{query}: {v}");
}
for platform in ["csharp", "C#", "dotnet"] {
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": platform, "packages": ["offline-protocol-csharp"]}),
);
assert!(!err, "{platform}: {v}");
let commands = v["installCommands"]
.as_array()
.unwrap_or_else(|| panic!("{platform}: {v}"))
.iter()
.map(|c| c.as_str().unwrap())
.collect::<Vec<_>>()
.join("\n");
assert!(commands.contains("v0.34.0"), "{platform}: {commands}");
assert!(
commands.contains("OfflineProtocol.Sdk.csproj"),
"{platform}: {commands}"
);
assert!(!commands.contains("npm install"), "{platform}: {commands}");
}
let (_, v) = tool_call(&s, "get_package", json!({"name": "csharp"}));
assert_eq!(v["name"], "offline-protocol-csharp", "{v}");
assert_eq!(v["status"], "preview", "{v}");
let (err, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "A C# desktop app that syncs state between laptops offline"}),
);
assert!(!err);
assert_eq!(v["planGenerated"], false, "{v}");
assert!(
v["reason"]
.as_str()
.unwrap()
.contains("offline-protocol-csharp"),
"{v}"
);
let (_, v) = tool_call(&s, "get_skill", json!({"name": "nearby-service"}));
let body = v["body"].as_str().unwrap_or_default();
assert!(body.contains("subscribeService"), "{v}");
assert!(body.contains("service_subscribe_received"), "{v}");
}
#[test]
fn sdk_0_28_questions_get_correct_answers() {
let s = server();
for (query, first) in [
("python", "server-runtime"),
("swift", "native-mobile"),
("kotlin", "native-mobile"),
("android native", "native-mobile"),
("esp32", "embedded-leaf"),
("local api", "local-api"),
("custody", "custody"),
] {
let (err, v) = tool_call(&s, "search_capabilities", json!({"query": query}));
assert!(!err);
assert_eq!(v[0]["name"], first, "{query}: {v}");
}
for (platform, package, expected, absent) in [
(
"python",
"python",
"pip install offline-protocol-sdk==0.34.0",
"npm install",
),
(
"swift",
"swift",
"offline-protocol-swift.git\", from: \"0.33.0\")",
"npm install",
),
(
"kotlin",
"kotlin",
"implementation(\"com.offlineprotocol:offline-protocol-sdk:0.34.0\")",
"npm install",
),
(
"esp32",
"esp32",
"cargo add offline-protocol-leaf@0.34.0 --no-default-features",
"npm install",
),
(
"rust",
"offline-protocol",
"cargo add offline-protocol@0.34.0",
"npm install",
),
(
"react-native",
"mesh-sdk",
"npm install @offline-protocol/mesh-sdk@0.34.0",
"pip",
),
] {
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": platform, "packages": [package]}),
);
assert!(!err, "{platform}: {v}");
let commands = v["installCommands"]
.as_array()
.unwrap()
.iter()
.map(|c| c.as_str().unwrap())
.collect::<Vec<_>>()
.join("\n");
assert!(commands.contains(expected), "{platform}: {commands}");
assert!(!commands.contains(absent), "{platform}: {commands}");
}
let (_, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "swift", "packages": ["swift"]}),
);
assert!(
v["warnings"][0].as_str().unwrap().contains("preview"),
"{v}"
);
for (prompt, package) in [
(
"A SwiftUI iPhone app for nearby chat",
"offline-protocol-swift",
),
(
"Native Android Kotlin app for nearby chat",
"offline-protocol-android",
),
] {
let (err, v) = tool_call(&s, "generate_architecture", json!({"prompt": prompt}));
assert!(!err);
assert_eq!(v["planGenerated"], false, "{v}");
let reason = v["reason"].as_str().unwrap();
assert!(reason.contains(package), "{reason}");
assert!(reason.contains("early preview"), "{reason}");
}
let (_, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "Native Android Kotlin app for nearby chat"}),
);
assert!(v["reason"]
.as_str()
.unwrap()
.contains("on Maven Central (com.offlineprotocol:offline-protocol-sdk"));
let (err, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "share notes between desktop apps", "platform": "python"}),
);
assert!(!err);
assert_eq!(v["planGenerated"], false, "{v}");
assert!(v["alternatives"]
.as_array()
.unwrap()
.iter()
.any(|a| a["description"] == "Workflows available on python: nearby-chat"));
assert!(v["alternatives"]
.as_array()
.unwrap()
.iter()
.any(|a| a["arguments"]["packages"][0] == "offline-protocol-sdk"));
let (_, v) = tool_call(&s, "get_package", json!({"name": "esp32"}));
let note = v["notes"][0].as_str().unwrap();
assert!(note.starts_with("CI builds and lints the crate"), "{note}");
assert!(note.contains("IntelligenceMesh Relay"), "{note}");
let (_, v) = tool_call(&s, "get_skill", json!({"name": "esp32"}));
let body = v["body"].as_str().unwrap();
assert!(body.contains("links it into a"), "{body}");
assert!(body.contains("IntelligenceMesh Relay"), "{body}");
let (_, v) = tool_call(&s, "get_package", json!({"name": "kotlin"}));
assert_eq!(v["registry"], "maven", "{v}");
assert_eq!(v["status"], "preview", "{v}");
assert!(v["install"]
.as_str()
.unwrap()
.contains("implementation(\"com.offlineprotocol:offline-protocol-sdk:0.34.0\")"));
}
#[test]
fn platform_aliases_resolve_with_a_note() {
let s = server();
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "ios", "workflow": "nearby-chat"}),
);
assert!(!err, "{v}");
assert_eq!(v["platform"], "react-native");
assert!(v["note"]
.as_str()
.unwrap()
.contains("native packages are early previews"));
for (alias, resolved) in [
("android", "react-native"),
("react", "react-vite"),
("vite", "react-vite"),
("next", "nextjs"),
("browser", "nextjs"),
] {
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": alias, "packages": ["@offline-protocol/core"]}),
);
assert!(!err, "{alias}: {v}");
assert_eq!(v["platform"], resolved, "{alias}");
assert!(v["note"].as_str().unwrap().contains(alias), "{alias}");
}
let (err, v) = tool_call(&s, "resolve_packages", json!({"platform": "ios"}));
assert!(!err, "{v}");
assert_eq!(v["resolved"], false);
assert!(v["packages"]
.as_array()
.unwrap()
.iter()
.any(|p| p["name"] == "@offline-protocol/mesh-sdk"));
assert!(v["note"].is_string());
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "windows95", "packages": ["mesh-sdk"]}),
);
assert!(err);
assert!(v
.as_str()
.unwrap()
.contains("react-native, nextjs, react-vite, web, rust"));
let (err, v) = tool_call(
&s,
"generate_architecture",
json!({"prompt": "nearby chat", "platform": "android"}),
);
assert!(!err);
assert_eq!(v["plan"]["platform"], "react-native");
assert!(v["note"].is_string());
}
#[test]
fn incompatible_requests_are_structured_answers() {
let s = server();
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "web", "workflow": "nearby-chat"}),
);
assert!(!err);
assert_eq!(v["supported"], false);
assert!(v["reason"].as_str().unwrap().contains(
"workflow `nearby-chat` supports platforms [java, python, react-native], not `web`"
));
let offered: Vec<&str> = v["alternatives"]
.as_array()
.unwrap()
.iter()
.filter_map(|a| a["arguments"]["platform"].as_str())
.collect();
assert_eq!(offered, ["java", "python", "react-native"], "{v}");
let (err, v) = tool_call(
&s,
"resolve_packages",
json!({"platform": "web", "packages": ["@offline-protocol/id-react-native"]}),
);
assert!(!err);
assert!(v["alternatives"]
.as_array()
.unwrap()
.iter()
.any(|a| a["arguments"]["packages"][0] == "@offline-protocol/id-react"));
}
#[test]
fn preview_without_a_name_uses_a_placeholder() {
let s = server();
let (err, v) = tool_call(
&s,
"preview_scaffold",
json!({"prompt": "Plan a nearby chat app"}),
);
assert!(!err, "{v}");
assert_eq!(v["dryRun"], true);
assert_eq!(v["project"], crate::tools::DEFAULT_PREVIEW_NAME);
assert!(v["notes"]
.as_array()
.unwrap()
.iter()
.any(|n| n.as_str().unwrap().contains("no `name` given")));
let (err, v) = tool_call(
&s,
"scaffold_project",
json!({"prompt": "Plan a nearby chat app"}),
);
assert!(err);
assert!(v
.as_str()
.unwrap()
.contains("missing required argument `name`"));
let (err, v) = tool_call(
&s,
"preview_scaffold",
json!({"workflow": "offline-social-network"}),
);
assert!(!err, "{v}");
assert_eq!(v["matches"].as_array().unwrap().len(), 3);
}
#[test]
fn malformed_json_yields_parse_error() {
let s = server();
let raw = s.handle_message("{not json").unwrap();
let resp: Value = serde_json::from_str(&raw).unwrap();
assert_eq!(resp["error"]["code"], -32700);
}
#[test]
fn unknown_method_yields_method_not_found() {
let s = server();
let resp = call(&s, json!({"jsonrpc": "2.0", "id": 10, "method": "wat"}));
assert_eq!(resp["error"]["code"], -32601);
}
#[test]
fn run_loop_processes_stream() {
let s = server();
let input = concat!(
r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}"#,
"\n",
r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#,
"\n",
r#"{"jsonrpc":"2.0","id":2,"method":"ping"}"#,
"\n"
);
let mut output = Vec::new();
s.run(input.as_bytes(), &mut output).unwrap();
let lines: Vec<&str> = std::str::from_utf8(&output).unwrap().lines().collect();
assert_eq!(lines.len(), 2);
}
struct FakeAccount;
impl crate::AccountTools for FakeAccount {
fn definitions(&self) -> Vec<serde_json::Value> {
vec![
serde_json::json!({"name": "app_status", "description": "d", "inputSchema": {"type": "object"}}),
]
}
fn call(
&self,
name: &str,
_args: &serde_json::Value,
) -> Option<Result<serde_json::Value, String>> {
(name == "app_status").then(|| Ok(serde_json::json!({"ready": true})))
}
}
#[test]
fn account_tools_are_listed_and_called_only_on_the_local_server() {
let local = McpServer::new(offline_registry::Registry::load_embedded().unwrap())
.with_account_tools(Box::new(FakeAccount));
let list = local
.handle_message(r#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}"#)
.unwrap();
assert!(list.contains("\"app_status\""));
let call = local
.handle_message(r#"{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"app_status","arguments":{}}}"#)
.unwrap();
assert!(call.contains("ready"));
let other = local
.handle_message(r#"{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"list_packages","arguments":{}}}"#)
.unwrap();
assert!(other.contains("\"isError\":false"));
let hosted = McpServer::with_mode(
offline_registry::Registry::load_embedded().unwrap(),
DeploymentMode::Hosted,
)
.with_account_tools(Box::new(FakeAccount));
let list = hosted
.handle_message(r#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}"#)
.unwrap();
assert!(!list.contains("\"app_status\""));
}
}