claudemesh-cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -55340,13 +55340,28 @@ ${body}`;
 }
 async function startMcpServer() {
   const config2 = loadConfig();
-  const server = new Server({ name: "claudemesh", version: "0.1.0" }, {
-    capabilities: { tools: {} },
-    instructions: `You are connected to claudemesh — a peer mesh for Claude Code sessions.
+  const server = new Server({ name: "claudemesh", version: "0.1.1" }, {
+    capabilities: {
+      experimental: { "claude/channel": {} },
+      tools: {}
+    },
+    instructions: `You are connected to claudemesh — a peer mesh for Claude Code sessions on this machine and elsewhere.
+
+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.
+
+Read the from_id, from_name, mesh_slug, and priority attributes to understand context. Reply by calling send_message with the same target (for direct messages the from_id is the sender's pubkey).
 
-Use these tools to coordinate with peers on demand. Respond promptly when you receive messages (they're like someone tapping your shoulder).
+Available tools:
+- list_peers: see joined meshes + their connection status
+- send_message: send to a peer pubkey, 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)
 
-Tools: send_message, list_peers, check_messages, set_summary, set_status.
+Message priority:
+- "now": delivered immediately regardless of recipient status (use sparingly)
+- "next" (default): delivered when recipient is idle
+- "low": pull-only (check_messages)
 
 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.`
   });
