@dolusoft/claude-collab 1.11.3 → 1.11.5

package/dist/cli.js

@@ -59,7 +59,7 @@ public class ConInject {
         string lpFileName, uint dwDesiredAccess, uint dwShareMode,
         IntPtr lpSecurityAttributes, uint dwCreationDisposition,
         uint dwFlagsAndAttributes, IntPtr hTemplateFile);
-    [DllImport("kernel32.dll")] public static extern bool WriteConsoleInput(
+    [DllImport("kernel32.dll", CharSet=CharSet.Unicode)] public static extern bool WriteConsoleInput(
         IntPtr hIn, INPUT_RECORD[] buf, uint len, out uint written);
     [DllImport("kernel32.dll")] public static extern bool CloseHandle(IntPtr h);
 
@@ -270,8 +270,10 @@ var FIXED_PORT = 12345;
 var MeshNode = class {
   server = null;
   myName = "";
+  myProfile = "";
   running = false;
   firewallOpened = false;
+  cachedLocalIps = [];
   // One connection per peer (inbound or outbound — whichever was established first)
   peerConnections = /* @__PURE__ */ new Map();
   // Reverse map: ws → peer name (only for registered connections)
@@ -284,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)
@@ -302,6 +306,7 @@ var MeshNode = class {
   }
   async join(name, displayName) {
     this.myName = name;
+    this.cachedLocalIps = this.scanLocalIps();
     await this.startServer();
     return {
       memberId: v4(),
@@ -325,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 {
@@ -337,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);
@@ -378,7 +384,10 @@ var MeshNode = class {
   }
   waitForAnswer(questionId, timeoutMs) {
     const cached = this.receivedAnswers.get(questionId);
-    if (cached) return Promise.resolve(this.formatAnswer(questionId, cached));
+    if (cached) {
+      this.receivedAnswers.delete(questionId);
+      return Promise.resolve(this.formatAnswer(questionId, cached));
+    }
     return new Promise((resolve) => {
       const timeout = setTimeout(() => {
         this.answerWaiters.delete(questionId);
@@ -392,7 +401,9 @@ var MeshNode = class {
   }
   async checkAnswer(questionId) {
     const cached = this.receivedAnswers.get(questionId);
-    return cached ? this.formatAnswer(questionId, cached) : null;
+    if (!cached) return null;
+    this.receivedAnswers.delete(questionId);
+    return this.formatAnswer(questionId, cached);
   }
   formatAnswer(questionId, cached) {
     return {
@@ -451,10 +462,15 @@ 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() {
+    return this.cachedLocalIps;
+  }
+  scanLocalIps() {
     const result = [];
     const interfaces = os.networkInterfaces();
     for (const iface of Object.values(interfaces)) {
@@ -465,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();
@@ -540,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) {
@@ -566,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 {
@@ -600,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;
@@ -614,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);
@@ -627,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);
           }
         }
@@ -649,14 +679,18 @@ var MeshNode = class {
             answeredAt: msg.answeredAt,
             fromName: msg.from
           };
-          this.receivedAnswers.set(msg.questionId, record);
           const waiter = this.answerWaiters.get(msg.questionId);
           if (waiter) {
             this.answerWaiters.delete(msg.questionId);
             waiter(this.formatAnswer(msg.questionId, record));
+          } else {
+            this.receivedAnswers.set(msg.questionId, record);
           }
         }
         break;
+      case "PROFILE_UPDATE":
+        this.peerProfiles.set(msg.name, msg.profile);
+        break;
     }
   }
   handleIncomingAsk(ws, msg) {
@@ -803,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(
@@ -975,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) {
@@ -982,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}`;
@@ -1001,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) {
@@ -1013,6 +1097,7 @@ function createMcpServer(options) {
   registerStatusTool(server, client);
   registerAskTool(server, client);
   registerReplyTool(server, client);
+  registerSetProfileTool(server, client);
   return server;
 }
 async function startMcpServer(options) {