@dolusoft/claude-collab 1.8.6 → 1.9.0

package/dist/mcp-main.js

@@ -1,23 +1,82 @@
 #!/usr/bin/env node
 import { WebSocket, WebSocketServer } from 'ws';
 import { v4 } from 'uuid';
+import { createSocket } from 'dgram';
 import { EventEmitter } from 'events';
 import { execFile, spawn } from 'child_process';
 import { unlinkSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { createSocket } from 'dgram';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-// src/infrastructure/hub/hub-protocol.ts
+// src/infrastructure/p2p/p2p-protocol.ts
 function serialize(msg) {
   return JSON.stringify(msg);
 }
 function parse(data) {
   return JSON.parse(data);
 }
+var PEER_DISCOVERY_PORT = 9998;
+var BROADCAST_INTERVAL_MS = 3e3;
+var BROADCAST_ADDRESS = "255.255.255.255";
+var PeerBroadcaster = class {
+  socket = null;
+  timer = null;
+  start(name, port) {
+    if (this.socket) return;
+    const socket = createSocket("udp4");
+    this.socket = socket;
+    socket.on("error", (err) => {
+      console.error("[peer-broadcaster] 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 }));
+        socket.send(msg, 0, msg.length, PEER_DISCOVERY_PORT, BROADCAST_ADDRESS, (err) => {
+          if (err) console.error("[peer-broadcaster] send error:", err.message);
+        });
+      };
+      send();
+      this.timer = setInterval(send, BROADCAST_INTERVAL_MS);
+    });
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+  }
+};
+function watchForPeer(onFound) {
+  const socket = createSocket("udp4");
+  socket.on("error", (err) => {
+    console.error("[peer-listener] error:", 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 });
+      }
+    } catch {
+    }
+  });
+  socket.bind(PEER_DISCOVERY_PORT, "0.0.0.0");
+  return () => {
+    try {
+      socket.close();
+    } catch {
+    }
+  };
+}
 var CS_CONINJECT = `
 using System;
 using System.Collections.Generic;
@@ -236,93 +295,73 @@ var InjectionQueue = class extends EventEmitter {
 };
 var injectionQueue = new InjectionQueue();
 
-// src/infrastructure/hub/hub-client.ts
-var HubClient = class {
-  ws = null;
+// src/infrastructure/p2p/p2p-node.ts
+var P2PNode = class {
+  constructor(port) {
+    this.port = port;
+  }
+  server = null;
   myName = "";
-  serverUrl = "";
-  reconnectTimer = null;
-  connectedPeers = /* @__PURE__ */ new Set();
+  running = false;
+  // One connection per peer (inbound or outbound — whichever was established first)
+  peerConnections = /* @__PURE__ */ new Map();
+  // Reverse map: ws → peer name (only for registered connections)
+  wsToName = /* @__PURE__ */ new Map();
+  // Prevent duplicate outbound connect attempts
+  connectingPeers = /* @__PURE__ */ new Set();
   incomingQuestions = /* @__PURE__ */ new Map();
   receivedAnswers = /* @__PURE__ */ new Map();
-  questionToName = /* @__PURE__ */ new Map();
-  questionToSender = /* @__PURE__ */ new Map();
   sentQuestions = /* @__PURE__ */ new Map();
+  questionToSender = /* @__PURE__ */ new Map();
   pendingHandlers = /* @__PURE__ */ new Set();
-  setServerUrl(url) {
-    this.serverUrl = url;
-  }
+  broadcaster = null;
+  stopPeerWatcher = null;
+  // ---------------------------------------------------------------------------
+  // ICollabClient implementation
+  // ---------------------------------------------------------------------------
   get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return this.running;
   }
   get currentTeamId() {
     return this.myName || void 0;
   }
   async join(name, displayName) {
     this.myName = name;
-    if (this.serverUrl) {
-      await this.connectAndHello();
-    }
+    await this.startServer();
+    this.startDiscovery();
     return {
       memberId: v4(),
       teamId: name,
       teamName: name,
       displayName,
       status: "ONLINE",
-      port: 0
+      port: this.port
     };
   }
-  async connectToHub(url) {
-    this.serverUrl = url;
-    await this.connectAndHello();
-  }
   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.`);
+    }
     const questionId = v4();
