claudemesh-cli 1.6.0 → 1.7.0

package/README.md

@@ -2,7 +2,9 @@
 
 Peer mesh for Claude Code sessions. Connect multiple Claude Code instances into a shared mesh with real-time messaging, shared state, memory, file sharing, vector store, scheduled jobs, and more — all driven from the `claudemesh` CLI. The MCP server is a tool-less push-pipe that delivers inbound peer messages to Claude as `<channel>` interrupts; everything else lives behind CLI verbs that Claude learns from the auto-installed `claudemesh` skill.
 
-> **What's new in 1.6.0:** topics (channel pub/sub), API keys for human/REST clients, and bridge peers that forward a topic between two meshes. New verbs: `claudemesh topic`, `claudemesh apikey`, `claudemesh bridge`. The broker now exposes a REST surface at `/api/v1/*` (messages, topics, peers, history) for non-WebSocket clients.
+> **What's new in 1.7.0:** terminal parity for the v1.6.x server features. New verbs: `claudemesh topic tail` (live SSE message stream — Ctrl-C to exit), `claudemesh notification list` (recent `@you` mentions across topics), `claudemesh member list` (mesh roster with online dots, distinct from `peer list`'s live-session view). Each command auto-mints a 5-minute read-only apikey via the WebSocket and revokes it on exit, so no token plumbing is needed.
+>
+> **What was new in 1.6.0:** topics (channel pub/sub), API keys for human/REST clients, and bridge peers that forward a topic between two meshes. New verbs: `claudemesh topic`, `claudemesh apikey`, `claudemesh bridge`. A REST surface at `https://claudemesh.com/api/v1/*` (messages, topics, peers, history) accepts `Authorization: Bearer cm_...` keys, so any HTTPS client can participate without WebSocket + ed25519 plumbing. **Note**: REST lives on the web host (`claudemesh.com`), not the broker host (`ic.claudemesh.com`) — the broker only speaks WebSocket.
 >
 > **Migration note (1.5.0):** the previous 79 MCP tools (`send_message`, `list_peers`, `remember`, …) are removed. Use the matching CLI verbs (`claudemesh send`, `claudemesh peers`, `claudemesh remember`). Run `claudemesh install` and the bundled skill teaches Claude the full surface.
 
@@ -43,6 +45,9 @@ USAGE
   claudemesh profile         view or edit your profile
 
   claudemesh topic ...       create, list, join, send to topics
+  claudemesh topic tail <t>  live SSE tail of a topic
+  claudemesh member list     mesh roster with online state
+  claudemesh notification list  recent @-mentions of you
   claudemesh apikey ...      issue, list, revoke API keys (REST clients)
   claudemesh bridge ...      forward a topic between two meshes
 

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.6.0", env;
+var URLS, VERSION = "1.7.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -751,10 +751,25 @@ function requireToken() {
     throw new NotSignedIn;
   return auth.session_token;
 }
