@dolusoft/claude-collab 1.9.5 → 1.9.7

package/dist/cli.js

@@ -2,8 +2,8 @@
 import { Command } from 'commander';
 import { WebSocket, WebSocketServer } from 'ws';
 import { v4 } from 'uuid';
-import { createSocket } from 'dgram';
-import { tmpdir, networkInterfaces } from 'os';
+import dgram from 'dgram';
+import os, { tmpdir } from 'os';
 import { EventEmitter } from 'events';
 import { execFile, spawn } from 'child_process';
 import { unlinkSync } from 'fs';
@@ -19,79 +19,121 @@ function serialize(msg) {
 function parse(data) {
   return JSON.parse(data);
 }
-var PEER_DISCOVERY_PORT = 9998;
-var BROADCAST_INTERVAL_MS = 3e3;
-function getBroadcastAddresses() {
-  const addrs = /* @__PURE__ */ new Set(["255.255.255.255"]);
-  for (const ifaces of Object.values(networkInterfaces())) {
-    for (const iface of ifaces ?? []) {
-      if (iface.family !== "IPv4" || iface.internal) continue;
-      const ip = iface.address.split(".").map(Number);
-      const mask = iface.netmask.split(".").map(Number);
-      const broadcast = ip.map((b, i) => b | ~mask[i] & 255).join(".");
-      addrs.add(broadcast);
-    }
-  }
-  return [...addrs];
-}
-var PeerBroadcaster = class {
+var MULTICAST_ADDR = "239.255.42.42";
+var MULTICAST_PORT = 11776;
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var PEER_TIMEOUT_MS = 2e4;
+var MulticastDiscovery = class extends EventEmitter {
   socket = null;
-  timer = null;
-  start(name, port) {
-    if (this.socket) return;
-    const socket = createSocket({ type: "udp4", reuseAddr: true });
+  heartbeatTimer = null;
+  timeoutTimer = null;
+  peers = /* @__PURE__ */ new Map();
+  myName = "";
+  myWsPort = 0;
+  start(name, wsPort) {
+    this.myName = name;
+    this.myWsPort = wsPort;
+    const socket = dgram.createSocket({ type: "udp4", reuseAddr: true });
     this.socket = socket;
     socket.on("error", (err) => {
-      console.error("[peer-broadcaster] error:", err.message);
+      console.error("[multicast] socket error:", err.message);
     });
-    socket.bind(0, () => {
-      socket.setBroadcast(true);
-      const send = () => {
-        if (!this.socket) return;
-        const msg = Buffer.from(JSON.stringify({ type: "claude-collab-peer", name, port }));
-        for (const addr of getBroadcastAddresses()) {
-          socket.send(msg, 0, msg.length, PEER_DISCOVERY_PORT, addr, (err) => {
-            if (err) console.error(`[peer-broadcaster] send to ${addr} error:`, err.message);
-          });
-        }
-      };
-      send();
-      this.timer = setInterval(send, BROADCAST_INTERVAL_MS);
+    socket.on("message", (buf, rinfo) => {
+      try {
+        const msg = JSON.parse(buf.toString());
+        this.handleMessage(msg, rinfo.address);
+      } catch {
+      }
+    });
+    socket.bind(MULTICAST_PORT, () => {
+      try {
+        socket.addMembership(MULTICAST_ADDR);
+        socket.setMulticastTTL(1);
+        socket.setMulticastLoopback(false);
+      } catch (err) {
+        console.error("[multicast] membership error:", err);
+      }
+      this.announce();
+      this.heartbeatTimer = setInterval(() => this.announce(), HEARTBEAT_INTERVAL_MS);
+      this.timeoutTimer = setInterval(() => this.checkTimeouts(), 5e3);
     });
   }
   stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.timeoutTimer) {
+      clearInterval(this.timeoutTimer);
+      this.timeoutTimer = null;
     }
     if (this.socket) {
-      this.socket.close();
+      this.sendMessage({ type: "LEAVE", name: this.myName });
+      try {
+        this.socket.dropMembership(MULTICAST_ADDR);
+        this.socket.close();
+      } catch {
+      }
       this.socket = null;
     }
+    this.peers.clear();
   }
-};
-function watchForPeer(onFound) {
-  const socket = createSocket({ type: "udp4", reuseAddr: true });
-  socket.on("error", (err) => {
-    console.error("[peer-listener] bind failed on port", PEER_DISCOVERY_PORT, "\u2014", err.message);
-  });
-  socket.on("message", (msg, rinfo) => {
-    try {
-      const data = JSON.parse(msg.toString());
-      if (data.type === "claude-collab-peer" && typeof data.name === "string" && typeof data.port === "number") {
-        onFound({ name: data.name, host: rinfo.address, port: data.port });
+  resolveLocalIp() {
+    const interfaces = os.networkInterfaces();
+    for (const iface of Object.values(interfaces)) {
+      if (!iface) continue;
+      for (const addr of iface) {
+        if (addr.family === "IPv4" && !addr.internal) return addr.address;
       }
-    } catch {
     }
-  });
-  socket.bind(PEER_DISCOVERY_PORT, "0.0.0.0");
-  return () => {
-    try {
-      socket.close();
-    } catch {
+    return "127.0.0.1";
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  announce() {
+    this.sendMessage({ type: "ANNOUNCE", name: this.myName, wsPort: this.myWsPort });
+  }
+  sendMessage(msg) {
+    if (!this.socket) return;
+    const buf = Buffer.from(JSON.stringify(msg));
+    this.socket.send(buf, MULTICAST_PORT, MULTICAST_ADDR, (err) => {
+      if (err) console.error("[multicast] send error:", err.message);
+    });
+  }
+  handleMessage(msg, fromIp) {
+    if (msg.type === "ANNOUNCE") {
+      if (msg.name === this.myName) return;
+      const existing = this.peers.get(msg.name);
+      if (!existing) {
+        const peer = { name: msg.name, ip: fromIp, wsPort: msg.wsPort, lastSeen: Date.now() };
+        this.peers.set(msg.name, peer);
+        this.emit("peer-found", { name: peer.name, ip: peer.ip, wsPort: peer.wsPort });
+        console.error(`[multicast] discovered peer: ${msg.name} @ ${fromIp}:${msg.wsPort}`);
+      } else {
+        existing.lastSeen = Date.now();
+        existing.ip = fromIp;
+        existing.wsPort = msg.wsPort;
+      }
+    } else if (msg.type === "LEAVE") {
+      if (this.peers.has(msg.name)) {
+        this.peers.delete(msg.name);
+        this.emit("peer-lost", msg.name);
+        console.error(`[multicast] peer left: ${msg.name}`);
+      }
     }
-  };
-}
+  }
+  checkTimeouts() {
+    const now = Date.now();
+    for (const [name, peer] of this.peers) {
+      if (now - peer.lastSeen > PEER_TIMEOUT_MS) {
+        this.peers.delete(name);
+        this.emit("peer-lost", name);
+        console.error(`[multicast] peer timed out: ${name}`);
+      }
+    }
+  }
+};
 var CS_CONINJECT = `
 using System;
 using System.Collections.Generic;
@@ -333,8 +375,7 @@ var P2PNode = class {
   answerWaiters = /* @__PURE__ */ new Map();
   // Answers queued for offline peers: peerName → AnswerMsg (delivered on reconnect)
   pendingOutboundAnswers = /* @__PURE__ */ new Map();
-  broadcaster = null;
-  stopPeerWatcher = null;
+  discovery = null;
   boundPort = 0;
   // ---------------------------------------------------------------------------
   // ICollabClient implementation
@@ -477,8 +518,8 @@ var P2PNode = class {
     return entries.sort((a, b) => a.askedAt.localeCompare(b.askedAt));
   }
   async disconnect() {
-    this.stopPeerWatcher?.();
-    this.broadcaster?.stop();
+    this.discovery?.stop();
+    this.discovery = null;
     for (const ws of this.peerConnections.values()) ws.close();
     this.peerConnections.clear();
     this.wsToName.clear();
@@ -549,14 +590,14 @@ var P2PNode = class {
   // Private: discovery + outbound connections
   // ---------------------------------------------------------------------------
   startDiscovery() {
-    this.broadcaster = new PeerBroadcaster();
-    this.broadcaster.start(this.myName, this.boundPort);
-    this.stopPeerWatcher = watchForPeer((peer) => {
-      if (peer.name === this.myName) return;
+    const discovery = new MulticastDiscovery();
+    this.discovery = discovery;
+    discovery.on("peer-found", (peer) => {
       if (this.peerConnections.has(peer.name)) return;
       if (this.connectingPeers.has(peer.name)) return;
-      this.connectToPeer(peer.name, peer.host, peer.port);
+      this.connectToPeer(peer.name, peer.ip, peer.wsPort);
     });
+    discovery.start(this.myName, this.boundPort);
   }
   connectToPeer(peerName, host, port) {
     this.connectingPeers.add(peerName);
@@ -935,17 +976,7 @@ ${answerLine}`;
     };
   });
 }
-function runDirect(argArray) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn("netsh", argArray, { stdio: "ignore" });
-    proc.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`netsh exited with code ${code}`));
-    });
-    proc.on("error", (err) => reject(new Error(`netsh not found: ${err.message}`)));
-  });
-}
-function runElevated(argArray) {
+function runNetshElevated(argArray) {
   const argList = argArray.map((a) => `"${a}"`).join(",");
   const psCommand = `Start-Process -FilePath "netsh" -ArgumentList @(${argList}) -Verb RunAs -Wait`;
   return new Promise((resolve, reject) => {
@@ -960,16 +991,10 @@ function runElevated(argArray) {
   });
 }
 async function runNetsh(argArray) {
-  try {
-    await runDirect(argArray);
-    return { method: "direct" };
-  } catch {
-    await runElevated(argArray);
-    return { method: "elevated" };
-  }
+  await runNetshElevated(argArray);
 }
 async function addFirewallRule(port) {
-  const result = await runNetsh([
+  await runNetsh([
     "advfirewall",
     "firewall",
     "add",
@@ -989,15 +1014,14 @@ async function addFirewallRule(port) {
       "name=claude-collab-discovery",
       "protocol=UDP",
       "dir=in",
-      "localport=9998",
+      "localport=11776",
       "action=allow"
     ]);
   } catch {
   }
-  return result;
 }
 async function removeFirewallRule(port) {
-  const result = await runNetsh([
+  await runNetsh([
     "advfirewall",
     "firewall",
     "delete",
@@ -1008,7 +1032,6 @@ async function removeFirewallRule(port) {
     await runNetsh(["advfirewall", "firewall", "delete", "rule", "name=claude-collab-discovery"]);
   } catch {
   }
-  return result;
 }
 
 // src/presentation/mcp/tools/firewall-open.tool.ts
@@ -1048,13 +1071,12 @@ function registerFirewallOpenTool(server, client) {
         };
       }
       try {
-        const { method } = await addFirewallRule(targetPort);
-        const how = method === "direct" ? "applied directly (already elevated)" : "applied via UAC popup";
+        await addFirewallRule(targetPort);
         return {
           content: [{
             type: "text",
             text: [
-              `Firewall rule opened for port ${targetPort} (claude-collab-${targetPort}). ${how}.`,
+              `Firewall rule opened for port ${targetPort} (claude-collab-${targetPort}).`,
               `Peers on the LAN can now connect to you inbound.`,
               `Call firewall_close() when you are done with this session.`
             ].join("\n")
@@ -1110,12 +1132,11 @@ function registerFirewallCloseTool(server, client) {
         };
       }
       try {
-        const { method } = await removeFirewallRule(targetPort);
-        const how = method === "direct" ? "applied directly (already elevated)" : "applied via UAC popup";
+        await removeFirewallRule(targetPort);
         return {
           content: [{
             type: "text",
-            text: `Firewall rule removed for port ${targetPort} (claude-collab-${targetPort}). ${how}.`
+            text: `Firewall rule removed for port ${targetPort} (claude-collab-${targetPort}).`
           }]
         };
       } catch (err) {