-    const requestId = v4();
-    this.questionToName.set(questionId, toPeer);
     this.sentQuestions.set(questionId, { toPeer, content, askedAt: (/* @__PURE__ */ new Date()).toISOString() });
     const ackPromise = this.waitForResponse(
-      (m) => m.type === "ASK_ACK" && m.requestId === requestId,
+      (m) => m.type === "ASK_ACK" && m.questionId === questionId,
       5e3
     );
-    this.sendToHub({ type: "ASK", from: this.myName, to: toPeer, questionId, requestId, content, format });
+    this.sendToWs(ws, { type: "ASK", from: this.myName, questionId, content, format });
     await ackPromise;
     return questionId;
   }
   async checkAnswer(questionId) {
     const cached = this.receivedAnswers.get(questionId);
-    if (cached) {
-      return {
-        questionId,
-        from: { displayName: `${cached.fromName} Claude`, teamName: cached.fromName },
-        content: cached.content,
-        format: cached.format,
-        answeredAt: cached.answeredAt
-      };
-    }
-    const toPeer = this.questionToName.get(questionId);
-    if (!toPeer || !this.isConnected) return null;
-    const requestId = v4();
-    const responsePromise = this.waitForResponse(
-      (m) => m.type === "ANSWER" && m.questionId === questionId || m.type === "ANSWER_PENDING" && m.requestId === requestId,
-      5e3
-    );
-    this.sendToHub({ type: "GET_ANSWER", from: this.myName, to: toPeer, questionId, requestId });
-    const response = await responsePromise;
-    if (response.type === "ANSWER_PENDING") return null;
-    const answer = response;
-    this.receivedAnswers.set(questionId, {
-      content: answer.content,
-      format: answer.format,
-      answeredAt: answer.answeredAt,
-      fromName: answer.from
-    });
+    if (!cached) return null;
     return {
       questionId,
-      from: { displayName: `${answer.from} Claude`, teamName: answer.from },
-      content: answer.content,
-      format: answer.format,
-      answeredAt: answer.answeredAt
+      from: { displayName: `${cached.fromName} Claude`, teamName: cached.fromName },
+      content: cached.content,
+      format: cached.format,
+      answeredAt: cached.answeredAt
     };
   }
   async reply(questionId, content, format) {
@@ -333,15 +372,17 @@ var HubClient = class {
     question.answerFormat = format;
     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()
-      });
+      const ws = this.peerConnections.get(senderName);
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        this.sendToWs(ws, {
+          type: "ANSWER",
+          from: this.myName,
+          questionId,
+          content,
+          format,
+          answeredAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
     }
     injectionQueue.notifyReplied();
   }
@@ -361,8 +402,8 @@ var HubClient = class {
   getInfo() {
     return {
       teamName: this.myName,
-      port: void 0,
-      connectedPeers: [...this.connectedPeers]
+      port: this.port,
+      connectedPeers: [...this.peerConnections.keys()]
     };
   }
   getHistory() {
@@ -374,107 +415,143 @@ var HubClient = class {
         questionId,
         peer: sent.toPeer,
         question: sent.content,
-        answer: answer?.content,
         askedAt: sent.askedAt,
-        answeredAt: answer?.answeredAt
+        ...answer ? { answer: answer.content, answeredAt: answer.answeredAt } : {}
       });
     }
-    for (const [questionId, incoming] of this.incomingQuestions) {
+    for (const [, incoming] of this.incomingQuestions) {
       entries.push({
         direction: "received",
-        questionId,
+        questionId: incoming.questionId,
         peer: incoming.fromName,
         question: incoming.content,
-        answer: incoming.answered ? incoming.answerContent : void 0,
         askedAt: incoming.createdAt.toISOString(),
-        answeredAt: incoming.answered ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+        ...incoming.answered && incoming.answerContent ? { answer: incoming.answerContent, answeredAt: (/* @__PURE__ */ new Date()).toISOString() } : {}
       });
     }
     return entries.sort((a, b) => a.askedAt.localeCompare(b.askedAt));
   }
   async disconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.ws?.close();
