claudemesh-cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -46250,8 +46250,11 @@ var TOOLS = [
       type: "object",
       properties: {
         to: {
-          type: "string",
-          description: "Peer name, pubkey, @group, or #channel"
+          oneOf: [
+            { type: "string", description: "Peer name, pubkey, @group" },
+            { type: "array", items: { type: "string" }, description: "Multiple targets" }
+          ],
+          description: "Single target or array of targets"
         },
         message: { type: "string", description: "Message text" },
         priority: {
@@ -46276,6 +46279,20 @@ var TOOLS = [
       }
     }
   },
+  {
+    name: "message_status",
+    description: "Check the delivery status of a sent message. Shows whether each recipient received it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Message ID (returned by send_message)"
+        }
+      },
+      required: ["id"]
+    }
+  },
   {
     name: "check_messages",
     description: "Pull any undelivered messages from the broker. Normally messages arrive via push; use this to drain the queue after being offline.",
@@ -46332,6 +46349,143 @@ var TOOLS = [
       },
       required: ["name"]
     }
+  },
+  {
+    name: "set_state",
+    description: "Set a shared state value visible to all peers in the mesh. Pushes a change notification.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string" },
+        value: { description: "Any JSON value" }
+      },
+      required: ["key", "value"]
+    }
+  },
+  {
+    name: "get_state",
+    description: "Read a shared state value.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string" }
+      },
+      required: ["key"]
+    }
+  },
+  {
+    name: "list_state",
+    description: "List all shared state keys and values in the mesh.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "remember",
+    description: "Store persistent knowledge in the mesh's shared memory. Survives across sessions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The knowledge to remember"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional categorization tags"
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "recall",
+    description: "Search the mesh's shared memory by relevance.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "forget",
+    description: "Remove a memory from the mesh's shared knowledge.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Memory ID to forget" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "share_file",
+    description: "Share a persistent file with the mesh. All current and future peers can access it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Local file path to share" },
+        name: {
+          type: "string",
+          description: "Display name (defaults to filename)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "get_file",
+    description: "Download a shared file to a local path.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "File ID" },
+        save_to: {
+          type: "string",
+          description: "Local path to save the file"
+        }
+      },
+      required: ["id", "save_to"]
+    }
+  },
+  {
+    name: "list_files",
+    description: "List files shared in the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search by name or tags" },
+        from: { type: "string", description: "Filter by uploader name" }
+      }
+    }
+  },
+  {
+    name: "file_status",
+    description: "Check who has accessed a shared file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "File ID" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "delete_file",
+    description: "Remove a shared file from the mesh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "File ID" }
+      },
+      required: ["id"]
+    }
   }
 ];
 
