claudemesh-cli 0.8.9 → 0.9.1

package/dist/index.js

@@ -6514,7 +6514,7 @@ function loadConfig() {
     if (!parsed || !Array.isArray(parsed.meshes)) {
       return { version: 1, meshes: [] };
     }
-    return { version: 1, meshes: parsed.meshes, displayName: parsed.displayName, role: parsed.role, groups: parsed.groups, messageMode: parsed.messageMode };
+    return { version: 1, meshes: parsed.meshes, displayName: parsed.displayName, role: parsed.role, groups: parsed.groups, messageMode: parsed.messageMode, accountId: parsed.accountId };
   } catch (e) {
     throw new Error(`Failed to load ${CONFIG_PATH}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -40005,6 +40005,48 @@ var init_file_crypto = __esm(() => {
   init_keypair();
 });
 
+// src/auth/sync-with-broker.ts
+var exports_sync_with_broker = {};
+__export(exports_sync_with_broker, {
+  syncWithBroker: () => syncWithBroker
+});
+async function syncWithBroker(syncToken, peerPubkey, displayName, brokerBaseUrl) {
+  const base = brokerBaseUrl ?? deriveHttpUrl(process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws");
+  const res = await fetch(`${base}/cli-sync`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      sync_token: syncToken,
+      peer_pubkey: peerPubkey,
+      display_name: displayName
+    })
+  });
+  if (!res.ok) {
+    const body2 = await res.text();
+    let msg;
+    try {
+      msg = JSON.parse(body2).error ?? body2;
+    } catch {
+      msg = body2;
+    }
+    throw new Error(`Broker sync failed (${res.status}): ${msg}`);
+  }
+  const body = await res.json();
+  if (!body.ok) {
+    throw new Error(`Broker sync failed: ${body.error ?? "unknown error"}`);
+  }
+  return {
+    account_id: body.account_id,
+    meshes: body.meshes
+  };
+}
+function deriveHttpUrl(wssUrl) {
+  const url = new URL(wssUrl);
+  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+  url.pathname = url.pathname.replace(/\/ws\/?$/, "");
+  return url.toString().replace(/\/$/, "");
+}
+
 // ../../node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
 var STR_SPLITTERS = [
@@ -47547,18 +47589,29 @@ var TOOLS = [
   },
   {
     name: "share_skill",
-    description: "Publish a reusable skill to the mesh. Other peers can discover and load it. If a skill with the same name exists, it is updated.",
+    description: "Publish a reusable skill to the mesh. Other peers can discover and load it as a slash command. If a skill with the same name exists, it is updated. Skills are automatically exposed as MCP prompts and skill:// resources for native Claude Code integration.",
     inputSchema: {
       type: "object",
       properties: {
-        name: { type: "string", description: "Unique skill name (e.g. 'code-review', 'deploy-checklist')" },
+        name: { type: "string", description: "Unique skill name (e.g. 'code-review', 'deploy-checklist'). Becomes the slash command name." },
         description: { type: "string", description: "Short description of what the skill does" },
-        instructions: { type: "string", description: "Full instructions/prompt that a peer loads to acquire this capability" },
+        instructions: { type: "string", description: "Full instructions/prompt markdown. Can include frontmatter (---) block." },
         tags: {
           type: "array",
           items: { type: "string" },
           description: "Tags for discoverability"
-        }
+        },
+        when_to_use: { type: "string", description: "Detailed description of when Claude should auto-invoke this skill" },
+        allowed_tools: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tool names this skill is allowed to use (e.g. ['Bash', 'Read', 'Edit'])"
+        },
+        model: { type: "string", description: "Model override (e.g. 'sonnet', 'opus', 'haiku')" },
+        context: { type: "string", enum: ["inline", "fork"], description: "Execution context: 'inline' (default) or 'fork' (sub-agent)" },
+        agent: { type: "string", description: "Agent type when forked (e.g. 'general-purpose')" },
+        user_invocable: { type: "boolean", description: "Whether users can invoke via /skill-name (default: true)" },
+        argument_hint: { type: "string", description: "Hint text for arguments (e.g. '<file-path>')" }
       },
       required: ["name", "description", "instructions"]
     }
@@ -48702,7 +48755,7 @@ class BrokerClient {
   skillAckResolvers = new Map;
   skillDataResolvers = new Map;
   skillListResolvers = new Map;
-  async shareSkill(name, description, instructions, tags) {
+  async shareSkill(name, description, instructions, tags, manifest) {
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       return null;
     return new Promise((resolve) => {
@@ -48713,7 +48766,7 @@ class BrokerClient {
         if (this.skillAckResolvers.delete(reqId))
           resolve(null);
       }, 5000) });
-      this.ws.send(JSON.stringify({ type: "share_skill", name, description, instructions, tags, _reqId: reqId }));
+      this.ws.send(JSON.stringify({ type: "share_skill", name, description, instructions, tags, manifest, _reqId: reqId }));
     });
   }
   async getSkill(name) {
@@ -49890,7 +49943,9 @@ async function startMcpServer() {
   const server = new Server({ name: "claudemesh", version: "0.3.0" }, {
     capabilities: {
       experimental: { "claude/channel": {} },
-      tools: {}
+      tools: {},
+      prompts: {},
+      resources: {}
     },
     instructions: `## Identity
 You are "${myName}"${myRole ? ` (${myRole})` : ""} — 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.
@@ -50018,6 +50073,129 @@ Your message mode is "${messageMode}".
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS
   }));
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    const client2 = allClients()[0];
+    if (!client2)
+      return { prompts: [] };
+    const skills = await client2.listSkills();
+    return {
+      prompts: skills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        arguments: []
+      }))
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    const { name, arguments: promptArgs } = req.params;
+    const client2 = allClients()[0];
+    if (!client2)
+      throw new Error("Not connected to any mesh");
+    const skill = await client2.getSkill(name);
+    if (!skill)
+      throw new Error(`Skill "${name}" not found in the mesh`);
+    let content = skill.instructions;
+    const manifest = skill.manifest;
+    if (manifest && typeof manifest === "object") {
+      const fm = ["---"];
+      if (manifest.description)
+        fm.push(`description: "${manifest.description}"`);
+      if (manifest.when_to_use)
+        fm.push(`when_to_use: "${manifest.when_to_use}"`);
+      if (manifest.allowed_tools?.length)
+        fm.push(`allowed-tools:
+${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
+`)}`);
+      if (manifest.model)
+        fm.push(`model: ${manifest.model}`);
+      if (manifest.context)
+        fm.push(`context: ${manifest.context}`);
+      if (manifest.agent)
+        fm.push(`agent: ${manifest.agent}`);
+      if (manifest.user_invocable === false)
+        fm.push(`user-invocable: false`);
+      if (manifest.argument_hint)
+        fm.push(`argument-hint: "${manifest.argument_hint}"`);
+      fm.push(`---
+`);
+      if (fm.length > 3)
+        content = fm.join(`
+`) + content;
+    }
+    return {
+      description: skill.description,
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text: content }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const client2 = allClients()[0];
+    if (!client2)
+      return { resources: [] };
+    const skills = await client2.listSkills();
+    return {
+      resources: skills.map((s) => ({
+        uri: `skill://claudemesh/${encodeURIComponent(s.name)}`,
+        name: s.name,
+        description: s.description,
+        mimeType: "text/markdown"
+      }))
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    const { uri } = req.params;
+    const match = uri.match(/^skill:\/\/claudemesh\/(.+)$/);
+    if (!match)
+      throw new Error(`Unknown resource URI: ${uri}`);
+    const name = decodeURIComponent(match[1]);
+    const client2 = allClients()[0];
+    if (!client2)
+      throw new Error("Not connected to any mesh");
+    const skill = await client2.getSkill(name);
+    if (!skill)
+      throw new Error(`Skill "${name}" not found`);
+    const manifest = skill.manifest;
+    const fmLines = ["---"];
+    fmLines.push(`name: ${skill.name}`);
+    fmLines.push(`description: "${skill.description}"`);
+    if (skill.tags.length)
+      fmLines.push(`tags: [${skill.tags.join(", ")}]`);
+    if (manifest && typeof manifest === "object") {
+      if (manifest.when_to_use)
+        fmLines.push(`when_to_use: "${manifest.when_to_use}"`);
+      if (manifest.allowed_tools?.length)
+        fmLines.push(`allowed-tools:
+${manifest.allowed_tools.map((t) => `  - ${t}`).join(`
+`)}`);
+      if (manifest.model)
+        fmLines.push(`model: ${manifest.model}`);
+      if (manifest.context)
+        fmLines.push(`context: ${manifest.context}`);
+      if (manifest.agent)
+        fmLines.push(`agent: ${manifest.agent}`);
+      if (manifest.user_invocable === false)
+        fmLines.push(`user-invocable: false`);
+      if (manifest.argument_hint)
+        fmLines.push(`argument-hint: "${manifest.argument_hint}"`);
+    }
+    fmLines.push(`---
+`);
+    const fullContent = fmLines.join(`
+`) + skill.instructions;
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/markdown",
+          text: fullContent
+        }
+      ]
+    };
+  });
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
     for (const c of allClients()) {
@@ -50826,16 +51004,45 @@ ${rows.join(`
 `));
       }
       case "share_skill": {
-        const { name: skillName, description: skillDesc, instructions: skillInstr, tags: skillTags } = args ?? {};
+        const {
+          name: skillName,
+          description: skillDesc,
+          instructions: skillInstr,
+          tags: skillTags,
+          when_to_use,
+          allowed_tools,
+          model,
+          context: skillContext,
+          agent,
+          user_invocable,
+          argument_hint
+        } = args ?? {};
         if (!skillName || !skillDesc || !skillInstr)
           return text("share_skill: `name`, `description`, and `instructions` required", true);
         const client2 = allClients()[0];
         if (!client2)
           return text("share_skill: not connected", true);
-        const result = await client2.shareSkill(skillName, skillDesc, skillInstr, skillTags);
+        const manifest = {};
+        if (when_to_use)
+          manifest.when_to_use = when_to_use;
+        if (allowed_tools?.length)
+          manifest.allowed_tools = allowed_tools;
+        if (model)
+          manifest.model = model;
+        if (skillContext)
+          manifest.context = skillContext;
+        if (agent)
+          manifest.agent = agent;
+        if (user_invocable === false)
+          manifest.user_invocable = false;
+        if (argument_hint)
+          manifest.argument_hint = argument_hint;
+        const result = await client2.shareSkill(skillName, skillDesc, skillInstr, skillTags, Object.keys(manifest).length > 0 ? manifest : undefined);
         if (!result)
           return text("share_skill: broker did not acknowledge", true);
-        return text(`Skill "${skillName}" published to the mesh.`);
+        server.notification({ method: "notifications/prompts/list_changed" });
+        server.notification({ method: "notifications/resources/list_changed" });
+        return text(`Skill "${skillName}" published to the mesh. It will appear as /claudemesh:${skillName} in Claude Code.`);
       }
       case "get_skill": {
         const { name: gsName } = args ?? {};
@@ -50847,13 +51054,30 @@ ${rows.join(`
         const skill = await client2.getSkill(gsName);
         if (!skill)
           return text(`Skill "${gsName}" not found in the mesh.`);
+        const manifest = skill.manifest;
+        const metaLines = [];
+        if (manifest) {
+          if (manifest.when_to_use)
+            metaLines.push(`**When to use:** ${manifest.when_to_use}`);
+          if (manifest.allowed_tools)
+            metaLines.push(`**Allowed tools:** ${manifest.allowed_tools.join(", ")}`);
+          if (manifest.model)
+            metaLines.push(`**Model:** ${manifest.model}`);
+          if (manifest.context)
+            metaLines.push(`**Context:** ${manifest.context}`);
+          if (manifest.agent)
+            metaLines.push(`**Agent:** ${manifest.agent}`);
+        }
         return text(`# Skill: ${skill.name}
 
 **Description:** ${skill.description}
 **Author:** ${skill.author}
 **Tags:** ${skill.tags.length ? skill.tags.join(", ") : "none"}
 **Created:** ${skill.createdAt}
-
+**Slash command:** /claudemesh:${skill.name}
+` + (metaLines.length ? metaLines.join(`
+`) + `
+` : "") + `
 ---
 
 ## Instructions
@@ -50881,6 +51105,10 @@ ${lines.join(`
         if (!client2)
           return text("remove_skill: not connected", true);
         const removed = await client2.removeSkill(rsName);
+        if (removed) {
+          server.notification({ method: "notifications/prompts/list_changed" });
+          server.notification({ method: "notifications/resources/list_changed" });
+        }
         return text(removed ? `Skill "${rsName}" removed.` : `Skill "${rsName}" not found.`, !removed);
       }
       case "ping_mesh": {
@@ -51394,159 +51622,163 @@ ${lines.join(`
         return text(`Unknown tool: ${name}`, true);
     }
   });
-  await startClients(config2);
   const transport = new StdioServerTransport;
   await server.connect(transport);
-  for (const client2 of allClients()) {
-    client2.onPush(async (msg) => {
-      if (messageMode === "off")
-        return;
-      if (msg.subtype === "system" && msg.event) {
-        const eventName = msg.event;
-        const data = msg.eventData ?? {};
-        let content2;
-        if (eventName === "tick") {
-          const tick = data.tick ?? 0;
-          const simTime = String(data.simTime ?? "").replace("T", " ").replace(/\..*/, "");
-          const speed = data.speed ?? 1;
-          content2 = `[heartbeat] tick ${tick} | sim time: ${simTime} | speed: x${speed}`;
-        } else if (eventName === "peer_joined") {
-          content2 = `[system] Peer "${data.name ?? "unknown"}" joined the mesh`;
-        } else if (eventName === "peer_returned") {
-          const peerName = String(data.name ?? "unknown");
-          const lastSeenAt = data.lastSeenAt ? relativeTime(String(data.lastSeenAt)) : "unknown";
-          const groups = Array.isArray(data.groups) ? data.groups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "";
-          const summary = data.summary ? ` Summary: "${data.summary}"` : "";
-          content2 = `[system] Welcome back, "${peerName}"! Last seen ${lastSeenAt}.${groups ? ` Restored: ${groups}` : ""}${summary}`;
-        } else if (eventName === "peer_left") {
-          content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
-        } else if (eventName === "mcp_registered") {
-          const tools = Array.isArray(data.tools) ? data.tools.join(", ") : "";
-          content2 = `[system] New MCP server available: "${data.serverName}" (hosted by ${data.hostedBy}). Tools: ${tools}. Use mesh_tool_call to invoke.`;
-        } else if (eventName === "mcp_unregistered") {
-          content2 = `[system] MCP server "${data.serverName}" removed (was hosted by ${data.hostedBy})`;
-        } else if (eventName === "mcp_restored") {
-          content2 = `[system] MCP server "${data.serverName}" is back online (hosted by ${data.hostedBy})`;
-        } else if (eventName === "watch_triggered") {
-          content2 = `[WATCH] ${data.label ?? data.url}: ${data.oldValue} → ${data.newValue}`;
-        } else if (eventName === "mcp_deployed") {
-          content2 = `[SERVICE] "${data.name}" deployed (${data.tool_count} tools) by ${data.deployed_by}`;
-        } else if (eventName === "mcp_undeployed") {
-          content2 = `[SERVICE] "${data.name}" undeployed by ${data.by}`;
-        } else if (eventName === "mcp_scope_changed") {
-          content2 = `[SERVICE] "${data.name}" scope changed to ${JSON.stringify(data.scope)} by ${data.by}`;
-        } else {
-          content2 = `[system] ${eventName}: ${JSON.stringify(data)}`;
+  startClients(config2).then(() => {
+    wirePushHandlers();
+  }).catch(() => {
+    wirePushHandlers();
+  });
+  async function wirePushHandlers() {
+    for (const client2 of allClients()) {
+      client2.onPush(async (msg) => {
+        if (messageMode === "off")
+          return;
+        if (msg.subtype === "system" && msg.event) {
+          const eventName = msg.event;
+          const data = msg.eventData ?? {};
+          let content2;
+          if (eventName === "tick") {
+            const tick = data.tick ?? 0;
+            const simTime = String(data.simTime ?? "").replace("T", " ").replace(/\..*/, "");
+            const speed = data.speed ?? 1;
+            content2 = `[heartbeat] tick ${tick} | sim time: ${simTime} | speed: x${speed}`;
+          } else if (eventName === "peer_joined") {
+            content2 = `[system] Peer "${data.name ?? "unknown"}" joined the mesh`;
+          } else if (eventName === "peer_returned") {
+            const peerName = String(data.name ?? "unknown");
+            const lastSeenAt = data.lastSeenAt ? relativeTime(String(data.lastSeenAt)) : "unknown";
+            const groups = Array.isArray(data.groups) ? data.groups.map((g) => g.role ? `@${g.name}:${g.role}` : `@${g.name}`).join(", ") : "";
+            const summary = data.summary ? ` Summary: "${data.summary}"` : "";
+            content2 = `[system] Welcome back, "${peerName}"! Last seen ${lastSeenAt}.${groups ? ` Restored: ${groups}` : ""}${summary}`;
+          } else if (eventName === "peer_left") {
+            content2 = `[system] Peer "${data.name ?? "unknown"}" left the mesh`;
+          } else if (eventName === "mcp_registered") {
+            const tools = Array.isArray(data.tools) ? data.tools.join(", ") : "";
+            content2 = `[system] New MCP server available: "${data.serverName}" (hosted by ${data.hostedBy}). Tools: ${tools}. Use mesh_tool_call to invoke.`;
+          } else if (eventName === "mcp_unregistered") {
+            content2 = `[system] MCP server "${data.serverName}" removed (was hosted by ${data.hostedBy})`;
+          } else if (eventName === "mcp_restored") {
+            content2 = `[system] MCP server "${data.serverName}" is back online (hosted by ${data.hostedBy})`;
+          } else if (eventName === "watch_triggered") {
+            content2 = `[WATCH] ${data.label ?? data.url}: ${data.oldValue} → ${data.newValue}`;
+          } else if (eventName === "mcp_deployed") {
+            content2 = `[SERVICE] "${data.name}" deployed (${data.tool_count} tools) by ${data.deployed_by}`;
+          } else if (eventName === "mcp_undeployed") {
+            content2 = `[SERVICE] "${data.name}" undeployed by ${data.by}`;
+          } else if (eventName === "mcp_scope_changed") {
+            content2 = `[SERVICE] "${data.name}" scope changed to ${JSON.stringify(data.scope)} by ${data.by}`;
+          } else {
+            content2 = `[system] ${eventName}: ${JSON.stringify(data)}`;
+          }
+          try {
+            await server.notification({
+              method: "notifications/claude/channel",
+              params: {
+                content: content2,
+                meta: {
+                  kind: "system",
+                  event: eventName,
+                  mesh_slug: client2.meshSlug,
+                  mesh_id: client2.meshId,
+                  ...Object.keys(data).length > 0 ? { eventData: data } : {}
+                }
+              }
+            });
+            process.stderr.write(`[claudemesh] system: ${content2}
+`);
+          } catch (pushErr) {
+            process.stderr.write(`[claudemesh] system push FAILED: ${pushErr}
+`);
+          }
+          return;
+        }
+        const fromPubkey = msg.senderPubkey || "";
+        const fromName = fromPubkey ? await resolvePeerName(client2, fromPubkey) : "unknown";
+        if (messageMode === "inbox") {
+          try {
+            await server.notification({
+              method: "notifications/claude/channel",
+              params: {
+                content: `[inbox] New message from ${fromName}. Use check_messages to read.`,
+                meta: { kind: "inbox_notification", from_name: fromName }
+              }
+            });
+          } catch {}
+          return;
         }
+        const content = msg.plaintext ?? decryptFailedWarning(fromPubkey);
         try {
           await server.notification({
             method: "notifications/claude/channel",
             params: {
-              content: content2,
+              content,
               meta: {
-                kind: "system",
-                event: eventName,
+                from_id: fromPubkey,
+                from_name: fromName,
                 mesh_slug: client2.meshSlug,
                 mesh_id: client2.meshId,
-                ...Object.keys(data).length > 0 ? { eventData: data } : {}
+                priority: msg.priority,
+                sent_at: msg.createdAt,
+                delivered_at: msg.receivedAt,
+                kind: msg.kind,
+                ...msg.subtype ? { subtype: msg.subtype } : {}
               }
             }
           });
-          process.stderr.write(`[claudemesh] system: ${content2}
+          process.stderr.write(`[claudemesh] pushed: from=${fromName} content=${content.slice(0, 60)}
 `);
         } catch (pushErr) {
-          process.stderr.write(`[claudemesh] system push FAILED: ${pushErr}
+          process.stderr.write(`[claudemesh] push FAILED: ${pushErr}
 `);
         }
-        return;
-      }
-      const fromPubkey = msg.senderPubkey || "";
-      const fromName = fromPubkey ? await resolvePeerName(client2, fromPubkey) : "unknown";
-      if (messageMode === "inbox") {
+      });
+      client2.onStreamData(async (evt) => {
         try {
           await server.notification({
             method: "notifications/claude/channel",
             params: {
-              content: `[inbox] New message from ${fromName}. Use check_messages to read.`,
-              meta: { kind: "inbox_notification", from_name: fromName }
+              content: `[stream:${evt.stream}] from ${evt.publishedBy}: ${JSON.stringify(evt.data)}`,
+              meta: {
+                kind: "stream_data",
+                stream: evt.stream,
+                published_by: evt.publishedBy
+              }
             }
           });
         } catch {}
-        return;
-      }
-      const content = msg.plaintext ?? decryptFailedWarning(fromPubkey);
-      try {
-        await server.notification({
-          method: "notifications/claude/channel",
-          params: {
-            content,
-            meta: {
-              from_id: fromPubkey,
-              from_name: fromName,
-              mesh_slug: client2.meshSlug,
-              mesh_id: client2.meshId,
-              priority: msg.priority,
-              sent_at: msg.createdAt,
-              delivered_at: msg.receivedAt,
-              kind: msg.kind,
-              ...msg.subtype ? { subtype: msg.subtype } : {}
-            }
-          }
-        });
-        process.stderr.write(`[claudemesh] pushed: from=${fromName} content=${content.slice(0, 60)}
-`);
-      } catch (pushErr) {
-        process.stderr.write(`[claudemesh] push FAILED: ${pushErr}
-`);
-      }
-    });
-    client2.onStreamData(async (evt) => {
-      try {
-        await server.notification({
-          method: "notifications/claude/channel",
-          params: {
-            content: `[stream:${evt.stream}] from ${evt.publishedBy}: ${JSON.stringify(evt.data)}`,
-            meta: {
-              kind: "stream_data",
-              stream: evt.stream,
-              published_by: evt.publishedBy
+      });
+      client2.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 {}
-    });
-    client2.onStateChange(async (change) => {
+          });
+        } catch {}
+      });
+    }
+    const welcomeClient = allClients()[0];
+    if (welcomeClient && welcomeClient.status === "open") {
       try {
+        const peers = await welcomeClient.listPeers();
+        const peerNames = peers.filter((p) => p.displayName !== myName).map((p) => p.displayName).join(", ") || "none";
         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
-            }
+            content: `[system] Connected as ${myName} to mesh ${welcomeClient.meshSlug}. ${peers.length} peer(s) online: ${peerNames}. Call mesh_info for full details or set_summary to announce yourself.`,
+            meta: { kind: "welcome", mesh_slug: welcomeClient.meshSlug }
           }
         });
       } catch {}
-    });
+    }
   }
-  setTimeout(async () => {
-    const client2 = allClients()[0];
-    if (!client2 || client2.status !== "open")
-      return;
-    try {
-      const peers = await client2.listPeers();
-      const peerNames = peers.filter((p) => p.displayName !== myName).map((p) => p.displayName).join(", ") || "none";
-      await server.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: `[system] Connected as ${myName} to mesh ${client2.meshSlug}. ${peers.length} peer(s) online: ${peerNames}. Call mesh_info for full details or set_summary to announce yourself.`,
-          meta: { kind: "welcome", mesh_slug: client2.meshSlug }
-        }
-      });
-    } catch {}
-  }, 3000);
   const keepalive = setInterval(() => {}, 1000);
   const shutdown = () => {
     clearInterval(keepalive);
@@ -52371,6 +52603,84 @@ import { mkdtempSync, writeFileSync as writeFileSync4, rmSync, readdirSync, stat
 import { tmpdir, hostname as hostname2, homedir as homedir4 } from "node:os";
 import { join as join4 } from "node:path";
 import { createInterface } from "node:readline";
+
+// src/auth/callback-listener.ts
+import { createServer } from "node:http";
+function startCallbackListener() {
+  return new Promise((resolveStart) => {
+    let resolveToken;
+    const tokenPromise = new Promise((r) => {
+      resolveToken = r;
+    });
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, "http://localhost");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, {
+          "Access-Control-Allow-Origin": "https://claudemesh.com",
+          "Access-Control-Allow-Methods": "GET",
+          "Access-Control-Allow-Headers": "Content-Type"
+        });
+        res.end();
+        return;
+      }
+      if (url.pathname === "/ping") {
+        res.writeHead(200, {
+          "Content-Type": "text/plain",
+          "Access-Control-Allow-Origin": "https://claudemesh.com"
+        });
+        res.end("ok");
+        return;
+      }
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        if (token) {
+          res.writeHead(200, {
+            "Content-Type": "text/html",
+            "Access-Control-Allow-Origin": "https://claudemesh.com"
+          });
+          res.end("<html><body><h2>Done! You can close this tab.</h2><p>Launching claudemesh...</p></body></html>");
+          resolveToken(token);
+          setTimeout(() => server.close(), 500);
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Missing token");
+        }
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolveStart({
+        port: addr.port,
+        token: tokenPromise,
+        close: () => server.close()
+      });
+    });
+  });
+}
+// src/auth/open-browser.ts
+import { exec } from "node:child_process";
+function openBrowser(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    return Promise.resolve(false);
+  }
+  const quoted = JSON.stringify(url);
+  const browserCmd = process.env.BROWSER;
+  const cmd = browserCmd ? `${browserCmd} ${quoted}` : process.platform === "darwin" ? `open ${quoted}` : process.platform === "win32" ? `rundll32 url.dll,FileProtocolHandler ${quoted}` : `xdg-open ${quoted}`;
+  return new Promise((resolve2) => {
+    exec(cmd, (err) => resolve2(!err));
+  });
+}
+// src/auth/pairing-code.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789";
+function generatePairingCode() {
+  const bytes = randomBytes2(4);
+  return Array.from(bytes, (b) => CHARS[b % CHARS.length]).join("");
+}
+// src/commands/launch.ts
 async function pickMesh(meshes) {
   if (meshes.length === 1)
     return meshes[0];
@@ -52509,6 +52819,73 @@ async function runLaunch(flags, rawArgs) {
     console.log(`✓ Joined "${invite.payload.mesh_slug}"${enroll.alreadyMember ? " (already member)" : ""}`);
   }
   const config2 = loadConfig();
+  let justSynced = false;
+  if (config2.meshes.length === 0 && !args.joinLink) {
+    const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+    const bold2 = (s) => useColor ? `\x1B[1m${s}\x1B[22m` : s;
+    const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+    const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+    const code = generatePairingCode();
+    const listener = await startCallbackListener();
+    const url = `https://claudemesh.com/cli-auth?port=${listener.port}&code=${code}&action=sync`;
+    console.log(`
+  ${bold2("Welcome to claudemesh!")} No meshes found.`);
+    console.log(`  Opening browser to sign in...
+`);
+    const opened = await openBrowser(url);
+    if (!opened) {
+      console.log(`  Couldn't open browser automatically.`);
+    }
+    console.log(`  ${dim(`Visit: ${url}`)}`);
+    console.log(`  ${dim(`Or join with invite: claudemesh launch --join <url>`)}
+`);
+    const manualPromise = new Promise((resolve2) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      rl.question("  Paste sync token (or wait for browser): ", (answer) => {
+        rl.close();
+        if (answer.trim())
+          resolve2(answer.trim());
+      });
+    });
+    const timeoutPromise = new Promise((resolve2) => {
+      setTimeout(() => resolve2(null), 900000);
+    });
+    const syncToken = await Promise.race([
+      listener.token,
+      manualPromise,
+      timeoutPromise
+    ]);
+    listener.close();
+    if (!syncToken) {
+      console.error(`
+  Timed out waiting for sign-in.`);
+      process.exit(1);
+    }
+    const { generateKeypair: generateKeypair3 } = await Promise.resolve().then(() => (init_keypair(), exports_keypair));
+    const keypair = await generateKeypair3();
+    const displayNameForSync = args.name ?? `${hostname2()}-${process.pid}`;
+    const { syncWithBroker: syncWithBroker2 } = await Promise.resolve().then(() => exports_sync_with_broker);
+    const result = await syncWithBroker2(syncToken, keypair.publicKey, displayNameForSync);
+    const { saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+    for (const m of result.meshes) {
+      config2.meshes.push({
+        meshId: m.mesh_id,
+        memberId: m.member_id,
+        slug: m.slug,
+        name: m.slug,
+        pubkey: keypair.publicKey,
+        secretKey: keypair.secretKey,
+        brokerUrl: m.broker_url,
+        joinedAt: new Date().toISOString()
+      });
+    }
+    config2.accountId = result.account_id;
+    saveConfig2(config2);
+    justSynced = true;
+    console.log(`
+  ${green("✓")} Synced ${result.meshes.length} mesh(es): ${result.meshes.map((m) => m.slug).join(", ")}
+`);
+  }
   if (config2.meshes.length === 0) {
     console.error("No meshes joined. Run `claudemesh join <url>` or use --join <url>.");
     process.exit(1);
@@ -52528,7 +52905,7 @@ async function runLaunch(flags, rawArgs) {
   let role = args.role;
   let parsedGroups = args.groups ? parseGroupsString(args.groups) : [];
   let messageMode = args.messageMode ?? "push";
-  if (!args.quiet) {
+  if (!args.quiet && !justSynced) {
     if (role === null) {
       const answer = await askLine("  Role (optional): ");
       if (answer)
@@ -52754,7 +53131,7 @@ init_config();
 // package.json
 var package_default = {
   name: "claudemesh-cli",
-  version: "0.8.9",
+  version: "0.9.1",
   description: "Claude Code MCP client for claudemesh — peer mesh messaging between Claude sessions.",
   keywords: [
     "claude-code",
@@ -53698,6 +54075,151 @@ function runCreate(args) {
   console.log("       claudemesh create --list-templates");
 }
 
+// src/commands/sync.ts
+init_config();
+import { createInterface as createInterface2 } from "node:readline";
+import { hostname as hostname4 } from "node:os";
+init_keypair();
+async function runSync(args) {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+  const config2 = loadConfig();
+  const code = generatePairingCode();
+  const listener = await startCallbackListener();
+  const url = `https://claudemesh.com/cli-auth?port=${listener.port}&code=${code}&action=sync`;
+  console.log(`Opening browser to sync meshes...`);
+  console.log(dim(`Visit: ${url}`));
+  await openBrowser(url);
+  const manualPromise = new Promise((resolve2) => {
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
+    rl.question("Paste sync token (or wait for browser): ", (answer) => {
+      rl.close();
+      if (answer.trim())
+        resolve2(answer.trim());
+    });
+  });
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => resolve2(null), 15 * 60000);
+  });
+  const syncToken = await Promise.race([
+    listener.token,
+    manualPromise,
+    timeoutPromise
+  ]);
+  listener.close();
+  if (!syncToken) {
+    console.error("Timed out waiting for sign-in.");
+    process.exit(1);
+  }
+  const keypair = config2.meshes.length > 0 ? { publicKey: config2.meshes[0].pubkey, secretKey: config2.meshes[0].secretKey } : await generateKeypair2();
+  const displayName = config2.displayName ?? `${hostname4()}-${process.pid}`;
+  const result = await syncWithBroker(syncToken, keypair.publicKey, displayName);
+  let added = 0;
+  for (const m of result.meshes) {
+    if (config2.meshes.some((existing) => existing.meshId === m.mesh_id))
+      continue;
+    config2.meshes.push({
+      meshId: m.mesh_id,
+      memberId: m.member_id,
+      slug: m.slug,
+      name: m.slug,
+      pubkey: keypair.publicKey,
+      secretKey: keypair.secretKey,
+      brokerUrl: m.broker_url,
+      joinedAt: new Date().toISOString()
+    });
+    added++;
+  }
+  config2.accountId = result.account_id;
+  saveConfig(config2);
+  if (added > 0) {
+    console.log(green(`✓ Added ${added} new mesh(es)`));
+  } else {
+    console.log(`Already up to date (${config2.meshes.length} meshes)`);
+  }
+}
+
+// src/commands/profile.ts
+init_config();
+async function runProfile(flags) {
+  const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[22m` : s;
+  const green = (s) => useColor ? `\x1B[32m${s}\x1B[39m` : s;
+  const config2 = loadConfig();
+  if (config2.meshes.length === 0) {
+    console.error("No meshes joined. Run `claudemesh join <url>` first.");
+    process.exit(1);
+  }
+  const mesh = flags.mesh ? config2.meshes.find((m) => m.slug === flags.mesh) : config2.meshes[0];
+  if (!mesh) {
+    console.error(`Mesh "${flags.mesh}" not found. Joined: ${config2.meshes.map((m) => m.slug).join(", ")}`);
+    process.exit(1);
+  }
+  const brokerUrl = mesh.brokerUrl.replace("wss://", "https://").replace("ws://", "http://").replace(/\/ws\/?$/, "");
+  const hasEdits = flags["role-tag"] !== undefined || flags.groups !== undefined || flags["message-mode"] !== undefined || flags.name !== undefined;
+  if (hasEdits) {
+    const targetMemberId = flags.member ?? mesh.memberId;
+    const body = {};
+    if (flags.name !== undefined)
+      body.displayName = flags.name;
+    if (flags["role-tag"] !== undefined)
+      body.roleTag = flags["role-tag"];
+    if (flags.groups !== undefined) {
+      body.groups = flags.groups.split(",").map((s) => {
+        const [name, role] = s.trim().split(":");
+        return role ? { name, role } : { name };
+      });
+    }
+    if (flags["message-mode"] !== undefined)
+      body.messageMode = flags["message-mode"];
+    const res = await fetch(`${brokerUrl}/mesh/${mesh.meshId}/member/${targetMemberId}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Member-Id": mesh.memberId
+      },
+      body: JSON.stringify(body)
+    });
+    const result = await res.json();
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (result.ok) {
+      console.log(green("✓ Profile updated"));
+      const member = result.member;
+      printProfile(member, dim);
+    } else {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+  } else {
+    const res = await fetch(`${brokerUrl}/mesh/${mesh.meshId}/members`);
+    const result = await res.json();
+    if (!result.ok) {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+    const me = result.members?.find((m) => m.id === mesh.memberId);
+    if (flags.json) {
+      console.log(JSON.stringify(me ?? {}, null, 2));
+    } else if (me) {
+      printProfile(me, dim);
+    } else {
+      console.log("Member not found in mesh.");
+    }
+  }
+}
+function printProfile(member, dim) {
+  const groups = member.groups;
+  const groupStr = groups?.length ? groups.map((g) => g.role ? `${g.name} (${g.role})` : g.name).join(", ") : dim("(none)");
+  console.log(`  Name:     ${member.displayName ?? dim("(not set)")}`);
+  console.log(`  Role:     ${member.roleTag ?? dim("(not set)")}`);
+  console.log(`  Groups:   ${groupStr}`);
+  console.log(`  Messages: ${member.messageMode ?? "push"}`);
+  console.log(`  Access:   ${member.permission ?? "member"}`);
+  console.log(`  Mesh:     ${dim(String(member.id ?? ""))}`);
+}
+
 // src/index.ts
 var launch = defineCommand({
   meta: {
@@ -53954,6 +54476,30 @@ var main = defineCommand({
         await runRemind(args, positionals);
       }
     }),
+    sync: defineCommand({
+      meta: { name: "sync", description: "Sync meshes from your dashboard account" },
+      args: {
+        force: { type: "boolean", description: "Re-link account even if already linked", default: false }
+      },
+      async run({ args }) {
+        await runSync(args);
+      }
+    }),
+    profile: defineCommand({
+      meta: { name: "profile", description: "View or edit your member profile" },
+      args: {
+        mesh: { type: "string", description: "Mesh slug (auto-selected if only one joined)" },
+        "role-tag": { type: "string", description: "Set role tag (e.g. 'backend-dev', 'lead')" },
+        groups: { type: "string", description: "Set groups as 'group:role,...' (e.g. 'eng:lead,review')" },
+        "message-mode": { type: "string", description: "'push' | 'inbox' | 'off'" },
+        name: { type: "string", description: "Set display name" },
+        member: { type: "string", description: "Edit another member (admin only)" },
+        json: { type: "boolean", description: "Output as JSON", default: false }
+      },
+      async run({ args }) {
+        await runProfile(args);
+      }
+    }),
     status: defineCommand({
       meta: { name: "status", description: "Check broker connectivity for each joined mesh" },
       async run() {

package/package.json

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