-    this.ws = null;
+    this.stopPeerWatcher?.();
+    this.broadcaster?.stop();
+    for (const ws of this.peerConnections.values()) ws.close();
+    this.peerConnections.clear();
+    this.wsToName.clear();
+    this.server?.close();
+    this.server = null;
+    this.running = false;
+  }
+  // ---------------------------------------------------------------------------
+  // Private: server startup
+  // ---------------------------------------------------------------------------
+  startServer() {
+    return new Promise((resolve, reject) => {
+      const wss = new WebSocketServer({ port: this.port });
+      this.server = wss;
+      wss.on("listening", () => {
+        this.running = true;
+        console.error(`[p2p] listening on port ${this.port} as "${this.myName}"`);
+        resolve();
+      });
+      wss.on("error", (err) => {
+        if (!this.running) reject(err);
+        else console.error("[p2p] server error:", err.message);
+      });
+      wss.on("connection", (ws) => {
+        ws.on("message", (data) => {
+          try {
+            this.handleMessage(ws, parse(data.toString()));
+          } catch {
+          }
+        });
+        ws.on("close", () => {
+          const name = this.wsToName.get(ws);
+          if (name) {
+            this.wsToName.delete(ws);
+            if (this.peerConnections.get(name) === ws) {
+              this.peerConnections.delete(name);
+              console.error(`[p2p] peer disconnected (inbound): ${name}`);
+            }
+          }
+        });
+        ws.on("error", (err) => {
+          console.error("[p2p] inbound ws error:", err.message);
+        });
+      });
+    });
   }
   // ---------------------------------------------------------------------------
-  // Private: connection management
+  // Private: discovery + outbound connections
   // ---------------------------------------------------------------------------
-  async connectAndHello() {
-    const ws = new WebSocket(this.serverUrl);
-    this.ws = ws;
+  startDiscovery() {
+    this.broadcaster = new PeerBroadcaster();
+    this.broadcaster.start(this.myName, this.port);
+    this.stopPeerWatcher = watchForPeer((peer) => {
+      if (peer.name === this.myName) return;
+      if (this.peerConnections.has(peer.name)) return;
+      if (this.connectingPeers.has(peer.name)) return;
+      this.connectToPeer(peer.name, peer.host, peer.port);
+    });
+  }
+  connectToPeer(peerName, host, port) {
+    this.connectingPeers.add(peerName);
+    const ws = new WebSocket(`ws://${host}:${port}`);
+    ws.on("open", () => {
+      this.sendToWs(ws, { type: "HELLO", name: this.myName });
+    });
     ws.on("message", (data) => {
       try {
-        const msg = parse(data.toString());
-        this.handleMessage(msg);
+        this.handleMessage(ws, parse(data.toString()));
       } catch {
       }
     });
     ws.on("close", () => {
-      this.connectedPeers.clear();
-      this.scheduleReconnect();
+      this.connectingPeers.delete(peerName);
+      const name = this.wsToName.get(ws);
+      if (name) {
+        this.wsToName.delete(ws);
+        if (this.peerConnections.get(name) === ws) {
+          this.peerConnections.delete(name);
+          console.error(`[p2p] disconnected from peer: ${name}`);
+        }
+      }
     });
     ws.on("error", (err) => {
-      console.error("[hub-client] error:", err.message);
-    });
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error(`Cannot connect to hub at ${this.serverUrl}`)),
-        1e4
-      );
-      ws.on("open", () => {
-        clearTimeout(timeout);
-        ws.send(serialize({ type: "HELLO", name: this.myName }));
-        resolve();
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
+      console.error(`[p2p] connect to "${peerName}" failed: ${err.message}`);
+      this.connectingPeers.delete(peerName);
     });
-    const ack = await this.waitForResponse(
-      (m) => m.type === "HELLO_ACK",
-      1e4
-    );
-    for (const peer of ack.peers) this.connectedPeers.add(peer);
-    console.error(`[hub-client] connected as "${this.myName}", peers: [${ack.peers.join(", ")}]`);
-  }
-  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: message handling
   // ---------------------------------------------------------------------------
-  handleMessage(msg) {
+  handleMessage(ws, msg) {
     for (const handler of this.pendingHandlers) handler(msg);
     switch (msg.type) {
-      case "PEER_JOINED":
-        this.connectedPeers.add(msg.name);
-        console.error(`[hub-client] peer joined: ${msg.name}`);
+      case "HELLO": {
+        if (this.peerConnections.has(msg.name)) {
+          ws.terminate();
+          return;
+        }
+        this.peerConnections.set(msg.name, ws);
+        this.wsToName.set(ws, msg.name);
+        this.connectingPeers.delete(msg.name);
+        this.sendToWs(ws, { type: "HELLO_ACK", name: this.myName });
+        console.error(`[p2p] peer joined (inbound): ${msg.name}`);
         break;
-      case "PEER_LEFT":
-        this.connectedPeers.delete(msg.name);
-        console.error(`[hub-client] peer left: ${msg.name}`);
+      }
+      case "HELLO_ACK": {
+        if (this.peerConnections.has(msg.name)) {
+          ws.terminate();
+          return;
+        }
+        this.peerConnections.set(msg.name, ws);
+        this.wsToName.set(ws, msg.name);
+        this.connectingPeers.delete(msg.name);
+        console.error(`[p2p] connected to peer: ${msg.name}`);
         break;
+      }
       case "ASK":
-        this.handleIncomingAsk(msg);
-        break;
-      case "GET_ANSWER":
-        this.handleGetAnswer(msg);
+        this.handleIncomingAsk(ws, msg);
         break;
       case "ANSWER":
         if (!this.receivedAnswers.has(msg.questionId)) {
@@ -486,12 +563,9 @@ var HubClient = class {
           });
         }
         break;
-      case "HUB_ERROR":
-        console.error(`[hub-client] hub error: ${msg.message}`);
-        break;
     }
   }
