@dolusoft/claude-collab 1.9.6 → 1.10.0

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);
@@ -973,7 +1014,7 @@ async function addFirewallRule(port) {
       "name=claude-collab-discovery",
       "protocol=UDP",
       "dir=in",
-      "localport=9998",
+      "localport=11776",
       "action=allow"
     ]);
   } catch {
@@ -1115,6 +1156,84 @@ function registerFirewallCloseTool(server, client) {
     }
   );
 }
+var PEER_FIND_DESCRIPTION = `Discover and connect to peers on the LAN automatically.
+
+WHAT IT DOES:
+1. Opens your firewall so peers can connect inbound to you (UAC popup)
+2. Waits 30 seconds while multicast discovery finds peers
+3. Closes the firewall (UAC popup) \u2014 established connections persist
+
+WHEN TO USE:
+- First time setup: everyone on the team calls peer_find
+- Adding a new peer to an existing session: only the NEW peer calls peer_find
+  (existing peers will connect to them automatically \u2014 no action needed from others)
+- After a disconnect/restart: the reconnecting peer calls peer_find
+
+HOW NEW PEERS JOIN AN EXISTING SESSION:
+  Existing peers always listen for multicast announcements in the background.
+  When you call peer_find, they hear your announcement and connect OUTBOUND to you.
+  Outbound connections do not require a firewall rule on their side.
+  You only need your own firewall open to accept those inbound connections.
+
+NOTE: Two UAC popups will appear \u2014 one to open, one to close after the wait.`;
+function registerPeerFindTool(server, client) {
+  server.tool(
+    "peer_find",
+    PEER_FIND_DESCRIPTION,
+    {
+      wait_seconds: z.number().min(10).max(120).optional().describe("How long to wait for peers in seconds (default: 30)")
+    },
+    async ({ wait_seconds = 30 }) => {
+      const port = client.getInfo().port;
+      if (!port) {
+        return {
+          content: [{ type: "text", text: "P2P node is not running yet. Try again in a moment." }],
+          isError: true
+        };
+      }
+      try {
+        await addFirewallRule(port);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Failed to open firewall: ${msg}` }],
+          isError: true
+        };
+      }
+      const peersAtStart = new Set(client.getInfo().connectedPeers);
+      await new Promise((resolve) => setTimeout(resolve, wait_seconds * 1e3));
+      try {
+        await removeFirewallRule(port);
+      } catch {
+      }
+      const allPeers = client.getInfo().connectedPeers;
+      const newPeers = allPeers.filter((p) => !peersAtStart.has(p));
+      if (allPeers.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `No peers found after ${wait_seconds}s.`,
+              ``,
+              `Make sure other peers are also running peer_find at the same time,`,
+              `and that all machines are on the same LAN.`
+            ].join("\n")
+          }]
+        };
+      }
+      const lines = [
+        `Firewall closed. Connected peers (${allPeers.length}):`,
+        ...allPeers.map((p) => `  \u2022 ${p}${newPeers.includes(p) ? " (new)" : ""}`),
+        ``,
+        `Connections will persist until a peer disconnects or restarts.`,
+        `If a peer disconnects, they call peer_find again \u2014 no action needed from you.`
+      ];
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
 
 // src/presentation/mcp/server.ts
 function createMcpServer(options) {
@@ -1129,6 +1248,7 @@ function createMcpServer(options) {
   registerHistoryTool(server, client);
   registerFirewallOpenTool(server, client);
   registerFirewallCloseTool(server, client);
+  registerPeerFindTool(server, client);
   return server;
 }
 async function startMcpServer(options) {