@dolusoft/claude-collab 1.11.2 → 1.11.4

package/dist/cli.js

@@ -3,7 +3,8 @@ import { Command } from 'commander';
 import { WebSocket, WebSocketServer } from 'ws';
 import { v4 } from 'uuid';
 import os, { tmpdir } from 'os';
-import { execSync, spawn, execFile } from 'child_process';
+import { exec, spawn, execFile } from 'child_process';
+import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import { unlinkSync } from 'fs';
 import { join } from 'path';
@@ -58,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);
 
@@ -264,12 +265,14 @@ var InjectionQueue = class extends EventEmitter {
 var injectionQueue = new InjectionQueue();
 
 // src/infrastructure/mesh/mesh-node.ts
+var execAsync = promisify(exec);
 var FIXED_PORT = 12345;
 var MeshNode = class {
   server = null;
   myName = "";
   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)
@@ -280,12 +283,11 @@ var MeshNode = class {
   connectingPeers = /* @__PURE__ */ new Set();
   incomingQuestions = /* @__PURE__ */ new Map();
   receivedAnswers = /* @__PURE__ */ new Map();
-  sentQuestions = /* @__PURE__ */ new Map();
   questionToSender = /* @__PURE__ */ new Map();
   pendingHandlers = /* @__PURE__ */ new Set();
   // Push-based answer resolution: questionId → resolve callback
   answerWaiters = /* @__PURE__ */ new Map();
-  // Answers queued for offline peers: peerName → AnswerMsg (delivered on reconnect)
+  // Answers queued for offline peers: peerName → AnswerMsg[] (delivered on reconnect)
   pendingOutboundAnswers = /* @__PURE__ */ new Map();
   // ---------------------------------------------------------------------------
   // ICollabClient implementation
@@ -301,6 +303,7 @@ var MeshNode = class {
   }
   async join(name, displayName) {
     this.myName = name;
+    this.cachedLocalIps = this.scanLocalIps();
     await this.startServer();
     return {
       memberId: v4(),
@@ -346,7 +349,6 @@ var MeshNode = class {
       });
       ws.on("close", () => {
         clearTimeout(timeout);
-        this.connectingPeers.delete(ip);
         const name = this.wsToName.get(ws);
         if (name) {
           this.wsToName.delete(ws);
@@ -358,7 +360,6 @@ var MeshNode = class {
       });
       ws.on("error", (err) => {
         clearTimeout(timeout);
-        this.connectingPeers.delete(ip);
         reject(new Error(`Failed to connect to ${ip}:${FIXED_PORT} \u2014 ${err.message}`));
       });
     });
@@ -369,7 +370,6 @@ var MeshNode = class {
       throw new Error(`Peer "${toPeer}" is not connected. Use status() to see who's online.`);
     }
     const questionId = v4();
-    this.sentQuestions.set(questionId, { toPeer, content, askedAt: (/* @__PURE__ */ new Date()).toISOString() });
     const ackPromise = this.waitForResponse(
       (m) => m.type === "ASK_ACK" && m.questionId === questionId,
       5e3
@@ -380,7 +380,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);
@@ -394,7 +397,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 {
@@ -412,6 +417,8 @@ var MeshNode = class {
     question.answerContent = content;
     question.answerFormat = format;
     const senderName = this.questionToSender.get(questionId);
+    this.incomingQuestions.delete(questionId);
+    this.questionToSender.delete(questionId);
     if (senderName) {
       const answerMsg = {
         type: "ANSWER",
@@ -425,7 +432,9 @@ var MeshNode = class {
       if (ws && ws.readyState === WebSocket.OPEN) {
         this.sendToWs(ws, answerMsg);
       } else {
-        this.pendingOutboundAnswers.set(senderName, answerMsg);
+        const queue = this.pendingOutboundAnswers.get(senderName) ?? [];
+        queue.push(answerMsg);
+        this.pendingOutboundAnswers.set(senderName, queue);
         console.error(`[mesh] "${senderName}" is offline, answer queued for delivery on reconnect`);
       }
     }
@@ -433,7 +442,7 @@ var MeshNode = class {
   }
   async getInbox() {
     const now = Date.now();
-    const questions = [...this.incomingQuestions.values()].filter((q) => !q.answered).map((q) => ({
+    const questions = [...this.incomingQuestions.values()].map((q) => ({
       questionId: q.questionId,
       from: { displayName: `${q.fromName} Claude`, teamName: q.fromName },
       content: q.content,
@@ -453,6 +462,9 @@ var MeshNode = class {
     };
   }
   getLocalIps() {
+    return this.cachedLocalIps;
+  }
+  scanLocalIps() {
     const result = [];
     const interfaces = os.networkInterfaces();
     for (const iface of Object.values(interfaces)) {
@@ -463,31 +475,6 @@ var MeshNode = class {
     }
     return result;
   }
-  getHistory() {
-    const entries = [];
-    for (const [questionId, sent] of this.sentQuestions) {
-      const answer = this.receivedAnswers.get(questionId);
-      entries.push({
-        direction: "sent",
-        questionId,
-        peer: sent.toPeer,
-        question: sent.content,
-        askedAt: sent.askedAt,
-        ...answer ? { answer: answer.content, answeredAt: answer.answeredAt } : {}
-      });
-    }
-    for (const [, incoming] of this.incomingQuestions) {
-      entries.push({
-        direction: "received",
-        questionId: incoming.questionId,
-        peer: incoming.fromName,
-        question: incoming.content,
-        askedAt: incoming.createdAt.toISOString(),
-        ...incoming.answered && incoming.answerContent ? { answer: incoming.answerContent, answeredAt: (/* @__PURE__ */ new Date()).toISOString() } : {}
-      });
-    }
-    return entries.sort((a, b) => a.askedAt.localeCompare(b.askedAt));
-  }
   async disconnect() {
     for (const ws of this.peerConnections.values()) ws.close();
     this.peerConnections.clear();
@@ -618,7 +605,6 @@ var MeshNode = class {
   // ---------------------------------------------------------------------------
   /** Handles messages on inbound connections (server side — we know the remote IP). */
   handleInboundMessage(ws, remoteIp, msg) {
-    for (const handler of this.pendingHandlers) handler(msg);
     if (msg.type === "HELLO") {
       if (this.peerConnections.has(msg.name)) {
         ws.terminate();
@@ -673,11 +659,12 @@ 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;
@@ -706,10 +693,10 @@ var MeshNode = class {
   }
   deliverPendingAnswer(peerName, ws) {
     const pending = this.pendingOutboundAnswers.get(peerName);
-    if (pending) {
+    if (pending && pending.length > 0) {
       this.pendingOutboundAnswers.delete(peerName);
-      this.sendToWs(ws, pending);
-      console.error(`[mesh] delivered queued answer to "${peerName}" after reconnect`);
+      for (const msg of pending) this.sendToWs(ws, msg);
+      console.error(`[mesh] delivered ${pending.length} queued answer(s) to "${peerName}" after reconnect`);
     }
   }
   sendToWs(ws, msg) {
@@ -737,12 +724,9 @@ var MeshNode = class {
 async function killProcessOnPort(port) {
   try {
     if (process.platform === "win32") {
-      const out = execSync(
-        `netstat -ano | findstr ":${port} "`,
-        { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }
-      );
+      const { stdout } = await execAsync(`netstat -ano | findstr ":${port} "`);
       const pids = /* @__PURE__ */ new Set();
-      for (const line of out.split("\n")) {
+      for (const line of stdout.split("\n")) {
         const parts = line.trim().split(/\s+/);
         if (parts.length >= 5 && parts[3] === "LISTENING" && parts[4]) {
           pids.add(parts[4]);
@@ -750,13 +734,13 @@ async function killProcessOnPort(port) {
       }
       for (const pid of pids) {
         try {
-          execSync(`taskkill /PID ${pid} /F`, { stdio: "ignore" });
+          await execAsync(`taskkill /PID ${pid} /F`);
           console.error(`[mesh] killed PID ${pid} on port ${port}`);
         } catch {
         }
       }
     } else {
-      execSync(`fuser -k ${port}/tcp`, { stdio: "ignore" });
+      await execAsync(`fuser -k ${port}/tcp`);
     }
   } catch {
   }
@@ -972,49 +956,6 @@ function registerReplyTool(server, client) {
   });
 }
 
-// src/presentation/mcp/tools/history.tool.ts
-var HISTORY_DESCRIPTION = `Show all questions and answers exchanged this session \u2014 both sent and received.
-
-WHEN TO USE:
-- To review what was already discussed before asking a follow-up question
-- To check if a previously sent question has been answered yet
-- To find a questionId you need to reference
-- To catch up on received questions you may have missed
-
-OUTPUT FORMAT:
-- \u2192 peer: question you sent, with their answer below
-- \u2190 peer: question they sent you, with your reply below
-- (no answer yet) means the question is still waiting for a response`;
-function registerHistoryTool(server, client) {
-  server.tool("history", HISTORY_DESCRIPTION, {}, async () => {
-    const entries = client.getHistory();
-    if (entries.length === 0) {
-      return {
-        content: [{ type: "text", text: "No questions exchanged yet this session." }]
-      };
-    }
-    const unanswered = entries.filter((e) => !e.answer);
-    const lines = entries.map((e) => {
-      const time = new Date(e.askedAt).toLocaleTimeString();
-      if (e.direction === "sent") {
-        const answerLine = e.answer ? `  \u21B3 ${e.peer}: ${e.answer}` : `  \u21B3 (no answer yet)`;
-        return `[${time}] \u2192 ${e.peer}: ${e.question}
-${answerLine}`;
-      } else {
-        const answerLine = e.answer ? `  \u21B3 you: ${e.answer}` : `  \u21B3 (not replied yet \u2014 use reply() if you haven't answered)`;
-        return `[${time}] \u2190 ${e.peer}: ${e.question}
-${answerLine}`;
-      }
-    });
-    const summary = unanswered.length > 0 ? `
-
-\u26A0 ${unanswered.length} question(s) still waiting for a response.` : "";
-    return {
-      content: [{ type: "text", text: lines.join("\n\n") + summary }]
-    };
-  });
-}
-
 // src/presentation/mcp/tools/status.tool.ts
 var STATUS_DESCRIPTION = `Show your identity and network address on the collaboration network.
 
@@ -1083,7 +1024,6 @@ function createMcpServer(options) {
   registerStatusTool(server, client);
   registerAskTool(server, client);
   registerReplyTool(server, client);
-  registerHistoryTool(server, client);
   return server;
 }
 async function startMcpServer(options) {