claudemesh-cli 0.7.0 → 0.8.0

package/dist/index.js

@@ -47478,6 +47478,10 @@ var TOOLS = [
             required: ["name", "description", "inputSchema"]
           },
           description: "Tool definitions to expose"
+        },
+        persistent: {
+          type: "boolean",
+          description: "If true, registration survives peer disconnect. Other peers see it as 'offline' until you reconnect. Default: false"
         }
       },
       required: ["server_name", "description", "tools"]
@@ -47659,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"] }
   }
 ];
 
@@ -47747,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;
@@ -47810,6 +47887,7 @@ class BrokerClient {
             sessionId: `${process.pid}-${Date.now()}`,
             pid: process.pid,
             cwd: process.cwd(),
+            hostname: __require("os").hostname(),
             peerType: "ai",
             channel: "claude-code",
             model: process.env.CLAUDE_MODEL || undefined,
@@ -47841,6 +47919,21 @@ class BrokerClient {
           this.reconnectAttempt = 0;
           this.flushOutbound();
           this.startStatsReporting();
+          if (msg.restored) {
+            const groups = msg.restoredGroups ? msg.restoredGroups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "none";
+            process.stderr.write(`[claudemesh] session restored — last seen ${msg.lastSeenAt ?? "unknown"}, groups: ${groups}
+`);
+            if (msg.restoredStats) {
+              const rs = msg.restoredStats;
+              this._statsCounters.messagesIn = rs.messagesIn ?? 0;
+              this._statsCounters.messagesOut = rs.messagesOut ?? 0;
+              this._statsCounters.toolCalls = rs.toolCalls ?? 0;
+              this._statsCounters.errors = rs.errors ?? 0;
+            }
+          }
+          if (msg.services) {
+            this._serviceCatalog = msg.services;
+          }
           resolve();
           return;
         }
@@ -48129,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;
@@ -48427,7 +48528,7 @@ class BrokerClient {
     this.stateChangeHandlers.add(handler);
     return () => this.stateChangeHandlers.delete(handler);
   }
-  async mcpRegister(serverName, description, tools) {
+  async mcpRegister(serverName, description, tools, persistent) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
     return new Promise((resolve) => {
@@ -48436,7 +48537,7 @@ class BrokerClient {
         if (this.mcpRegisterResolvers.delete(reqId))
           resolve(null);
       }, 5000) });
-      this.ws.send(JSON.stringify({ type: "mcp_register", serverName, description, tools, _reqId: reqId }));
+      this.ws.send(JSON.stringify({ type: "mcp_register", serverName, description, tools, ...persistent ? { persistent: true } : {}, _reqId: reqId }));
     });
   }
   async mcpUnregister(serverName) {
@@ -48661,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();
@@ -49162,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;
@@ -49215,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;
@@ -49312,6 +49625,25 @@ function stopAll() {
 }
 
 // src/mcp/server.ts
+function relativeTime(isoStr) {
+  const then = new Date(isoStr).getTime();
+  if (isNaN(then))
+    return "unknown";
+  const diffMs = Date.now() - then;
+  if (diffMs < 0)
+    return "just now";
+  const seconds = Math.floor(diffMs / 1000);
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days} day${days !== 1 ? "s" : ""} ago`;
+}
 function text(msg, isError = false) {
   return {
     content: [{ type: "text", text: msg }],
@@ -49392,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;
@@ -49484,9 +49820,14 @@ Shared key-value store scoped to the mesh. Use get_state/set_state for live coor
 ## Memory
 Persistent knowledge that survives across sessions. Use remember(content, tags?) to store lessons, decisions, and incidents. Use recall(query) to search before asking peers. New peers should recall at session start to load institutional knowledge.
 
-## Files
-share_file for persistent references, send_message(file:) for ephemeral attachments.
-Tags on shared files make them searchable. Use list_files to find what peers shared.
+## File access — decision guide
+Three ways to access files. Pick the right one:
+
+1. **Local peer (same machine, [local] tag):** Read files directly via filesystem using their \`cwd\` path from list_peers. No limit, instant. This is the default for local peers.
+2. **Remote peer (different machine, [remote] tag):** Use \`read_peer_file(peer, path)\` — relays through the mesh. **1 MB limit**, base64 encoded. Use \`list_peer_files\` to browse first.
+3. **Persistent sharing (any peer):** Use \`share_file(path)\` — uploads to mesh storage (MinIO). **No size limit**. All peers can download anytime via \`get_file\`. Use for files that need to persist or be shared with multiple peers.
+
+**Rule of thumb:** local peer → filesystem. Remote peer, small file → read_peer_file. Large file or needs to persist → share_file.
 
 ## Vectors
 Store and search semantic embeddings. Use vector_store to index content, vector_search to find similar content.
@@ -49583,10 +49924,12 @@ No peers connected.`);
                 meta2.push(`model:${p.model}`);
               const metaStr = meta2.length ? ` {${meta2.join(", ")}}` : "";
               const cwdStr = p.cwd ? ` cwd:${p.cwd}` : "";
