claudemesh-cli 1.0.2 → 1.1.0

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.0.2", env;
+var URLS, VERSION = "1.1.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -6715,6 +6715,263 @@ var init_recall = __esm(() => {
   init_exit_codes();
 });
 
+// src/commands/broker-actions.ts
+var exports_broker_actions = {};
+__export(exports_broker_actions, {
+  runVisible: () => runVisible,
+  runTaskComplete: () => runTaskComplete,
+  runTaskClaim: () => runTaskClaim,
+  runSummary: () => runSummary,
+  runStatusSet: () => runStatusSet,
+  runStats: () => runStats,
+  runPing: () => runPing,
+  runMsgStatus: () => runMsgStatus,
+  runGroupLeave: () => runGroupLeave,
+  runGroupJoin: () => runGroupJoin,
+  runForget: () => runForget,
+  runClock: () => runClock
+});
+async function runStatusSet(state, opts) {
+  const valid = ["idle", "working", "dnd"];
+  if (!valid.includes(state)) {
+    render.err(`Invalid status: ${state}`, `must be one of: ${valid.join(", ")}`);
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.setStatus(state);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ status: state }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`status set to ${bold(state)}`);
+  return EXIT.SUCCESS;
+}
+async function runSummary(text, opts) {
+  if (!text) {
+    render.err("Usage: claudemesh summary <text>");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.setSummary(text);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ summary: text }));
+    return EXIT.SUCCESS;
+  }
+  render.ok("summary set", dim(text));
+  return EXIT.SUCCESS;
+}
+async function runVisible(value, opts) {
+  let visible;
+  if (value === "true" || value === "1" || value === "yes")
+    visible = true;
+  else if (value === "false" || value === "0" || value === "no")
+    visible = false;
+  else {
+    render.err("Usage: claudemesh visible <true|false>");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.setVisible(visible);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ visible }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(visible ? "you are now visible to peers" : "you are now hidden", visible ? undefined : "direct messages still reach you");
+  return EXIT.SUCCESS;
+}
+async function runGroupJoin(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh group join @<name> [--role X]");
+    return EXIT.INVALID_ARGS;
+  }
+  const cleanName = name.startsWith("@") ? name.slice(1) : name;
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.joinGroup(cleanName, opts.role);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ group: cleanName, role: opts.role ?? null }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`joined ${clay("@" + cleanName)}`, opts.role ? `as ${opts.role}` : undefined);
+  return EXIT.SUCCESS;
+}
+async function runGroupLeave(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh group leave @<name>");
+    return EXIT.INVALID_ARGS;
+  }
+  const cleanName = name.startsWith("@") ? name.slice(1) : name;
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.leaveGroup(cleanName);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ group: cleanName, left: true }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`left ${clay("@" + cleanName)}`);
+  return EXIT.SUCCESS;
+}
+async function runForget(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh forget <memory-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.forget(id);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ id, forgotten: true }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`forgot ${dim(id.slice(0, 8))}`);
+  return EXIT.SUCCESS;
+}
+async function runMsgStatus(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh msg-status <message-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const result = await client.messageStatus(id);
+    if (!result) {
+      if (opts.json)
+        console.log(JSON.stringify({ id, found: false }));
+      else
+        render.err(`Message ${id} not found or timed out.`);
+      return EXIT.NOT_FOUND;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`message ${id.slice(0, 12)}…`);
+    render.kv([
+      ["target", result.targetSpec],
+      ["delivered", result.delivered ? "yes" : "no"],
+      ["delivered_at", result.deliveredAt ?? dim("—")]
+    ]);
+    if (result.recipients.length > 0) {
+      render.blank();
+      render.heading("recipients");
+      for (const r of result.recipients) {
+        process.stdout.write(`  ${bold(r.name)} ${dim(r.pubkey.slice(0, 12) + "…")} ${dim("·")} ${r.status}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runClock(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const result = await client.getClock();
+    if (!result) {
+      if (opts.json)
+        console.log(JSON.stringify({ error: "timed out" }));
+      else
+        render.err("Clock query timed out");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return EXIT.SUCCESS;
+    }
+    const statusLabel = result.speed === 0 ? "not started" : result.paused ? "paused" : "running";
+    render.section(`mesh clock — ${statusLabel}`);
+    render.kv([
+      ["speed", `x${result.speed}`],
+      ["tick", String(result.tick)],
+      ["sim_time", result.simTime],
+      ["started_at", result.startedAt]
+    ]);
+    return EXIT.SUCCESS;
+  });
+}
+async function runStats(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const peers = await client.listPeers();
+    if (opts.json) {
+      console.log(JSON.stringify({
+        mesh: client.meshSlug,
+        peers: peers.map((p) => ({ name: p.displayName, pubkey: p.pubkey, stats: p.stats ?? null }))
+      }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(client.meshSlug);
+    for (const p of peers) {
+      const s = p.stats;
+      if (!s) {
+        process.stdout.write(`  ${bold(p.displayName)} ${dim("(no stats)")}
+`);
+        continue;
+      }
+      const up = s.uptime != null ? `${Math.floor(s.uptime / 60)}m` : "—";
+      process.stdout.write(`  ${bold(p.displayName)}  ${dim(`in:${s.messagesIn ?? 0}  out:${s.messagesOut ?? 0}  tools:${s.toolCalls ?? 0}  up:${up}  err:${s.errors ?? 0}`)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runPing(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const peers = await client.listPeers();
+    if (opts.json) {
+      console.log(JSON.stringify({
+        mesh: client.meshSlug,
+        ws_status: client.status,
+        peers_online: peers.length,
+        push_buffer: client.pushHistory.length
+      }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    render.section(`ping ${client.meshSlug}`);
+    render.kv([
+      ["ws_status", client.status],
+      ["peers_online", String(peers.length)],
+      ["push_buffer", String(client.pushHistory.length)]
+    ]);
+    return EXIT.SUCCESS;
+  });
+}
+async function runTaskClaim(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh task claim <id>");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.claimTask(id);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ id, claimed: true }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`claimed ${dim(id.slice(0, 8))}`);
+  return EXIT.SUCCESS;
+}
+async function runTaskComplete(id, result, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh task complete <id> [result]");
+    return EXIT.INVALID_ARGS;
+  }
+  await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.completeTask(id, result);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ id, completed: true, result: result ?? null }));
+    return EXIT.SUCCESS;
+  }
+  render.ok(`completed ${dim(id.slice(0, 8))}`, result);
+  return EXIT.SUCCESS;
+}
+var init_broker_actions = __esm(() => {
+  init_connect();
+  init_render();
+  init_styles();
+  init_exit_codes();
+});
+
 // src/commands/remind.ts
 var exports_remind = {};
 __export(exports_remind, {
@@ -10163,12 +10420,34 @@ 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]) {
     return startServiceProxy(process.argv[serviceIdx + 1]);
   }
+  const meshIdx = process.argv.indexOf("--mesh");
+  const onlyMesh = meshIdx !== -1 ? process.argv[meshIdx + 1] : null;
   const config = readConfig();
+  if (onlyMesh) {
+    const available = config.meshes.map((m) => m.slug);
+    const filtered = config.meshes.filter((m) => m.slug === onlyMesh);
+    if (filtered.length === 0) {
+      process.stderr.write(`[claudemesh] --mesh "${onlyMesh}" not found in config. ` + `Joined meshes: ${available.join(", ") || "(none)"}
+`);
+      process.exit(1);
+    }
+    config.meshes = filtered;
+  }
   const myName = config.displayName ?? "unnamed";
   const myRole = config.role ?? process.env.CLAUDEMESH_ROLE ?? null;
   const myGroups = (config.groups ?? []).map((g) => `@${g.name}${g.role ? ":" + g.role : ""}`).join(", ") || "none";
@@ -10446,6 +10725,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 ?? {};
@@ -12209,12 +12489,40 @@ async function startServiceProxy(serviceName) {
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000;
+var peerNameCache, peerNameCacheAge = 0, CACHE_TTL_MS = 30000, DEPRECATED_TOOL_HINTS, warnedTools;
 var init_server = __esm(() => {
   init_definitions();
   init_facade();
   init_facade8();
   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/commands/mcp.ts
@@ -12509,12 +12817,28 @@ Messaging
   claudemesh peers                 see who's online
   claudemesh send <to> <msg>       send a message
   claudemesh inbox                 drain pending messages
+  claudemesh msg-status <id>       check delivery status
   claudemesh state get|set|list    shared state
   claudemesh remember <text>       store a memory
   claudemesh recall <query>        search memories
+  claudemesh forget <id>           remove a memory
   claudemesh remind ...            schedule a reminder
   claudemesh profile               view or edit your profile
   claudemesh info                  mesh overview
+  claudemesh stats                 per-peer activity counters
+  claudemesh clock                 mesh logical clock state
+  claudemesh ping                  diagnostic round-trip
+
+Identity / presence
+  claudemesh status set <state>    set peer status (idle | working | dnd)
+  claudemesh summary <text>        broadcast 1-2 sentence work summary
+  claudemesh visible <true|false>  toggle peer visibility
+  claudemesh group join @<name>    join a group (--role X optional)
+  claudemesh group leave @<name>   leave a group
+
+Tasks
+  claudemesh task claim <id>       claim an unclaimed task
+  claudemesh task complete <id>    mark task done [result]
 
 Auth
   claudemesh login                 sign in (browser or paste token)
@@ -12711,6 +13035,11 @@ async function main() {
       process.exit(await recall2(positionals.join(" "), { json: !!flags.json }));
       break;
     }
+    case "forget": {
+      const { runForget: runForget2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runForget2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
     case "remind": {
       const { runRemind: runRemind2 } = await Promise.resolve().then(() => (init_remind(), exports_remind));
       await runRemind2({ mesh: flags.mesh }, positionals);
@@ -12721,6 +13050,64 @@ async function main() {
       await runProfile2(flags);
       break;
     }
+    case "summary": {
+      const { runSummary: runSummary2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runSummary2(positionals.join(" "), { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "visible": {
+      const { runVisible: runVisible2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runVisible2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "group": {
+      const sub = positionals[0];
+      if (sub === "join") {
+        const { runGroupJoin: runGroupJoin2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runGroupJoin2(positionals[1], { mesh: flags.mesh, role: flags.role, json: !!flags.json }));
+      } else if (sub === "leave") {
+        const { runGroupLeave: runGroupLeave2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runGroupLeave2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh group <join|leave> @<name> [--role X]");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "msg-status": {
+      const { runMsgStatus: runMsgStatus2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runMsgStatus2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "clock": {
+      const { runClock: runClock2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runClock2({ mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "stats": {
+      const { runStats: runStats2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runStats2({ mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "ping": {
+      const { runPing: runPing2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+      process.exit(await runPing2({ mesh: flags.mesh, json: !!flags.json }));
+      break;
+    }
+    case "task": {
+      const sub = positionals[0];
+      if (sub === "claim") {
+        const { runTaskClaim: runTaskClaim2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskClaim2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
+      } else if (sub === "complete") {
+        const { runTaskComplete: runTaskComplete2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskComplete2(positionals[1], positionals.slice(2).join(" ") || undefined, { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        console.error("Usage: claudemesh task <claim|complete> <id> [result]");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
     case "login": {
       const { login: login2 } = await Promise.resolve().then(() => (init_login(), exports_login));
       process.exit(await login2());
@@ -12757,8 +13144,13 @@ async function main() {
       break;
     }
     case "status": {
-      const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
-      await runStatus2();
+      if (positionals[0] === "set") {
+        const { runStatusSet: runStatusSet2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runStatusSet2(positionals[1] ?? "", { mesh: flags.mesh, json: !!flags.json }));
+      } else {
+        const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
+        await runStatus2();
+      }
       break;
     }
     case "sync": {
@@ -12854,4 +13246,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=80234995420998CA64756E2164756E21
+//# debugId=0A4A6F72C9E014B864756E2164756E21