claudemesh-cli 0.7.1 → 0.8.1

package/dist/index.js

@@ -47663,6 +47663,75 @@ var TOOLS = [
       },
       required: ["name"]
     }
+  },
+  {
+    name: "mesh_mcp_deploy",
+    description: "Deploy an MCP server to the mesh from a zip file or git repo. Runs on the broker VPS, persists across peer sessions. Default scope: private (only you).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Unique name for the server in this mesh" },
+        file_id: { type: "string", description: "File ID of uploaded zip (from share_file)" },
+        git_url: { type: "string", description: "Git repo URL" },
+        git_branch: { type: "string", description: "Branch to clone (default: main)" },
+        env: { type: "object", description: "Environment variables. Use $vault:<key> for vault secrets." },
+        runtime: { type: "string", enum: ["node", "python", "bun"], description: "Runtime (auto-detected if omitted)" },
+        memory_mb: { type: "number", description: "Memory limit in MB (default: 256)" },
+        network_allow: { type: "array", items: { type: "string" }, description: "Allowed outbound hosts (default: none)" },
+        scope: { description: "Visibility: 'peer' (default), 'mesh', or {group/groups/role/peers}" }
+      },
+      required: ["server_name"]
+    }
+  },
+  {
+    name: "mesh_mcp_undeploy",
+    description: "Stop and remove a managed MCP server from the mesh.",
+    inputSchema: { type: "object", properties: { server_name: { type: "string" } }, required: ["server_name"] }
+  },
+  {
+    name: "mesh_mcp_update",
+    description: "Pull latest code and restart a git-sourced MCP server.",
+    inputSchema: { type: "object", properties: { server_name: { type: "string" } }, required: ["server_name"] }
+  },
+  {
+    name: "mesh_mcp_logs",
+    description: "View recent logs from a managed MCP server.",
+    inputSchema: { type: "object", properties: { server_name: { type: "string" }, lines: { type: "number", description: "Lines (default: 50, max: 1000)" } }, required: ["server_name"] }
+  },
+  {
+    name: "mesh_mcp_scope",
+    description: "Get or set the visibility scope of a deployed MCP server.",
+    inputSchema: { type: "object", properties: { server_name: { type: "string" }, scope: { description: "New scope to set. Omit to read current." } }, required: ["server_name"] }
+  },
+  {
+    name: "mesh_mcp_schema",
+    description: "Inspect tool schemas for a deployed MCP server.",
+    inputSchema: { type: "object", properties: { server_name: { type: "string" }, tool_name: { type: "string", description: "Specific tool (omit for all)" } }, required: ["server_name"] }
+  },
+  {
+    name: "mesh_mcp_catalog",
+    description: "List all deployed services in the mesh with status, scope, and tool count.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_skill_deploy",
+    description: "Deploy a multi-file skill bundle from a zip or git repo.",
+    inputSchema: { type: "object", properties: { file_id: { type: "string" }, git_url: { type: "string" }, git_branch: { type: "string" } } }
+  },
+  {
+    name: "vault_set",
+    description: "Store an encrypted credential in your vault. Reference in mesh_mcp_deploy with $vault:<key>.",
+    inputSchema: { type: "object", properties: { key: { type: "string" }, value: { type: "string", description: "Secret value or local file path (for type=file)" }, type: { type: "string", enum: ["env", "file"] }, mount_path: { type: "string" }, description: { type: "string" } }, required: ["key", "value"] }
+  },
+  {
+    name: "vault_list",
+    description: "List your vault entries (keys and metadata only, no secret values).",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "vault_delete",
+    description: "Remove a credential from your vault.",
+    inputSchema: { type: "object", properties: { key: { type: "string" } }, required: ["key"] }
   }
 ];
 
@@ -47751,6 +47820,10 @@ class BrokerClient {
   peerFileResponseResolvers = new Map;
   peerDirResponseResolvers = new Map;
   sharedDirs = [process.cwd()];
+  _serviceCatalog = [];
+  get serviceCatalog() {
+    return this._serviceCatalog;
+  }
   closed = false;
   reconnectAttempt = 0;
   helloTimer = null;
@@ -47858,6 +47931,9 @@ class BrokerClient {
               this._statsCounters.errors = rs.errors ?? 0;
             }
           }
+          if (msg.services) {
+            this._serviceCatalog = msg.services;
+          }
           resolve();
           return;
         }
