@dolusoft/claude-collab 1.11.0 → 1.11.2

package/dist/mcp-main.js

@@ -2,7 +2,7 @@
 import { WebSocket, WebSocketServer } from 'ws';
 import { v4 } from 'uuid';
 import os, { tmpdir } from 'os';
-import { execFile, spawn } from 'child_process';
+import { execSync, execFile, spawn } from 'child_process';
 import { EventEmitter } from 'events';
 import { unlinkSync } from 'fs';
 import { join } from 'path';
@@ -10,7 +10,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-// src/infrastructure/p2p/p2p-protocol.ts
+// src/infrastructure/mesh/protocol.ts
 function serialize(msg) {
   return JSON.stringify(msg);
 }
@@ -262,9 +262,9 @@ var InjectionQueue = class extends EventEmitter {
 };
 var injectionQueue = new InjectionQueue();
 
-// src/infrastructure/p2p/p2p-node.ts
+// src/infrastructure/mesh/mesh-node.ts
 var FIXED_PORT = 12345;
-var P2PNode = class {
+var MeshNode = class {
   server = null;
   myName = "";
   running = false;
@@ -351,7 +351,7 @@ var P2PNode = class {
           this.wsToName.delete(ws);
           if (this.peerConnections.get(name) === ws) {
             this.peerConnections.delete(name);
-            console.error(`[p2p] disconnected from peer: ${name}`);
+            console.error(`[mesh] disconnected from peer: ${name}`);
           }
         }
       });
@@ -365,7 +365,7 @@ var P2PNode = class {
   async ask(toPeer, content, format) {
     const ws = this.peerConnections.get(toPeer);
     if (!ws || ws.readyState !== WebSocket.OPEN) {
-      throw new Error(`Peer "${toPeer}" is not connected. Use peers() to see who's online.`);
+      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() });
@@ -425,7 +425,7 @@ var P2PNode = class {
         this.sendToWs(ws, answerMsg);
       } else {
         this.pendingOutboundAnswers.set(senderName, answerMsg);
-        console.error(`[p2p] "${senderName}" is offline, answer queued for delivery on reconnect`);
+        console.error(`[mesh] "${senderName}" is offline, answer queued for delivery on reconnect`);
       }
     }
     injectionQueue.notifyReplied();
@@ -499,13 +499,27 @@ var P2PNode = class {
   // ---------------------------------------------------------------------------
   // Private: server startup
   // ---------------------------------------------------------------------------
-  startServer() {
+  async startServer() {
+    try {
+      await this.tryBind();
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code === "EADDRINUSE") {
+        console.error(`[mesh] port ${FIXED_PORT} in use \u2014 killing existing process`);
+        await killProcessOnPort(FIXED_PORT);
+        await this.tryBind();
+      } else {
+        throw err;
+      }
+    }
+  }
+  tryBind() {
     return new Promise((resolve, reject) => {
       const wss = new WebSocketServer({ port: FIXED_PORT });
       wss.once("listening", () => {
         this.server = wss;
         this.running = true;
-        console.error(`[p2p] listening on port ${FIXED_PORT} as "${this.myName}"`);
+        console.error(`[mesh] listening on port ${FIXED_PORT} as "${this.myName}"`);
         this.attachServerHandlers(wss);
         resolve();
       });
@@ -531,16 +545,16 @@ var P2PNode = class {
           this.wsToName.delete(ws);
           if (this.peerConnections.get(name) === ws) {
             this.peerConnections.delete(name);
-            console.error(`[p2p] peer disconnected (inbound): ${name}`);
+            console.error(`[mesh] peer disconnected (inbound): ${name}`);
           }
         }
       });
       ws.on("error", (err) => {
-        console.error("[p2p] inbound ws error:", err.message);
+        console.error("[mesh] inbound ws error:", err.message);
       });
     });
     wss.on("error", (err) => {
-      console.error("[p2p] server error:", err.message);
+      console.error("[mesh] server error:", err.message);
     });
   }
   // ---------------------------------------------------------------------------
@@ -564,7 +578,7 @@ var P2PNode = class {
     this.wsToName.set(ws, name);
     this.peerIPs.set(name, ip);
     this.connectingPeers.delete(name);
-    console.error(`[p2p] peer registered: ${name} @ ${ip}`);
+    console.error(`[mesh] peer registered: ${name} @ ${ip}`);
     this.deliverPendingAnswer(name, ws);
   }
   /** Connect outbound to a peer discovered via PEER_LIST or PEER_ANNOUNCE. */
