claudemesh-cli 0.6.9 → 0.7.0

package/dist/index.js

@@ -46941,6 +46941,46 @@ var TOOLS = [
       required: ["status"]
     }
   },
+  {
+    name: "set_visible",
+    description: "Control your visibility in the mesh. When hidden, you won't appear in list_peers and won't receive broadcasts — but direct messages still reach you.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        visible: {
+          type: "boolean",
+          description: "true to be visible (default), false to hide"
+        }
+      },
+      required: ["visible"]
+    }
+  },
+  {
+    name: "set_profile",
+    description: "Set your public profile — what other peers see about you. Avatar (emoji), title, bio, and capabilities list.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        avatar: {
+          type: "string",
+          description: "Emoji or URL for your avatar"
+        },
+        title: {
+          type: "string",
+          description: "Short role label (e.g. 'Frontend Lead', 'DevOps')"
+        },
+        bio: {
+          type: "string",
+          description: "One-liner about yourself"
+        },
+        capabilities: {
+          type: "array",
+          items: { type: "string" },
+          description: "What you can help with"
+        }
+      }
+    }
+  },
   {
     name: "join_group",
     description: "Join a group with an optional role. Other peers see your group membership in list_peers.",
@@ -47413,6 +47453,144 @@ var TOOLS = [
     description: "Get a complete overview of the mesh: peers, groups, state, memory, files, tasks, streams, tables. Call on session start for full situational awareness.",
     inputSchema: { type: "object", properties: {} }
   },
+  {
+    name: "mesh_stats",
+    description: "View resource usage stats for all peers: messages sent/received, tool calls, uptime, errors.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_mcp_register",
+    description: "Register an MCP server with the mesh. Other peers can invoke its tools through the mesh without restarting their sessions. Provide the server name, description, and full tool definitions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Unique name for the MCP server (e.g. 'github', 'jira')" },
+        description: { type: "string", description: "What this MCP server does" },
+        tools: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              inputSchema: { type: "object", description: "JSON Schema for tool arguments" }
+            },
+            required: ["name", "description", "inputSchema"]
+          },
+          description: "Tool definitions to expose"
+        }
+      },
+      required: ["server_name", "description", "tools"]
+    }
+  },
+  {
+    name: "mesh_mcp_list",
+    description: "List MCP servers available in the mesh with their tools. Shows which peer hosts each server.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_tool_call",
+    description: "Call a tool on a mesh-registered MCP server. Route: you -> broker -> hosting peer -> execute -> result back. Timeout: 30s.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Name of the MCP server" },
+        tool_name: { type: "string", description: "Name of the tool to call" },
+        args: { type: "object", description: "Tool arguments (JSON object)" }
+      },
+      required: ["server_name", "tool_name"]
+    }
+  },
+  {
+    name: "mesh_mcp_remove",
+    description: "Unregister an MCP server you previously registered with the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_name: { type: "string", description: "Name of the MCP server to remove" }
+      },
+      required: ["server_name"]
+    }
+  },
+  {
+    name: "mesh_set_clock",
+    description: "Set the simulation clock speed. x1 = real-time, x10 = 10x faster, x100 = 100x. Peers receive heartbeat ticks at the simulated rate.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        speed: {
+          type: "number",
+          description: "Speed multiplier (1-100). x1 = tick every 60s, x10 = tick every 6s, x100 = tick every 600ms."
+        }
+      },
+      required: ["speed"]
+    }
+  },
+  {
+    name: "mesh_pause_clock",
+    description: "Pause the simulation clock. Ticks stop until resumed.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_resume_clock",
+    description: "Resume a paused simulation clock.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "mesh_clock",
+    description: "Get current simulation clock status: speed, tick count, simulated time.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "share_skill",
+    description: "Publish a reusable skill to the mesh. Other peers can discover and load it. If a skill with the same name exists, it is updated.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Unique skill name (e.g. 'code-review', 'deploy-checklist')" },
+        description: { type: "string", description: "Short description of what the skill does" },
+        instructions: { type: "string", description: "Full instructions/prompt that a peer loads to acquire this capability" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for discoverability"
+        }
+      },
+      required: ["name", "description", "instructions"]
+    }
+  },
+  {
+    name: "get_skill",
+    description: "Load a skill's full instructions by name. Use to acquire capabilities shared by other peers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Skill name to load" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "list_skills",
+    description: "Browse available skills in the mesh. Optionally filter by keyword across name, description, and tags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search keyword (optional)" }
+      }
+    }
+  },
+  {
+    name: "remove_skill",
+    description: "Remove a skill you published from the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Skill name to remove" }
+      },
+      required: ["name"]
+    }
+  },
   {
     name: "ping_mesh",
     description: "Send test messages through the full pipeline and measure round-trip timing per priority. Diagnoses push delivery issues.",
@@ -47426,6 +47604,61 @@ var TOOLS = [
         }
       }
     }