@@ -46425,6 +46579,11 @@ class BrokerClient {
   pushHandlers = new Set;
   pushBuffer = [];
   listPeersResolvers = [];
+  stateResolvers = [];
+  stateListResolvers = [];
+  memoryStoreResolvers = [];
+  memoryRecallResolvers = [];
+  stateChangeHandlers = new Set;
   sessionPubkey = null;
   sessionSecretKey = null;
   closed = false;
@@ -46626,6 +46785,172 @@ class BrokerClient {
       return;
     this.ws.send(JSON.stringify({ type: "leave_group", name }));
   }
+  async setState(key, value) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "set_state", key, value }));
+  }
+  async getState(key) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.stateResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "get_state", key }));
+      setTimeout(() => {
+        const idx = this.stateResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.stateResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async listState() {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.stateListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_state" }));
+      setTimeout(() => {
+        const idx = this.stateListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.stateListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async remember(content, tags) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.memoryStoreResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "remember", content, tags }));
+      setTimeout(() => {
+        const idx = this.memoryStoreResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.memoryStoreResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async recall(query) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.memoryRecallResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "recall", query }));
+      setTimeout(() => {
+        const idx = this.memoryRecallResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.memoryRecallResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async forget(memoryId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "forget", memoryId }));
+  }
+  messageStatusResolvers = [];
+  fileUrlResolvers = [];
+  fileListResolvers = [];
+  fileStatusResolvers = [];
+  async messageStatus(messageId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.messageStatusResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "message_status", messageId }));
+      setTimeout(() => {
+        const idx = this.messageStatusResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.messageStatusResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async getFile(fileId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return null;
+    return new Promise((resolve) => {
+      this.fileUrlResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "get_file", fileId }));
+      setTimeout(() => {
+        const idx = this.fileUrlResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.fileUrlResolvers.splice(idx, 1);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+  async listFiles(query, from) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.fileListResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "list_files", query, from }));
+      setTimeout(() => {
+        const idx = this.fileListResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.fileListResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async fileStatus(fileId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return [];
+    return new Promise((resolve) => {
+      this.fileStatusResolvers.push(resolve);
+      this.ws.send(JSON.stringify({ type: "file_status", fileId }));
+      setTimeout(() => {
+        const idx = this.fileStatusResolvers.indexOf(resolve);
+        if (idx !== -1) {
+          this.fileStatusResolvers.splice(idx, 1);
+          resolve([]);
+        }
+      }, 5000);
+    });
+  }
+  async deleteFile(fileId) {
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
+      return;
+    this.ws.send(JSON.stringify({ type: "delete_file", fileId }));
+  }
+  async uploadFile(filePath, meshId, memberId, opts) {
+    const { readFileSync: readFileSync2 } = await import("node:fs");
+    const { basename } = await import("node:path");
+    const data = readFileSync2(filePath);
+    const fileName = opts.name ?? basename(filePath);
+    const brokerHttp = this.mesh.brokerUrl.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
+    const res = await fetch(`${brokerHttp}/upload`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "X-Mesh-Id": meshId,
+        "X-Member-Id": memberId,
+        "X-File-Name": fileName,
+        "X-Tags": JSON.stringify(opts.tags ?? []),
+        "X-Persistent": String(opts.persistent ?? true),
+        "X-Target-Spec": opts.targetSpec ?? ""
+      },
+      body: data,
+      signal: AbortSignal.timeout(30000)
+    });
+    const body = await res.json();
+    return body.fileId ?? null;
+  }
+  onStateChange(handler) {
+    this.stateChangeHandlers.add(handler);
+    return () => this.stateChangeHandlers.delete(handler);
+  }
   close() {
     this.closed = true;
     if (this.helloTimer)
@@ -46708,6 +47033,86 @@ class BrokerClient {
       })();
       return;
     }
