@dolusoft/claude-collab 1.11.4 → 1.11.5

package/dist/cli.js

@@ -270,6 +270,7 @@ var FIXED_PORT = 12345;
 var MeshNode = class {
   server = null;
   myName = "";
+  myProfile = "";
   running = false;
   firewallOpened = false;
   cachedLocalIps = [];
@@ -285,6 +286,8 @@ var MeshNode = class {
   receivedAnswers = /* @__PURE__ */ new Map();
   questionToSender = /* @__PURE__ */ new Map();
   pendingHandlers = /* @__PURE__ */ new Set();
+  // Peer profiles: peerName → profile text
+  peerProfiles = /* @__PURE__ */ new Map();
   // Push-based answer resolution: questionId → resolve callback
   answerWaiters = /* @__PURE__ */ new Map();
   // Answers queued for offline peers: peerName → AnswerMsg[] (delivered on reconnect)
@@ -327,7 +330,7 @@ var MeshNode = class {
         reject(new Error(`Connection to ${ip}:${FIXED_PORT} timed out`));
       }, 1e4);
       ws.on("open", () => {
-        this.sendToWs(ws, { type: "HELLO", name: this.myName });
+        this.sendToWs(ws, { type: "HELLO", name: this.myName, profile: this.myProfile });
       });
       ws.on("message", (data) => {
         try {
@@ -339,6 +342,7 @@ var MeshNode = class {
               resolve(msg.name);
               return;
             }
+            if (msg.profile) this.peerProfiles.set(msg.name, msg.profile);
             this.registerPeer(msg.name, ip, ws);
             this.afterHandshake(msg.name, ws);
             resolve(msg.name);
@@ -458,7 +462,9 @@ var MeshNode = class {
       teamName: this.myName,
       port: FIXED_PORT,
       connectedPeers: [...this.peerConnections.keys()],
-      peerIPs: Object.fromEntries(this.peerIPs)
+      peerIPs: Object.fromEntries(this.peerIPs),
+      myProfile: this.myProfile,
+      peerProfiles: Object.fromEntries(this.peerProfiles)
     };
   }
   getLocalIps() {
@@ -475,6 +481,12 @@ var MeshNode = class {
     }
     return result;
   }
+  async setProfile(profile) {
+    this.myProfile = profile;
+    for (const ws of this.peerConnections.values()) {
+      this.sendToWs(ws, { type: "PROFILE_UPDATE", name: this.myName, profile });
+    }
+  }
   async disconnect() {
     for (const ws of this.peerConnections.values()) ws.close();
     this.peerConnections.clear();
@@ -550,7 +562,12 @@ var MeshNode = class {
   // ---------------------------------------------------------------------------
   /** Called once handshake completes — exchange peer lists and announce to existing peers. */
   afterHandshake(newPeerName, ws) {
-    const listForNew = [...this.peerConnections.keys()].filter((n) => n !== newPeerName).map((n) => ({ name: n, ip: this.peerIPs.get(n) ?? "" })).filter((p) => p.ip !== "");
+    const listForNew = [...this.peerConnections.keys()].filter((n) => n !== newPeerName).map((n) => {
+      const entry = { name: n, ip: this.peerIPs.get(n) ?? "" };
+      const profile = this.peerProfiles.get(n);
+      if (profile) entry.profile = profile;
+      return entry;
+    }).filter((p) => p.ip !== "");
     this.sendToWs(ws, { type: "PEER_LIST", peers: listForNew });
     const newIp = this.peerIPs.get(newPeerName);
     if (newIp) {
@@ -576,7 +593,7 @@ var MeshNode = class {
     this.connectingPeers.add(name);
     const ws = new WebSocket(`ws://${ip}:${FIXED_PORT}`);
     ws.on("open", () => {
-      this.sendToWs(ws, { type: "HELLO", name: this.myName });
+      this.sendToWs(ws, { type: "HELLO", name: this.myName, profile: this.myProfile });
     });
     ws.on("message", (data) => {
       try {
@@ -610,8 +627,9 @@ var MeshNode = class {
         ws.terminate();
         return;
       }
+      if (msg.profile) this.peerProfiles.set(msg.name, msg.profile);
       this.registerPeer(msg.name, remoteIp, ws);
-      this.sendToWs(ws, { type: "HELLO_ACK", name: this.myName });
+      this.sendToWs(ws, { type: "HELLO_ACK", name: this.myName, profile: this.myProfile });
       console.error(`[mesh] peer joined (inbound): ${msg.name}`);
       this.afterHandshake(msg.name, ws);
       return;
@@ -624,6 +642,7 @@ var MeshNode = class {
     switch (msg.type) {
       case "HELLO_ACK":
         if (!this.peerConnections.has(msg.name)) {
+          if (msg.profile) this.peerProfiles.set(msg.name, msg.profile);
           this.peerConnections.set(msg.name, ws);
           this.wsToName.set(ws, msg.name);
           this.connectingPeers.delete(msg.name);
@@ -637,6 +656,7 @@ var MeshNode = class {
           if (peer.name !== this.myName && !this.peerConnections.has(peer.name)) {
             console.error(`[mesh] connecting to ${peer.name} @ ${peer.ip} via PEER_LIST`);
             this.peerIPs.set(peer.name, peer.ip);
+            if (peer.profile) this.peerProfiles.set(peer.name, peer.profile);
             this.connectMeshPeer(peer.name, peer.ip);
           }
         }
@@ -668,6 +688,9 @@ var MeshNode = class {
           }
         }
         break;
+      case "PROFILE_UPDATE":
+        this.peerProfiles.set(msg.name, msg.profile);
+        break;
     }
   }
   handleIncomingAsk(ws, msg) {
@@ -814,25 +837,35 @@ function registerConnectTool(server, client) {
 }
 var ASK_DESCRIPTION = `Send a question to another Claude instance on the LAN and wait for their answer.
 
-WHEN TO USE:
-- You need input, a decision, or work output from a specific peer Claude
-- You want to delegate a subtask to another Claude and use their result
-- You need to coordinate or synchronize work across multiple Claudes
+AUTONOMOUS ROUTING \u2014 decide who to ask yourself:
+1. Call status() to see all connected peers and their profiles
+2. Match your information need to the most relevant peer profile
+3. Call ask(peer, question) without waiting for the user to tell you who to contact
+
+TRIGGER THIS TOOL AUTOMATICALLY when you encounter:
+- A missing API response type, schema, or interface you need to implement against
+- An unknown endpoint behavior, error code, or contract detail
+- A module or system owned by another peer that you need to integrate with
+- Any blocking uncertainty that another peer's profile suggests they can answer
+
+DO NOT guess, use "any" types, or leave TODO comments when a peer can answer.
+DO NOT ask the user which peer to contact \u2014 read profiles and decide yourself.
 
 WORKFLOW:
-1. Call peers() first to confirm the target is online and get their exact name
-2. Call ask(peer, question) \u2014 this blocks until they reply (up to 5 minutes)
-3. Use their answer directly in your ongoing task
+1. Call status() \u2014 read each peer's profile carefully
+2. Identify which peer owns the relevant module or technology
+3. Call ask(peer, question) with full context
+4. Use their answer directly in your ongoing task
 
 WRITING GOOD QUESTIONS:
 - Include all context the other Claude needs \u2014 they cannot see your conversation
-- Be specific about what format or level of detail you expect in the answer
-- If you need code, specify language and constraints
+- Mention the specific file, function, or module you are working on
+- State what format you need: type definition, example response, explanation
 - One focused question per call works better than multiple combined
 
 DO NOT use this tool if:
-- The peer is not listed in peers() \u2014 the call will fail immediately
-- You just want to share information without needing a response (there is no broadcast tool yet)`;
+- The peer is not listed in status() \u2014 the call will fail immediately
+- You just want to share information without needing a response`;
 var askSchema = {
   peer: z.string().describe("Exact name of the peer to ask. Use peers() first to see who is online and get the correct name."),
   question: z.string().describe(
@@ -986,6 +1019,7 @@ function registerStatusTool(server, client) {
     }
     const ipLine = ips.length > 0 ? ips.join(", ") : "(could not detect \u2014 check your network interface)";
     const peerIPs = info.peerIPs ?? {};
+    const peerProfiles = info.peerProfiles ?? {};
     const connected = info.connectedPeers;
     let peersSection;
     if (connected.length === 0) {
@@ -993,7 +1027,9 @@ function registerStatusTool(server, client) {
     } else {
       const list = connected.map((n) => {
         const ip = peerIPs[n] ? ` (${peerIPs[n]})` : "";
-        return `  \u2022 ${n}${ip}`;
+        const profile = peerProfiles[n] ? `
+      ${peerProfiles[n]}` : "";
+        return `  \u2022 ${n}${ip}${profile}`;
       }).join("\n");
       peersSection = `Connected peers (${connected.length}):
 ${list}`;
@@ -1012,6 +1048,43 @@ ${list}`;
     };
   });
 }
+var SET_PROFILE_DESCRIPTION = `Set your profile so other peers know who you are and what you work on.
+
+Your profile is broadcast to all connected peers immediately and shared
+with any peer that connects in the future. Other Claude instances use
+your profile to decide who to ask when they need specific information.
+
+WHAT TO INCLUDE:
+- Your role (backend, frontend, devops, etc.)
+- The modules or systems you are responsible for
+- Technologies you work with
+
+EXAMPLES:
+- "Backend developer. Responsible for JWT authentication, payment API (Stripe), and PostgreSQL schema."
+- "Frontend developer. Works on React components, Next.js routing, and the checkout flow."
+- "DevOps. Manages CI/CD pipelines, Docker images, and AWS infrastructure."
+
+Call this once when you start working. Update it if your focus changes.`;
+var setProfileSchema = {
+  profile: z.string().min(1).describe("A short description of your role and responsibilities. 1-3 sentences.")
+};
+function registerSetProfileTool(server, client) {
+  server.tool("set_profile", SET_PROFILE_DESCRIPTION, setProfileSchema, async (args) => {
+    await client.setProfile(args.profile);
+    const info = client.getInfo();
+    const peerCount = info.connectedPeers.length;
+    return {
+      content: [{
+        type: "text",
+        text: peerCount > 0 ? `Profile set and broadcast to ${peerCount} peer(s).
+
+"${args.profile}"` : `Profile saved. It will be shared automatically when peers connect.
+
+"${args.profile}"`
+      }]
+    };
+  });
+}
 
 // src/presentation/mcp/server.ts
 function createMcpServer(options) {
@@ -1024,6 +1097,7 @@ function createMcpServer(options) {
   registerStatusTool(server, client);
   registerAskTool(server, client);
   registerReplyTool(server, client);
+  registerSetProfileTool(server, client);
   return server;
 }
 async function startMcpServer(options) {