+  },
+  {
+    name: "read_peer_file",
+    description: "Read a file from another peer's project. Specify the peer (by name) and the file path relative to their working directory. The peer must be online and sharing files. Max file size: 1MB.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        peer: { type: "string", description: "Peer display name or pubkey" },
+        path: { type: "string", description: "File path relative to peer's working directory" }
+      },
+      required: ["peer", "path"]
+    }
+  },
+  {
+    name: "list_peer_files",
+    description: "List files in a peer's shared directory. Returns a tree of file names (not contents). The peer must be online and sharing files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        peer: { type: "string", description: "Peer display name or pubkey" },
+        path: { type: "string", description: "Directory path relative to peer's cwd (default: root)" },
+        pattern: { type: "string", description: "Glob-like filter pattern (e.g. '*.ts', 'src/*')" }
+      },
+      required: ["peer"]
+    }
+  },
+  {
+    name: "create_webhook",
+    description: "Create an inbound webhook. Returns a URL that external services (GitHub, CI/CD, monitoring) can POST to — the payload becomes a mesh message to all peers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Webhook name (e.g. 'github-ci', 'datadog-alerts')"
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "list_webhooks",
+    description: "List active webhooks for this mesh.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "delete_webhook",
+    description: "Deactivate a webhook.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Webhook name to deactivate" }
+      },
+      required: ["name"]
+    }
   }
 ];
 
@@ -47511,10 +47744,21 @@ class BrokerClient {
   sessionPubkey = null;
   sessionSecretKey = null;
   grantFileAccessResolvers = new Map;
+  peerFileResponseResolvers = new Map;
+  peerDirResponseResolvers = new Map;
+  sharedDirs = [process.cwd()];
   closed = false;
   reconnectAttempt = 0;
   helloTimer = null;
   reconnectTimer = null;
+  _statsCounters = {
+    messagesIn: 0,
+    messagesOut: 0,
+    toolCalls: 0,
+    errors: 0
+  };
+  _sessionStartedAt = Date.now();
+  _statsReportTimer = null;
   constructor(mesh, opts = {}) {
     this.mesh = mesh;
     this.opts = opts;
@@ -47596,6 +47840,7 @@ class BrokerClient {
           this.setConnStatus("open");
           this.reconnectAttempt = 0;
           this.flushOutbound();
+          this.startStatsReporting();
           resolve();
           return;
         }
@@ -47635,6 +47880,7 @@ class BrokerClient {
       nonce = randomNonce();
       ciphertext = Buffer.from(message, "utf-8").toString("base64");
     }
+    this._statsCounters.messagesOut++;
     return new Promise((resolve) => {
       if (this.pendingSends.size >= MAX_QUEUED) {
         resolve({ ok: false, error: "outbound queue full" });
@@ -47692,6 +47938,16 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "set_status", status }));
   }
+  async setVisible(visible) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "set_visible", visible }));
+  }
+  async setProfile(profile) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "set_profile", ...profile }));
+  }
   async listPeers() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return [];
@@ -47709,6 +47965,34 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "set_summary", summary }));
   }
+  setStats(stats) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    const payload = stats ?? {
+      ...this._statsCounters,
+      uptime: Math.round((Date.now() - this._sessionStartedAt) / 1000)
+    };
+    this.ws.send(JSON.stringify({ type: "set_stats", stats: payload }));
+  }
+  incrementToolCalls() {
+    this._statsCounters.toolCalls++;
+  }
+  incrementErrors() {
+    this._statsCounters.errors++;
+  }
+  startStatsReporting() {
+    if (this._statsReportTimer)
+      return;
+    this._statsReportTimer = setInterval(() => {
+      this.setStats();
+    }, 60000);
+  }
+  stopStatsReporting() {
+    if (this._statsReportTimer) {
+      clearInterval(this._statsReportTimer);
+      this._statsReportTimer = null;
+    }
+  }
   async joinGroup(name, role) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return;
@@ -47841,6 +48125,10 @@ class BrokerClient {
   scheduledAckResolvers = new Map;
   scheduledListResolvers = new Map;
   cancelScheduledResolvers = new Map;
+  mcpRegisterResolvers = new Map;
+  mcpListResolvers = new Map;
+  mcpCallResolvers = new Map;
+  mcpCallForwardHandler = null;
   async messageStatus(messageId) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
@@ -48139,7 +48427,105 @@ class BrokerClient {
     this.stateChangeHandlers.add(handler);
     return () => this.stateChangeHandlers.delete(handler);
   }
+  async mcpRegister(serverName, description, tools) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.mcpRegisterResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.mcpRegisterResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mcp_register", serverName, description, tools, _reqId: reqId }));
+    });
+  }
+  async mcpUnregister(serverName) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "mcp_unregister", serverName }));
+  }
+  async mcpList() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.mcpListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.mcpListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "mcp_list", _reqId: reqId }));
+    });
+  }
+  async mcpCall(serverName, toolName, args) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return { error: "not connected" };
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.mcpCallResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.mcpCallResolvers.delete(reqId))
+          resolve({ error: "MCP call timed out (30s)" });
+      }, 30000) });
+      this.ws.send(JSON.stringify({ type: "mcp_call", serverName, toolName, args, _reqId: reqId }));
+    });
+  }
+  onMcpCallForward(handler) {
+    this.mcpCallForwardHandler = handler;
+  }
+  sendMcpCallResponse(callId, result, error2) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "mcp_call_response", callId, result, error: error2 }));
+  }
   meshInfoResolvers = new Map;
+  clockStatusResolvers = new Map;
+  async setClock(speed) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "set_clock", speed, _reqId: reqId }));
+    });
+  }
+  async pauseClock() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "pause_clock", _reqId: reqId }));
+    });
+  }
+  async resumeClock() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "resume_clock", _reqId: reqId }));
+    });
+  }
+  async getClock() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.clockStatusResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.clockStatusResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_clock", _reqId: reqId }));
+    });
+  }
   async meshInfo() {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
@@ -48152,8 +48538,132 @@ class BrokerClient {
       this.ws.send(JSON.stringify({ type: "mesh_info", _reqId: reqId }));
     });
   }
