@dolusoft/claude-collab 1.3.0 → 1.4.1

package/dist/cli.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { WebSocketServer, WebSocket } from 'ws';
-import { createServer } from 'net';
 import { v4 } from 'uuid';
-import multicastDns from 'multicast-dns';
 import { EventEmitter } from 'events';
 import { execFile } from 'child_process';
 import { unlinkSync } from 'fs';
@@ -13,147 +11,6 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-var SERVICE_TYPE = "_claude-collab._tcp.local";
-var MdnsDiscovery = class {
-  mdns;
-  announced = false;
-  port = 0;
-  teamName = "";
-  memberId = "";
-  peersByTeam = /* @__PURE__ */ new Map();
-  peersByMemberId = /* @__PURE__ */ new Map();
-  onPeerFoundCb;
-  onPeerLostCb;
-  constructor() {
-    this.mdns = multicastDns();
-    this.setupHandlers();
-  }
-  get serviceName() {
-    return `${this.memberId}.${SERVICE_TYPE}`;
-  }
-  buildAnswers() {
-    return [
-      {
-        name: SERVICE_TYPE,
-        type: "PTR",
-        ttl: 300,
-        data: this.serviceName
-      },
-      {
-        name: this.serviceName,
-        type: "SRV",
-        ttl: 300,
-        data: {
-          priority: 0,
-          weight: 0,
-          port: this.port,
-          target: "localhost"
-        }
-      },
-      {
-        name: this.serviceName,
-        type: "TXT",
-        ttl: 300,
-        data: [
-          Buffer.from(`team=${this.teamName}`),
-          Buffer.from(`memberId=${this.memberId}`),
-          Buffer.from("ver=1")
-        ]
-      }
-    ];
-  }
-  setupHandlers() {
-    this.mdns.on("query", (query) => {
-      if (!this.announced) return;
-      const questions = query.questions ?? [];
-      const ptrQuery = questions.find(
-        (q) => q.type === "PTR" && q.name === SERVICE_TYPE
-      );
-      if (!ptrQuery) return;
-      this.mdns.respond({ answers: this.buildAnswers() });
-    });
-    this.mdns.on("response", (response) => {
-      this.parseResponse(response);
-    });
-  }
-  parseResponse(response) {
-    const allRecords = [
-      ...response.answers ?? [],
-      ...response.additionals ?? []
-    ];
-    const ptrRecords = allRecords.filter(
-      (r) => r.type === "PTR" && r.name === SERVICE_TYPE
-    );
-    for (const ptr of ptrRecords) {
-      const instanceName = ptr.data;
-      const srv = allRecords.find(
-        (r) => r.type === "SRV" && r.name === instanceName
-      );
-      const txt = allRecords.find(
-        (r) => r.type === "TXT" && r.name === instanceName
-      );
-      if (!srv) continue;
-      const port = srv.data.port;
-      const host = "localhost";
-      let teamName = "";
-      let memberId = "";
-      if (txt) {
-        const txtData = txt.data ?? [];
-        for (const entry of txtData) {
-          const str = Buffer.isBuffer(entry) ? entry.toString() : String(entry);
-          if (str.startsWith("team=")) teamName = str.slice(5);
-          if (str.startsWith("memberId=")) memberId = str.slice(9);
-        }
-      }
-      if (!teamName || !memberId) continue;
-      if (memberId === this.memberId) continue;
-      const ptrTtl = ptr.ttl ?? 300;
-      const srvTtl = srv.ttl ?? 300;
-      if (ptrTtl === 0 || srvTtl === 0) {
-        this.peersByTeam.delete(teamName);
-        this.peersByMemberId.delete(memberId);
-        this.onPeerLostCb?.(memberId);
-        continue;
-      }
-      const peer = { host, port, teamName, memberId };
-      this.peersByTeam.set(teamName, peer);
-      this.peersByMemberId.set(memberId, peer);
-      this.onPeerFoundCb?.(peer);
-    }
-  }
-  /**
-   * Announce this node's service via mDNS.
-   * Sends an unsolicited response so existing peers notice immediately.
-   */
-  announce(port, teamName, memberId) {
-    this.port = port;
-    this.teamName = teamName;
-    this.memberId = memberId;
-    this.announced = true;
-    this.mdns.respond({ answers: this.buildAnswers() });
-  }
-  /**
-   * Send a PTR query to discover existing peers.
-   */
-  discover() {
-    this.mdns.query({
-      questions: [{ name: SERVICE_TYPE, type: "PTR" }]
-    });
-  }
-  getPeerByTeam(teamName) {
-    return this.peersByTeam.get(teamName);
-  }
-  onPeerFound(cb) {
-    this.onPeerFoundCb = cb;
-  }
-  onPeerLost(cb) {
-    this.onPeerLostCb = cb;
-  }
-  destroy() {
-    this.mdns.destroy();
-  }
-};
-
 // src/infrastructure/p2p/p2p-message-protocol.ts
 function serializeP2PMsg(msg) {
   return JSON.stringify(msg);
@@ -354,35 +211,18 @@ var config = {
    */
   p2p: {
     /**
-     * Minimum port for the random WS server port range
-     */
-    portRangeMin: 1e4,
-    /**
-     * Maximum port for the random WS server port range
+     * Fixed port for the WS server. Override with CLAUDE_COLLAB_PORT env var.
      */
-    portRangeMax: 19999
+    port: Number(process.env["CLAUDE_COLLAB_PORT"] ?? 11777)
   }};
 
 // src/infrastructure/p2p/p2p-node.ts
-function getRandomPort(min, max) {
-  return new Promise((resolve) => {
-    const port = Math.floor(Math.random() * (max - min + 1)) + min;
-    const server = createServer();
-    server.listen(port, () => {
-      server.close(() => resolve(port));
-    });
-    server.on("error", () => {
-      resolve(getRandomPort(min, max));
-    });
-  });
-}
 var P2PNode = class {
   wss = null;
-  mdnsDiscovery = null;
   port = 0;
   // Connections indexed by remote team name
   peerConns = /* @__PURE__ */ new Map();
-  // Reverse lookup: ws → teamName (for cleanup on incoming connections)
+  // Reverse lookup: ws → teamName (for cleanup)
   wsToTeam = /* @__PURE__ */ new Map();
   // Questions we received from remote peers (our inbox)
   incomingQuestions = /* @__PURE__ */ new Map();
@@ -401,14 +241,13 @@ var P2PNode = class {
     return this.localMember?.teamName;
   }
   /**
-   * Starts the WS server on a random port and initialises mDNS.
+   * Starts the WS server on the configured fixed port.
    * Called automatically from join() if not yet started.
    */
   async start() {
-    this.port = await getRandomPort(config.p2p.portRangeMin, config.p2p.portRangeMax);
+    this.port = config.p2p.port;
     this.wss = new WebSocketServer({ port: this.port });
     this.setupWssHandlers();
-    this.mdnsDiscovery = new MdnsDiscovery();
     this._isStarted = true;
     console.error(`P2P node started on port ${this.port}`);
   }
@@ -418,17 +257,60 @@ var P2PNode = class {
     }
     const memberId = v4();
     this.localMember = { memberId, teamName, displayName };
-    this.mdnsDiscovery.onPeerFound((peer) => {
-      if (peer.teamName !== teamName) {
-        console.error(`Discovered peer '${peer.teamName}' at ${peer.host}:${peer.port}`);
-        this.connectToPeer(peer.teamName, peer.host, peer.port).catch((err) => {
-          console.error(`Could not eagerly connect to ${peer.teamName}:`, err);
-        });
+    return { memberId, teamId: teamName, teamName, displayName, status: "ONLINE" };
+  }
+  /**
+   * Connects to a peer at the given IP and port.
+   * Performs a bidirectional HELLO handshake and returns the peer's team name.
+   */
+  async connectPeer(ip, port) {
+    if (!this.localMember) {
+      throw new Error("Must call join() before connectPeer()");
+    }
+    const targetPort = port ?? config.p2p.port;
+    const ws = new WebSocket(`ws://${ip}:${targetPort}`);
+    ws.on("message", (data) => {
+      try {
+        const msg = parseP2PMsg(data.toString());
+        this.handleMessage(ws, msg);
+      } catch (err) {
+        console.error("Failed to parse P2P message:", err);
       }
     });
-    this.mdnsDiscovery.announce(this.port, teamName, memberId);
-    this.mdnsDiscovery.discover();
-    return { memberId, teamId: teamName, teamName, displayName, status: "ONLINE" };
+    ws.on("close", () => {
+      const team = this.wsToTeam.get(ws);
+      if (team) {
+        if (this.peerConns.get(team) === ws) {
+          this.peerConns.delete(team);
+        }
+        this.wsToTeam.delete(ws);
+      }
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error(`Connection timeout to ${ip}:${targetPort}`)),
+        5e3
+      );
+      ws.on("open", () => {
+        clearTimeout(timeout);
+        const hello = {
+          type: "P2P_HELLO",
+          fromTeam: this.localMember.teamName,
+          fromMemberId: this.localMember.memberId
+        };
+        ws.send(serializeP2PMsg(hello));
+        resolve();
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+    const helloMsg = await this.waitForResponse(
+      (m) => m.type === "P2P_HELLO",
+      1e4
+    );
+    return helloMsg.fromTeam;
   }
   async ask(toTeam, content, format) {
     const ws = await this.getPeerConnection(toTeam);
@@ -534,7 +416,6 @@ var P2PNode = class {
     };
   }
   async disconnect() {
-    this.mdnsDiscovery?.destroy();
     for (const ws of this.peerConns.values()) {
       ws.close();
     }
@@ -556,6 +437,14 @@ var P2PNode = class {
       ws.on("message", (data) => {
         try {
           const msg = parseP2PMsg(data.toString());
+          if (msg.type === "P2P_HELLO" && this.localMember) {
+            const hello = {
+              type: "P2P_HELLO",
+              fromTeam: this.localMember.teamName,
+              fromMemberId: this.localMember.memberId
+            };
+            ws.send(serializeP2PMsg(hello));
+          }
           this.handleMessage(ws, msg);
         } catch (err) {
           console.error("Failed to parse incoming P2P message:", err);
@@ -573,7 +462,7 @@ var P2PNode = class {
     });
   }
   // ---------------------------------------------------------------------------
-  // Private: unified message handler (used for both incoming & outgoing sockets)
+  // Private: unified message handler
   // ---------------------------------------------------------------------------
   handleMessage(ws, msg) {
     for (const handler of this.pendingHandlers) {
@@ -668,78 +557,9 @@ var P2PNode = class {
     if (existing && existing.readyState === WebSocket.OPEN) {
       return existing;
     }
-    let peer = this.mdnsDiscovery?.getPeerByTeam(teamName);
-    if (!peer) {
-      this.mdnsDiscovery?.discover();
-      await this.waitForMdnsPeer(teamName, 1e4);
-      peer = this.mdnsDiscovery?.getPeerByTeam(teamName);
-    }
-    if (!peer) {
-      throw new Error(
-        `Peer for team '${teamName}' not found via mDNS. Make sure the other terminal has joined with that team name.`
-      );
-    }
-    return this.connectToPeer(teamName, peer.host, peer.port);
-  }
-  async connectToPeer(teamName, host, port) {
-    const existing = this.peerConns.get(teamName);
-    if (existing && existing.readyState === WebSocket.OPEN) {
-      return existing;
-    }
-    const ws = new WebSocket(`ws://${host}:${port}`);
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error(`Connection timeout to team '${teamName}'`)),
-        5e3
-      );
-      ws.on("open", () => {
-        clearTimeout(timeout);
-        const hello = {
-          type: "P2P_HELLO",
-          fromTeam: this.localMember?.teamName ?? "unknown",
-          fromMemberId: this.localMember?.memberId ?? "unknown"
-        };
-        ws.send(serializeP2PMsg(hello));
-        resolve();
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-    });
-    ws.on("message", (data) => {
-      try {
-        const msg = parseP2PMsg(data.toString());
-        this.handleMessage(ws, msg);
-      } catch (err) {
-        console.error("Failed to parse P2P message:", err);
-      }
-    });
-    ws.on("close", () => {
-      if (this.peerConns.get(teamName) === ws) {
-        this.peerConns.delete(teamName);
-      }
-    });
-    this.peerConns.set(teamName, ws);
-    return ws;
-  }
-  waitForMdnsPeer(teamName, timeoutMs) {
-    return new Promise((resolve, reject) => {
-      const deadline = Date.now() + timeoutMs;
-      const check = () => {
-        if (this.mdnsDiscovery?.getPeerByTeam(teamName)) {
-          resolve();
-          return;
-        }
-        if (Date.now() >= deadline) {
-          reject(new Error(`mDNS timeout: team '${teamName}' not found`));
-          return;
-        }
-        this.mdnsDiscovery?.discover();
-        setTimeout(check, 500);
-      };
-      check();
-    });
+    throw new Error(
+      `No connection to team '${teamName}'. Use the connect_peer tool to connect first.`
+    );
   }
   waitForResponse(filter, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -794,6 +614,37 @@ Status: ${member.status}`
     }
   });
 }
+var connectPeerSchema = {
+  ip: z.string().describe('IP address of the peer to connect to (e.g., "172.16.40.137")'),
+  port: z.number().optional().describe(`Port the peer is listening on (default: ${config.p2p.port})`)
+};
+function registerConnectPeerTool(server, client) {
+  server.tool("connect_peer", connectPeerSchema, async (args) => {
+    const targetPort = args.port ?? config.p2p.port;
+    try {
+      const peerTeam = await client.connectPeer(args.ip, args.port);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Connected to peer "${peerTeam}" at ${args.ip}:${targetPort}.`
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to connect to ${args.ip}:${targetPort}: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
 var askSchema = {
   team: z.string().describe('Target team name to ask (e.g., "backend", "frontend")'),
   question: z.string().describe("The question to ask (supports markdown)")
@@ -1040,6 +891,7 @@ function createMcpServer(options) {
     }
   );
   registerJoinTool(server, client);
+  registerConnectPeerTool(server, client);
   registerAskTool(server, client);
   registerCheckAnswerTool(server, client);
   registerInboxTool(server, client);
@@ -1077,14 +929,10 @@ async function startMcpServer(options) {
 // src/cli.ts
 var program = new Command();
 program.name("claude-collab").description("Real-time P2P team collaboration between Claude Code terminals").version("0.1.0");
-program.command("client").description("Start MCP client (P2P mode, connects to Claude Code)").option("-t, --team <team>", "Team to auto-join (e.g., frontend, backend)").action(async (options) => {
+program.command("client").description("Start MCP client (P2P mode, connects to Claude Code)").action(async () => {
   const p2pNode = new P2PNode();
   try {
     await p2pNode.start();
-    if (options.team) {
-      await p2pNode.join(options.team, `${options.team} Claude`);
-      console.error(`Auto-joined team: ${options.team}`);
-    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     console.error(`Failed to start P2P node: ${errorMessage}`);