@dolusoft/claude-collab 1.5.0 → 1.6.0

package/dist/mcp-main.js

@@ -1,145 +1,22 @@
 #!/usr/bin/env node
-import { WebSocketServer, WebSocket } from 'ws';
+import { WebSocket } from 'ws';
 import { v4 } from 'uuid';
-import dgram from 'dgram';
-import os, { tmpdir } from 'os';
 import { EventEmitter } from 'events';
 import { execFile } from 'child_process';
 import { unlinkSync } from 'fs';
+import { tmpdir } from 'os';
 import { join } from 'path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-// src/infrastructure/p2p/p2p-message-protocol.ts
-function serializeP2PMsg(msg) {
+// src/infrastructure/hub/hub-protocol.ts
+function serialize(msg) {
   return JSON.stringify(msg);
 }
-function parseP2PMsg(data) {
+function parse(data) {
   return JSON.parse(data);
 }
-var MULTICAST_ADDR = "239.255.42.42";
-var MULTICAST_PORT = 11776;
-var HEARTBEAT_INTERVAL_MS = 3e4;
-var PEER_TIMEOUT_MS = 95e3;
-var MulticastDiscovery = class extends EventEmitter {
-  socket = null;
-  heartbeatTimer = null;
-  timeoutTimer = null;
-  peers = /* @__PURE__ */ new Map();
-  myName = "";
-  myWsPort = 0;
-  myIp = "";
-  start(name, wsPort) {
-    this.myName = name;
-    this.myWsPort = wsPort;
-    this.myIp = this.resolveLocalIp();
-    const socket = dgram.createSocket({ type: "udp4", reuseAddr: true });
-    this.socket = socket;
-    socket.on("error", (err) => {
-      console.error("[multicast] socket error:", err.message);
-    });
-    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(), 1e4);
-    });
-  }
-  stop() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-    if (this.timeoutTimer) {
-      clearInterval(this.timeoutTimer);
-      this.timeoutTimer = null;
-    }
-    if (this.socket) {
-      this.sendMessage({ type: "LEAVE", name: this.myName });
-      try {
-        this.socket.dropMembership(MULTICAST_ADDR);
-        this.socket.close();
-      } catch {
-      }
-      this.socket = null;
-    }
-    this.peers.clear();
-  }
-  getMyIp() {
-    return this.myIp;
-  }
-  // ---------------------------------------------------------------------------
-  // 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}`);
-      }
-    }
-  }
-  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;
-        }
-      }
-    }
-    return "127.0.0.1";
-  }
-};
 var CS_CONINJECT = `
 using System;
 using System.Collections.Generic;
@@ -358,125 +235,50 @@ var InjectionQueue = class extends EventEmitter {
 };
 var injectionQueue = new InjectionQueue();
 
-// src/config/index.ts
-var config = {
-  /**
-   * P2P node configuration
-   */
-  p2p: {
-    /**
-     * Port range for the WS server. Override with CLAUDE_COLLAB_PORT_MIN / MAX env vars.
-     */
-    portRangeMin: Number(process.env["CLAUDE_COLLAB_PORT_MIN"] ?? 11700),
-    portRangeMax: Number(process.env["CLAUDE_COLLAB_PORT_MAX"] ?? 11750)
-  }};
-
-// src/infrastructure/p2p/p2p-node.ts
-var P2PNode = class {
-  wss = null;
-  port = 0;
-  discovery = new MulticastDiscovery();
-  // Connections indexed by remote peer name
-  peerConns = /* @__PURE__ */ new Map();
-  // Reverse lookup: ws → peerName (for cleanup)
-  wsToName = /* @__PURE__ */ new Map();
-  // Track which connections we initiated (for dedup tiebreaker)
-  wsOutgoing = /* @__PURE__ */ new Set();
-  // Remote IP per connection (for dedup tiebreaker)
-  wsToIp = /* @__PURE__ */ new Map();
-  // Questions we received from remote peers (our inbox)
+// src/infrastructure/hub/hub-client.ts
+var HubClient = class {
+  ws = null;
+  myName = "";
+  serverUrl = "";
+  reconnectTimer = null;
+  connectedPeers = /* @__PURE__ */ new Set();
   incomingQuestions = /* @__PURE__ */ new Map();
-  // Answers we received for questions we asked
   receivedAnswers = /* @__PURE__ */ new Map();
-  // Maps questionId → remote peer name (so we know who to poll)
   questionToName = /* @__PURE__ */ new Map();
-  // Questions we sent — for history
+  questionToSender = /* @__PURE__ */ new Map();
   sentQuestions = /* @__PURE__ */ new Map();
-  // Pending response handlers (request-response correlation by filter)
   pendingHandlers = /* @__PURE__ */ new Set();
-  localMember = null;
-  _isStarted = false;
+  setServerUrl(url) {
+    this.serverUrl = url;
+  }
   get isConnected() {
-    return this._isStarted;
+    return this.ws?.readyState === WebSocket.OPEN;
   }
   get currentTeamId() {
-    return this.localMember?.name;
-  }
-  /**
-   * Starts the WS server on a random available port within the configured range.
-   * Called automatically from join() if not yet started.
-   */
-  async start() {
-    const { portRangeMin, portRangeMax } = config.p2p;
-    const range = portRangeMax - portRangeMin + 1;
-    const startOffset = Math.floor(Math.random() * range);
-    for (let i = 0; i < range; i++) {
-      const port = portRangeMin + (startOffset + i) % range;
-      const bound = await this.tryBind(port);
-      if (bound) {
-        this.port = port;
-        break;
-      }
-    }
-    if (!this.wss) {
-      throw new Error(
-        `No available port in range ${portRangeMin}-${portRangeMax}. Override with CLAUDE_COLLAB_PORT_MIN / CLAUDE_COLLAB_PORT_MAX.`
-      );
-    }
-    this.setupWssHandlers();
-    this._isStarted = true;
-    console.error(`P2P node started on port ${this.port}`);
-  }
-  tryBind(port) {
-    return new Promise((resolve) => {
-      const wss = new WebSocketServer({ port });
-      wss.once("listening", () => {
-        this.wss = wss;
-        resolve(true);
-      });
-      wss.once("error", () => resolve(false));
-    });
+    return this.myName || void 0;
   }
   async join(name, displayName) {
-    if (!this._isStarted) {
-      await this.start();
-    }
-    const memberId = v4();
-    this.localMember = { memberId, name, displayName };
-    this.discovery.start(name, this.port);
-    this.discovery.on("peer-found", ({ name: peerName, ip, wsPort }) => {
-      void this.autoConnect(peerName, ip, wsPort);
-    });
-    this.discovery.on("peer-lost", (peerName) => {
-      const ws = this.peerConns.get(peerName);
-      if (ws) {
-        ws.close();
-        this.peerConns.delete(peerName);
-      }
-    });
-    return { memberId, teamId: name, teamName: name, displayName, status: "ONLINE", port: this.port };
+    this.myName = name;
+    await this.connectAndHello();
+    return {
+      memberId: v4(),
+      teamId: name,
+      teamName: name,
+      displayName,
+      status: "ONLINE",
+      port: 0
+    };
   }
-  async ask(toName, content, format) {
-    const ws = await this.getPeerConnection(toName);
+  async ask(toPeer, content, format) {
     const questionId = v4();
     const requestId = v4();
-    this.questionToName.set(questionId, toName);
-    this.sentQuestions.set(questionId, { toPeer: toName, content, askedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    this.questionToName.set(questionId, toPeer);
+    this.sentQuestions.set(questionId, { toPeer, content, askedAt: (/* @__PURE__ */ new Date()).toISOString() });
     const ackPromise = this.waitForResponse(
-      (m) => m.type === "P2P_ASK_ACK" && m.requestId === requestId,
+      (m) => m.type === "ASK_ACK" && m.requestId === requestId,
       5e3
     );
-    const msg = {
-      type: "P2P_ASK",
-      questionId,
-      fromMemberId: this.localMember.memberId,
-      fromTeam: this.localMember.name,
-      toTeam: toName,
-      content,
-      format,
-      requestId
-    };
-    ws.send(serializeP2PMsg(msg));
+    this.sendToHub({ type: "ASK", from: this.myName, to: toPeer, questionId, requestId, content, format });
     await ackPromise;
     return questionId;
   }
@@ -485,40 +287,32 @@ var P2PNode = class {
     if (cached) {
       return {
         questionId,
-        from: { displayName: `${cached.fromTeam} Claude`, teamName: cached.fromTeam },
+        from: { displayName: `${cached.fromName} Claude`, teamName: cached.fromName },
         content: cached.content,
         format: cached.format,
         answeredAt: cached.answeredAt
       };
     }
-    const toName = this.questionToName.get(questionId);
-    if (!toName) return null;
-    const ws = this.peerConns.get(toName);
-    if (!ws || ws.readyState !== WebSocket.OPEN) return null;
+    const toPeer = this.questionToName.get(questionId);
+    if (!toPeer || !this.isConnected) return null;
     const requestId = v4();
     const responsePromise = this.waitForResponse(
-      (m) => m.type === "P2P_ANSWER" && m.questionId === questionId || m.type === "P2P_ANSWER_PENDING" && m.requestId === requestId,
+      (m) => m.type === "ANSWER" && m.questionId === questionId || m.type === "ANSWER_PENDING" && m.requestId === requestId,
       5e3
     );
-    const getMsg = {
-      type: "P2P_GET_ANSWER",
-      questionId,
-      requestId
-    };
-    ws.send(serializeP2PMsg(getMsg));
+    this.sendToHub({ type: "GET_ANSWER", from: this.myName, to: toPeer, questionId, requestId });
     const response = await responsePromise;
-    if (response.type === "P2P_ANSWER_PENDING") return null;
+    if (response.type === "ANSWER_PENDING") return null;
     const answer = response;
     this.receivedAnswers.set(questionId, {
       content: answer.content,
       format: answer.format,
       answeredAt: answer.answeredAt,
-      fromTeam: answer.fromTeam,
-      fromMemberId: answer.fromMemberId
+      fromName: answer.from
     });
     return {
       questionId,
-      from: { displayName: `${answer.fromTeam} Claude`, teamName: answer.fromTeam },
+      from: { displayName: `${answer.from} Claude`, teamName: answer.from },
       content: answer.content,
       format: answer.format,
       answeredAt: answer.answeredAt
@@ -526,45 +320,42 @@ var P2PNode = class {
   }
   async reply(questionId, content, format) {
     const question = this.incomingQuestions.get(questionId);
-    if (!question) throw new Error(`Question ${questionId} not found in inbox`);
+    if (!question) throw new Error(`Question ${questionId} not found`);
     question.answered = true;
     question.answerContent = content;
     question.answerFormat = format;
-    const answerMsg = {
-      type: "P2P_ANSWER",
-      questionId,
-      content,
-      format,
-      answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fromTeam: this.localMember.name,
-      fromMemberId: this.localMember.memberId
-    };
-    if (question.ws.readyState === WebSocket.OPEN) {
-      question.ws.send(serializeP2PMsg(answerMsg));
+    const senderName = this.questionToSender.get(questionId);
+    if (senderName) {
+      this.sendToHub({
+        type: "ANSWER",
+        from: this.myName,
+        to: senderName,
+        questionId,
+        content,
+        format,
+        answeredAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
+    injectionQueue.notifyReplied();
   }
   async getInbox() {
     const now = Date.now();
     const questions = [...this.incomingQuestions.values()].filter((q) => !q.answered).map((q) => ({
       questionId: q.questionId,
-      from: { displayName: `${q.fromTeam} Claude`, teamName: q.fromTeam },
+      from: { displayName: `${q.fromName} Claude`, teamName: q.fromName },
       content: q.content,
       format: q.format,
       status: "PENDING",
       createdAt: q.createdAt.toISOString(),
       ageMs: now - q.createdAt.getTime()
     }));
-    return {
-      questions,
-      totalCount: questions.length,
-      pendingCount: questions.length
-    };
+    return { questions, totalCount: questions.length, pendingCount: questions.length };
   }
   getInfo() {
     return {
-      teamName: this.localMember?.name,
-      port: this._isStarted ? this.port : void 0,
-      connectedPeers: [...this.peerConns.keys()]
+      teamName: this.myName,
+      port: void 0,
+      connectedPeers: [...this.connectedPeers]
     };
   }
   getHistory() {
@@ -585,7 +376,7 @@ var P2PNode = class {
       entries.push({
         direction: "received",
         questionId,
-        peer: incoming.fromTeam,
+        peer: incoming.fromName,
         question: incoming.content,
         answer: incoming.answered ? incoming.answerContent : void 0,
         askedAt: incoming.createdAt.toISOString(),
@@ -595,66 +386,41 @@ var P2PNode = class {
     return entries.sort((a, b) => a.askedAt.localeCompare(b.askedAt));
   }
   async disconnect() {
-    this.discovery.stop();
-    for (const ws of this.peerConns.values()) {
-      ws.close();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
     }
-    this.peerConns.clear();
-    await new Promise((resolve) => {
-      if (this.wss) {
-        this.wss.close(() => resolve());
-      } else {
-        resolve();
-      }
-    });
-    this._isStarted = false;
+    this.ws?.close();
+    this.ws = null;
   }
   // ---------------------------------------------------------------------------
-  // Private: auto-connect from multicast discovery
+  // Private: connection management
   // ---------------------------------------------------------------------------
-  async autoConnect(peerName, ip, wsPort) {
-    const existing = this.peerConns.get(peerName);
-    if (existing && existing.readyState === WebSocket.OPEN) return;
-    try {
-      await this.connectToPeer(ip, wsPort);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`[p2p] auto-connect to ${peerName} @ ${ip}:${wsPort} failed: ${msg}`);
-    }
-  }
-  /**
-   * Internal: open a WebSocket connection to a peer and perform HELLO handshake.
-   */
-  async connectToPeer(ip, port) {
-    if (!this.localMember) {
-      throw new Error("Must call join() before connecting to peers");
-    }
-    const ws = new WebSocket(`ws://${ip}:${port}`);
-    this.wsOutgoing.add(ws);
-    this.wsToIp.set(ws, ip);
+  async connectAndHello() {
+    const ws = new WebSocket(this.serverUrl);
+    this.ws = ws;
     ws.on("message", (data) => {
       try {
-        const msg = parseP2PMsg(data.toString());
-        this.handleMessage(ws, msg);
-      } catch (err) {
-        console.error("[p2p] Failed to parse message:", err);
+        const msg = parse(data.toString());
+        this.handleMessage(msg);
+      } catch {
       }
     });
-    ws.on("close", () => this.cleanupWs(ws));
-    ws.on("error", (err) => console.error("[p2p] ws error:", err.message));
+    ws.on("close", () => {
+      this.connectedPeers.clear();
+      this.scheduleReconnect();
+    });
+    ws.on("error", (err) => {
+      console.error("[hub-client] error:", err.message);
+    });
     await new Promise((resolve, reject) => {
       const timeout = setTimeout(
-        () => reject(new Error(`Connection timeout to ${ip}:${port}`)),
-        5e3
+        () => reject(new Error(`Cannot connect to hub at ${this.serverUrl}`)),
+        1e4
       );
       ws.on("open", () => {
         clearTimeout(timeout);
-        const hello = {
-          type: "P2P_HELLO",
-          fromTeam: this.localMember.name,
-          fromMemberId: this.localMember.memberId
-        };
-        ws.send(serializeP2PMsg(hello));
+        ws.send(serialize({ type: "HELLO", name: this.myName }));
         resolve();
       });
       ws.on("error", (err) => {
@@ -662,174 +428,115 @@ var P2PNode = class {
         reject(err);
       });
     });
-    const helloMsg = await this.waitForResponse(
-      (m) => m.type === "P2P_HELLO",
+    const ack = await this.waitForResponse(
+      (m) => m.type === "HELLO_ACK",
       1e4
     );
-    return helloMsg.fromTeam;
+    for (const peer of ack.peers) this.connectedPeers.add(peer);
+    console.error(`[hub-client] connected as "${this.myName}", peers: [${ack.peers.join(", ")}]`);
   }
-  // ---------------------------------------------------------------------------
-  // Private: WebSocket server setup
-  // ---------------------------------------------------------------------------
-  setupWssHandlers() {
-    this.wss.on("connection", (ws, req) => {
-      const remoteIp = (req.socket.remoteAddress ?? "").replace("::ffff:", "");
-      this.wsToIp.set(ws, remoteIp);
-      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.name,
-              fromMemberId: this.localMember.memberId
-            };
-            ws.send(serializeP2PMsg(hello));
-          }
-          this.handleMessage(ws, msg);
-        } catch (err) {
-          console.error("[p2p] Failed to parse incoming message:", err);
-        }
-      });
-      ws.on("close", () => this.cleanupWs(ws));
-    });
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connectAndHello();
+        console.error("[hub-client] reconnected to hub");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[hub-client] reconnect failed: ${msg}, retrying in 5s...`);
+        this.scheduleReconnect();
+      }
+    }, 5e3);
   }
   // ---------------------------------------------------------------------------
-  // Private: unified message handler
+  // Private: message handling
   // ---------------------------------------------------------------------------
-  handleMessage(ws, msg) {
-    for (const handler of this.pendingHandlers) {
-      handler(msg);
-    }
+  handleMessage(msg) {
+    for (const handler of this.pendingHandlers) handler(msg);
     switch (msg.type) {
-      case "P2P_HELLO":
-        this.handleHello(ws, msg);
+      case "PEER_JOINED":
+        this.connectedPeers.add(msg.name);
+        console.error(`[hub-client] peer joined: ${msg.name}`);
+        break;
+      case "PEER_LEFT":
+        this.connectedPeers.delete(msg.name);
+        console.error(`[hub-client] peer left: ${msg.name}`);
         break;
-      case "P2P_ASK":
-        this.handleIncomingAsk(ws, msg);
+      case "ASK":
+        this.handleIncomingAsk(msg);
         break;
-      case "P2P_GET_ANSWER":
-        this.handleGetAnswer(ws, msg);
+      case "GET_ANSWER":
+        this.handleGetAnswer(msg);
         break;
-      case "P2P_ANSWER":
+      case "ANSWER":
         if (!this.receivedAnswers.has(msg.questionId)) {
           this.receivedAnswers.set(msg.questionId, {
             content: msg.content,
             format: msg.format,
             answeredAt: msg.answeredAt,
-            fromTeam: msg.fromTeam,
-            fromMemberId: msg.fromMemberId
+            fromName: msg.from
           });
         }
         break;
-      case "P2P_PING":
-        ws.send(serializeP2PMsg({ type: "P2P_PONG" }));
+      case "HUB_ERROR":
+        console.error(`[hub-client] hub error: ${msg.message}`);
         break;
     }
   }
-  handleHello(ws, msg) {
-    const peerName = msg.fromTeam;
-    const existing = this.peerConns.get(peerName);
-    if (existing && existing.readyState === WebSocket.OPEN) {
-      const myIp = this.discovery.getMyIp();
-      const peerIp = this.wsToIp.get(ws) ?? "";
-      const iShouldInitiate = myIp < peerIp;
-      const thisIsOutgoing = this.wsOutgoing.has(ws);
-      if (iShouldInitiate && !thisIsOutgoing) {
-        ws.close();
-        return;
-      } else if (!iShouldInitiate && thisIsOutgoing) {
-        ws.close();
-        return;
-      }
-      ws.close();
-      return;
-    }
-    this.wsToName.set(ws, peerName);
-    this.peerConns.set(peerName, ws);
-    console.error(`[p2p] connected to peer: ${peerName}`);
-  }
-  handleIncomingAsk(ws, msg) {
+  handleIncomingAsk(msg) {
+    this.questionToSender.set(msg.questionId, msg.from);
     this.incomingQuestions.set(msg.questionId, {
       questionId: msg.questionId,
-      fromTeam: msg.fromTeam,
-      fromMemberId: msg.fromMemberId,
+      fromName: msg.from,
       content: msg.content,
       format: msg.format,
       createdAt: /* @__PURE__ */ new Date(),
-      ws,
       answered: false
     });
     injectionQueue.enqueue({
       questionId: msg.questionId,
-      from: {
-        displayName: `${msg.fromTeam} Claude`,
-        teamName: msg.fromTeam
-      },
+      from: { displayName: `${msg.from} Claude`, teamName: msg.from },
       content: msg.content,
       format: msg.format,
       status: "PENDING",
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       ageMs: 0
     });
-    const ack = {
-      type: "P2P_ASK_ACK",
-      questionId: msg.questionId,
-      requestId: msg.requestId
-    };
-    ws.send(serializeP2PMsg(ack));
   }
-  handleGetAnswer(ws, msg) {
+  handleGetAnswer(msg) {
     const question = this.incomingQuestions.get(msg.questionId);
     if (!question?.answered) {
-      const pending = {
-        type: "P2P_ANSWER_PENDING",
+      this.sendToHub({
+        type: "ANSWER_PENDING",
+        to: msg.from,
         questionId: msg.questionId,
         requestId: msg.requestId
-      };
-      ws.send(serializeP2PMsg(pending));
+      });
       return;
     }
-    const answer = {
-      type: "P2P_ANSWER",
+    this.sendToHub({
+      type: "ANSWER",
+      from: this.myName,
+      to: msg.from,
       questionId: msg.questionId,
       content: question.answerContent,
       format: question.answerFormat,
       answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fromTeam: this.localMember.name,
-      fromMemberId: this.localMember.memberId,
       requestId: msg.requestId
-    };
-    ws.send(serializeP2PMsg(answer));
-  }
-  // ---------------------------------------------------------------------------
-  // Private: peer connection management
-  // ---------------------------------------------------------------------------
-  cleanupWs(ws) {
-    const name = this.wsToName.get(ws);
-    if (name) {
-      if (this.peerConns.get(name) === ws) {
-        this.peerConns.delete(name);
-      }
-      this.wsToName.delete(ws);
-    }
-    this.wsOutgoing.delete(ws);
-    this.wsToIp.delete(ws);
+    });
   }
-  async getPeerConnection(name) {
-    const existing = this.peerConns.get(name);
-    if (existing && existing.readyState === WebSocket.OPEN) {
-      return existing;
+  sendToHub(msg) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected to hub. Will retry automatically.");
     }
-    throw new Error(
-      `No connection to peer '${name}'. They may not be on the network yet \u2014 wait a moment and try again.`
-    );
+    this.ws.send(serialize(msg));
   }
   waitForResponse(filter, timeoutMs) {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.pendingHandlers.delete(handler);
-        reject(new Error("P2P request timed out"));
+        reject(new Error("Hub request timed out"));
       }, timeoutMs);
       const handler = (msg) => {
         if (filter(msg)) {
@@ -1024,20 +731,26 @@ async function startMcpServer(options) {
 }
 
 // src/mcp-main.ts
-function parseName() {
-  const idx = process.argv.indexOf("--name");
-  const value = process.argv[idx + 1];
-  if (idx !== -1 && value) {
-    return value;
-  }
-  console.error("Usage: claude-collab --name <your-name>");
-  process.exit(1);
+function getArg(flag) {
+  const idx = process.argv.indexOf(flag);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
 }
 async function main() {
-  const name = parseName();
-  const p2pNode = new P2PNode();
-  await p2pNode.join(name, name);
-  await startMcpServer({ client: p2pNode });
+  const name = getArg("--name");
+  const server = getArg("--server");
+  if (!name) {
+    console.error("--name is required");
+    process.exit(1);
+  }
+  if (!server) {
+    console.error("--server is required");
+    process.exit(1);
+  }
+  const url = server.startsWith("ws") ? server : `ws://${server}`;
+  const client = new HubClient();
+  client.setServerUrl(url);
+  await client.join(name, name);
+  await startMcpServer({ client });
 }
 main().catch((error) => {
   console.error("Unexpected error:", error);