+  skillAckResolvers = new Map;
+  skillDataResolvers = new Map;
+  skillListResolvers = new Map;
+  async shareSkill(name, description, instructions, tags) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillAckResolvers.set(reqId, { resolve: (result) => {
+        resolve(result ? { ok: true, action: result.action } : null);
+      }, timer: setTimeout(() => {
+        if (this.skillAckResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "share_skill", name, description, instructions, tags, _reqId: reqId }));
+    });
+  }
+  async getSkill(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillDataResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.skillDataResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "get_skill", name, _reqId: reqId }));
+    });
+  }
+  async listSkills(query) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.skillListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_skills", query, _reqId: reqId }));
+    });
+  }
+  async removeSkill(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return false;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.skillAckResolvers.set(reqId, { resolve: (result) => {
+        resolve(result?.action === "removed");
+      }, timer: setTimeout(() => {
+        if (this.skillAckResolvers.delete(reqId))
+          resolve(false);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "remove_skill", name, _reqId: reqId }));
+    });
+  }
+  webhookAckResolvers = new Map;
+  webhookListResolvers = new Map;
+  async createWebhook(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.webhookAckResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.webhookAckResolvers.delete(reqId))
+          resolve(null);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "create_webhook", name, _reqId: reqId }));
+    });
+  }
+  async listWebhooks() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.webhookListResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.webhookListResolvers.delete(reqId))
+          resolve([]);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "list_webhooks", _reqId: reqId }));
+    });
+  }
+  async deleteWebhook(name) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return false;
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.webhookAckResolvers.set(reqId, { resolve: () => resolve(true), timer: setTimeout(() => {
+        if (this.webhookAckResolvers.delete(reqId))
+          resolve(false);
+      }, 5000) });
+      this.ws.send(JSON.stringify({ type: "delete_webhook", name, _reqId: reqId }));
+    });
+  }
+  setSharedDirs(dirs) {
+    this.sharedDirs = dirs.map((d) => {
+      const { resolve } = __require("node:path");
+      return resolve(d);
+    });
+  }
+  async requestFile(targetPubkey, filePath) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return { error: "not connected" };
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.peerFileResponseResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.peerFileResponseResolvers.delete(reqId))
+          resolve({ error: "timeout waiting for peer response" });
+      }, 15000) });
+      this.ws.send(JSON.stringify({ type: "peer_file_request", targetPubkey, filePath, _reqId: reqId }));
+    });
+  }
+  async requestDir(targetPubkey, dirPath, pattern) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return { error: "not connected" };
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.peerDirResponseResolvers.set(reqId, { resolve, timer: setTimeout(() => {
+        if (this.peerDirResponseResolvers.delete(reqId))
+          resolve({ error: "timeout waiting for peer response" });
+      }, 15000) });
+      this.ws.send(JSON.stringify({ type: "peer_dir_request", targetPubkey, dirPath, ...pattern ? { pattern } : {}, _reqId: reqId }));
+    });
+  }
   close() {
     this.closed = true;
+    this.stopStatsReporting();
     if (this.helloTimer)
       clearTimeout(this.helloTimer);
     if (this.reconnectTimer)
@@ -48165,6 +48675,141 @@ class BrokerClient {
     }
     this.setConnStatus("closed");
   }
