claudemesh-cli 1.0.3 → 1.2.0

package/dist/entrypoints/mcp.js

@@ -3337,6 +3337,197 @@ var init_facade3 = __esm(() => {
   init_errors();
 });
 
+// src/services/bridge/protocol.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function socketPath(meshSlug) {
+  return join2(homedir2(), ".claudemesh", "sockets", `${meshSlug}.sock`);
+}
+function socketDir() {
+  return join2(homedir2(), ".claudemesh", "sockets");
+}
+function frame(obj) {
+  return JSON.stringify(obj) + `
+`;
+}
+
+class LineParser {
+  buf = "";
+  feed(chunk) {
+    this.buf += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    const lines = [];
+    let nl = this.buf.indexOf(`
+`);
+    while (nl !== -1) {
+      lines.push(this.buf.slice(0, nl));
+      this.buf = this.buf.slice(nl + 1);
+      nl = this.buf.indexOf(`
+`);
+    }
+    return lines;
+  }
+}
+var init_protocol = () => {};
+
+// src/services/bridge/server.ts
+import { createServer } from "node:net";
+import { mkdirSync as mkdirSync2, unlinkSync, existsSync as existsSync2, chmodSync as chmodSync2 } from "node:fs";
+async function resolveTarget(client, to) {
+  if (to.startsWith("@") || to === "*" || /^[0-9a-f]{64}$/i.test(to)) {
+    return { ok: true, spec: to };
+  }
+  const peers = await client.listPeers();
+  const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
+  if (!match) {
+    return {
+      ok: false,
+      error: `peer "${to}" not found. online: ${peers.map((p) => p.displayName).join(", ") || "(none)"}`
+    };
+  }
+  return { ok: true, spec: match.pubkey };
+}
+async function dispatch(client, req) {
+  const args = req.args ?? {};
+  try {
+    switch (req.verb) {
+      case "ping": {
+        const peers = await client.listPeers();
+        return {
+          id: req.id,
+          ok: true,
+          result: {
+            mesh: client.meshSlug,
+            ws_status: client.status,
+            peers_online: peers.length,
+            push_buffer: client.pushHistory.length
+          }
+        };
+      }
+      case "peers": {
+        const peers = await client.listPeers();
+        return { id: req.id, ok: true, result: peers };
+      }
+      case "send": {
+        const to = String(args.to ?? "");
+        const message = String(args.message ?? "");
+        const priority = args.priority ?? "next";
+        if (!to || !message) {
+          return { id: req.id, ok: false, error: "send: `to` and `message` required" };
+        }
+        const resolved = await resolveTarget(client, to);
+        if (!resolved.ok)
+          return { id: req.id, ok: false, error: resolved.error };
+        const result = await client.send(resolved.spec, message, priority);
+        if (!result.ok) {
+          return { id: req.id, ok: false, error: result.error ?? "send failed" };
+        }
+        return {
+          id: req.id,
+          ok: true,
+          result: { messageId: result.messageId, target: resolved.spec }
+        };
+      }
+      case "summary": {
+        const text = String(args.summary ?? "");
+        if (!text)
+          return { id: req.id, ok: false, error: "summary: `summary` required" };
+        await client.setSummary(text);
+        return { id: req.id, ok: true, result: { summary: text } };
+      }
+      case "status_set": {
+        const state = String(args.status ?? "");
+        if (!["idle", "working", "dnd"].includes(state)) {
+          return { id: req.id, ok: false, error: "status_set: must be idle | working | dnd" };
+        }
+        await client.setStatus(state);
+        return { id: req.id, ok: true, result: { status: state } };
+      }
+      case "visible": {
+        const visible = Boolean(args.visible);
+        await client.setVisible(visible);
+        return { id: req.id, ok: true, result: { visible } };
+      }
+      default:
+        return { id: req.id, ok: false, error: `unknown verb: ${req.verb}` };
+    }
+  } catch (err) {
+    return {
+      id: req.id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function handleConnection(socket, client) {
+  const parser = new LineParser;
+  socket.on("data", (chunk) => {
+    const lines = parser.feed(chunk);
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      let req;
+      try {
+        req = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!req || typeof req !== "object" || !req.id || !req.verb)
+        continue;
+      dispatch(client, req).then((res) => {
+        try {
+          socket.write(frame(res));
+        } catch {}
+      });
+    }
+  });
+  socket.on("error", () => {});
+}
+function startBridgeServer(client) {
+  const path = socketPath(client.meshSlug);
+  const dir = socketDir();
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+  }
+  if (existsSync2(path)) {
+    try {
+      unlinkSync(path);
+    } catch {}
+  }
+  const server = createServer((socket) => handleConnection(socket, client));
+  try {
+    server.listen(path);
+  } catch (err) {
+    process.stderr.write(`[claudemesh] bridge: failed to bind ${path}: ${String(err)}
+`);
+    return null;
+  }
+  server.on("error", (err) => {
+    process.stderr.write(`[claudemesh] bridge: ${String(err)}
+`);
+  });
+  try {
+    chmodSync2(path, 384);
+  } catch {}
+  let stopped = false;
+  return {
+    path,
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        server.close();
+      } catch {}
+      try {
+        unlinkSync(path);
+      } catch {}
+    }
+  };
+}
+var init_server = __esm(() => {
+  init_protocol();
+});
+
 // src/commands/connect.ts
 import { hostname } from "node:os";
 import { createInterface } from "node:readline";