@@ -55422,6 +55437,31 @@ ${drained.join(`
   await startClients(config2);
   const transport = new StdioServerTransport;
   await server.connect(transport);
+  for (const client of allClients()) {
+    client.onPush(async (msg) => {
+      const fromPubkey = msg.senderPubkey || "";
+      const fromName = fromPubkey ? `peer-${fromPubkey.slice(0, 8)}` : "unknown";
+      const content = msg.plaintext ?? "(decryption failed)";
+      try {
+        await server.notification({
+          method: "notifications/claude/channel",
+          params: {
+            content,
+            meta: {
+              from_id: fromPubkey,
+              from_name: fromName,
+              mesh_slug: client.meshSlug,
+              mesh_id: client.meshId,
+              priority: msg.priority,
+              sent_at: msg.createdAt,
+              delivered_at: msg.receivedAt,
+              kind: msg.kind
+            }
+          }
+        });
+      } catch {}
+    });
+  }
   const shutdown = () => {
     stopAll();
     process.exit(0);
@@ -55444,6 +55484,10 @@ import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
 var MCP_NAME = "claudemesh";
 var CLAUDE_CONFIG = join2(homedir2(), ".claude.json");
+var CLAUDE_SETTINGS = join2(homedir2(), ".claude", "settings.json");
+var HOOK_COMMAND_STOP = "claudemesh hook idle";
+var HOOK_COMMAND_USER_PROMPT = "claudemesh hook working";
+var HOOK_MARKER = "claudemesh hook ";
 function readClaudeConfig() {
   if (!existsSync2(CLAUDE_CONFIG))
     return {};
@@ -55491,7 +55535,71 @@ function buildMcpEntry(entryPath) {
 function entriesEqual(a, b) {
   return a.command === b.command && JSON.stringify(a.args ?? []) === JSON.stringify(b.args ?? []);
 }
-function runInstall() {
+function readClaudeSettings() {
+  if (!existsSync2(CLAUDE_SETTINGS))
+    return {};
+  const text2 = readFileSync2(CLAUDE_SETTINGS, "utf-8").trim();
+  if (!text2)
+    return {};
+  try {
+    return JSON.parse(text2);
+  } catch (e) {
+    throw new Error(`failed to parse ${CLAUDE_SETTINGS}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function writeClaudeSettings(obj) {
+  mkdirSync2(dirname2(CLAUDE_SETTINGS), { recursive: true });
+  writeFileSync2(CLAUDE_SETTINGS, JSON.stringify(obj, null, 2) + `
+`, "utf-8");
+}
+function installHooks() {
+  const settings = readClaudeSettings();
+  const hooks = (settings.hooks ??= {}) ?? {};
+  let added = 0;
+  let unchanged = 0;
+  const ensure = (event, command) => {
+    const list = hooks[event] ??= [];
+    const alreadyPresent = list.some((entry) => (entry.hooks ?? []).some((h) => h.command === command));
+    if (alreadyPresent) {
+      unchanged += 1;
+      return;
+    }
+    list.push({ hooks: [{ type: "command", command }] });
+    added += 1;
+  };
+  ensure("Stop", HOOK_COMMAND_STOP);
+  ensure("UserPromptSubmit", HOOK_COMMAND_USER_PROMPT);
+  settings.hooks = hooks;
+  writeClaudeSettings(settings);
+  return { added, unchanged };
+}
+function uninstallHooks() {
+  if (!existsSync2(CLAUDE_SETTINGS))
+    return 0;
+  const settings = readClaudeSettings();
+  const hooks = settings.hooks;
+  if (!hooks)
+    return 0;
+  let removed = 0;
+  for (const event of Object.keys(hooks)) {
+    const kept = [];
+    for (const entry of hooks[event] ?? []) {
+      const filtered = (entry.hooks ?? []).filter((h) => !(h.command ?? "").includes(HOOK_MARKER));
+      removed += (entry.hooks ?? []).length - filtered.length;
+      if (filtered.length > 0)
+        kept.push({ ...entry, hooks: filtered });
+    }
+    if (kept.length === 0)
+      delete hooks[event];
+    else
+      hooks[event] = kept;
+  }
+  settings.hooks = hooks;
+  writeClaudeSettings(settings);
+  return removed;
+}
+function runInstall(args = []) {
+  const skipHooks = args.includes("--no-hooks");
   console.log("claudemesh install");
   console.log("------------------");
   const entry = resolveEntry();
@@ -55534,6 +55642,22 @@ function runInstall() {
   console.log(`✓ MCP server "${MCP_NAME}" ${action}`);
   console.log(dim(`  config:  ${CLAUDE_CONFIG}`));
   console.log(dim(`  command: ${desired.command}${desired.args?.length ? " " + desired.args.join(" ") : ""}`));
+  if (!skipHooks) {
+    try {
+      const { added, unchanged } = installHooks();
+      if (added > 0) {
+        console.log(`✓ Hooks registered (Stop + UserPromptSubmit) → ${added} added, ${unchanged} already present`);
+      } else {
+        console.log(`✓ Hooks already registered (${unchanged} present)`);
+      }
+      console.log(dim(`  config:  ${CLAUDE_SETTINGS}`));
+    } catch (e) {
+      console.error(`⚠  hook registration failed: ${e instanceof Error ? e.message : String(e)}`);
+      console.error("   (MCP is still installed — hooks just skip. Retry with --no-hooks to suppress.)");
+    }
+  } else {
+    console.log(dim("· Hooks skipped (--no-hooks)"));
+  }
   console.log("");
   console.log(yellow(bold("⚠  RESTART CLAUDE CODE")) + yellow(" for MCP tools to appear."));
   console.log("");
@@ -55542,21 +55666,32 @@ function runInstall() {
 function runUninstall() {
   console.log("claudemesh uninstall");
   console.log("--------------------");
-  if (!existsSync2(CLAUDE_CONFIG)) {
-    console.log(`· no ${CLAUDE_CONFIG} — nothing to remove`);
-    return;
+  if (existsSync2(CLAUDE_CONFIG)) {
+    const cfg = readClaudeConfig();
+    const servers = cfg.mcpServers;
+    if (servers && MCP_NAME in servers) {
+      delete servers[MCP_NAME];
+      cfg.mcpServers = servers;
+      writeClaudeConfig(cfg);
+      console.log(`✓ MCP server "${MCP_NAME}" removed`);
+    } else {
+      console.log(`· MCP server "${MCP_NAME}" not present`);
+    }
+  } else {
+    console.log(`· no ${CLAUDE_CONFIG} — MCP entry skipped`);
   }
-  const cfg = readClaudeConfig();
-  const servers = cfg.mcpServers;
-  if (!servers || !(MCP_NAME in servers)) {
-    console.log(`· MCP server "${MCP_NAME}" not present — nothing to remove`);
-    return;
+  try {
+    const removed = uninstallHooks();
+    if (removed > 0) {
+      console.log(`✓ Hooks removed (${removed} entries)`);
+    } else {
+      console.log("· No claudemesh hooks to remove");
+    }
+  } catch (e) {
+    console.error(`⚠  hook removal failed: ${e instanceof Error ? e.message : String(e)}`);
   }
-  delete servers[MCP_NAME];
-  cfg.mcpServers = servers;
-  writeClaudeConfig(cfg);
-  console.log(`✓ MCP server "${MCP_NAME}" removed`);
-  console.log("Restart Claude Code to drop the MCP connection.");
+  console.log("");
+  console.log("Restart Claude Code to drop the MCP connection + hooks.");
 }
 
 // src/invite/parse.ts
@@ -55794,6 +55929,82 @@ function runSeedTestMesh(args) {
   console.log(`Run \`claudemesh mcp\` to connect, or register with Claude Code via \`claudemesh install\`.`);
 }
 
+// src/commands/hook.ts
+var DEBUG = process.env.CLAUDEMESH_HOOK_DEBUG === "1";
+function debug(msg) {
+  if (DEBUG)
+    console.error(`[claudemesh-hook] ${msg}`);
+}
+function wsToHttp2(wsUrl) {
+  try {
+    const u = new URL(wsUrl);
+    const httpScheme = u.protocol === "wss:" ? "https:" : "http:";
+    return `${httpScheme}//${u.host}`;
+  } catch {
+    return wsUrl;
+  }
+}
+async function readStdinJson() {
+  if (process.stdin.isTTY)
+    return {};
+  const chunks = [];
+  const reader = process.stdin;
+  try {
+    for await (const chunk of reader) {
+      chunks.push(chunk);
+      if (chunks.reduce((n, c) => n + c.length, 0) > 256 * 1024)
+        break;
+    }
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw)
+      return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function postHook(brokerWsUrl, body) {
+  const base = wsToHttp2(brokerWsUrl);
+  try {
+    const controller = new AbortController;
+    const t = setTimeout(() => controller.abort(), 1000);
+    await fetch(`${base}/hook/set-status`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    }).finally(() => clearTimeout(t));
+  } catch (e) {
+    debug(`post failed ${base}: ${e instanceof Error ? e.message : e}`);
+  }
+}
+async function runHook(args) {
+  const status = args[0];
+  if (!status || !["idle", "working", "dnd"].includes(status)) {
+    process.exit(0);
+  }
+  const stdinTimeout = new Promise((r) => setTimeout(() => r({}), 500));
+  const payload = await Promise.race([readStdinJson(), stdinTimeout]);
+  const cwd = typeof payload.cwd === "string" && payload.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const sessionId = typeof payload.session_id === "string" && payload.session_id || "";
+  let config2;
+  try {
+    config2 = loadConfig();
+  } catch (e) {
+    debug(`config load failed: ${e instanceof Error ? e.message : e}`);
+    process.exit(0);
+  }
+  if (config2.meshes.length === 0) {
+    debug("no joined meshes, nothing to do");
+    process.exit(0);
+  }
+  const body = { cwd, pid: process.ppid, status, session_id: sessionId };
+  debug(`status=${status} cwd=${cwd} meshes=${config2.meshes.length} session=${sessionId.slice(0, 8)}`);
+  const brokerUrls = [...new Set(config2.meshes.map((m) => m.brokerUrl))];
+  await Promise.all(brokerUrls.map((url2) => postHook(url2, body)));
+  process.exit(0);
+}
+
 // src/index.ts
 var HELP = `claudemesh — peer mesh for Claude Code sessions
 
@@ -55801,8 +56012,9 @@ Usage:
   claudemesh <command> [args]
 
 Commands:
-  install         Register claudemesh as a Claude Code MCP server
-  uninstall       Remove claudemesh MCP server registration
+  install         Register MCP + Stop/UserPromptSubmit status hooks
+                  (add --no-hooks for bare MCP registration)
+  uninstall       Remove MCP server + hooks
   join <url>      Join a mesh via https://claudemesh.com/join/... URL
   list            Show all joined meshes
   leave <slug>    Leave a joined mesh
@@ -55823,11 +56035,14 @@ async function main() {
       await startMcpServer();
       return;
     case "install":
-      runInstall();
+      runInstall(args);
       return;
     case "uninstall":
       runUninstall();
       return;
+    case "hook":
+      await runHook(args);
+      return;
     case "join":
       await runJoin(args);
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudemesh-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   "keywords": [
     "claude-code",