+              const locality = p.hostname && p.hostname === __require("os").hostname() ? "local" : "remote";
+              const localityTag = ` [${locality}]`;
               const profileAvatar = p.profile?.avatar ? `${p.profile.avatar} ` : "";
               const profileTitle = p.profile?.title ? ` (${p.profile.title})` : "";
               const hiddenTag = p.visible === false ? " [hidden]" : "";
-              return `- ${profileAvatar}**${p.displayName}**${profileTitle} [${p.status}]${hiddenTag}${groupsStr}${metaStr} (${p.pubkey.slice(0, 12)}…)${cwdStr}${summary}`;
+              return `- ${profileAvatar}**${p.displayName}**${profileTitle} [${p.status}]${localityTag}${hiddenTag}${groupsStr}${metaStr} (${p.pubkey.slice(0, 12)}…)${cwdStr}${summary}`;
             });
             sections.push(`${header}
 ${peerLines.join(`
@@ -50423,16 +50766,17 @@ ${lines.join(`
 `));
       }
       case "mesh_mcp_register": {
-        const { server_name, description, tools: regTools } = args ?? {};
+        const { server_name, description, tools: regTools, persistent: regPersistent } = args ?? {};
         if (!server_name || !description || !regTools?.length)
           return text("mesh_mcp_register: `server_name`, `description`, and `tools` required", true);
         const client2 = allClients()[0];
         if (!client2)
           return text("mesh_mcp_register: not connected", true);
-        const result = await client2.mcpRegister(server_name, description, regTools);
+        const result = await client2.mcpRegister(server_name, description, regTools, regPersistent);
         if (!result)
           return text("mesh_mcp_register: broker did not acknowledge", true);
-        return text(`Registered MCP server "${result.serverName}" with ${result.toolCount} tool(s). Other peers can now call its tools via mesh_tool_call.`);
+        const persistLabel = regPersistent ? " (persistent — survives disconnect)" : "";
+        return text(`Registered MCP server "${result.serverName}" with ${result.toolCount} tool(s)${persistLabel}. Other peers can now call its tools via mesh_tool_call.`);
       }
       case "mesh_mcp_list": {
         const client2 = allClients()[0];
@@ -50444,7 +50788,8 @@ ${lines.join(`
         const lines = servers.map((s) => {
           const toolList = s.tools.map((t) => `    - **${t.name}**: ${t.description}`).join(`
 `);
-          return `- **${s.name}** (hosted by ${s.hostedBy}): ${s.description}
+          const status = s.online === false ? ` [OFFLINE${s.offlineSince ? ` since ${s.offlineSince}` : ""}]` : "";
+          return `- **${s.name}** (hosted by ${s.hostedBy})${status}: ${s.description}
 ${toolList}`;
         });
         return text(`${servers.length} MCP server(s) in mesh:
@@ -50531,6 +50876,17 @@ ${lines.join(`
             targetPubkey = match.pubkey;
           }
         }