@@ -3558,7 +3749,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.0.3", env;
+var URLS, VERSION = "1.2.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -3799,7 +3990,7 @@ var init_facade6 = __esm(() => {
 
 // src/services/spawn/claude.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 function findClaudeBinary() {
   const candidates = [
     process.env.CLAUDE_BIN,
@@ -3808,7 +3999,7 @@ function findClaudeBinary() {
     `${process.env.HOME}/.npm/bin/claude`
   ].filter(Boolean);
   for (const bin of candidates) {
-    if (existsSync2(bin))
+    if (existsSync3(bin))
       return bin;
   }
   const which = spawnSync("which", ["claude"], { encoding: "utf-8" });
@@ -3869,9 +4060,9 @@ var init_facade7 = __esm(() => {
 });
 
 // src/services/auth/token-store.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync3, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync4, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
 function getStoredToken() {
-  if (!existsSync3(PATHS.AUTH_FILE))
+  if (!existsSync4(PATHS.AUTH_FILE))
     return null;
   try {
     const raw = readFileSync2(PATHS.AUTH_FILE, "utf-8");
@@ -3894,7 +4085,7 @@ function storeToken(auth) {
 }
 function clearToken() {
   try {
-    unlinkSync(PATHS.AUTH_FILE);
+    unlinkSync2(PATHS.AUTH_FILE);
   } catch {}
 }
 var init_token_store = __esm(() => {
@@ -4131,7 +4322,7 @@ var init_dashboard_sync = __esm(() => {
 });
 
 // src/services/auth/callback-listener.ts
-import { createServer } from "node:http";
+import { createServer as createServer2 } from "node:http";
 function startCallbackListener() {
   return new Promise((resolveStart) => {
     let resolveToken;
@@ -4139,7 +4330,7 @@ function startCallbackListener() {
     const tokenPromise = new Promise((r) => {
       resolveToken = r;
     });
-    const server = createServer((req, res) => {
+    const server = createServer2((req, res) => {
       const url = new URL(req.url, "http://localhost");
       if (req.method === "OPTIONS") {
         res.writeHead(204, {
@@ -4231,9 +4422,9 @@ __export(exports_grants, {
   runBlock: () => runBlock,
   isAllowed: () => isAllowed
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
 async function syncToBroker(meshSlug, grants) {
   const auth = getStoredToken();
   if (!auth)
@@ -4251,7 +4442,7 @@ async function syncToBroker(meshSlug, grants) {
   }
 }
 function readGrants() {
-  if (!existsSync4(GRANT_FILE))
+  if (!existsSync5(GRANT_FILE))
     return {};
   try {
     return JSON.parse(readFileSync3(GRANT_FILE, "utf-8"));
@@ -4260,9 +4451,9 @@ function readGrants() {
   }
 }
 function writeGrants(g) {
-  const dir = join2(homedir2(), ".claudemesh");
-  if (!existsSync4(dir))
-    mkdirSync2(dir, { recursive: true });
+  const dir = join3(homedir3(), ".claudemesh");
+  if (!existsSync5(dir))
+    mkdirSync3(dir, { recursive: true });
   writeFileSync3(GRANT_FILE, JSON.stringify(g, null, 2), { mode: 384 });
 }
 function resolveCaps(input) {
@@ -4419,7 +4610,7 @@ var init_grants = __esm(() => {
   BROKER_HTTP2 = URLS.BROKER.replace("wss://", "https://").replace("ws://", "http://").replace("/ws", "");
   ALL_CAPS = ["read", "dm", "broadcast", "state-read", "state-write", "file-read"];
   DEFAULT_CAPS = ["read", "dm", "broadcast", "state-read"];
-  GRANT_FILE = join2(homedir2(), ".claudemesh", "grants.json");
+  GRANT_FILE = join3(homedir3(), ".claudemesh", "grants.json");
 });
 
 // src/mcp/server.ts
@@ -4604,6 +4795,16 @@ function formatPush(p, meshSlug) {
   return `[${meshSlug}]${tag} from ${p.senderPubkey.slice(0, 12)}… (${p.priority}, ${p.createdAt}):
 ${body}`;
 }
+function maybeWarnDeprecated(toolName) {
+  const hint = DEPRECATED_TOOL_HINTS[toolName];
+  if (!hint)
+    return;
+  if (warnedTools.has(toolName))
+    return;
+  warnedTools.add(toolName);
+  process.stderr.write(`[claudemesh] mcp tool "${toolName}" is soft-deprecated in 1.1.0 ` + `and will be removed in 2.0.0. Use \`${hint}\` instead.
+`);
+}
 async function startMcpServer() {
   const serviceIdx = process.argv.indexOf("--service");
   if (serviceIdx !== -1 && process.argv[serviceIdx + 1]) {
@@ -4899,6 +5100,7 @@ ${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
     if (config.meshes.length === 0) {
       return text("No meshes joined. Run `claudemesh join https://claudemesh.com/join/<token>` first.", true);
     }
+    maybeWarnDeprecated(name);
     switch (name) {
       case "send_message": {
         const { to, message, priority } = args ?? {};
@@ -4976,12 +5178,12 @@ ${peerLines.join(`
           }
         }
         try {
-          const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync3, existsSync: existsSync5 } = await import("node:fs");
+          const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync4, existsSync: existsSync6 } = await import("node:fs");
           const { join: joinPath } = await import("node:path");
-          const { homedir: homedir3 } = await import("node:os");
-          const dir = joinPath(homedir3(), ".claudemesh");
-          if (!existsSync5(dir))
-            mkdirSync3(dir, { recursive: true });
+          const { homedir: homedir4 } = await import("node:os");
+          const dir = joinPath(homedir4(), ".claudemesh");
+          if (!existsSync6(dir))
+            mkdirSync4(dir, { recursive: true });
           writeFileSync4(joinPath(dir, "peer-cache.json"), JSON.stringify(statusCache));
         } catch {}
         return text(sections.join(`
@@ -5224,17 +5426,17 @@ ${lines.join(`
         const { path: filePath, name: fileName, tags, to: fileTo } = args ?? {};
         if (!filePath)
           return text("share_file: `path` required", true);
-        const { existsSync: existsSync5 } = await import("node:fs");
-        if (!existsSync5(filePath))
+        const { existsSync: existsSync6 } = await import("node:fs");
+        if (!existsSync6(filePath))
           return text(`share_file: file not found: ${filePath}`, true);
         const client = allClients()[0];
         if (!client)
           return text("share_file: not connected", true);
         if (fileTo) {
           const { encryptFile: encryptFile2, sealKeyForPeer: sealKeyForPeer2 } = await Promise.resolve().then(() => (init_file_crypto(), exports_file_crypto));
-          const { readFileSync: readFileSync4, writeFileSync: writeFileSync4, mkdtempSync, unlinkSync: unlinkSync2, rmdirSync } = await import("node:fs");
+          const { readFileSync: readFileSync4, writeFileSync: writeFileSync4, mkdtempSync, unlinkSync: unlinkSync3, rmdirSync } = await import("node:fs");
           const { tmpdir } = await import("node:os");
-          const { join: join3, basename } = await import("node:path");
+          const { join: join4, basename } = await import("node:path");
           const peers = await client.listPeers();
           const targetPeer = peers.find((p) => p.pubkey === fileTo || p.displayName === fileTo);
           if (!targetPeer) {
@@ -5257,8 +5459,8 @@ ${lines.join(`
           combined.set(ciphertext, nonceBytes.length);
           const rawName = fileName ?? basename(filePath);
           const baseName = basename(rawName).replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 255);
-          const tmpDir = mkdtempSync(join3(tmpdir(), "cm-"));
-          const tmpPath = join3(tmpDir, baseName);
+          const tmpDir = mkdtempSync(join4(tmpdir(), "cm-"));
+          const tmpPath = join4(tmpDir, baseName);
           writeFileSync4(tmpPath, combined);
           try {
             const fileId = await client.uploadFile(tmpPath, client.meshId, client.meshSlug, {
@@ -5274,7 +5476,7 @@ ${lines.join(`
             return text(`share_file: upload failed — ${e instanceof Error ? e.message : String(e)}`, true);
           } finally {
             try {
-              unlinkSync2(tmpPath);
+              unlinkSync3(tmpPath);
             } catch {}
             try {
               rmdirSync(tmpDir);
@@ -5334,9 +5536,9 @@ ${lines.join(`
           const plaintext = await decryptFile2(ciphertext, nonce, kf);
           if (!plaintext)
             return text(genericErr, true);
-          const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync4 } = await import("node:fs");
+          const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync5 } = await import("node:fs");
           const { dirname: dirname2 } = await import("node:path");
-          mkdirSync4(dirname2(save_to), { recursive: true });
+          mkdirSync5(dirname2(save_to), { recursive: true });
           writeFileSync5(save_to, plaintext);
           return text(`Downloaded and decrypted: ${result.name} → ${save_to}`);
         }
@@ -5347,9 +5549,9 @@ ${lines.join(`
         }
         if (!res.ok)
           return text(`get_file: download failed (${res.status})`, true);
-        const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync3 } = await import("node:fs");
+        const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync4 } = await import("node:fs");
         const { dirname } = await import("node:path");
-        mkdirSync3(dirname(save_to), { recursive: true });
+        mkdirSync4(dirname(save_to), { recursive: true });
         writeFileSync4(save_to, Buffer.from(await res.arrayBuffer()));
         return text(`Downloaded: ${result.name} → ${save_to}`);
       }
@@ -6108,8 +6310,8 @@ ${lines.join(`
         const entryType = vType ?? "env";
         let plaintextBytes;
         if (entryType === "file") {
-          const { existsSync: existsSync5, readFileSync: readFileSync4 } = await import("node:fs");
-          if (!existsSync5(value))
+          const { existsSync: existsSync6, readFileSync: readFileSync4 } = await import("node:fs");
+          if (!existsSync6(value))
             return text(`vault_set: file not found: ${value}`, true);
           plaintextBytes = new Uint8Array(readFileSync4(value));
         } else {
@@ -6368,8 +6570,14 @@ ${lines.join(`
   });
   const transport = new StdioServerTransport;
   await server.connect(transport);
+  const bridges = [];
   startClients(config).then(() => {
     wirePushHandlers().catch(() => {});
+    for (const client of allClients()) {
+      const bridge = startBridgeServer(client);
+      if (bridge)
+        bridges.push(bridge);
+    }
   }).catch(() => {
     wirePushHandlers().catch(() => {});
   });
@@ -6542,6 +6750,11 @@ ${lines.join(`
   const keepalive = setInterval(() => {}, 1000);
   const shutdown = () => {
     clearInterval(keepalive);
+    for (const b of bridges) {
+      try {
+        b.stop();
+      } catch {}
+    }
     stopAll();
     process.exit(0);
   };
@@ -6662,20 +6875,49 @@ async function startServiceProxy(serviceName) {
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000;
-var init_server = __esm(() => {
+var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000, DEPRECATED_TOOL_HINTS, warnedTools;
+var init_server2 = __esm(() => {
   init_definitions();
   init_facade();
   init_facade3();
+  init_server();
   peerNameCache = new Map;
+  DEPRECATED_TOOL_HINTS = {
+    send_message: "claudemesh send <to> <msg> [--mesh X] [--priority Y]",
+    list_peers: "claudemesh peers --json",
+    check_messages: "claudemesh inbox --json",
+    message_status: "claudemesh msg-status <id>",
+    set_profile: "claudemesh profile --avatar X --bio Y",
+    set_status: "claudemesh status set <state>",
+    set_summary: "claudemesh summary <text>",
+    set_visible: "claudemesh visible <true|false>",
+    join_group: "claudemesh group join @<name> [--role X]",
+    leave_group: "claudemesh group leave @<name>",
+    get_state: "claudemesh state get <key> --json",
+    set_state: "claudemesh state set <key> <value>",
+    list_state: "claudemesh state list --json",
+    remember: "claudemesh remember <text>",
+    recall: "claudemesh recall <query> --json",
+    forget: "claudemesh forget <id>",
+    schedule_reminder: "claudemesh remind <msg> --in/--at/--cron",
+    list_scheduled: "claudemesh remind list --json",
+    cancel_scheduled: "claudemesh remind cancel <id>",
+    mesh_info: "claudemesh info --json",
+    mesh_stats: "claudemesh stats --json",
+    mesh_clock: "claudemesh clock --json",
+    ping_mesh: "claudemesh ping",
+    claim_task: "claudemesh task claim <id>",
+    complete_task: "claudemesh task complete <id>"
+  };
+  warnedTools = new Set;
 });
 
 // src/entrypoints/mcp.ts
-init_server();
+init_server2();
 startMcpServer().catch((err) => {
   process.stderr.write(`MCP server error: ${err instanceof Error ? err.message : err}
 `);
   process.exit(1);
 });
 
-//# debugId=14E079338155978264756E2164756E21
+//# debugId=7613DACF856C905764756E2164756E21