+function localView() {
+  const cfg = readConfig();
+  if (cfg.meshes.length === 0)
+    return;
+  return {
+    config_path: PATHS.CONFIG_FILE,
+    meshes: cfg.meshes.map((m) => ({
+      slug: m.slug,
+      mesh_id: m.meshId,
+      member_id: m.memberId,
+      pubkey_prefix: m.pubkey.slice(0, 12)
+    }))
+  };
+}
 async function whoAmI() {
   const auth = getStoredToken();
+  const local = localView();
   if (!auth)
-    return { signed_in: false };
+    return { signed_in: false, local };
   try {
     const profile = await exports_my.getProfile(auth.session_token);
     const meshes = await exports_my.getMeshes(auth.session_token);
@@ -763,12 +778,13 @@ async function whoAmI() {
       signed_in: true,
       user: profile,
       token_source: auth.token_source,
-      meshes: { owned, guest: meshes.length - owned }
+      meshes: { owned, guest: meshes.length - owned },
+      local
     };
   } catch (err) {
     if (err instanceof ApiError && err.isUnauthorized) {
       clearToken();
-      return { signed_in: false };
+      return { signed_in: false, local };
     }
     throw err;
   }
@@ -791,6 +807,8 @@ async function register(callbackPort) {
 var init_client2 = __esm(() => {
   init_facade3();
   init_facade3();
+  init_facade();
+  init_paths();
   init_token_store();
   init_errors2();
 });
@@ -1138,6 +1156,7 @@ class BrokerClient {
   topicHistoryResolvers = new Map;
   apiKeyCreatedResolvers = new Map;
   apiKeyListResolvers = new Map;
+  apiKeyRevokeResolvers = new Map;
   sharedDirs = [process.cwd()];
   _serviceCatalog = [];
   get serviceCatalog() {
@@ -1546,9 +1565,21 @@ class BrokerClient {
     });
   }
   async apiKeyRevoke(id) {
-    if (!this.ws || this.ws.readyState !== this.ws.OPEN)
-      return;
-    this.ws.send(JSON.stringify({ type: "apikey_revoke", id }));
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
+      return { ok: false, code: "not_connected", message: "broker not connected" };
+    }
+    return new Promise((resolve) => {
+      const reqId = this.makeReqId();
+      this.apiKeyRevokeResolvers.set(reqId, {
+        resolve,
+        timer: setTimeout(() => {
+          if (this.apiKeyRevokeResolvers.delete(reqId)) {
+            resolve({ ok: false, code: "timeout", message: "broker did not respond within 5s" });
+          }
+        }, 5000)
+      });
+      this.ws.send(JSON.stringify({ type: "apikey_revoke", id, _reqId: reqId }));
+    });
   }
   async setState(key, value) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
@@ -2667,6 +2698,28 @@ class BrokerClient {
       this.resolveFromMap(this.apiKeyListResolvers, msgReqId, msg.keys ?? []);
       return;
     }
+    if (msg.type === "apikey_revoke_response") {
+      const status = String(msg.status ?? "");
+      if (status === "revoked") {
+        this.resolveFromMap(this.apiKeyRevokeResolvers, msgReqId, {
+          ok: true,
+          id: String(msg.id ?? "")
+        });
+      } else if (status === "not_found") {
+        this.resolveFromMap(this.apiKeyRevokeResolvers, msgReqId, {
+          ok: false,
+          code: "not_found",
+          message: "no api key matches that id in this mesh"
+        });
+      } else if (status === "not_unique") {
+        this.resolveFromMap(this.apiKeyRevokeResolvers, msgReqId, {
+          ok: false,
+          code: "not_unique",
+          message: `prefix matches ${Number(msg.matches ?? 0)} keys; use the full id`
+        });
+      }
+      return;
+    }
     if (msg.type === "push") {
       this._statsCounters.messagesIn++;
       const nonce = String(msg.nonce ?? "");
@@ -7521,18 +7574,33 @@ async function whoami(opts) {
   const result = await whoAmI();
   if (opts.json) {
     console.log(JSON.stringify({ schema_version: "1.0", ...result }, null, 2));
-    return EXIT.SUCCESS;
+    return result.signed_in || result.local ? EXIT.SUCCESS : EXIT.AUTH_FAILED;
   }
-  if (!result.signed_in) {
-    render.err("Not signed in", "Run `claudemesh login` to sign in.");
+  if (!result.signed_in && !result.local) {
+    render.err("Not signed in", "Run `claudemesh login` to sign in or `claudemesh <invite>` to join.");
     return EXIT.AUTH_FAILED;
   }
   render.section("whoami");
-  render.kv([
-    ["user", `${bold(result.user.display_name)} ${dim(`(${result.user.email})`)}`],
-    ["token", `${result.token_source} ${dim("(~/.claudemesh/auth.json)")}`],
-    ...result.meshes ? [["meshes", `${result.meshes.owned} owned · ${result.meshes.guest} guest`]] : []
-  ]);
+  if (result.signed_in) {
+    render.kv([
+      ["user", `${bold(result.user.display_name)} ${dim(`(${result.user.email})`)}`],
+      ["token", `${result.token_source} ${dim("(~/.claudemesh/auth.json)")}`],
+      ...result.meshes ? [["meshes", `${result.meshes.owned} owned · ${result.meshes.guest} guest`]] : []
+    ]);
+  } else {
+    render.kv([
+      ["web", dim("not signed in · run `claudemesh login` for account features")]
+    ]);
+  }
+  if (result.local) {
+    render.blank();
+    render.kv([
+      ["local", `${result.local.meshes.length} mesh${result.local.meshes.length === 1 ? "" : "es"} · ${dim(result.local.config_path)}`]
+    ]);
+    for (const m of result.local.meshes) {
+      console.log(`    ${clay("●")} ${bold(m.slug)}  ${dim(`member ${m.member_id.slice(0, 8)}…  pk ${m.pubkey_prefix}…`)}`);
+    }
+  }
   render.blank();
   return EXIT.SUCCESS;
 }
@@ -11394,11 +11462,19 @@ async function runApiKeyRevoke(id, flags) {
     return EXIT.INVALID_ARGS;
   }
   return await withMesh({ meshSlug: flags.mesh ?? null }, async (client) => {
-    await client.apiKeyRevoke(id);
+    const result = await client.apiKeyRevoke(id);
+    if (!result.ok) {
+      if (flags.json) {
+        console.log(JSON.stringify({ ok: false, code: result.code, message: result.message }));
+      } else {
+        render.err(`${result.code}: ${result.message}`);
+      }
+      return result.code === "not_found" ? EXIT.NOT_FOUND : result.code === "not_unique" ? EXIT.INVALID_ARGS : EXIT.INTERNAL_ERROR;
+    }
     if (flags.json)
-      console.log(JSON.stringify({ revoked: id }));
+      console.log(JSON.stringify({ revoked: result.id }));
     else
-      render.ok("revoked", clay(id.slice(0, 8)));
+      render.ok("revoked", clay(result.id.slice(0, 8)));
     return EXIT.SUCCESS;
   });
 }
@@ -11572,6 +11648,304 @@ var init_topic = __esm(() => {
   init_exit_codes();
 });
 
+// src/services/api/with-rest-key.ts
+async function withRestKey(opts, fn) {
+  return withMesh({ meshSlug: opts.meshSlug ?? null }, async (client, mesh) => {
+    const result = await client.apiKeyCreate({
+      label: `cli-${opts.purpose ?? "rest"}-${process.pid}`,
+      capabilities: opts.capabilities ?? ["read"],
+      topicScopes: opts.topicScopes ?? undefined,
+      expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString()
+    });
+    if (!result || !result.secret) {
+      throw new Error("apikey mint failed — broker did not return a secret");
+    }
+    try {
+      return await fn({
+        secret: result.secret,
+        meshId: mesh.meshId,
+        meshSlug: mesh.slug,
+        client,
+        mesh
+      });
+    } finally {
+      try {
+        await client.apiKeyRevoke(result.id);
+      } catch {}
+    }
+  });
+}
+var init_with_rest_key = __esm(() => {
+  init_connect();
+});
+
+// src/commands/topic-tail.ts
+var exports_topic_tail = {};
+__export(exports_topic_tail, {
+  runTopicTail: () => runTopicTail
+});
+function decodeCiphertext(b64) {
+  try {
+    return Buffer.from(b64, "base64").toString("utf-8");
+  } catch {
+    return "[decode failed]";
+  }
+}
+function fmtTime(iso) {
+  try {
+    return new Date(iso).toLocaleTimeString([], {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+  } catch {
+    return iso;
+  }
+}
+function printMessage(m, json) {
+  const text = decodeCiphertext(m.ciphertext);
+  if (json) {
+    console.log(JSON.stringify({ ...m, message: text }));
+    return;
+  }
+  process.stdout.write(`  ${dim(fmtTime(m.createdAt))}  ${bold(m.senderName || m.senderPubkey.slice(0, 8))}  ${text}
+`);
+}
+async function* readSseStream(reader) {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf(`
+
+`)) !== -1) {
+      const block = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      const ev = { event: "message", data: "" };
+      const dataLines = [];
+      for (const line of block.split(`
+`)) {
+        if (!line || line.startsWith(":"))
+          continue;
+        const colon = line.indexOf(":");
+        if (colon < 0)
+          continue;
+        const field = line.slice(0, colon);
+        const val = line.slice(colon + 1).replace(/^ /, "");
+        if (field === "event")
+          ev.event = val;
+        else if (field === "id")
+          ev.id = val;
+        else if (field === "data")
+          dataLines.push(val);
+      }
+      ev.data = dataLines.join(`
+`);
+      yield ev;
+    }
+  }
+}
+async function runTopicTail(name, flags) {
+  if (!name) {
+    render.err("Usage: claudemesh topic tail <topic> [--limit N]");
+    return EXIT.INVALID_ARGS;
+  }
+  const cleanName = name.replace(/^#/, "");
+  const limit = flags.limit ? Number(flags.limit) : 20;
+  return withRestKey({
+    meshSlug: flags.mesh ?? null,
+    purpose: `tail-${cleanName}`,
+    capabilities: ["read"],
+    topicScopes: [cleanName]
+  }, async ({ secret, meshSlug }) => {
+    if (!flags.forwardOnly && limit > 0) {
+      try {
+        const history = await request({
+          path: `/api/v1/topics/${encodeURIComponent(cleanName)}/messages?limit=${limit}`,
+          token: secret
+        });
+        if (!flags.json) {
+          render.section(`${clay("#" + cleanName)} on ${dim(meshSlug)} — backfill ${history.messages.length}, then live`);
+        }
+        for (const m of history.messages.slice().reverse()) {
+          printMessage(m, flags.json ?? false);
+        }
+      } catch (err) {
+        render.warn(`backfill failed: ${err.message}`);
+      }
+    }
+    const url = `${URLS.API_BASE}/api/v1/topics/${encodeURIComponent(cleanName)}/stream`;
+    const ctl = new AbortController;
+    const onSig = () => ctl.abort();
+    process.once("SIGINT", onSig);
+    process.once("SIGTERM", onSig);
+    try {
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${secret}` },
+        signal: ctl.signal
+      });
+      if (!res.ok || !res.body) {
+        render.err(`stream open failed: ${res.status}`);
+        return EXIT.INTERNAL_ERROR;
+      }
+      if (!flags.json) {
+        render.info(dim("tailing — Ctrl-C to exit"));
+      }
+      const reader = res.body.getReader();
+      for await (const ev of readSseStream(reader)) {
+        if (ev.event === "ready" || ev.event === "heartbeat")
+          continue;
+        if (ev.event === "error") {
+          try {
+            const parsed = JSON.parse(ev.data);
+            render.err(`stream error: ${parsed.error ?? "unknown"}`);
+          } catch {
+            render.err("stream error");
+          }
+          continue;
+        }
+        if (ev.event === "message") {
+          try {
+            const m = JSON.parse(ev.data);
+            printMessage(m, flags.json ?? false);
+          } catch {}
+        }
+      }
+      return EXIT.SUCCESS;
+    } catch (err) {
+      if (ctl.signal.aborted)
+        return EXIT.SUCCESS;
+      render.err(`tail aborted: ${err.message}`);
+      return EXIT.INTERNAL_ERROR;
+    } finally {
+      process.removeListener("SIGINT", onSig);
+      process.removeListener("SIGTERM", onSig);
+    }
+  });
+}
+var init_topic_tail = __esm(() => {
+  init_urls();
+  init_with_rest_key();
+  init_client();
+  init_render();
+  init_styles();
+  init_exit_codes();
+});
+
+// src/commands/notification.ts
+var exports_notification = {};
+__export(exports_notification, {
+  runNotificationList: () => runNotificationList
+});
+function decodeCiphertext2(b64) {
+  try {
+    return Buffer.from(b64, "base64").toString("utf-8");
+  } catch {
+    return "[decode failed]";
+  }
+}
+function fmtRelative(iso) {
+  const ms = Date.now() - new Date(iso).getTime();
+  if (ms < 60000)
+    return "now";
+  if (ms < 3600000)
+    return `${Math.floor(ms / 60000)}m`;
+  if (ms < 86400000)
+    return `${Math.floor(ms / 3600000)}h`;
+  return `${Math.floor(ms / 86400000)}d`;
+}
+async function runNotificationList(flags) {
+  return withRestKey({ meshSlug: flags.mesh ?? null, purpose: "notifications" }, async ({ secret }) => {
+    const qs = flags.since ? `?since=${encodeURIComponent(flags.since)}` : "";
+    const result = await request({
+      path: `/api/v1/notifications${qs}`,
+      token: secret
+    });
+    if (flags.json) {
+      const decoded = result.notifications.map((n) => ({
+        ...n,
+        message: decodeCiphertext2(n.ciphertext)
+      }));
+      console.log(JSON.stringify({ ...result, notifications: decoded }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    if (result.notifications.length === 0) {
+      render.info(dim(`no mentions of @${result.mentionedAs} since ${result.since}.`));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mentions of @${bold(result.mentionedAs)} (${result.notifications.length})`);
+    for (const n of result.notifications) {
+      const when = fmtRelative(n.createdAt);
+      const msg = decodeCiphertext2(n.ciphertext).replace(/\s+/g, " ").trim();
+      const snippet = msg.length > 100 ? msg.slice(0, 97) + "…" : msg;
+      process.stdout.write(`  ${clay("#" + n.topicName)}  ${dim(when)}  ${bold(n.senderName)}
+`);
+      process.stdout.write(`    ${snippet}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+var init_notification = __esm(() => {
+  init_with_rest_key();
+  init_client();
+  init_render();
+  init_styles();
+  init_exit_codes();
+});
+
+// src/commands/member.ts
+var exports_member = {};
+__export(exports_member, {
+  runMemberList: () => runMemberList
+});
+function statusGlyph(m) {
+  if (!m.online)
+    return dim("○");
+  if (m.status === "dnd")
+    return red("●");
+  if (m.status === "working")
+    return yellow("●");
+  return green("●");
+}
+async function runMemberList(flags) {
+  return withRestKey({ meshSlug: flags.mesh ?? null, purpose: "members" }, async ({ secret, meshSlug }) => {
+    const result = await request({
+      path: "/api/v1/members",
+      token: secret
+    });
+    const filtered = flags.online ? result.members.filter((m) => m.online) : result.members;
+    if (flags.json) {
+      console.log(JSON.stringify({ members: filtered }, null, 2));
+      return EXIT.SUCCESS;
+    }
+    if (filtered.length === 0) {
+      render.info(dim(flags.online ? `no online members in ${meshSlug}.` : `no members in ${meshSlug}.`));
+      return EXIT.SUCCESS;
+    }
+    const onlineCount = result.members.filter((m) => m.online).length;
+    render.section(`${clay(meshSlug)} members (${onlineCount}/${result.members.length} online)`);
+    for (const m of filtered) {
+      const tag = m.isHuman ? dim("human") : dim("bot");
+      const summary = m.summary ? ` — ${dim(m.summary)}` : "";
+      process.stdout.write(`  ${statusGlyph(m)} ${bold(m.displayName)}  ${tag}  ${dim(m.role)}  ${dim(m.pubkey.slice(0, 8))}${summary}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+var init_member = __esm(() => {
+  init_with_rest_key();
+  init_client();
+  init_render();
+  init_styles();
+  init_exit_codes();
+});
+
 // src/mcp/tools/definitions.ts
 var TOOLS;
 var init_definitions = __esm(() => {
@@ -13143,7 +13517,10 @@ Topic  (conversation scope, v0.2.0)
   claudemesh topic members <t>     list topic subscribers
   claudemesh topic history <t>     fetch message history [--limit --before]
   claudemesh topic read <topic>    mark all as read
+  claudemesh topic tail <topic>    live SSE tail [--limit --forward-only]
   claudemesh send "#topic" "msg"   send to a topic
+  claudemesh member list           mesh roster with online state [--online]
+  claudemesh notification list     recent @-mentions of you [--since <ISO>]
 
 Schedule  (resource form)
   claudemesh schedule msg <m>      one-shot or recurring     (alias: remind)
@@ -13922,8 +14299,51 @@ async function main() {
       } else if (sub === "read") {
         const { runTopicMarkRead: runTopicMarkRead2 } = await Promise.resolve().then(() => (init_topic(), exports_topic));
         process.exit(await runTopicMarkRead2(arg, f));
+      } else if (sub === "tail") {
+        const tailFlags = {
+          mesh: flags.mesh,
+          json: !!flags.json,
+          limit: flags.limit,
+          forwardOnly: !!flags["forward-only"]
+        };
+        const { runTopicTail: runTopicTail2 } = await Promise.resolve().then(() => (init_topic_tail(), exports_topic_tail));
+        process.exit(await runTopicTail2(arg, tailFlags));
+      } else {
+        console.error("Usage: claudemesh topic <create|list|join|leave|members|history|read|tail>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "notification":
+    case "notifications": {
+      const sub = positionals[0] ?? "list";
+      const f = {
+        mesh: flags.mesh,
+        json: !!flags.json,
+        since: flags.since
+      };
+      if (sub === "list") {
+        const { runNotificationList: runNotificationList2 } = await Promise.resolve().then(() => (init_notification(), exports_notification));
+        process.exit(await runNotificationList2(f));
+      } else {
+        console.error("Usage: claudemesh notification list [--since <ISO>]");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "member":
+    case "members": {
+      const sub = positionals[0] ?? "list";
+      const f = {
+        mesh: flags.mesh,
+        json: !!flags.json,
+        online: !!flags.online
+      };
+      if (sub === "list") {
+        const { runMemberList: runMemberList2 } = await Promise.resolve().then(() => (init_member(), exports_member));
+        process.exit(await runMemberList2(f));
       } else {
-        console.error("Usage: claudemesh topic <create|list|join|leave|members|history|read>");
+        console.error("Usage: claudemesh member list [--online]");
         process.exit(EXIT.INVALID_ARGS);
       }
       break;
@@ -13976,4 +14396,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=E78F8FEDBA22CD8C64756E2164756E21
+//# debugId=81FA5977F36B50C364756E2164756E21