+        const resolvedPeer = peers.find((p) => p.pubkey === targetPubkey);
+        const isLocal = resolvedPeer?.hostname && resolvedPeer.hostname === __require("os").hostname();
+        let localHint = "";
+        if (isLocal && resolvedPeer?.cwd) {
+          const directPath = __require("path").resolve(resolvedPeer.cwd, filePath);
+          localHint = `
+
+> **Hint:** This peer is LOCAL (same machine). Next time, read directly: \`${directPath}\` — faster, no size limit.
+
+`;
+        }
         const result = await client2.requestFile(targetPubkey, filePath);
         if (result.error)
           return text(`read_peer_file: ${result.error}`, true);
@@ -50538,7 +50894,7 @@ ${lines.join(`
           return text("read_peer_file: empty response from peer", true);
         try {
           const decoded = Buffer.from(result.content, "base64").toString("utf-8");
-          return text(decoded);
+          return text(localHint + decoded);
         } catch {
           return text("read_peer_file: failed to decode file content (binary file?)", true);
         }
@@ -50638,8 +50994,21 @@ ${lines.join(`
           content2 = `[heartbeat] tick ${tick} | sim time: ${simTime} | speed: x${speed}`;
         } else if (eventName === "peer_joined") {
           content2 = `[system] Peer "${data.name ?? "unknown"}" joined the mesh`;
+        } else if (eventName === "peer_returned") {
+          const peerName = String(data.name ?? "unknown");
+          const lastSeenAt = data.lastSeenAt ? relativeTime(String(data.lastSeenAt)) : "unknown";
+          const groups = Array.isArray(data.groups) ? data.groups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "";
+          const summary = data.summary ? ` Summary: "${data.summary}"` : "";
+          content2 = `[system] Welcome back, "${peerName}"! Last seen ${lastSeenAt}.${groups ? ` Restored: ${groups}` : ""}${summary}`;
         } else if (eventName === "peer_left") {
           content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
+        } else if (eventName === "mcp_registered") {
+          const tools = Array.isArray(data.tools) ? data.tools.join(", ") : "";
+          content2 = `[system] New MCP server available: "${data.serverName}" (hosted by ${data.hostedBy}). Tools: ${tools}. Use mesh_tool_call to invoke.`;
+        } else if (eventName === "mcp_unregistered") {
+          content2 = `[system] MCP server "${data.serverName}" removed (was hosted by ${data.hostedBy})`;
+        } else if (eventName === "mcp_restored") {
+          content2 = `[system] MCP server "${data.serverName}" is back online (hosted by ${data.hostedBy})`;
         } else {
           content2 = `[system] ${eventName}: ${JSON.stringify(data)}`;
         }
@@ -50761,6 +51130,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();
@@ -51457,8 +51940,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) {
@@ -51657,6 +52140,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,
@@ -51674,6 +52195,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") {
@@ -51698,10 +52263,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 {}
@@ -51734,12 +52314,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.0",
+  version: "0.8.0",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",
@@ -51840,7 +52420,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)`;
@@ -51889,8 +52469,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() {
@@ -51915,8 +52495,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,
@@ -51924,7 +52504,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",
@@ -51941,8 +52521,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,
@@ -51950,7 +52530,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",
@@ -51967,7 +52547,7 @@ function checkHooksRegistered() {
 }
 function checkConfigFile() {
   const path = getConfigPath();
-  if (!existsSync4(path)) {
+  if (!existsSync5(path)) {
     return {
       name: "~/.claudemesh/config.json exists and parses",
       pass: true,
@@ -52071,15 +52651,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.0",
+  "version": "0.8.0",
   "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/tsconfig": "0.1.0",
+    "@turbostarter/eslint-config": "0.1.0",
     "@turbostarter/prettier-config": "0.1.0",
-    "@turbostarter/vitest-config": "0.1.0",
-    "@turbostarter/eslint-config": "0.1.0"
+    "@turbostarter/tsconfig": "0.1.0",
+    "@turbostarter/vitest-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",