-  handleIncomingAsk(msg) {
+  handleIncomingAsk(ws, msg) {
     this.questionToSender.set(msg.questionId, msg.from);
     this.incomingQuestions.set(msg.questionId, {
       questionId: msg.questionId,
@@ -501,6 +575,7 @@ var HubClient = class {
       createdAt: /* @__PURE__ */ new Date(),
       answered: false
     });
+    this.sendToWs(ws, { type: "ASK_ACK", questionId: msg.questionId });
     injectionQueue.enqueue({
       questionId: msg.questionId,
       from: { displayName: `${msg.from} Claude`, teamName: msg.from },
@@ -511,39 +586,16 @@ var HubClient = class {
       ageMs: 0
     });
   }
-  handleGetAnswer(msg) {
-    const question = this.incomingQuestions.get(msg.questionId);
-    if (!question?.answered) {
-      this.sendToHub({
-        type: "ANSWER_PENDING",
-        to: msg.from,
-        questionId: msg.questionId,
-        requestId: msg.requestId
-      });
-      return;
-    }
-    this.sendToHub({
-      type: "ANSWER",
-      from: this.myName,
-      to: msg.from,
-      questionId: msg.questionId,
-      content: question.answerContent,
-      format: question.answerFormat,
-      answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      requestId: msg.requestId
-    });
-  }
-  sendToHub(msg) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error("Not connected to hub. Will retry automatically.");
+  sendToWs(ws, msg) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(serialize(msg));
     }
-    this.ws.send(serialize(msg));
   }
   waitForResponse(filter, timeoutMs) {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.pendingHandlers.delete(handler);
-        reject(new Error("Hub request timed out"));
+        reject(new Error("Request timed out"));
       }, timeoutMs);
       const handler = (msg) => {
         if (filter(msg)) {
@@ -556,239 +608,6 @@ var HubClient = class {
     });
   }
 };