@@ -48146,6 +48222,14 @@ class BrokerClient {
   mcpListResolvers = new Map;
   mcpCallResolvers = new Map;
   mcpCallForwardHandler = null;
+  vaultAckResolvers = new Map;
+  vaultListResolvers = new Map;
+  mcpDeployResolvers = new Map;
+  mcpLogsResolvers = new Map;
+  mcpSchemaServiceResolvers = new Map;
+  mcpCatalogResolvers = new Map;
+  mcpScopeResolvers = new Map;
+  skillDeployResolvers = new Map;
   async messageStatus(messageId) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
@@ -48678,6 +48762,138 @@ class BrokerClient {
       this.ws.send(JSON.stringify({ type: "peer_dir_request", targetPubkey, dirPath, ...pattern ? { pattern } : {}, _reqId: reqId }));
     });
   }
+  async vaultSet(key, ciphertext, nonce, sealedKey, entryType, mountPath, description) {
+    return new Promise((resolve) => {
+      const reqId = `vset_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const timer = setTimeout(() => {
+        this.vaultAckResolvers.delete(reqId);
+        resolve(false);
+      }, 1e4);
+      this.vaultAckResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "vault_set", key, ciphertext, nonce, sealed_key: sealedKey, entry_type: entryType, mount_path: mountPath, description, _reqId: reqId });
+    });
+  }
+  async vaultList() {
+    return new Promise((resolve) => {
+      const reqId = `vlist_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.vaultListResolvers.delete(reqId);
+        resolve([]);
+      }, 1e4);
+      this.vaultListResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "vault_list", _reqId: reqId });
+    });
+  }
+  async vaultDelete(key) {
+    return new Promise((resolve) => {
+      const reqId = `vdel_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.vaultAckResolvers.delete(reqId);
+        resolve(false);
+      }, 1e4);
+      this.vaultAckResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "vault_delete", key, _reqId: reqId });
+    });
+  }
+  async mcpDeploy(serverName, source, config2, scope) {
+    return new Promise((resolve) => {
+      const reqId = `deploy_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpDeployResolvers.delete(reqId);
+        resolve({ status: "timeout" });
+      }, 60000);
+      this.mcpDeployResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "mcp_deploy", server_name: serverName, source, config: config2, scope, _reqId: reqId });
+    });
+  }
+  async mcpUndeploy(serverName) {
+    return new Promise((resolve) => {
+      const reqId = `undeploy_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpDeployResolvers.delete(reqId);
+        resolve(false);
+      }, 1e4);
+      this.mcpDeployResolvers.set(reqId, { resolve: (r) => resolve(r.status === "stopped"), timer });
+      this.sendRaw({ type: "mcp_undeploy", server_name: serverName, _reqId: reqId });
+    });
+  }
+  async mcpUpdate(serverName) {
+    return new Promise((resolve) => {
+      const reqId = `update_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpDeployResolvers.delete(reqId);
+        resolve({ status: "timeout" });
+      }, 60000);
+      this.mcpDeployResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "mcp_update", server_name: serverName, _reqId: reqId });
+    });
+  }
+  async mcpLogs(serverName, lines) {
+    return new Promise((resolve) => {
+      const reqId = `logs_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpLogsResolvers.delete(reqId);
+        resolve([]);
+      }, 1e4);
+      this.mcpLogsResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "mcp_logs", server_name: serverName, lines, _reqId: reqId });
+    });
+  }
+  async mcpScope(serverName, scope) {
+    return new Promise((resolve) => {
+      const reqId = `scope_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpScopeResolvers.delete(reqId);
+        resolve({ scope: { type: "peer" }, deployed_by: "unknown" });
+      }, 1e4);
+      this.mcpScopeResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "mcp_scope", server_name: serverName, scope, _reqId: reqId });
+    });
+  }
+  async mcpServiceSchema(serverName, toolName) {
+    return new Promise((resolve) => {
+      const reqId = `schema_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpSchemaServiceResolvers.delete(reqId);
+        resolve([]);
+      }, 1e4);
+      this.mcpSchemaServiceResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "mcp_schema", server_name: serverName, tool_name: toolName, _reqId: reqId });
+    });
+  }
+  async mcpCatalog() {
+    return new Promise((resolve) => {
+      const reqId = `catalog_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.mcpCatalogResolvers.delete(reqId);
+        resolve([]);
+      }, 1e4);
+      this.mcpCatalogResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "mcp_catalog", _reqId: reqId });
+    });
+  }
+  async skillDeploy(source) {
+    return new Promise((resolve) => {
+      const reqId = `skilldeploy_${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.skillDeployResolvers.delete(reqId);
+        resolve({ name: "unknown", files: [] });
+      }, 30000);
+      this.skillDeployResolvers.set(reqId, { resolve, timer });
+      this.sendRaw({ type: "skill_deploy", source, _reqId: reqId });
+    });
+  }
+  async getServiceTools(serviceName) {
+    const cached2 = this._serviceCatalog.find((s) => s.name === serviceName);
+    if (cached2?.tools?.length)
+      return cached2.tools;
+    return this.mcpServiceSchema(serviceName);
+  }
+  sendRaw(payload) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify(payload));
+  }
   close() {
     this.closed = true;
     this.stopStatsReporting();
@@ -49179,6 +49395,78 @@ class BrokerClient {
       this.resolveFromMap(this.webhookListResolvers, msgReqId, webhooks);
       return;
     }
+    if (msg.type === "vault_ack") {
+      const reqId = msg._reqId;
+      if (reqId && this.vaultAckResolvers.has(reqId)) {
+        const r = this.vaultAckResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.vaultAckResolvers.delete(reqId);
+        r.resolve(msg.action !== "not_found");
+      }
+    }
+    if (msg.type === "vault_list_result") {
+      const reqId = msg._reqId;
+      if (reqId && this.vaultListResolvers.has(reqId)) {
+        const r = this.vaultListResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.vaultListResolvers.delete(reqId);
+        r.resolve(msg.entries ?? []);
+      }
+    }
+    if (msg.type === "mcp_deploy_status") {
+      const reqId = msg._reqId;
+      if (reqId && this.mcpDeployResolvers.has(reqId)) {
+        const r = this.mcpDeployResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.mcpDeployResolvers.delete(reqId);
+        r.resolve({ status: msg.status, tools: msg.tools, error: msg.error });
+      }
+    }
+    if (msg.type === "mcp_logs_result") {
+      const reqId = msg._reqId;
+      if (reqId && this.mcpLogsResolvers.has(reqId)) {
+        const r = this.mcpLogsResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.mcpLogsResolvers.delete(reqId);
+        r.resolve(msg.lines ?? []);
+      }
+    }
+    if (msg.type === "mcp_schema_result") {
+      const reqId = msg._reqId;
+      if (reqId && this.mcpSchemaServiceResolvers.has(reqId)) {
+        const r = this.mcpSchemaServiceResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.mcpSchemaServiceResolvers.delete(reqId);
+        r.resolve(msg.tools ?? []);
+      }
+    }
+    if (msg.type === "mcp_catalog_result") {
+      const reqId = msg._reqId;
+      if (reqId && this.mcpCatalogResolvers.has(reqId)) {
+        const r = this.mcpCatalogResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.mcpCatalogResolvers.delete(reqId);
+        r.resolve(msg.services ?? []);
+      }
+    }
+    if (msg.type === "mcp_scope_result") {
+      const reqId = msg._reqId;
+      if (reqId && this.mcpScopeResolvers.has(reqId)) {
+        const r = this.mcpScopeResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.mcpScopeResolvers.delete(reqId);
+        r.resolve({ scope: msg.scope, deployed_by: msg.deployed_by });
+      }
+    }
+    if (msg.type === "skill_deploy_ack") {
+      const reqId = msg._reqId;
+      if (reqId && this.skillDeployResolvers.has(reqId)) {
+        const r = this.skillDeployResolvers.get(reqId);
+        clearTimeout(r.timer);
+        this.skillDeployResolvers.delete(reqId);
+        r.resolve({ name: msg.name, files: msg.files ?? [] });
+      }
+    }
     if (msg.type === "error") {
       this.debug(`broker error: ${msg.code} ${msg.message}`);
       const id = msg.id ? String(msg.id) : null;
@@ -49232,7 +49520,15 @@ class BrokerClient {
           [this.peerFileResponseResolvers, { error: "broker error" }],
           [this.peerDirResponseResolvers, { error: "broker error" }],
           [this.webhookAckResolvers, null],
-          [this.webhookListResolvers, []]
+          [this.webhookListResolvers, []],
+          [this.vaultAckResolvers, false],
+          [this.vaultListResolvers, []],
+          [this.mcpDeployResolvers, { status: "error" }],
+          [this.mcpLogsResolvers, []],
+          [this.mcpSchemaServiceResolvers, []],
+          [this.mcpCatalogResolvers, []],
+          [this.mcpScopeResolvers, { scope: { type: "peer" }, deployed_by: "unknown" }],
+          [this.skillDeployResolvers, { name: "unknown", files: [] }]
         ];
         for (const [map2, defaultVal] of allMaps) {
           const first = map2.entries().next().value;
@@ -49428,6 +49724,10 @@ function formatPush(p, meshSlug) {
 ${body}`;
 }
 async function startMcpServer() {
+  const serviceIdx = process.argv.indexOf("--service");
+  if (serviceIdx !== -1 && process.argv[serviceIdx + 1]) {
+    return startServiceProxy(process.argv[serviceIdx + 1]);
+  }
   const config2 = loadConfig();
   const myName = config2.displayName ?? "unnamed";
   const myRole = config2.role ?? process.env.CLAUDEMESH_ROLE ?? null;
@@ -50672,6 +50972,178 @@ ${lines.join(`
         const ok = await client2.deleteWebhook(delName);
         return text(ok ? `Webhook "${delName}" deactivated.` : `Failed to deactivate webhook "${delName}".`, !ok);
       }
+      case "vault_set": {
+        const { key, value, type: vType, mount_path, description } = args ?? {};
+        if (!key || !value)
+          return text("vault_set: `key` and `value` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("vault_set: not connected", true);
+        const entryType = vType ?? "env";
+        let plaintext = value;
+        if (entryType === "file") {
+          const { existsSync: existsSync2, readFileSync: readFileSync2 } = await import("node:fs");
+          if (!existsSync2(value))
+            return text(`vault_set: file not found: ${value}`, true);
+          plaintext = readFileSync2(value, "base64");
+        }
+        const encoded = Buffer.from(plaintext).toString("base64");
+        const ok = await client2.vaultSet(key, encoded, "placeholder-nonce", "placeholder-sealed", entryType, mount_path, description);
+        if (!ok)
+          return text("vault_set: broker did not acknowledge", true);
+        return text(`Vault entry "${key}" stored (${entryType}).`);
+      }
+      case "vault_list": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("vault_list: not connected", true);
+        const entries = await client2.vaultList();
+        if (entries.length === 0)
+          return text("Vault is empty.");
+        const lines = entries.map((e) => `- **${e.key}** (${e.entry_type}${e.mount_path ? ` → ${e.mount_path}` : ""})${e.description ? ` — ${e.description}` : ""} (${e.updated_at})`);
+        return text(`${entries.length} vault entry(s):
+${lines.join(`
+`)}`);
+      }
+      case "vault_delete": {
+        const { key } = args ?? {};
+        if (!key)
+          return text("vault_delete: `key` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("vault_delete: not connected", true);
+        const ok = await client2.vaultDelete(key);
+        return text(ok ? `Vault entry "${key}" deleted.` : `Vault entry "${key}" not found.`);
+      }
+      case "mesh_mcp_deploy": {
+        const { server_name, file_id, git_url, git_branch, env: deployEnv, runtime, memory_mb, network_allow, scope } = args ?? {};
+        if (!server_name)
+          return text("mesh_mcp_deploy: `server_name` required", true);
+        if (!file_id && !git_url)
+          return text("mesh_mcp_deploy: either `file_id` or `git_url` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_deploy: not connected", true);
+        const source = file_id ? { type: "zip", file_id } : { type: "git", url: git_url, branch: git_branch };
+        const config3 = {};
+        if (deployEnv)
+          config3.env = deployEnv;
+        if (runtime)
+          config3.runtime = runtime;
+        if (memory_mb)
+          config3.memory_mb = memory_mb;
+        if (network_allow)
+          config3.network_allow = network_allow;
+        const result = await client2.mcpDeploy(server_name, source, Object.keys(config3).length > 0 ? config3 : undefined, scope);
+        const toolList = result.tools?.map((t) => `  - ${t.name}: ${t.description}`).join(`
+`) ?? "  (pending)";
+        return text(`Deployed "${server_name}" (status: ${result.status}).
+
+Tools:
+${toolList}
+
+Default scope: peer (private). Use mesh_mcp_scope to share.`);
+      }
+      case "mesh_mcp_undeploy": {
+        const { server_name } = args ?? {};
+        if (!server_name)
+          return text("mesh_mcp_undeploy: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_undeploy: not connected", true);
+        const ok = await client2.mcpUndeploy(server_name);
+        return text(ok ? `Service "${server_name}" undeployed.` : `Failed to undeploy "${server_name}".`);
+      }
+      case "mesh_mcp_update": {
+        const { server_name } = args ?? {};
+        if (!server_name)
+          return text("mesh_mcp_update: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_update: not connected", true);
+        const result = await client2.mcpUpdate(server_name);
+        return text(`Updated "${server_name}" (status: ${result.status}).`);
+      }
+      case "mesh_mcp_logs": {
+        const { server_name, lines: logLines } = args ?? {};
+        if (!server_name)
+          return text("mesh_mcp_logs: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_logs: not connected", true);
+        const logs = await client2.mcpLogs(server_name, logLines);
+        if (logs.length === 0)
+          return text(`No logs for "${server_name}".`);
+        return text(`Logs for "${server_name}" (${logs.length} lines):
+\`\`\`
+${logs.join(`
+`)}
+\`\`\``);
+      }
+      case "mesh_mcp_scope": {
+        const { server_name, scope } = args ?? {};
+        if (!server_name)
+          return text("mesh_mcp_scope: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_scope: not connected", true);
+        const result = await client2.mcpScope(server_name, scope);
+        if (scope !== undefined) {
+          return text(`Scope for "${server_name}" updated to: ${JSON.stringify(result.scope)}`);
+        }
+        return text(`**${server_name}** scope: ${JSON.stringify(result.scope)}
+Deployed by: ${result.deployed_by}`);
+      }
+      case "mesh_mcp_schema": {
+        const { server_name, tool_name } = args ?? {};
+        if (!server_name)
+          return text("mesh_mcp_schema: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_schema: not connected", true);
+        const tools = await client2.mcpServiceSchema(server_name, tool_name);
+        if (tools.length === 0)
+          return text(`No tools found for "${server_name}"${tool_name ? ` (tool: ${tool_name})` : ""}.`);
+        const lines = tools.map((t) => `### ${t.name}
+${t.description}
+\`\`\`json
+${JSON.stringify(t.inputSchema, null, 2)}
+\`\`\``);
+        return text(`Tools for "${server_name}":
+
+${lines.join(`
+
+`)}`);
+      }
+      case "mesh_mcp_catalog": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_catalog: not connected", true);
+        const services = await client2.mcpCatalog();
+        if (services.length === 0)
+          return text("No services deployed in the mesh.");
+        const lines = services.map((s) => {
+          const scopeStr = typeof s.scope === "string" ? s.scope : JSON.stringify(s.scope);
+          return `- **${s.name}** (${s.type}, ${s.status}) — ${s.description}
+  ${s.tool_count} tools | scope: ${scopeStr} | by ${s.deployed_by} | ${s.source_type}${s.runtime ? ` (${s.runtime})` : ""}`;
+        });
+        return text(`${services.length} service(s) in mesh:
+
+${lines.join(`
+`)}`);
+      }
+      case "mesh_skill_deploy": {
+        const { file_id, git_url, git_branch } = args ?? {};
+        if (!file_id && !git_url)
+          return text("mesh_skill_deploy: either `file_id` or `git_url` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_skill_deploy: not connected", true);
+        const source = file_id ? { type: "zip", file_id } : { type: "git", url: git_url, branch: git_branch };
+        const result = await client2.skillDeploy(source);
+        return text(`Skill "${result.name}" deployed.
+Files: ${result.files.join(", ")}`);
+      }
       default:
         return text(`Unknown tool: ${name}`, true);
     }
@@ -50830,6 +51302,120 @@ ${lines.join(`
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
+async function startServiceProxy(serviceName) {
+  const config2 = loadConfig();
+  if (config2.meshes.length === 0) {
+    process.stderr.write(`[mesh:${serviceName}] no meshes joined
+`);
+    process.exit(1);
+  }
+  const mesh = config2.meshes[0];
+  const client2 = new BrokerClient(mesh, {
+    displayName: config2.displayName ?? `proxy:${serviceName}`
+  });
+  try {
+    await client2.connect();
+  } catch (e) {
+    process.stderr.write(`[mesh:${serviceName}] broker connect failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(1);
+  }
+  await new Promise((r) => setTimeout(r, 1500));
+  let tools = [];
+  try {
+    const fetched = await client2.getServiceTools(serviceName);
+    tools = fetched;
+  } catch {
+    const cached2 = client2.serviceCatalog.find((s) => s.name === serviceName);
+    if (cached2) {
+      tools = cached2.tools;
+    }
+  }
+  if (tools.length === 0) {
+    process.stderr.write(`[mesh:${serviceName}] no tools found — service may not be running
+`);
+  }
+  const server = new Server({ name: `mesh:${serviceName}`, version: "0.1.0" }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, () => ({
+    tools: tools.map((t) => ({
+      name: t.name,
+      description: `[mesh:${serviceName}] ${t.description}`,
+      inputSchema: t.inputSchema
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const toolName = req.params.name;
+    const args = req.params.arguments ?? {};
+    if (client2.status !== "open") {
+      let waited = 0;
+      while (client2.status !== "open" && waited < 1e4) {
+        await new Promise((r) => setTimeout(r, 500));
+        waited += 500;
+      }
+      if (client2.status !== "open") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Service temporarily unavailable — broker reconnecting. Retry in a few seconds.`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    try {
+      const result = await client2.mcpCall(serviceName, toolName, args);
+      if (result.error) {
+        return {
+          content: [{ type: "text", text: `Error: ${result.error}` }],
+          isError: true
+        };
+      }
+      const resultText = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
+      return {
+        content: [{ type: "text", text: resultText }]
+      };
+    } catch (e) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Call failed: ${e instanceof Error ? e.message : String(e)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  client2.onPush((push) => {
+    if (push.event === "mcp_undeployed" && push.eventData?.name === serviceName) {
+      process.stderr.write(`[mesh:${serviceName}] service undeployed — exiting
+`);
+      client2.close();
+      process.exit(0);
+    }
+    if (push.event === "mcp_updated" && push.eventData?.name === serviceName) {
+      const newTools = push.eventData?.tools;
+      if (Array.isArray(newTools)) {
+        tools = newTools;
+        server.notification({
+          method: "notifications/tools/list_changed"
+        }).catch(() => {});
+      }
+    }
+  });
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  const keepalive = setInterval(() => {}, 1000);
+  const shutdown = () => {
+    clearInterval(keepalive);
+    client2.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
 
 // src/commands/install.ts
 init_config();
@@ -51526,8 +52112,8 @@ async function runHook(args) {
 // src/commands/launch.ts
 init_config();
 import { spawn } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync4, rmSync, readdirSync, statSync } from "node:fs";
-import { tmpdir, hostname as hostname2 } from "node:os";
+import { mkdtempSync, writeFileSync as writeFileSync4, rmSync, readdirSync, statSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { tmpdir, hostname as hostname2, homedir as homedir4 } from "node:os";
 import { join as join4 } from "node:path";
 import { createInterface } from "node:readline";
 async function pickMesh(meshes) {
@@ -51726,6 +52312,44 @@ async function runLaunch(flags, rawArgs) {
         rmSync(full, { recursive: true, force: true });
     }
   } catch {}
+  try {
+    const claudeConfigPath = join4(homedir4(), ".claude.json");
+    if (existsSync3(claudeConfigPath)) {
+      const claudeConfig = JSON.parse(readFileSync3(claudeConfigPath, "utf-8"));
+      const mcpServers = claudeConfig.mcpServers ?? {};
+      let cleaned = 0;
+      for (const key of Object.keys(mcpServers)) {
+        if (!key.startsWith("mesh:"))
+          continue;
+        const meta2 = mcpServers[key]?._meshSession;
+        if (!meta2?.pid)
+          continue;
+        try {
+          process.kill(meta2.pid, 0);
+        } catch {
+          delete mcpServers[key];
+          cleaned++;
+        }
+      }
+      if (cleaned > 0) {
+        claudeConfig.mcpServers = mcpServers;
+        writeFileSync4(claudeConfigPath, JSON.stringify(claudeConfig, null, 2) + `
+`, "utf-8");
+      }
+    }
+  } catch {}
+  let serviceCatalog = [];
+  try {
+    const tmpClient = new BrokerClient(mesh, { displayName });
+    await tmpClient.connect();
+    await new Promise((r) => setTimeout(r, 2000));
+    serviceCatalog = tmpClient.serviceCatalog;
+    tmpClient.close();
+  } catch {
+    if (!args.quiet) {
+      console.log("  (Could not fetch service catalog — mesh services won't be natively available)");
+    }
+  }
   const tmpDir = mkdtempSync(join4(tmpdir(), "claudemesh-"));
   const sessionConfig = {
     version: 1,
@@ -51743,6 +52367,50 @@ async function runLaunch(flags, rawArgs) {
       await confirmPermissions();
     }
   }
+  const meshMcpEntries = [];
+  if (serviceCatalog.length > 0) {
+    const claudeConfigPath = join4(homedir4(), ".claude.json");
+    let claudeConfig = {};
+    try {
+      claudeConfig = JSON.parse(readFileSync3(claudeConfigPath, "utf-8"));
+    } catch {
+      claudeConfig = {};
+    }
+    const mcpServers = claudeConfig.mcpServers ?? {};
+    const sessionTag = `${process.pid}`;
+    for (const svc of serviceCatalog) {
+      if (svc.status !== "running")
+        continue;
+      const entryKey = `mesh:${svc.name}:${sessionTag}`;
+      const entry = {
+        command: "claudemesh",
+        args: ["mcp", "--service", svc.name],
+        env: {
+          CLAUDEMESH_CONFIG_DIR: tmpDir
+        },
+        _meshSession: {
+          pid: process.pid,
+          meshSlug: mesh.slug,
+          serviceName: svc.name,
+          createdAt: new Date().toISOString()
+        }
+      };
+      mcpServers[entryKey] = entry;
+      meshMcpEntries.push({ key: entryKey, entry });
+    }
+    claudeConfig.mcpServers = mcpServers;
+    writeFileSync4(claudeConfigPath, JSON.stringify(claudeConfig, null, 2) + `
+`, "utf-8");
+    if (!args.quiet && meshMcpEntries.length > 0) {
+      console.log(`  ${meshMcpEntries.length} mesh service(s) registered as native MCPs:`);
+      for (const { key } of meshMcpEntries) {
+        const svcName = key.split(":")[1];
+        const svc = serviceCatalog.find((s) => s.name === svcName);
+        console.log(`    ${svcName} (${svc?.tools.length ?? 0} tools)`);
+      }
+      console.log("");
+    }
+  }
   const filtered = [];
   for (let i = 0;i < args.claudeArgs.length; i++) {
     if (args.claudeArgs[i] === "--dangerously-load-development-channels" || args.claudeArgs[i] === "--dangerously-skip-permissions") {
@@ -51767,10 +52435,25 @@ async function runLaunch(flags, rawArgs) {
       ...process.env,
       CLAUDEMESH_CONFIG_DIR: tmpDir,
       CLAUDEMESH_DISPLAY_NAME: displayName,
+      MCP_TIMEOUT: process.env.MCP_TIMEOUT ?? "30000",
+      MAX_MCP_OUTPUT_TOKENS: process.env.MAX_MCP_OUTPUT_TOKENS ?? "50000",
       ...role ? { CLAUDEMESH_ROLE: role } : {}
     }
   });
   const cleanup = () => {
+    if (meshMcpEntries.length > 0) {
+      try {
+        const claudeConfigPath = join4(homedir4(), ".claude.json");
+        const claudeConfig = JSON.parse(readFileSync3(claudeConfigPath, "utf-8"));
+        const mcpServers = claudeConfig.mcpServers ?? {};
+        for (const { key } of meshMcpEntries) {
+          delete mcpServers[key];
+        }
+        claudeConfig.mcpServers = mcpServers;
+        writeFileSync4(claudeConfigPath, JSON.stringify(claudeConfig, null, 2) + `
+`, "utf-8");
+      } catch {}
+    }
     try {
       rmSync(tmpDir, { recursive: true, force: true });
     } catch {}
@@ -51803,12 +52486,12 @@ async function runLaunch(flags, rawArgs) {
 }
 
 // src/commands/status.ts
-import { statSync as statSync2, existsSync as existsSync3 } from "node:fs";
+import { statSync as statSync2, existsSync as existsSync4 } from "node:fs";
 init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.7.1",
+  version: "0.8.1",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",
@@ -51909,7 +52592,7 @@ async function runStatus() {
   console.log("─".repeat(60));
   const configPath = getConfigPath();
   let configPerms = "missing";
-  if (existsSync3(configPath)) {
+  if (existsSync4(configPath)) {
     const st = statSync2(configPath);
     const mode = (st.mode & 511).toString(8).padStart(4, "0");
     configPerms = mode === "0600" ? `${mode} ✓` : `${mode} ⚠ (expected 0600)`;
@@ -51958,8 +52641,8 @@ async function runStatus() {
 
 // src/commands/doctor.ts
 init_config();
-import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
-import { homedir as homedir4, platform as platform2 } from "node:os";
+import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { homedir as homedir5, platform as platform2 } from "node:os";
 import { join as join5 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 function checkNode() {
@@ -51984,8 +52667,8 @@ function checkClaudeOnPath() {
   };
 }
 function checkMcpRegistered() {
-  const claudeConfig = join5(homedir4(), ".claude.json");
-  if (!existsSync4(claudeConfig)) {
+  const claudeConfig = join5(homedir5(), ".claude.json");
+  if (!existsSync5(claudeConfig)) {
     return {
       name: "claudemesh MCP registered in ~/.claude.json",
       pass: false,
@@ -51993,7 +52676,7 @@ function checkMcpRegistered() {
     };
   }
   try {
-    const cfg = JSON.parse(readFileSync3(claudeConfig, "utf-8"));
+    const cfg = JSON.parse(readFileSync4(claudeConfig, "utf-8"));
     const registered = Boolean(cfg.mcpServers?.["claudemesh"]);
     return {
       name: "claudemesh MCP registered in ~/.claude.json",
@@ -52010,8 +52693,8 @@ function checkMcpRegistered() {
   }
 }
 function checkHooksRegistered() {
-  const settings = join5(homedir4(), ".claude", "settings.json");
-  if (!existsSync4(settings)) {
+  const settings = join5(homedir5(), ".claude", "settings.json");
+  if (!existsSync5(settings)) {
     return {
       name: "Status hooks registered in ~/.claude/settings.json",
       pass: false,
@@ -52019,7 +52702,7 @@ function checkHooksRegistered() {
     };
   }
   try {
-    const raw = readFileSync3(settings, "utf-8");
+    const raw = readFileSync4(settings, "utf-8");
     const has = raw.includes("claudemesh hook ");
     return {
       name: "Status hooks registered in ~/.claude/settings.json",
@@ -52036,7 +52719,7 @@ function checkHooksRegistered() {
 }
 function checkConfigFile() {
   const path = getConfigPath();
-  if (!existsSync4(path)) {
+  if (!existsSync5(path)) {
     return {
       name: "~/.claudemesh/config.json exists and parses",
       pass: true,
@@ -52140,15 +52823,15 @@ async function runDoctor() {
 
 // src/commands/welcome.ts
 init_config();
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import { join as join6 } from "node:path";
 function detectState() {
-  const claudeConfig = join6(homedir5(), ".claude.json");
+  const claudeConfig = join6(homedir6(), ".claude.json");
   let mcpRegistered = false;
-  if (existsSync5(claudeConfig)) {
+  if (existsSync6(claudeConfig)) {
     try {
-      const cfg = JSON.parse(readFileSync4(claudeConfig, "utf-8"));
+      const cfg = JSON.parse(readFileSync5(claudeConfig, "utf-8"));
       mcpRegistered = Boolean(cfg.mcpServers?.["claudemesh"]);
     } catch {}
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudemesh-cli",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   "keywords": [
     "claude-code",
@@ -48,10 +48,10 @@
     "prettier": "3.6.2",
     "typescript": "5.9.3",
     "vitest": "4.0.14",
-    "@turbostarter/eslint-config": "0.1.0",
+    "@turbostarter/vitest-config": "0.1.0",
     "@turbostarter/tsconfig": "0.1.0",
     "@turbostarter/prettier-config": "0.1.0",
-    "@turbostarter/vitest-config": "0.1.0"
+    "@turbostarter/eslint-config": "0.1.0"
   },
   "scripts": {
     "build": "bun build src/index.ts --target=node --outfile dist/index.js --banner \"#!/usr/bin/env node\" && chmod +x dist/index.js",