+    if (msg.type === "state_result") {
+      const resolver = this.stateResolvers.shift();
+      if (resolver) {
+        if (msg.key) {
+          resolver({
+            key: String(msg.key),
+            value: msg.value,
+            updatedBy: String(msg.updatedBy ?? ""),
+            updatedAt: String(msg.updatedAt ?? "")
+          });
+        } else {
+          resolver(null);
+        }
+      }
+      return;
+    }
+    if (msg.type === "state_list") {
+      const entries = msg.entries ?? [];
+      const resolver = this.stateListResolvers.shift();
+      if (resolver)
+        resolver(entries);
+      return;
+    }
+    if (msg.type === "state_change") {
+      const change = {
+        key: String(msg.key ?? ""),
+        value: msg.value,
+        updatedBy: String(msg.updatedBy ?? "")
+      };
+      for (const h of this.stateChangeHandlers) {
+        try {
+          h(change);
+        } catch {}
+      }
+      return;
+    }
+    if (msg.type === "memory_stored") {
+      const resolver = this.memoryStoreResolvers.shift();
+      if (resolver)
+        resolver(msg.id ? String(msg.id) : null);
+      return;
+    }
+    if (msg.type === "memory_results") {
+      const memories = msg.memories ?? [];
+      const resolver = this.memoryRecallResolvers.shift();
+      if (resolver)
+        resolver(memories);
+      return;
+    }
+    if (msg.type === "message_status_result") {
+      const resolver = this.messageStatusResolvers.shift();
+      if (resolver)
+        resolver(msg);
+      return;
+    }
+    if (msg.type === "file_url") {
+      const resolver = this.fileUrlResolvers.shift();
+      if (resolver) {
+        if (msg.url) {
+          resolver({ url: String(msg.url), name: String(msg.name ?? "") });
+        } else {
+          resolver(null);
+        }
+      }
+      return;
+    }
+    if (msg.type === "file_list") {
+      const files = msg.files ?? [];
+      const resolver = this.fileListResolvers.shift();
+      if (resolver)
+        resolver(files);
+      return;
+    }
+    if (msg.type === "file_status_result") {
+      const accesses = msg.accesses ?? [];
+      const resolver = this.fileStatusResolvers.shift();
+      if (resolver)
+        resolver(accesses);
+      return;
+    }
     if (msg.type === "error") {
       this.debug(`broker error: ${msg.code} ${msg.message}`);
       const id = msg.id ? String(msg.id) : null;
@@ -46879,32 +47284,73 @@ ${body}`;
 }
 async function startMcpServer() {
   const config2 = loadConfig();
-  const server = new Server({ name: "claudemesh", version: "0.1.4" }, {
+  const myName = config2.displayName ?? "unnamed";
+  const myGroups = (config2.groups ?? []).map((g) => `@${g.name}${g.role ? ":" + g.role : ""}`).join(", ") || "none";
+  const server = new Server({ name: "claudemesh", version: "0.3.0" }, {
     capabilities: {
       experimental: { "claude/channel": {} },
       tools: {}
     },
-    instructions: `You are connected to claudemesh — a peer mesh for Claude Code sessions on this machine and elsewhere.
+    instructions: `## Identity
+You are "${myName}" — a peer in the claudemesh network. Your groups: ${myGroups}. You are one of several Claude Code sessions connected to the same mesh. No orchestrator exists — peers are equals. Your identity comes from your name and group roles, not from a central authority.
 
-IMPORTANT: When you receive a <channel source="claudemesh" ...> message, RESPOND IMMEDIATELY. Do not wait until your current task is finished. Pause what you are doing, reply to the message using send_message, then resume your work. Treat incoming peer messages like a coworker tapping you on the shoulder — answer right away, even if you're in the middle of something.
+## Responding to messages
+When you receive a <channel source="claudemesh" ...> message, RESPOND IMMEDIATELY. Pause your current task, reply via send_message, then resume. Read from_name, mesh_slug, and priority from the channel attributes. Reply by setting \`to\` to the sender's from_name (display name). Stay in character per your system prompt. Do not ignore low-priority messages — acknowledge them briefly even if you defer action.
 
-Read the from_id, from_name, mesh_slug, and priority attributes to understand context. Reply by calling send_message with to set to the from_name (display name) of the sender. The \`to\` field can be a peer name, pubkey, @group, or * for broadcast.
+## Tools
+| Tool | Description |
+|------|-------------|
+| send_message(to, message, priority?) | Send to peer name, @group, or * broadcast. \`to\` accepts display name, pubkey hex, @groupname, or *. |
+| list_peers(mesh_slug?) | List connected peers with status, summary, groups, and roles. |
+| 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. |
+| 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. |
+| get_state(key) | Read a shared state value. |
+| list_state() | List all state keys with values, authors, and timestamps. |
+| remember(content, tags?) | Store persistent knowledge with optional tags. |
+| recall(query) | Full-text search over mesh memory. |
+| forget(id) | Soft-delete a memory entry. |
+| share_file(path, name?, tags?) | Share a persistent file with the mesh. |
+| get_file(id, save_to) | Download a shared file to a local path. |
+| list_files(query?, from?) | Find files shared in the mesh. |
+| file_status(id) | Check who has accessed a file. |
+| delete_file(id) | Remove a shared file from the mesh. |
 
-Available tools:
-- list_peers: see joined meshes + their connection status
-- send_message: send to a peer by display name, pubkey, @group, #channel, or * broadcast (priority: now/next/low)
-- check_messages: drain buffered inbound messages (usually auto-pushed)
-- set_summary: 1-2 sentence summary of what you're working on
-- set_status: manually override your status (idle/working/dnd)
-- join_group: join a @group with optional role
-- leave_group: leave a @group
+If multiple meshes are joined, prefix \`to\` with \`<mesh-slug>:\` to disambiguate (e.g. \`dev-team:Alice\`).
 
-Message priority:
-- "now": delivered immediately regardless of recipient status (use sparingly)
-- "next" (default): delivered when recipient is idle
-- "low": pull-only (check_messages)
+Multi-target: send_message accepts an array of targets for the 'to' field.
+  send_message(to: ["Alice", "@backend"], message: "sprint starts")
+Targets are deduplicated — each peer receives the message once.
 
-If you have multiple joined meshes, prefix the \`to\` argument of send_message with \`<mesh-slug>:\` to disambiguate. Otherwise claudemesh picks the single joined mesh.`
+Targeted views: when different audiences need different details about the same event,
+send tailored messages instead of one generic broadcast:
+  send_message(to: "@frontend", message: "Auth v2: useAuth hook changed, see src/auth/")
+  send_message(to: "@backend", message: "Auth v2: new /api/auth/v2 endpoints, v1 deprecated")
+  send_message(to: "@pm", message: "Auth v2 done. 3 points, no blockers.")
+
+## Groups
+Groups are routing labels. Send to @groupname to multicast to all members. Roles are metadata that peers interpret: a "lead" gathers input before synthesizing a response, a "member" contributes when asked, an "observer" watches silently. Join and leave groups dynamically with join_group/leave_group. Check list_peers to see who belongs to which groups and their roles.
+
+## State
+Shared key-value store scoped to the mesh. Use get_state/set_state for live coordination facts (deploy frozen? current sprint? PR queue). set_state pushes the change to all connected peers. Read state before asking peers questions — the answer may already be there. State is operational, not archival.
+
+## 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.
+
+## Priority
+- "now": interrupt immediately, even if recipient is in DND (use for urgent: broken deploy, blocking issue)
+- "next" (default): deliver when recipient goes idle (normal coordination)
+- "low": pull-only via check_messages (FYI, non-blocking context)
+
+## Coordination
+Call list_peers at session start to understand who is online, their roles, and what they are working on. If you are a group lead, gather input from members before responding to external requests — do not answer alone. If you are a member, contribute to your lead when asked. Use @group messages for team-wide questions, direct messages for 1:1 coordination. Set a meaningful summary so peers know your current focus.`
   });
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS
@@ -46919,13 +47365,27 @@ If you have multiple joined meshes, prefix the \`to\` argument of send_message w
         const { to, message, priority } = args ?? {};
         if (!to || !message)
           return text("send_message: `to` and `message` required", true);
-        const { client, targetSpec, error: error2 } = await resolveClient(to);
-        if (!client)
-          return text(`send_message: ${error2 ?? "no client resolved"}`, true);
-        const result = await client.send(targetSpec, message, priority ?? "next");
-        if (!result.ok)
-          return text(`send_message failed (${client.meshSlug}): ${result.error}`, true);
-        return text(`Sent to ${targetSpec} via ${client.meshSlug} [${priority ?? "next"}] → ${result.messageId}`);
+        const targets = Array.isArray(to) ? to : [to];
+        const results = [];
+        const seen = new Set;
+        for (const target of targets) {
+          const { client, targetSpec, error: error2 } = await resolveClient(target);
+          if (!client) {
+            results.push(`✗ ${target}: ${error2 ?? "no client resolved"}`);
+            continue;
+          }
+          if (seen.has(targetSpec))
+            continue;
+          seen.add(targetSpec);
+          const result = await client.send(targetSpec, message, priority ?? "next");
+          if (!result.ok) {
+            results.push(`✗ ${target}: ${result.error}`);
+          } else {
+            results.push(`✓ ${target} → ${result.messageId}`);
+          }
+        }
+        return text(results.join(`
+`));
       }
       case "list_peers": {
         const { mesh_slug } = args ?? {};
@@ -46953,6 +47413,23 @@ ${peerLines.join(`
         return text(sections.join(`
 
 `));
+      }
+      case "message_status": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("message_status: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("message_status: not connected", true);
+        const result = await client.messageStatus(id);
+        if (!result)
+          return text(`Message ${id} not found or timed out.`);
+        const recipientLines = result.recipients.map((r) => `  - ${r.name} (${r.pubkey.slice(0, 12)}…): ${r.status}`);
+        return text(`Message ${id.slice(0, 12)}… → ${result.targetSpec}
+` + `Delivered: ${result.delivered}${result.deliveredAt ? ` at ${result.deliveredAt}` : ""}
+` + `Recipients:
+${recipientLines.join(`
+`)}`);
       }
       case "check_messages": {
         const drained = [];
@@ -47004,6 +47481,147 @@ ${drained.join(`
           await c.leaveGroup(groupName);
         return text(`Left @${groupName}`);
       }
+      case "set_state": {
+        const { key, value } = args ?? {};
+        if (!key)
+          return text("set_state: `key` required", true);
+        for (const c of allClients())
+          await c.setState(key, value);
+        return text(`State set: ${key} = ${JSON.stringify(value)}`);
+      }
+      case "get_state": {
+        const { key } = args ?? {};
+        if (!key)
+          return text("get_state: `key` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("get_state: not connected", true);
+        const result = await client.getState(key);
+        if (!result)
+          return text(`State "${key}" not found.`);
+        return text(`${key} = ${JSON.stringify(result.value)} (set by ${result.updatedBy} at ${result.updatedAt})`);
+      }
+      case "list_state": {
+        const client = allClients()[0];
+        if (!client)
+          return text("list_state: not connected", true);
+        const entries = await client.listState();
+        if (entries.length === 0)
+          return text("No shared state set.");
+        const lines = entries.map((e) => `- **${e.key}** = ${JSON.stringify(e.value)} (by ${e.updatedBy})`);
+        return text(lines.join(`
+`));
+      }
+      case "remember": {
+        const { content, tags } = args ?? {};
+        if (!content)
+          return text("remember: `content` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("remember: not connected", true);
+        const id = await client.remember(content, tags);
+        return text(`Remembered${id ? ` (${id})` : ""}: "${content.slice(0, 80)}${content.length > 80 ? "..." : ""}"`);
+      }
+      case "recall": {
+        const { query } = args ?? {};
+        if (!query)
+          return text("recall: `query` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("recall: not connected", true);
+        const memories = await client.recall(query);
+        if (memories.length === 0)
+          return text(`No memories found for "${query}".`);
+        const lines = memories.map((m) => `- [${m.id.slice(0, 8)}] ${m.content} (by ${m.rememberedBy}, ${m.rememberedAt})`);
+        return text(`${memories.length} memor${memories.length === 1 ? "y" : "ies"}:
+${lines.join(`
+`)}`);
+      }
+      case "forget": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("forget: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("forget: not connected", true);
+        await client.forget(id);
+        return text(`Forgotten: ${id}`);
+      }
+      case "share_file": {
+        const { path: filePath, name: fileName, tags } = args ?? {};
+        if (!filePath)
+          return text("share_file: `path` required", true);
+        const { existsSync: existsSync2 } = await import("node:fs");
+        if (!existsSync2(filePath))
+          return text(`share_file: file not found: ${filePath}`, true);
+        const client = allClients()[0];
+        if (!client)
+          return text("share_file: not connected", true);
+        const fileId = await client.uploadFile(filePath, client.meshId, client.meshSlug, {
+          name: fileName,
+          tags,
+          persistent: true
+        });
+        if (!fileId)
+          return text("share_file: upload failed", true);
+        return text(`Shared: ${fileName ?? filePath} (${fileId})`);
+      }
+      case "get_file": {
+        const { id, save_to } = args ?? {};
+        if (!id || !save_to)
+          return text("get_file: `id` and `save_to` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("get_file: not connected", true);
+        const result = await client.getFile(id);
+        if (!result)
+          return text(`get_file: file ${id} not found`, true);
+        const res = await fetch(result.url, { signal: AbortSignal.timeout(30000) });
+        if (!res.ok)
+          return text(`get_file: download failed (${res.status})`, true);
+        const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("node:fs");
+        const { dirname: dirname2 } = await import("node:path");
+        mkdirSync2(dirname2(save_to), { recursive: true });
+        writeFileSync2(save_to, Buffer.from(await res.arrayBuffer()));
+        return text(`Downloaded: ${result.name} → ${save_to}`);
+      }
+      case "list_files": {
+        const { query, from } = args ?? {};
+        const client = allClients()[0];
+        if (!client)
+          return text("list_files: not connected", true);
+        const files = await client.listFiles(query, from);
+        if (files.length === 0)
+          return text("No files found.");
+        const lines = files.map((f) => `- **${f.name}** (${f.id.slice(0, 8)}…, ${f.size} bytes) by ${f.uploadedBy}${f.tags.length ? ` [${f.tags.join(", ")}]` : ""}`);
+        return text(lines.join(`
+`));
+      }
+      case "file_status": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("file_status: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("file_status: not connected", true);
+        const accesses = await client.fileStatus(id);
+        if (accesses.length === 0)
+          return text("No one has accessed this file yet.");
+        const lines = accesses.map((a) => `- ${a.peerName} at ${a.accessedAt}`);
+        return text(`Accessed by:
+${lines.join(`
+`)}`);
+      }
+      case "delete_file": {
+        const { id } = args ?? {};
+        if (!id)
+          return text("delete_file: `id` required", true);
+        const client = allClients()[0];
+        if (!client)
+          return text("delete_file: not connected", true);
+        await client.deleteFile(id);
+        return text(`Deleted: ${id}`);
+      }
       default:
         return text(`Unknown tool: ${name}`, true);
     }
@@ -47035,6 +47653,21 @@ ${drained.join(`
         });
       } catch {}
     });
+    client.onStateChange(async (change) => {
+      try {
+        await server.notification({
+          method: "notifications/claude/channel",
+          params: {
+            content: `[state] ${change.key} = ${JSON.stringify(change.value)} (set by ${change.updatedBy})`,
+            meta: {
+              kind: "state_change",
+              key: change.key,
+              updated_by: change.updatedBy
+            }
+          }
+        });
+      } catch {}
+    });
   }
   const shutdown = () => {
     stopAll();
@@ -47920,7 +48553,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.2.0",
+  version: "0.4.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.2.0",
+  "version": "0.4.0",
   "description": "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   "keywords": [
     "claude-code",