@@ -589,12 +603,12 @@ var P2PNode = class {
         this.wsToName.delete(ws);
         if (this.peerConnections.get(peerName) === ws) {
           this.peerConnections.delete(peerName);
-          console.error(`[p2p] disconnected from mesh peer: ${peerName}`);
+          console.error(`[mesh] disconnected from mesh peer: ${peerName}`);
         }
       }
     });
     ws.on("error", (err) => {
-      console.error(`[p2p] mesh connect to "${name}" @ ${ip} failed: ${err.message}`);
+      console.error(`[mesh] connect to "${name}" @ ${ip} failed: ${err.message}`);
       this.connectingPeers.delete(name);
     });
   }
@@ -611,7 +625,7 @@ var P2PNode = class {
       }
       this.registerPeer(msg.name, remoteIp, ws);
       this.sendToWs(ws, { type: "HELLO_ACK", name: this.myName });
-      console.error(`[p2p] peer joined (inbound): ${msg.name}`);
+      console.error(`[mesh] peer joined (inbound): ${msg.name}`);
       this.afterHandshake(msg.name, ws);
       return;
     }
@@ -626,7 +640,7 @@ var P2PNode = class {
           this.peerConnections.set(msg.name, ws);
           this.wsToName.set(ws, msg.name);
           this.connectingPeers.delete(msg.name);
-          console.error(`[p2p] connected to mesh peer: ${msg.name}`);
+          console.error(`[mesh] connected to mesh peer: ${msg.name}`);
           this.deliverPendingAnswer(msg.name, ws);
           this.afterHandshake(msg.name, ws);
         }
@@ -634,7 +648,7 @@ var P2PNode = class {
       case "PEER_LIST":
         for (const peer of msg.peers) {
           if (peer.name !== this.myName && !this.peerConnections.has(peer.name)) {
-            console.error(`[p2p] mesh: connecting to ${peer.name} @ ${peer.ip} via PEER_LIST`);
+            console.error(`[mesh] connecting to ${peer.name} @ ${peer.ip} via PEER_LIST`);
             this.peerIPs.set(peer.name, peer.ip);
             this.connectMeshPeer(peer.name, peer.ip);
           }
@@ -642,7 +656,7 @@ var P2PNode = class {
         break;
       case "PEER_ANNOUNCE":
         if (msg.name !== this.myName && !this.peerConnections.has(msg.name)) {
-          console.error(`[p2p] mesh: connecting to ${msg.name} @ ${msg.ip} via PEER_ANNOUNCE`);
+          console.error(`[mesh] connecting to ${msg.name} @ ${msg.ip} via PEER_ANNOUNCE`);
           this.peerIPs.set(msg.name, msg.ip);
           this.connectMeshPeer(msg.name, msg.ip);
         }
@@ -694,7 +708,7 @@ var P2PNode = class {
     if (pending) {
       this.pendingOutboundAnswers.delete(peerName);
       this.sendToWs(ws, pending);
-      console.error(`[p2p] delivered queued answer to "${peerName}" after reconnect`);
+      console.error(`[mesh] delivered queued answer to "${peerName}" after reconnect`);
     }
   }
   sendToWs(ws, msg) {
@@ -719,6 +733,34 @@ var P2PNode = class {
     });
   }
 };
+async function killProcessOnPort(port) {
+  try {
+    if (process.platform === "win32") {
+      const out = execSync(
+        `netstat -ano | findstr ":${port} "`,
+        { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }
+      );
+      const pids = /* @__PURE__ */ new Set();
+      for (const line of out.split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 5 && parts[3] === "LISTENING" && parts[4]) {
+          pids.add(parts[4]);
+        }
+      }
+      for (const pid of pids) {
+        try {
+          execSync(`taskkill /PID ${pid} /F`, { stdio: "ignore" });
+          console.error(`[mesh] killed PID ${pid} on port ${port}`);
+        } catch {
+        }
+      }
+    } else {
+      execSync(`fuser -k ${port}/tcp`, { stdio: "ignore" });
+    }
+  } catch {
+  }
+  await new Promise((resolve) => setTimeout(resolve, 300));
+}
 var CONNECT_DESCRIPTION = `Connect to another Claude instance by their IP address.
 
 WHEN TO USE:
@@ -821,7 +863,7 @@ function registerAskTool(server, client) {
         return {
           content: [{
             type: "text",
-            text: "P2P node is not ready yet. Wait a moment and try again."
+            text: "Node is not ready yet. Wait a moment and try again."
           }],
           isError: true
         };
@@ -902,7 +944,7 @@ function registerReplyTool(server, client) {
         return {
           content: [{
             type: "text",
-            text: "P2P node is not ready yet. Wait a moment and try again."
+            text: "Node is not ready yet. Wait a moment and try again."
           }],
           isError: true
         };
@@ -929,68 +971,6 @@ function registerReplyTool(server, client) {
   });
 }
 
-// src/presentation/mcp/tools/peers.tool.ts
-var PEERS_DESCRIPTION = `List all currently active peer connections.
-
-WHEN TO USE:
-- Before calling ask() \u2014 to confirm the target peer is online and get their exact name
-- After connect() \u2014 to verify the connection succeeded and the mesh formed
-- When a peer seems unreachable \u2014 to check if they are still connected
-
-WHAT IT SHOWS:
-- Your own name and port
-- All peers with an active direct connection
-
-IF NO PEERS ARE LISTED:
-- Use connect(ip) to connect to a peer
-- Ask your teammate to run status() to get their IP`;
-function registerPeersTool(server, client) {
-  server.tool("peers", PEERS_DESCRIPTION, {}, async () => {
-    const info = client.getInfo();
-    const myName = info.teamName ?? "(starting...)";
-    const myPort = info.port ?? "?";
-    const connected = info.connectedPeers;
-    if (!client.isConnected) {
-      return {
-        content: [{
-          type: "text",
-          text: [
-            `P2P server is not running yet (port ${myPort} may be in use).`,
-            `Check the MCP process logs for the error details.`
-          ].join("\n")
-        }],
-        isError: true
-      };
-    }
-    if (connected.length === 0) {
-      return {
-        content: [{
-          type: "text",
-          text: [
-            `You are "${myName}" (listening on port ${myPort}).`,
-            `No peers connected yet.`,
-            ``,
-            `Use connect(ip) to connect to a peer.`,
-            `Ask your teammate to run status() to get their IP.`
-          ].join("\n")
-        }]
-      };
-    }
-    const peerIPs = info.peerIPs ?? {};
-    const list = connected.map((name) => {
-      const ip = peerIPs[name] ? ` (${peerIPs[name]})` : "";
-      return `  \u2022 ${name}${ip}`;
-    }).join("\n");
-    return {
-      content: [{
-        type: "text",
-        text: `You are "${myName}" (port ${myPort}). Connected peers (${connected.length}):
-${list}`
-      }]
-    };
-  });
-}
-
 // src/presentation/mcp/tools/history.tool.ts
 var HISTORY_DESCRIPTION = `Show all questions and answers exchanged this session \u2014 both sent and received.
 
