@dolusoft/claude-collab 1.11.2 → 1.11.3

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';
@@ -264,6 +265,7 @@ 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;
@@ -280,12 +282,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
@@ -346,7 +347,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 +358,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 +368,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
@@ -412,6 +410,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 +425,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 +435,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,
@@ -463,31 +465,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 +595,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();
@@ -706,10 +682,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 +713,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 +723,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 +945,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 +1013,6 @@ function createMcpServer(options) {
   registerStatusTool(server, client);
   registerAskTool(server, client);
   registerReplyTool(server, client);
-  registerHistoryTool(server, client);
   return server;
 }
 async function startMcpServer(options) {