+  static MAX_FILE_SIZE = 1048576;
+  async handlePeerFileRequest(msg) {
+    const { resolve, join: join2, normalize } = await import("node:path");
+    const { readFileSync: readFileSync2, statSync } = await import("node:fs");
+    const reqId = msg._reqId;
+    const sendResponse = (content, error2) => {
+      if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+        return;
+      this.ws.send(JSON.stringify({
+        type: "peer_file_response",
+        requesterPubkey: msg.requesterPubkey,
+        filePath: msg.filePath,
+        ...content !== undefined ? { content } : {},
+        ...error2 ? { error: error2 } : {},
+        ...reqId ? { _reqId: reqId } : {}
+      }));
+    };
+    if (msg.filePath.includes("..")) {
+      sendResponse(undefined, "path traversal not allowed");
+      return;
+    }
+    let resolvedPath = null;
+    for (const dir of this.sharedDirs) {
+      const candidate = resolve(join2(dir, msg.filePath));
+      const normalizedCandidate = normalize(candidate);
+      const normalizedDir = normalize(dir);
+      if (normalizedCandidate.startsWith(normalizedDir + "/") || normalizedCandidate === normalizedDir) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+    if (!resolvedPath) {
+      sendResponse(undefined, "file outside shared directories");
+      return;
+    }
+    try {
+      const stat = statSync(resolvedPath);
+      if (!stat.isFile()) {
+        sendResponse(undefined, "not a file");
+        return;
+      }
+      if (stat.size > BrokerClient.MAX_FILE_SIZE) {
+        sendResponse(undefined, `file too large (${stat.size} bytes, max ${BrokerClient.MAX_FILE_SIZE})`);
+        return;
+      }
+      const content = readFileSync2(resolvedPath);
+      sendResponse(content.toString("base64"));
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      if (errMsg.includes("ENOENT")) {
+        sendResponse(undefined, "file not found");
+      } else {
+        sendResponse(undefined, `read error: ${errMsg}`);
+      }
+    }
+  }
+  async handlePeerDirRequest(msg) {
+    const { resolve, join: join2, normalize, relative } = await import("node:path");
+    const { readdirSync, statSync } = await import("node:fs");
+    const reqId = msg._reqId;
+    const sendResponse = (entries, error2) => {
+      if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+        return;
+      this.ws.send(JSON.stringify({
+        type: "peer_dir_response",
+        requesterPubkey: msg.requesterPubkey,
+        dirPath: msg.dirPath,
+        ...entries ? { entries } : {},
+        ...error2 ? { error: error2 } : {},
+        ...reqId ? { _reqId: reqId } : {}
+      }));
+    };
+    const dirPath = msg.dirPath || ".";
+    if (dirPath.includes("..")) {
+      sendResponse(undefined, "path traversal not allowed");
+      return;
+    }
+    let resolvedPath = null;
+    for (const dir of this.sharedDirs) {
+      const candidate = resolve(join2(dir, dirPath));
+      const normalizedCandidate = normalize(candidate);
+      const normalizedDir = normalize(dir);
+      if (normalizedCandidate.startsWith(normalizedDir + "/") || normalizedCandidate === normalizedDir) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+    if (!resolvedPath) {
+      sendResponse(undefined, "directory outside shared directories");
+      return;
+    }
+    try {
+      const stat = statSync(resolvedPath);
+      if (!stat.isDirectory()) {
+        sendResponse(undefined, "not a directory");
+        return;
+      }
+      const entries = [];
+      const MAX_ENTRIES = 500;
+      const MAX_DEPTH = 2;
+      const pattern = msg.pattern ? new RegExp(msg.pattern.replace(/\*/g, ".*").replace(/\?/g, "."), "i") : null;
+      const walk = (dir, depth) => {
+        if (entries.length >= MAX_ENTRIES || depth > MAX_DEPTH)
+          return;
+        try {
+          const items = readdirSync(dir, { withFileTypes: true });
+          for (const item of items) {
+            if (entries.length >= MAX_ENTRIES)
+              break;
+            if (item.name.startsWith("."))
+              continue;
+            const relPath = relative(resolvedPath, join2(dir, item.name));
+            const label = item.isDirectory() ? relPath + "/" : relPath;
+            if (pattern && !pattern.test(item.name)) {
+              if (item.isDirectory())
+                walk(join2(dir, item.name), depth + 1);
+              continue;
+            }
+            entries.push(label);
+            if (item.isDirectory())
+              walk(join2(dir, item.name), depth + 1);
+          }
+        } catch {}
+      };
+      walk(resolvedPath, 0);
+      sendResponse(entries.sort());
+    } catch (e) {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      if (errMsg.includes("ENOENT")) {
+        sendResponse(undefined, "directory not found");
+      } else {
+        sendResponse(undefined, `read error: ${errMsg}`);
+      }
+    }
+  }
   resolveFromMap(map2, reqId, value) {
     let entry = reqId ? map2.get(reqId) : undefined;
     if (!entry) {
@@ -48202,6 +48847,7 @@ class BrokerClient {
       return;
     }
     if (msg.type === "push") {
+      this._statsCounters.messagesIn++;
       const nonce = String(msg.nonce ?? "");
       const ciphertext = String(msg.ciphertext ?? "");
       const senderPubkey = String(msg.senderPubkey ?? "");
@@ -48402,10 +49048,34 @@ class BrokerClient {
       }
       return;
     }
+    if (msg.type === "clock_status") {
+      this.resolveFromMap(this.clockStatusResolvers, msgReqId, {
+        speed: Number(msg.speed ?? 0),
+        paused: Boolean(msg.paused),
+        tick: Number(msg.tick ?? 0),
+        simTime: String(msg.simTime ?? ""),
+        startedAt: String(msg.startedAt ?? "")
+      });
+      return;
+    }
     if (msg.type === "mesh_info_result") {
       this.resolveFromMap(this.meshInfoResolvers, msgReqId, msg);
       return;
     }
+    if (msg.type === "skill_ack") {
+      this.resolveFromMap(this.skillAckResolvers, msgReqId, { name: String(msg.name ?? ""), action: String(msg.action ?? "") });
+      return;
+    }
+    if (msg.type === "skill_data") {
+      const skill = msg.skill;
+      this.resolveFromMap(this.skillDataResolvers, msgReqId, skill ?? null);
+      return;
+    }
+    if (msg.type === "skill_list") {
+      const skills = msg.skills ?? [];
+      this.resolveFromMap(this.skillListResolvers, msgReqId, skills);
+      return;
+    }
     if (msg.type === "scheduled_ack") {
       this.resolveFromMap(this.scheduledAckResolvers, msgReqId, {
         scheduledId: String(msg.scheduledId ?? ""),
@@ -48423,6 +49093,75 @@ class BrokerClient {
       this.resolveFromMap(this.cancelScheduledResolvers, msgReqId, Boolean(msg.ok));
       return;
     }
+    if (msg.type === "mcp_register_ack") {
+      this.resolveFromMap(this.mcpRegisterResolvers, msgReqId, {
+        serverName: String(msg.serverName ?? ""),
+        toolCount: Number(msg.toolCount ?? 0)
+      });
+      return;
+    }
+    if (msg.type === "mcp_list_result") {
+      const servers = msg.servers ?? [];
+      this.resolveFromMap(this.mcpListResolvers, msgReqId, servers);
+      return;
+    }
+    if (msg.type === "mcp_call_result") {
+      this.resolveFromMap(this.mcpCallResolvers, msgReqId, {
+        ...msg.result !== undefined ? { result: msg.result } : {},
+        ...msg.error ? { error: String(msg.error) } : {}
+      });
+      return;
+    }
+    if (msg.type === "mcp_call_forward") {
+      const forward = {
+        callId: String(msg.callId ?? ""),
+        serverName: String(msg.serverName ?? ""),
+        toolName: String(msg.toolName ?? ""),
+        args: msg.args ?? {},
+        callerName: String(msg.callerName ?? "")
+      };
+      if (this.mcpCallForwardHandler) {
+        this.mcpCallForwardHandler(forward).then((res) => this.sendMcpCallResponse(forward.callId, res.result, res.error)).catch((e) => this.sendMcpCallResponse(forward.callId, undefined, e instanceof Error ? e.message : String(e)));
+      } else {
+        this.sendMcpCallResponse(forward.callId, undefined, "No MCP call handler registered on this peer");
+      }
+      return;
+    }
+    if (msg.type === "peer_file_request_forward") {
+      this.handlePeerFileRequest(msg);
+      return;
+    }
+    if (msg.type === "peer_file_response_forward") {
+      this.resolveFromMap(this.peerFileResponseResolvers, msgReqId, {
+        content: msg.content ? String(msg.content) : undefined,
+        error: msg.error ? String(msg.error) : undefined
+      });
+      return;
+    }
+    if (msg.type === "peer_dir_request_forward") {
+      this.handlePeerDirRequest(msg);
+      return;
+    }
+    if (msg.type === "peer_dir_response_forward") {
+      this.resolveFromMap(this.peerDirResponseResolvers, msgReqId, {
+        entries: msg.entries ?? undefined,
+        error: msg.error ? String(msg.error) : undefined
+      });
+      return;
+    }
+    if (msg.type === "webhook_ack") {
+      this.resolveFromMap(this.webhookAckResolvers, msgReqId, {
+        name: String(msg.name ?? ""),
+        url: String(msg.url ?? ""),
+        secret: String(msg.secret ?? "")
+      });
+      return;
+    }
+    if (msg.type === "webhook_list") {
+      const webhooks = msg.webhooks ?? [];
+      this.resolveFromMap(this.webhookListResolvers, msgReqId, webhooks);
+      return;
+    }
     if (msg.type === "error") {
       this.debug(`broker error: ${msg.code} ${msg.message}`);
       const id = msg.id ? String(msg.id) : null;
@@ -48465,7 +49204,18 @@ class BrokerClient {
           [this.taskCreatedResolvers, null],
           [this.streamCreatedResolvers, null],
           [this.listPeersResolvers, []],
-          [this.meshInfoResolvers, null]
+          [this.meshInfoResolvers, null],
+          [this.clockStatusResolvers, null],
+          [this.mcpRegisterResolvers, null],
+          [this.mcpListResolvers, []],
+          [this.mcpCallResolvers, { error: "broker error" }],
+          [this.skillAckResolvers, null],
+          [this.skillDataResolvers, null],
+          [this.skillListResolvers, []],
+          [this.peerFileResponseResolvers, { error: "broker error" }],
+          [this.peerDirResponseResolvers, { error: "broker error" }],
+          [this.webhookAckResolvers, null],
+          [this.webhookListResolvers, []]
         ];
         for (const [map2, defaultVal] of allMaps) {
           const first = map2.entries().next().value;
@@ -48668,6 +49418,8 @@ If the channel meta contains \`subtype: reminder\`, this is a scheduled reminder
 | check_messages() | Drain buffered inbound messages (auto-pushed in most cases, use as fallback). |
 | set_summary(summary) | Set 1-2 sentence description of your current work, visible to all peers. |
 | set_status(status) | Override status: idle, working, or dnd. |
+| set_visible(visible) | Toggle visibility. Hidden peers skip list_peers and broadcasts; direct messages still arrive. |
+| set_profile(avatar?, title?, bio?, capabilities?) | Set public profile: emoji avatar, short title, bio, capabilities list. |
 | join_group(name, role?) | Join a @group with optional role (lead, member, observer, or any string). |
 | leave_group(name) | Leave a @group. |
 | set_state(key, value) | Write shared state; pushes change to all peers. |
@@ -48704,6 +49456,12 @@ If the channel meta contains \`subtype: reminder\`, this is a scheduled reminder
 | schedule_reminder(message, in_seconds?, deliver_at?, to?) | Schedule a reminder to yourself (no \`to\`) or a delayed message to a peer/group. Delivered as a push with \`subtype: reminder\` in the channel meta. |
 | list_scheduled() | List pending scheduled reminders and messages. |
 | cancel_scheduled(id) | Cancel a pending scheduled item. |
+| read_peer_file(peer, path) | Read a file from another peer's project (max 1MB). |
+| list_peer_files(peer, path?, pattern?) | List files in a peer's shared directory. |
+| mesh_mcp_register(server_name, description, tools) | Register an MCP server with the mesh. Other peers can call its tools. |
+| mesh_mcp_list() | List MCP servers available in the mesh with their tools. |
+| mesh_tool_call(server_name, tool_name, args?) | Call a tool on a mesh-registered MCP server (30s timeout). |
+| mesh_mcp_remove(server_name) | Unregister an MCP server you registered. |
 
 If multiple meshes are joined, prefix \`to\` with \`<mesh-slug>:\` to disambiguate (e.g. \`dev-team:Alice\`).
 
@@ -48767,6 +49525,9 @@ Your message mode is "${messageMode}".
   }));
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
+    for (const c of allClients()) {
+      c.incrementToolCalls();
+    }
     if (config2.meshes.length === 0) {
       return text("No meshes joined. Run `claudemesh join https://claudemesh.com/join/<token>` first.", true);
     }
@@ -48822,7 +49583,10 @@ No peers connected.`);
                 meta2.push(`model:${p.model}`);
               const metaStr = meta2.length ? ` {${meta2.join(", ")}}` : "";
               const cwdStr = p.cwd ? ` cwd:${p.cwd}` : "";
-              return `- **${p.displayName}** [${p.status}]${groupsStr}${metaStr} (${p.pubkey.slice(0, 12)}…)${cwdStr}${summary}`;
+              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}`;
             });
             sections.push(`${header}
 ${peerLines.join(`
@@ -48889,6 +49653,32 @@ ${drained.join(`
           await c.setStatus(s);
         return text(`Status set to ${s} across ${allClients().length} mesh(es).`);
       }
+      case "set_visible": {
+        const { visible } = args ?? {};
+        if (visible === undefined)
+          return text("set_visible: `visible` required", true);
+        for (const c of allClients())
+          await c.setVisible(visible);
+        return text(visible ? "You are now visible to peers." : "You are now hidden. Direct messages still reach you, but you won't appear in list_peers or receive broadcasts.");
+      }
+      case "set_profile": {
+        const { avatar, title, bio, capabilities } = args ?? {};
+        const profile = { avatar, title, bio, capabilities };
+        for (const c of allClients())
+          await c.setProfile(profile);
+        const parts = [];
+        if (avatar)
+          parts.push(`Avatar: ${avatar}`);
+        if (title)
+          parts.push(`Title: ${title}`);
+        if (bio)
+          parts.push(`Bio: ${bio}`);
+        if (capabilities?.length)
+          parts.push(`Capabilities: ${capabilities.join(", ")}`);
+        return text(parts.length > 0 ? `Profile updated:
+${parts.join(`
+`)}` : "Profile cleared.");
+      }
       case "join_group": {
         const { name: groupName, role } = args ?? {};
         if (!groupName)
@@ -49422,6 +50212,72 @@ ${rows.join(`
           return text("No active streams.");
         const lines = streams.map((s) => `- **${s.name}** (${s.id.slice(0, 8)}…) by ${s.createdBy}, ${s.subscriberCount} subscriber(s)`);
         return text(lines.join(`
+`));
+      }
+      case "mesh_set_clock": {
+        const { speed } = args ?? {};
+        if (!speed || speed < 1 || speed > 100)
+          return text("mesh_set_clock: speed must be 1-100", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_set_clock: not connected", true);
+        const result = await client2.setClock(speed);
+        if (!result)
+          return text("mesh_set_clock: timed out", true);
+        return text([
+          `**Clock set to x${result.speed}**`,
+          `Paused: ${result.paused}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`,
+          `Started at: ${result.startedAt}`
+        ].join(`
+`));
+      }
+      case "mesh_pause_clock": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_pause_clock: not connected", true);
+        const result = await client2.pauseClock();
+        if (!result)
+          return text("mesh_pause_clock: timed out", true);
+        return text([
+          "**Clock paused**",
+          `Speed: x${result.speed}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`
+        ].join(`
+`));
+      }
+      case "mesh_resume_clock": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_resume_clock: not connected", true);
+        const result = await client2.resumeClock();
+        if (!result)
+          return text("mesh_resume_clock: timed out", true);
+        return text([
+          "**Clock resumed**",
+          `Speed: x${result.speed}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`
+        ].join(`
+`));
+      }
+      case "mesh_clock": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_clock: not connected", true);
+        const result = await client2.getClock();
+        if (!result)
+          return text("mesh_clock: timed out", true);
+        const statusLabel = result.speed === 0 ? "not started" : result.paused ? "paused" : "running";
+        return text([
+          `**Clock status: ${statusLabel}**`,
+          `Speed: x${result.speed}`,
+          `Tick: ${result.tick}`,
+          `Sim time: ${result.simTime}`,
+          `Started at: ${result.startedAt}`
+        ].join(`
 `));
       }
       case "mesh_info": {
@@ -49447,6 +50303,89 @@ ${rows.join(`
         return text(lines.join(`
 `));
       }
+      case "mesh_stats": {
+        const clients2 = allClients();
+        if (clients2.length === 0)
+          return text("mesh_stats: no joined meshes", true);
+        const sections = [];
+        for (const c of clients2) {
+          const peers = await c.listPeers();
+          const header = `## ${c.meshSlug}`;
+          const rows = peers.map((p) => {
+            const s = p.stats;
+            if (!s)
+              return `| ${p.displayName} | - | - | - | - | - |`;
+            const up = s.uptime != null ? `${Math.floor(s.uptime / 60)}m` : "-";
+            return `| ${p.displayName} | ${s.messagesIn ?? 0} | ${s.messagesOut ?? 0} | ${s.toolCalls ?? 0} | ${up} | ${s.errors ?? 0} |`;
+          });
+          sections.push(`${header}
+| Peer | Msgs In | Msgs Out | Tool Calls | Uptime | Errors |
+|------|---------|----------|------------|--------|--------|
+${rows.join(`
+`)}`);
+        }
+        return text(sections.join(`
+
+`));
+      }
+      case "share_skill": {
+        const { name: skillName, description: skillDesc, instructions: skillInstr, tags: skillTags } = args ?? {};
+        if (!skillName || !skillDesc || !skillInstr)
+          return text("share_skill: `name`, `description`, and `instructions` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("share_skill: not connected", true);
+        const result = await client2.shareSkill(skillName, skillDesc, skillInstr, skillTags);
+        if (!result)
+          return text("share_skill: broker did not acknowledge", true);
+        return text(`Skill "${skillName}" published to the mesh.`);
+      }
+      case "get_skill": {
+        const { name: gsName } = args ?? {};
+        if (!gsName)
+          return text("get_skill: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("get_skill: not connected", true);
+        const skill = await client2.getSkill(gsName);
+        if (!skill)
+          return text(`Skill "${gsName}" not found in the mesh.`);
+        return text(`# Skill: ${skill.name}
+
+**Description:** ${skill.description}
+**Author:** ${skill.author}
+**Tags:** ${skill.tags.length ? skill.tags.join(", ") : "none"}
+**Created:** ${skill.createdAt}
+
+---
+
+## Instructions
+
+${skill.instructions}`);
+      }
+      case "list_skills": {
+        const { query: skillQuery } = args ?? {};
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("list_skills: not connected", true);
+        const skills = await client2.listSkills(skillQuery);
+        if (skills.length === 0)
+          return text(skillQuery ? `No skills found for "${skillQuery}".` : "No skills in the mesh yet.");
+        const lines = skills.map((s) => `- **${s.name}**: ${s.description}${s.tags.length ? ` [${s.tags.join(", ")}]` : ""} (by ${s.author})`);
+        return text(`${skills.length} skill(s):
+${lines.join(`
+`)}`);
+      }
+      case "remove_skill": {
+        const { name: rsName } = args ?? {};
+        if (!rsName)
+          return text("remove_skill: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("remove_skill: not connected", true);
+        const removed = await client2.removeSkill(rsName);
+        return text(removed ? `Skill "${rsName}" removed.` : `Skill "${rsName}" not found.`, !removed);
+      }
       case "ping_mesh": {
         const { priorities: pingPriorities } = args ?? {};
         const toTest = pingPriorities ?? ["now", "next"];
@@ -49483,6 +50422,57 @@ ${rows.join(`
         return text(results.join(`
 `));
       }
+      case "mesh_mcp_register": {
+        const { server_name, description, tools: regTools } = 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);
+        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.`);
+      }
+      case "mesh_mcp_list": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_list: not connected", true);
+        const servers = await client2.mcpList();
+        if (servers.length === 0)
+          return text("No MCP servers registered in the mesh.");
+        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}
+${toolList}`;
+        });
+        return text(`${servers.length} MCP server(s) in mesh:
+${lines.join(`
+`)}`);
+      }
+      case "mesh_tool_call": {
+        const { server_name: callServer, tool_name: callTool, args: callArgs } = args ?? {};
+        if (!callServer || !callTool)
+          return text("mesh_tool_call: `server_name` and `tool_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_tool_call: not connected", true);
+        const callResult = await client2.mcpCall(callServer, callTool, callArgs ?? {});
+        if (callResult.error)
+          return text(`mesh_tool_call error: ${callResult.error}`, true);
+        return text(typeof callResult.result === "string" ? callResult.result : JSON.stringify(callResult.result, null, 2));
+      }
+      case "mesh_mcp_remove": {
+        const { server_name: rmServer } = args ?? {};
+        if (!rmServer)
+          return text("mesh_mcp_remove: `server_name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("mesh_mcp_remove: not connected", true);
+        await client2.mcpUnregister(rmServer);
+        return text(`Unregistered MCP server "${rmServer}" from the mesh.`);
+      }
       case "grant_file_access": {
         const { fileId, to: grantTo } = args ?? {};
         if (!fileId || !grantTo)
@@ -49515,6 +50505,117 @@ ${rows.join(`
           return text("grant_file_access: broker did not confirm", true);
         return text(`Access granted: ${targetPeer.displayName} can now download file ${fileId}`);
       }
+      case "read_peer_file": {
+        const { peer: peerName, path: filePath } = args ?? {};
+        if (!peerName || !filePath)
+          return text("read_peer_file: `peer` and `path` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("read_peer_file: not connected", true);
+        const peers = await client2.listPeers();
+        const nameLower = peerName.toLowerCase();
+        let targetPubkey = null;
+        if (/^[0-9a-f]{64}$/.test(peerName)) {
+          targetPubkey = peerName;
+        } else {
+          const match = peers.find((p) => p.displayName.toLowerCase() === nameLower);
+          if (!match) {
+            const partials = peers.filter((p) => p.displayName.toLowerCase().includes(nameLower));
+            if (partials.length === 1) {
+              targetPubkey = partials[0].pubkey;
+            } else {
+              const names = peers.map((p) => p.displayName).join(", ");
+              return text(`read_peer_file: peer "${peerName}" not found. Online: ${names || "(none)"}`, true);
+            }
+          } else {
+            targetPubkey = match.pubkey;
+          }
+        }
+        const result = await client2.requestFile(targetPubkey, filePath);
+        if (result.error)
+          return text(`read_peer_file: ${result.error}`, true);
+        if (!result.content)
+          return text("read_peer_file: empty response from peer", true);
+        try {
+          const decoded = Buffer.from(result.content, "base64").toString("utf-8");
+          return text(decoded);
+        } catch {
+          return text("read_peer_file: failed to decode file content (binary file?)", true);
+        }
+      }
+      case "list_peer_files": {
+        const { peer: peerName, path: dirPath, pattern } = args ?? {};
+        if (!peerName)
+          return text("list_peer_files: `peer` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("list_peer_files: not connected", true);
+        const peers = await client2.listPeers();
+        const nameLower = peerName.toLowerCase();
+        let targetPubkey = null;
+        if (/^[0-9a-f]{64}$/.test(peerName)) {
+          targetPubkey = peerName;
+        } else {
+          const match = peers.find((p) => p.displayName.toLowerCase() === nameLower);
+          if (!match) {
+            const partials = peers.filter((p) => p.displayName.toLowerCase().includes(nameLower));
+            if (partials.length === 1) {
+              targetPubkey = partials[0].pubkey;
+            } else {
+              const names = peers.map((p) => p.displayName).join(", ");
+              return text(`list_peer_files: peer "${peerName}" not found. Online: ${names || "(none)"}`, true);
+            }
+          } else {
+            targetPubkey = match.pubkey;
+          }
+        }
+        const result = await client2.requestDir(targetPubkey, dirPath ?? ".", pattern);
+        if (result.error)
+          return text(`list_peer_files: ${result.error}`, true);
+        if (!result.entries || result.entries.length === 0)
+          return text("No files found.");
+        return text(result.entries.join(`
+`));
+      }
+      case "create_webhook": {
+        const { name: whName } = args ?? {};
+        if (!whName)
+          return text("create_webhook: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("create_webhook: not connected", true);
+        const wh = await client2.createWebhook(whName);
+        if (!wh)
+          return text("create_webhook: broker did not acknowledge — check connection", true);
+        return text(`Webhook **${wh.name}** created.
+
+URL: ${wh.url}
+Secret: ${wh.secret}
+
+External services can POST JSON to this URL. The payload will be pushed to all connected mesh peers.`);
+      }
+      case "list_webhooks": {
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("list_webhooks: not connected", true);
+        const webhooks = await client2.listWebhooks();
+        if (webhooks.length === 0)
+          return text("No active webhooks.");
+        const lines = webhooks.map((w) => `- **${w.name}** — ${w.url} (created ${w.createdAt})`);
+        return text(`${webhooks.length} webhook(s):
+${lines.join(`
+`)}`);
+      }
+      case "delete_webhook": {
+        const { name: delName } = args ?? {};
+        if (!delName)
+          return text("delete_webhook: `name` required", true);
+        const client2 = allClients()[0];
+        if (!client2)
+          return text("delete_webhook: not connected", true);
+        const ok = await client2.deleteWebhook(delName);
+        return text(ok ? `Webhook "${delName}" deactivated.` : `Failed to deactivate webhook "${delName}".`, !ok);
+      }
       default:
         return text(`Unknown tool: ${name}`, true);
     }
@@ -49530,7 +50631,12 @@ ${rows.join(`
         const eventName = msg.event;
         const data = msg.eventData ?? {};
         let content2;
-        if (eventName === "peer_joined") {
+        if (eventName === "tick") {
+          const tick = data.tick ?? 0;
+          const simTime = String(data.simTime ?? "").replace("T", " ").replace(/\..*/, "");
+          const speed = data.speed ?? 1;
+          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_left") {
           content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
@@ -49657,6 +50763,7 @@ ${rows.join(`
 }
 
 // src/commands/install.ts
+init_config();
 import {
   chmodSync as chmodSync2,
   copyFileSync,
@@ -49957,10 +51064,22 @@ function runInstall(args = []) {
   } else {
     console.log(dim("· Hooks skipped (--no-hooks)"));
   }
+  let hasMeshes = false;
+  try {
+    const meshConfig = loadConfig();
+    hasMeshes = meshConfig.meshes.length > 0;
+  } catch {}
   console.log("");
   console.log(yellow(bold2("⚠  RESTART CLAUDE CODE")) + yellow(" for MCP tools to appear."));
-  console.log("");
-  console.log(`Next: ${bold2("claudemesh join https://claudemesh.com/join/<token>")}`);
+  if (!hasMeshes) {
+    console.log("");
+    console.log(yellow("No meshes joined.") + " To connect with peers:");
+    console.log(`  ${bold2("claudemesh join <invite-url>")}` + dim("   — join an existing mesh"));
+    console.log(`  ${dim("Create one at")} ${bold2("https://claudemesh.com/dashboard")}`);
+  } else {
+    console.log("");
+    console.log(`Next: ${bold2("claudemesh join https://claudemesh.com/join/<token>")}`);
+  }
   console.log("");
   console.log(yellow("⚠  For real-time push messages from peers, launch with:"));
   console.log(`     ${bold2("claudemesh launch")}` + dim("    (or: claude --dangerously-load-development-channels server:claudemesh)"));
@@ -50620,7 +51739,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.6.9",
+  version: "0.7.0",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudemesh-cli",
-  "version": "0.6.9",
+  "version": "0.7.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/eslint-config": "0.1.0",
-    "@turbostarter/prettier-config": "0.1.0",
     "@turbostarter/tsconfig": "0.1.0",
-    "@turbostarter/vitest-config": "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",