-var HubServer = class {
-  wss = null;
-  clients = /* @__PURE__ */ new Map();
-  // name → ws
-  wsToName = /* @__PURE__ */ new Map();
-  // ws → name
-  start(port) {
-    this.wss = new WebSocketServer({ port });
-    this.wss.on("listening", () => {
-      console.log(`claude-collab hub running on port ${port}`);
-      console.log("Waiting for peers...\n");
-    });
-    this.wss.on("connection", (ws) => {
-      ws.on("message", (data) => {
-        try {
-          const msg = parse(data.toString());
-          this.handleMessage(ws, msg);
-        } catch {
-        }
-      });
-      ws.on("close", () => {
-        const name = this.wsToName.get(ws);
-        if (name) {
-          this.clients.delete(name);
-          this.wsToName.delete(ws);
-          this.broadcast({ type: "PEER_LEFT", name });
-          console.log(`\u2190 ${name} left  (${this.clients.size} online: ${[...this.clients.keys()].join(", ") || "none"})`);
-        }
-      });
-      ws.on("error", (err) => {
-        console.error("[hub] ws error:", err.message);
-      });
-    });
-    this.wss.on("error", (err) => {
-      console.error("[hub] server error:", err.message);
-    });
-  }
-  stop() {
-    if (!this.wss) return;
-    for (const ws of this.clients.values()) ws.terminate();
-    this.clients.clear();
-    this.wsToName.clear();
-    this.wss.close();
-    this.wss = null;
-    console.log("claude-collab hub stopped");
-  }
-  handleMessage(ws, msg) {
-    switch (msg.type) {
-      case "HELLO": {
-        const existing = this.clients.get(msg.name);
-        const isReconnect = existing != null && existing !== ws;
-        if (isReconnect) {
-          this.wsToName.delete(existing);
-          existing.close();
-        }
-        this.clients.set(msg.name, ws);
-        this.wsToName.set(ws, msg.name);
-        const peers = [...this.clients.keys()].filter((n) => n !== msg.name);
-        const ack = { type: "HELLO_ACK", peers };
-        this.send(ws, ack);
-        if (!isReconnect) {
-          this.broadcast({ type: "PEER_JOINED", name: msg.name }, ws);
-        }
-        console.log(`\u2192 ${msg.name} joined (${this.clients.size} online: ${[...this.clients.keys()].join(", ")})`);
-        break;
-      }
-      case "ASK": {
-        const target = this.clients.get(msg.to);
-        if (!target) {
-          const err = {
-            type: "HUB_ERROR",
-            code: "PEER_NOT_FOUND",
-            message: `'${msg.to}' is not connected to the hub`
-          };
-          this.send(ws, err);
-          return;
-        }
-        this.send(target, msg);
-        const ack = { type: "ASK_ACK", questionId: msg.questionId, requestId: msg.requestId };
-        this.send(ws, ack);
-        break;
-      }
-      case "GET_ANSWER": {
-        const target = this.clients.get(msg.to);
-        if (!target) {
-          this.send(ws, { type: "ANSWER_PENDING", to: msg.from, questionId: msg.questionId, requestId: msg.requestId });
-          return;
-        }
-        this.send(target, msg);
-        break;
-      }
-      case "ANSWER":
-      case "ANSWER_PENDING": {
-        const target = this.clients.get(msg.to);
-        if (target) this.send(target, msg);
-        break;
-      }
-    }
-  }
-  send(ws, msg) {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(serialize(msg));
-    }
-  }
-  broadcast(msg, except) {
-    for (const ws of this.clients.values()) {
-      if (ws !== except) this.send(ws, msg);
-    }
-  }
-};
-var DISCOVERY_PORT = 9998;
-var BROADCAST_INTERVAL_MS = 3e3;
-var BROADCAST_ADDRESS = "255.255.255.255";
-var HubBroadcaster = class {
-  socket = null;
-  timer = null;
-  start(hubPort) {
-    if (this.socket) return;
-    const socket = createSocket("udp4");
-    this.socket = socket;
-    socket.on("error", (err) => {
-      console.error("[hub-broadcaster] error:", err.message);
-    });
-    socket.bind(0, () => {
-      socket.setBroadcast(true);
-      const send = () => {
-        if (!this.socket) return;
-        const msg = Buffer.from(JSON.stringify({ type: "claude-collab-hub", port: hubPort }));
-        socket.send(msg, 0, msg.length, DISCOVERY_PORT, BROADCAST_ADDRESS, (err) => {
-          if (err) console.error("[hub-broadcaster] send error:", err.message);
-        });
-      };
-      send();
-      this.timer = setInterval(send, BROADCAST_INTERVAL_MS);
-    });
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    if (this.socket) {
-      this.socket.close();
-      this.socket = null;
-    }
-  }
-};
-
-// src/infrastructure/hub/hub-manager.ts
-var HubManager = class {
-  hubServer = null;
-  broadcaster = null;
-  currentPort = null;
-  get isRunning() {
-    return this.hubServer !== null;
-  }
-  get port() {
-    return this.currentPort;
-  }
-  async start(port) {
-    if (this.isRunning) throw new Error("Hub is already running");
-    const server = new HubServer();
-    server.start(port);
-    this.hubServer = server;
-    this.currentPort = port;
-    const broadcaster = new HubBroadcaster();
-    broadcaster.start(port);
-    this.broadcaster = broadcaster;
-    let firewallAdded = false;
-    try {
-      await addFirewallRule(port);
-      firewallAdded = true;
-    } catch (err) {
-      console.error("[hub-manager] firewall rule failed:", err);
-    }
-    return { firewallAdded };
-  }
-  async stop() {
-    if (!this.isRunning) throw new Error("Hub is not running");
-    if (this.broadcaster) {
-      this.broadcaster.stop();
-      this.broadcaster = null;
-    }
-    const port = this.currentPort;
-    this.hubServer.stop();
-    this.hubServer = null;
-    this.currentPort = null;
-    let firewallRemoved = false;
-    try {
-      await removeFirewallRule(port);
-      firewallRemoved = true;
-    } catch (err) {
-      console.error("[hub-manager] firewall rule removal failed:", err);
-    }
-    return { firewallRemoved };
-  }
-};
-function runElevated(argArray) {
-  const argList = argArray.map((a) => `"${a}"`).join(",");
-  const psCommand = `Start-Process -FilePath "netsh" -ArgumentList @(${argList}) -Verb RunAs -Wait`;
-  return new Promise((resolve, reject) => {
-    const ps = spawn("powershell", ["-NoProfile", "-Command", psCommand]);
-    ps.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`Firewall UAC prompt was cancelled or denied (exit code ${code}).`));
-    });
-    ps.on("error", (err) => {
-      reject(new Error(`Failed to launch PowerShell: ${err.message}`));
-    });
-  });
-}
-async function addFirewallRule(port) {
-  await runElevated([
-    "advfirewall",
-    "firewall",
-    "add",
-    "rule",
-    `name=claude-collab-${port}`,
-    "protocol=TCP",
-    "dir=in",
-    `localport=${port}`,
-    "action=allow"
-  ]);
-}
-async function removeFirewallRule(port) {
-  await runElevated([
-    "advfirewall",
-    "firewall",
-    "delete",
-    "rule",
-    `name=claude-collab-${port}`
-  ]);
-}
 var askSchema = {
   peer: z.string().describe('Name of the peer to ask (e.g., "alice", "backend")'),
   question: z.string().describe("The question to ask (supports markdown)")
@@ -904,12 +723,14 @@ function registerPeersTool(server, client) {
   server.tool("peers", {}, async () => {
     const info = client.getInfo();
     const myName = info.teamName ?? "(starting...)";
+    const myPort = info.port ?? "?";
     const connected = info.connectedPeers;
     if (connected.length === 0) {
       return {
         content: [{
           type: "text",
-          text: `You are "${myName}". No peers connected yet \u2014 they will appear automatically when they come online.`
+          text: `You are "${myName}" (listening on port ${myPort}). No peers connected yet.
+Use firewall_open to allow inbound connections, or wait for peers to connect to you.`
         }]
       };
     }
@@ -917,7 +738,7 @@ function registerPeersTool(server, client) {
     return {
       content: [{
         type: "text",
-        text: `You are "${myName}". Connected peers (${connected.length}):
+        text: `You are "${myName}" (port ${myPort}). Connected peers (${connected.length}):
 ${list}`
       }]
     };
@@ -950,174 +771,108 @@ ${answerLine}`;
     };
   });
 }
-function registerStartHubTool(server, client, hubManager) {
+function runElevated(argArray) {
+  const argList = argArray.map((a) => `"${a}"`).join(",");
+  const psCommand = `Start-Process -FilePath "netsh" -ArgumentList @(${argList}) -Verb RunAs -Wait`;
+  return new Promise((resolve, reject) => {
+    const ps = spawn("powershell", ["-NoProfile", "-Command", psCommand]);
+    ps.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Firewall UAC prompt was cancelled or denied (exit code ${code}).`));
+    });
+    ps.on("error", (err) => {
+      reject(new Error(`Failed to launch PowerShell: ${err.message}`));
+    });
+  });
+}
+async function addFirewallRule(port) {
+  await runElevated([
+    "advfirewall",
+    "firewall",
+    "add",
+    "rule",
+    `name=claude-collab-${port}`,
+    "protocol=TCP",
+    "dir=in",
+    `localport=${port}`,
+    "action=allow"
+  ]);
+}
+async function removeFirewallRule(port) {
+  await runElevated([
+    "advfirewall",
+    "firewall",
+    "delete",
+    "rule",
+    `name=claude-collab-${port}`
+  ]);
+}
+
+// src/presentation/mcp/tools/firewall-open.tool.ts
+function registerFirewallOpenTool(server, client) {
   server.tool(
-    "start_hub",
-    "Start a hub server on this machine. Opens a firewall rule (UAC prompt) and advertises on LAN via mDNS \u2014 peers connect automatically, no IP sharing needed.",
-    { port: z.number().min(1024).max(65535).optional().describe("Port to listen on (default: 9999)") },
-    async ({ port = 9999 }) => {
-      if (hubManager.isRunning) {
+    "firewall_open",
+    "Open a Windows Firewall inbound rule for your P2P listen port. A UAC popup will appear \u2014 accept it to allow peers to connect to you directly.",
+    {
+      port: z.number().min(1024).max(65535).optional().describe("Port to open (defaults to your current listen port)")
+    },
+    async ({ port }) => {
+      const targetPort = port ?? client.getInfo().port;
+      if (!targetPort) {
         return {
-          content: [{
-            type: "text",
-            text: `Hub is already running on port ${hubManager.port}.`
-          }]
+          content: [{ type: "text", text: "Could not determine port. Pass port explicitly." }],
+          isError: true
         };
       }
-      let firewallAdded = false;
       try {
-        const result = await hubManager.start(port);
-        firewallAdded = result.firewallAdded;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `Failed to start hub: ${msg}` }]
-        };
-      }
-      try {
-        await client.connectToHub(`ws://localhost:${port}`);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `Hub started on port ${port}, but failed to self-connect: ${msg}` }]
-        };
-      }
-      const lines = [
-        `Hub started on port ${port}.`,
-        firewallAdded ? `Firewall rule added (claude-collab-${port}) \u2014 LAN peers can connect.` : `WARNING: Firewall rule could not be added (UAC was cancelled or denied). Peers on other machines may be blocked by Windows Firewall. Run start_hub again and accept the UAC prompt to fix this.`,
-        `Others on the LAN will auto-discover and connect via mDNS.`,
-        `Use stop_hub when you are done.`
-      ];
-      return {
-        content: [{ type: "text", text: lines.join("\n") }]
-      };
-    }
-  );
-}
-
-// src/presentation/mcp/tools/stop-hub.tool.ts
-function registerStopHubTool(server, hubManager) {
-  server.tool(
-    "stop_hub",
-    "Stop the running hub server. Removes the firewall rule (UAC prompt) and stops LAN advertising. Connected peers will be disconnected.",
-    {},
-    async () => {
-      if (!hubManager.isRunning) {
+        await addFirewallRule(targetPort);
         return {
           content: [{
             type: "text",
-            text: "No hub is currently running on this machine."
+            text: [
+              `Firewall rule opened for port ${targetPort} (rule name: claude-collab-${targetPort}).`,
+              `Peers on the LAN can now connect to you directly.`
+            ].join("\n")
           }]
         };
-      }
-      const port = hubManager.port;
-      let firewallRemoved = false;
-      try {
-        const result = await hubManager.stop();
-        firewallRemoved = result.firewallRemoved;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return {
-          content: [{ type: "text", text: `Failed to stop hub: ${msg}` }]
+          content: [{ type: "text", text: `Failed to open firewall: ${msg}` }],
+          isError: true
         };
       }
-      const lines = [
-        `Hub stopped (was on port ${port}).`,
-        firewallRemoved ? `Firewall rule removed (claude-collab-${port}).` : `WARNING: Firewall rule could not be removed (UAC was cancelled). Remove it manually: netsh advfirewall firewall delete rule name="claude-collab-${port}"`,
-        `All peers have been disconnected.`
-      ];
-      return {
-        content: [{ type: "text", text: lines.join("\n") }]
-      };
     }
   );
 }
-function discoverHub(timeoutMs = 1e4) {
-  return new Promise((resolve) => {
-    const socket = createSocket("udp4");
-    let settled = false;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      try {
-        socket.close();
-      } catch {
-      }
-      resolve(result);
-    };
-    const timer = setTimeout(() => finish(null), timeoutMs);
-    socket.on("error", () => finish(null));
-    socket.on("message", (msg, rinfo) => {
-      try {
-        const data = JSON.parse(msg.toString());
-        if (data.type === "claude-collab-hub" && typeof data.port === "number") {
-          finish({ host: rinfo.address, port: data.port });
-        }
-      } catch {
-      }
-    });
-    socket.bind(DISCOVERY_PORT, "0.0.0.0");
-  });
-}
-function watchForHub(onFound) {
-  const socket = createSocket("udp4");
-  socket.on("error", (err) => {
-    console.error("[hub-listener] error:", err.message);
-  });
-  socket.on("message", (msg, rinfo) => {
-    try {
-      const data = JSON.parse(msg.toString());
-      if (data.type === "claude-collab-hub" && typeof data.port === "number") {
-        onFound({ host: rinfo.address, port: data.port });
-      }
-    } catch {
-    }
-  });
-  socket.bind(DISCOVERY_PORT, "0.0.0.0");
-  return () => {
-    try {
-      socket.close();
-    } catch {
-    }
-  };
-}
-
-// src/presentation/mcp/tools/connect.tool.ts
-function registerConnectTool(server, client) {
+function registerFirewallCloseTool(server, client) {
   server.tool(
-    "connect",
-    "Find and connect to the hub on the LAN automatically. No IP or port needed.",
-    {},
-    async () => {
-      if (client.isConnected) {
-        const info = client.getInfo();
-        return {
-          content: [{ type: "text", text: `Already connected to hub as "${info.teamName}".` }]
-        };
-      }
-      const hub = await discoverHub(1e4);
-      if (!hub) {
+    "firewall_close",
+    "Remove the Windows Firewall inbound rule for your P2P listen port. A UAC popup will appear \u2014 accept it to close the rule.",
+    {
+      port: z.number().min(1024).max(65535).optional().describe("Port to close (defaults to your current listen port)")
+    },
+    async ({ port }) => {
+      const targetPort = port ?? client.getInfo().port;
+      if (!targetPort) {
         return {
-          content: [{
-            type: "text",
-            text: "No hub found on the LAN. Make sure someone has called start_hub on the host machine."
-          }]
+          content: [{ type: "text", text: "Could not determine port. Pass port explicitly." }],
+          isError: true
         };
       }
       try {
-        await client.connectToHub(`ws://${hub.host}:${hub.port}`);
-        const info = client.getInfo();
+        await removeFirewallRule(targetPort);
         return {
           content: [{
             type: "text",
-            text: `Connected to hub at ${hub.host}:${hub.port} as "${info.teamName}".`
+            text: `Firewall rule removed for port ${targetPort} (rule name: claude-collab-${targetPort}).`
           }]
         };
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return {
-          content: [{ type: "text", text: `Hub found at ${hub.host}:${hub.port} but connection failed: ${msg}` }]
+          content: [{ type: "text", text: `Failed to close firewall: ${msg}` }],
+          isError: true
         };
       }
     }
@@ -1126,7 +881,7 @@ function registerConnectTool(server, client) {
 
 // src/presentation/mcp/server.ts
 function createMcpServer(options) {
-  const { client, hubManager } = options;
+  const { client } = options;
   const server = new McpServer({
     name: "claude-collab",
     version: "0.1.0"
@@ -1135,9 +890,8 @@ function createMcpServer(options) {
   registerReplyTool(server, client);
   registerPeersTool(server, client);
   registerHistoryTool(server, client);
-  registerStartHubTool(server, client, hubManager);
-  registerStopHubTool(server, hubManager);
-  registerConnectTool(server, client);
+  registerFirewallOpenTool(server, client);
+  registerFirewallCloseTool(server, client);
   return server;
 }
 async function startMcpServer(options) {
@@ -1147,52 +901,20 @@ async function startMcpServer(options) {
 }
 
 // src/mcp-main.ts
+var P2P_PORT = 9999;
 function getArg(flag) {
   const idx = process.argv.indexOf(flag);
   return idx !== -1 ? process.argv[idx + 1] : void 0;
 }
 async function main() {
   const name = getArg("--name");
-  const server = getArg("--server");
   if (!name) {
     console.error("--name is required");
     process.exit(1);
   }
-  const hubManager = new HubManager();
-  const client = new HubClient();
-  if (server) {
-    const url = server.startsWith("ws") ? server : `ws://${server}`;
-    client.setServerUrl(url);
-    await client.join(name, name);
-  } else {
-    await client.join(name, name);
-  }
-  const mcpReady = startMcpServer({ client, hubManager });
-  if (!server) {
-    discoverHub(5e3).then(async (hub) => {
-      if (!hub || client.isConnected) return;
-      try {
-        console.error(`[mcp-main] hub found at ${hub.host}:${hub.port}, connecting...`);
-        await client.connectToHub(`ws://${hub.host}:${hub.port}`);
-      } catch {
-      }
-    });
-    const stopWatch = watchForHub(async (hub) => {
-      if (client.isConnected) {
-        stopWatch();
-        return;
-      }
-      try {
-        console.error(`[mcp-main] hub appeared at ${hub.host}:${hub.port}, connecting...`);
-        await client.connectToHub(`ws://${hub.host}:${hub.port}`);
-        stopWatch();
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`[mcp-main] auto-connect failed: ${msg}`);
-      }
-    });
-  }
-  await mcpReady;
+  const node = new P2PNode(P2P_PORT);
+  await node.join(name, name);
+  await startMcpServer({ client: node });
 }
 main().catch((error) => {
   console.error("Unexpected error:", error);