@@ -1059,12 +1039,23 @@ function registerStatusTool(server, client) {
       };
     }
     let ips = [];
-    if (client instanceof P2PNode) {
+    if (client instanceof MeshNode) {
       ips = client.getLocalIps();
     }
     const ipLine = ips.length > 0 ? ips.join(", ") : "(could not detect \u2014 check your network interface)";
-    const peerCount = info.connectedPeers.length;
-    const peerLine = peerCount === 0 ? "No peers connected yet. Share your IP so others can connect(ip)." : `Connected to ${peerCount} peer(s): ${info.connectedPeers.map((n) => `"${n}"`).join(", ")}`;
+    const peerIPs = info.peerIPs ?? {};
+    const connected = info.connectedPeers;
+    let peersSection;
+    if (connected.length === 0) {
+      peersSection = "No peers connected yet. Share your IP so others can connect(ip).";
+    } else {
+      const list = connected.map((n) => {
+        const ip = peerIPs[n] ? ` (${peerIPs[n]})` : "";
+        return `  \u2022 ${n}${ip}`;
+      }).join("\n");
+      peersSection = `Connected peers (${connected.length}):
+${list}`;
+    }
     return {
       content: [{
         type: "text",
@@ -1073,7 +1064,7 @@ function registerStatusTool(server, client) {
           `IP:    ${ipLine}`,
           `Port:  ${port}`,
           ``,
-          peerLine
+          peersSection
         ].join("\n")
       }]
     };
@@ -1091,7 +1082,6 @@ function createMcpServer(options) {
   registerStatusTool(server, client);
   registerAskTool(server, client);
   registerReplyTool(server, client);
-  registerPeersTool(server, client);
   registerHistoryTool(server, client);
   return server;
 }
@@ -1112,7 +1102,7 @@ async function main() {
     console.error("--name is required");
     process.exit(1);
   }
-  const node = new P2PNode();
+  const node = new MeshNode();
   const mcpReady = startMcpServer({ client: node });
   node.join(name, name).catch((err) => {
     console.error(`[mcp-main] Failed to start on port 12345: ${err.message}`);