@dolusoft/claude-collab 1.10.3 → 1.11.0

package/dist/cli.js

@@ -2,10 +2,9 @@
 import { Command } from 'commander';
 import { WebSocket, WebSocketServer } from 'ws';
 import { v4 } from 'uuid';
-import dgram from 'dgram';
 import os, { tmpdir } from 'os';
+import { spawn, execFile } from 'child_process';
 import { EventEmitter } from 'events';
-import { execFile, spawn } from 'child_process';
 import { unlinkSync } from 'fs';
 import { join } from 'path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -19,131 +18,33 @@ function serialize(msg) {
 function parse(data) {
   return JSON.parse(data);
 }
-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;
-  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("[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(), 5e3);
-    });
-  }
-  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();
-  }
-  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";
-  }
-  // ---------------------------------------------------------------------------
-  // 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);
+function runNetshElevated(argArray) {
+  const argList = argArray.map((a) => `"${a}"`).join(",");
+  const psCommand = `Start-Process -FilePath "netsh" -ArgumentList @(${argList}) -Verb RunAs -Wait`;
+  return new Promise((resolve, reject) => {
+    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}).`));
     });
-  }
-  sendUnicast(toIp) {
-    if (!this.socket) return;
-    const buf = Buffer.from(JSON.stringify({ type: "ANNOUNCE", name: this.myName, wsPort: this.myWsPort, unicast: true }));
-    this.socket.send(buf, MULTICAST_PORT, toIp, (err) => {
-      if (err) console.error(`[multicast] unicast reply to ${toIp} error:`, err.message);
+    ps.on("error", (err) => {
+      reject(new Error(`Failed to launch PowerShell: ${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);
-        console.error(`[multicast] discovered peer: ${msg.name} @ ${fromIp}:${msg.wsPort}`);
-      } else {
-        existing.lastSeen = Date.now();
-        existing.ip = fromIp;
-        existing.wsPort = msg.wsPort;
-      }
-      if (!msg.unicast) {
-        this.sendUnicast(fromIp);
-      }
-      this.emit("peer-found", { name: msg.name, ip: fromIp, 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}`);
-      }
-    }
-  }
-};
+  });
+}
+async function addFirewallRule(port) {
+  await runNetshElevated([
+    "advfirewall",
+    "firewall",
+    "add",
+    "rule",
+    `name=claude-collab-${port}`,
+    "protocol=TCP",
+    "dir=in",
+    `localport=${port}`,
+    "action=allow"
+  ]);
+}
 var CS_CONINJECT = `
 using System;
 using System.Collections.Generic;
@@ -363,17 +264,18 @@ var InjectionQueue = class extends EventEmitter {
 var injectionQueue = new InjectionQueue();
 
 // src/infrastructure/p2p/p2p-node.ts
+var FIXED_PORT = 12345;
 var P2PNode = class {
-  constructor(portRange = [1e4, 19999]) {
-    this.portRange = portRange;
-  }
   server = null;
   myName = "";
   running = false;
+  firewallOpened = 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();
+  // IP of each known peer: name → ip
+  peerIPs = /* @__PURE__ */ new Map();
   // Prevent duplicate outbound connect attempts
   connectingPeers = /* @__PURE__ */ new Set();
   incomingQuestions = /* @__PURE__ */ new Map();
@@ -385,8 +287,6 @@ var P2PNode = class {
   answerWaiters = /* @__PURE__ */ new Map();
   // Answers queued for offline peers: peerName → AnswerMsg (delivered on reconnect)
   pendingOutboundAnswers = /* @__PURE__ */ new Map();
-  discovery = null;
-  boundPort = 0;
   // ---------------------------------------------------------------------------
   // ICollabClient implementation
   // ---------------------------------------------------------------------------
@@ -394,7 +294,7 @@ var P2PNode = class {
     return this.running;
   }
   get port() {
-    return this.boundPort;
+    return FIXED_PORT;
   }
   get currentTeamId() {
     return this.myName || void 0;
@@ -402,16 +302,67 @@ var P2PNode = class {
   async join(name, displayName) {
     this.myName = name;
     await this.startServer();
-    this.startDiscovery();
     return {
       memberId: v4(),
       teamId: name,
       teamName: name,
       displayName,
       status: "ONLINE",
-      port: this.boundPort
+      port: FIXED_PORT
     };
   }
+  async connectByIp(ip) {
+    if (!this.firewallOpened) {
+      await addFirewallRule(FIXED_PORT);
+      this.firewallOpened = true;
+    }
+    return new Promise((resolve, reject) => {
+      const url = `ws://${ip}:${FIXED_PORT}`;
+      const ws = new WebSocket(url);
+      const timeout = setTimeout(() => {
+        ws.terminate();
+        reject(new Error(`Connection to ${ip}:${FIXED_PORT} timed out`));
+      }, 1e4);
+      ws.on("open", () => {
+        this.sendToWs(ws, { type: "HELLO", name: this.myName });
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = parse(data.toString());
+          if (msg.type === "HELLO_ACK") {
+            clearTimeout(timeout);
+            if (this.peerConnections.has(msg.name)) {
+              ws.terminate();
+              resolve(msg.name);
+              return;
+            }
+            this.registerPeer(msg.name, ip, ws);
+            this.afterHandshake(msg.name, ws);
+            resolve(msg.name);
+          }
+          this.handleMessage(ws, msg);
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        clearTimeout(timeout);
+        this.connectingPeers.delete(ip);
+        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) => {
+        clearTimeout(timeout);
+        this.connectingPeers.delete(ip);
+        reject(new Error(`Failed to connect to ${ip}:${FIXED_PORT} \u2014 ${err.message}`));
+      });
+    });
+  }
   async ask(toPeer, content, format) {
     const ws = this.peerConnections.get(toPeer);
     if (!ws || ws.readyState !== WebSocket.OPEN) {
@@ -429,9 +380,7 @@ var P2PNode = class {
   }
   waitForAnswer(questionId, timeoutMs) {
     const cached = this.receivedAnswers.get(questionId);
-    if (cached) {
-      return Promise.resolve(this.formatAnswer(questionId, cached));
-    }
+    if (cached) return Promise.resolve(this.formatAnswer(questionId, cached));
     return new Promise((resolve) => {
       const timeout = setTimeout(() => {
         this.answerWaiters.delete(questionId);
@@ -498,10 +447,22 @@ var P2PNode = class {
   getInfo() {
     return {
       teamName: this.myName,
-      port: this.boundPort,
-      connectedPeers: [...this.peerConnections.keys()]
+      port: FIXED_PORT,
+      connectedPeers: [...this.peerConnections.keys()],
+      peerIPs: Object.fromEntries(this.peerIPs)
     };
   }
+  getLocalIps() {
+    const result = [];
+    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) result.push(addr.address);
+      }
+    }
+    return result;
+  }
   getHistory() {
     const entries = [];
     for (const [questionId, sent] of this.sentQuestions) {
@@ -528,11 +489,10 @@ var P2PNode = class {
     return entries.sort((a, b) => a.askedAt.localeCompare(b.askedAt));
   }
   async disconnect() {
-    this.discovery?.stop();
-    this.discovery = null;
     for (const ws of this.peerConnections.values()) ws.close();
     this.peerConnections.clear();
     this.wsToName.clear();
+    this.peerIPs.clear();
     this.server?.close();
     this.server = null;
     this.running = false;
@@ -541,40 +501,28 @@ var P2PNode = class {
   // Private: server startup
   // ---------------------------------------------------------------------------
   startServer() {
-    const [min, max] = this.portRange;
-    const pick = () => Math.floor(Math.random() * (max - min + 1)) + min;
-    const tryBind = (attemptsLeft) => {
-      if (attemptsLeft === 0) {
-        return Promise.reject(new Error(`No free port found in range ${min}-${max}`));
-      }
-      const port = pick();
-      return new Promise((resolve, reject) => {
-        const wss = new WebSocketServer({ port });
-        wss.once("listening", () => {
-          this.server = wss;
-          this.boundPort = port;
-          this.running = true;
-          console.error(`[p2p] listening on port ${port} as "${this.myName}"`);
-          this.attachServerHandlers(wss);
-          resolve();
-        });
-        wss.once("error", (err) => {
-          wss.close();
-          if (err.code === "EADDRINUSE") {
-            tryBind(attemptsLeft - 1).then(resolve, reject);
-          } else {
-            reject(err);
-          }
-        });
+    return new Promise((resolve, reject) => {
+      const wss = new WebSocketServer({ port: FIXED_PORT });
+      wss.once("listening", () => {
+        this.server = wss;
+        this.running = true;
+        console.error(`[p2p] listening on port ${FIXED_PORT} as "${this.myName}"`);
+        this.attachServerHandlers(wss);
+        resolve();
       });
-    };
-    return tryBind(20);
+      wss.once("error", (err) => {
+        wss.close();
+        reject(err);
+      });
+    });
   }
   attachServerHandlers(wss) {
-    wss.on("connection", (ws) => {
+    wss.on("connection", (ws, request) => {
+      const rawIp = request.socket.remoteAddress ?? "";
+      const remoteIp = rawIp.replace(/^::ffff:/, "");
       ws.on("message", (data) => {
         try {
-          this.handleMessage(ws, parse(data.toString()));
+          this.handleInboundMessage(ws, remoteIp, parse(data.toString()));
         } catch {
         }
       });
@@ -597,21 +545,35 @@ var P2PNode = class {
     });
   }
   // ---------------------------------------------------------------------------
-  // Private: discovery + outbound connections
+  // Private: mesh helpers
   // ---------------------------------------------------------------------------
-  startDiscovery() {
-    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.ip, peer.wsPort);
-    });
-    discovery.start(this.myName, this.boundPort);
+  /** Called once handshake completes — exchange peer lists and announce to existing peers. */
+  afterHandshake(newPeerName, ws) {
+    const listForNew = [...this.peerConnections.keys()].filter((n) => n !== newPeerName).map((n) => ({ name: n, ip: this.peerIPs.get(n) ?? "" })).filter((p) => p.ip !== "");
+    this.sendToWs(ws, { type: "PEER_LIST", peers: listForNew });
+    const newIp = this.peerIPs.get(newPeerName);
+    if (newIp) {
+      for (const [name, existingWs] of this.peerConnections) {
+        if (name !== newPeerName) {
+          this.sendToWs(existingWs, { type: "PEER_ANNOUNCE", name: newPeerName, ip: newIp });
+        }
+      }
+    }
   }
-  connectToPeer(peerName, host, port) {
-    this.connectingPeers.add(peerName);
-    const ws = new WebSocket(`ws://${host}:${port}`);
+  registerPeer(name, ip, ws) {
+    this.peerConnections.set(name, ws);
+    this.wsToName.set(ws, name);
+    this.peerIPs.set(name, ip);
+    this.connectingPeers.delete(name);
+    console.error(`[p2p] peer registered: ${name} @ ${ip}`);
+    this.deliverPendingAnswer(name, ws);
+  }
+  /** Connect outbound to a peer discovered via PEER_LIST or PEER_ANNOUNCE. */
+  connectMeshPeer(name, ip) {
+    if (this.peerConnections.has(name)) return;
+    if (this.connectingPeers.has(name)) return;
+    this.connectingPeers.add(name);
+    const ws = new WebSocket(`ws://${ip}:${FIXED_PORT}`);
     ws.on("open", () => {
       this.sendToWs(ws, { type: "HELLO", name: this.myName });
     });
@@ -622,52 +584,70 @@ var P2PNode = class {
       }
     });
     ws.on("close", () => {
-      this.connectingPeers.delete(peerName);
-      const name = this.wsToName.get(ws);
-      if (name) {
+      this.connectingPeers.delete(name);
+      const peerName = this.wsToName.get(ws);
+      if (peerName) {
         this.wsToName.delete(ws);
-        if (this.peerConnections.get(name) === ws) {
-          this.peerConnections.delete(name);
-          console.error(`[p2p] disconnected from peer: ${name}`);
+        if (this.peerConnections.get(peerName) === ws) {
+          this.peerConnections.delete(peerName);
+          console.error(`[p2p] disconnected from mesh peer: ${peerName}`);
         }
       }
     });
     ws.on("error", (err) => {
-      console.error(`[p2p] connect to "${peerName}" failed: ${err.message}`);
-      this.connectingPeers.delete(peerName);
+      console.error(`[p2p] mesh connect to "${name}" @ ${ip} failed: ${err.message}`);
+      this.connectingPeers.delete(name);
     });
   }
   // ---------------------------------------------------------------------------
   // Private: message handling
   // ---------------------------------------------------------------------------
+  /** Handles messages on inbound connections (server side — we know the remote IP). */
+  handleInboundMessage(ws, remoteIp, msg) {
+    for (const handler of this.pendingHandlers) handler(msg);
+    if (msg.type === "HELLO") {
+      if (this.peerConnections.has(msg.name)) {
+        ws.terminate();
+        return;
+      }
+      this.registerPeer(msg.name, remoteIp, ws);
+      this.sendToWs(ws, { type: "HELLO_ACK", name: this.myName });
+      console.error(`[p2p] peer joined (inbound): ${msg.name}`);
+      this.afterHandshake(msg.name, ws);
+      return;
+    }
+    this.handleMessage(ws, msg);
+  }
+  /** Handles all other messages (both inbound and outbound connections). */
   handleMessage(ws, msg) {
     for (const handler of this.pendingHandlers) handler(msg);
     switch (msg.type) {
-      case "HELLO": {
-        if (this.peerConnections.has(msg.name)) {
-          ws.terminate();
-          return;
+      case "HELLO_ACK":
+        if (!this.peerConnections.has(msg.name)) {
+          this.peerConnections.set(msg.name, ws);
+          this.wsToName.set(ws, msg.name);
+          this.connectingPeers.delete(msg.name);
+          console.error(`[p2p] connected to mesh peer: ${msg.name}`);
+          this.deliverPendingAnswer(msg.name, ws);
+          this.afterHandshake(msg.name, ws);
         }
-        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}`);
-        this.deliverPendingAnswer(msg.name, ws);
         break;
-      }
-      case "HELLO_ACK": {
-        if (this.peerConnections.has(msg.name)) {
-          ws.terminate();
-          return;
+      case "PEER_LIST":
+        for (const peer of msg.peers) {
+          if (peer.name !== this.myName && !this.peerConnections.has(peer.name)) {
+            console.error(`[p2p] mesh: connecting to ${peer.name} @ ${peer.ip} via PEER_LIST`);
+            this.peerIPs.set(peer.name, peer.ip);
+            this.connectMeshPeer(peer.name, peer.ip);
+          }
+        }
+        break;
+      case "PEER_ANNOUNCE":
+        if (msg.name !== this.myName && !this.peerConnections.has(msg.name)) {
+          console.error(`[p2p] mesh: connecting to ${msg.name} @ ${msg.ip} via PEER_ANNOUNCE`);
+          this.peerIPs.set(msg.name, msg.ip);
+          this.connectMeshPeer(msg.name, msg.ip);
         }
-        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}`);
-        this.deliverPendingAnswer(msg.name, ws);
         break;
-      }
       case "ASK":
         this.handleIncomingAsk(ws, msg);
         break;
@@ -740,6 +720,72 @@ var P2PNode = class {
     });
   }
 };
+var CONNECT_DESCRIPTION = `Connect to another Claude instance by their IP address.
+
+WHEN TO USE:
+- First time connecting to a teammate
+- A new peer wants to join an existing session
+
+WHAT HAPPENS:
+1. First call only: opens Windows Firewall port 12345 via UAC popup (stays open)
+2. Connects directly to the peer at ws://IP:12345
+3. Both sides exchange their peer lists \u2014 everyone connects to everyone (full mesh)
+
+FINDING YOUR IP:
+- The other person calls status() to see their LAN IP, then tells you
+
+AFTER CONNECTING:
+- Use peers() to confirm connection
+- Use ask() to send questions to connected peers`;
+function registerConnectTool(server, client) {
+  server.tool(
+    "connect",
+    CONNECT_DESCRIPTION,
+    {
+      ip: z.string().describe("The peer's LAN IP address (e.g. 192.168.1.5)")
+    },
+    async ({ ip }) => {
+      if (!client.isConnected) {
+        return {
+          content: [{ type: "text", text: "Node is not ready yet. Wait a moment and try again." }],
+          isError: true
+        };
+      }
+      try {
+        const peerName = await client.connectByIp(ip);
+        const info = client.getInfo();
+        const allPeers = info.connectedPeers;
+        const others = allPeers.filter((n) => n !== peerName);
+        const lines = [
+          `Connected to "${peerName}" (${ip}).`
+        ];
+        if (others.length > 0) {
+          lines.push(``, `Mesh peers also connecting: ${others.map((n) => `"${n}"`).join(", ")}`);
+        }
+        lines.push(``, `Use peers() to see all connected peers.`);
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `Failed to connect to ${ip}: ${msg}`,
+              ``,
+              `Make sure:`,
+              `  \u2022 The peer is running claude-collab (--name <name>)`,
+              `  \u2022 The IP address is correct (they can check with status())`,
+              `  \u2022 Port 12345 is not blocked on their machine`
+            ].join("\n")
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
 var ASK_DESCRIPTION = `Send a question to another Claude instance on the LAN and wait for their answer.
 
 WHEN TO USE:
@@ -885,22 +931,20 @@ function registerReplyTool(server, client) {
 }
 
 // src/presentation/mcp/tools/peers.tool.ts
-var PEERS_DESCRIPTION = `Show your identity on the P2P network and list all currently connected peers.
+var PEERS_DESCRIPTION = `List all currently active peer connections.
 
 WHEN TO USE:
 - Before calling ask() \u2014 to confirm the target peer is online and get their exact name
-- After startup \u2014 to verify you joined the network successfully
+- After connect() \u2014 to verify the connection succeeded and the mesh formed
 - When a peer seems unreachable \u2014 to check if they are still connected
 
 WHAT IT SHOWS:
-- Your own name and the port you are listening on
-- All peers who have established a direct connection to you
+- Your own name and port
+- All peers with an active direct connection
 
 IF NO PEERS ARE LISTED:
-- Peers discover each other automatically via LAN broadcast every 3 seconds
-- If a peer just started, wait a few seconds and call peers() again
-- Call firewall_open() so peers on other machines can connect inbound to you
-- If still no peers, verify all machines are on the same LAN/subnet`;
+- Use connect(ip) to connect to a peer
+- Ask your teammate to run status() to get their IP`;
 function registerPeersTool(server, client) {
   server.tool("peers", PEERS_DESCRIPTION, {}, async () => {
     const info = client.getInfo();
@@ -927,13 +971,17 @@ function registerPeersTool(server, client) {
             `You are "${myName}" (listening on port ${myPort}).`,
             `No peers connected yet.`,
             ``,
-            `Peers auto-discover via LAN broadcast \u2014 wait a few seconds if they just started.`,
-            `Call firewall_open() if peers on other machines cannot reach you.`
+            `Use connect(ip) to connect to a peer.`,
+            `Ask your teammate to run status() to get their IP.`
           ].join("\n")
         }]
       };
     }
-    const list = connected.map((name) => `  \u2022 ${name}`).join("\n");
+    const peerIPs = info.peerIPs ?? {};
+    const list = connected.map((name) => {
+      const ip = peerIPs[name] ? ` (${peerIPs[name]})` : "";
+      return `  \u2022 ${name}${ip}`;
+    }).join("\n");
     return {
       content: [{
         type: "text",
@@ -986,263 +1034,51 @@ ${answerLine}`;
     };
   });
 }
-function runNetshElevated(argArray) {
-  const argList = argArray.map((a) => `"${a}"`).join(",");
-  const psCommand = `Start-Process -FilePath "netsh" -ArgumentList @(${argList}) -Verb RunAs -Wait`;
-  return new Promise((resolve, reject) => {
-    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 runNetsh(argArray) {
-  await runNetshElevated(argArray);
-}
-async function addFirewallRule(port) {
-  await runNetsh([
-    "advfirewall",
-    "firewall",
-    "add",
-    "rule",
-    `name=claude-collab-${port}`,
-    "protocol=TCP",
-    "dir=in",
-    `localport=${port}`,
-    "action=allow"
-  ]);
-  try {
-    await runNetsh([
-      "advfirewall",
-      "firewall",
-      "add",
-      "rule",
-      "name=claude-collab-discovery",
-      "protocol=UDP",
-      "dir=in",
-      "localport=11776",
-      "action=allow"
-    ]);
-  } catch {
-  }
-}
-async function removeFirewallRule(port) {
-  await runNetsh([
-    "advfirewall",
-    "firewall",
-    "delete",
-    "rule",
-    `name=claude-collab-${port}`
-  ]);
-  try {
-    await runNetsh(["advfirewall", "firewall", "delete", "rule", "name=claude-collab-discovery"]);
-  } catch {
-  }
-}
 
-// src/presentation/mcp/tools/firewall-open.tool.ts
-var FIREWALL_OPEN_DESCRIPTION = `Open a Windows Firewall inbound rule so peers on the LAN can connect directly to you.
-
-WHEN YOU NEED THIS:
-- Other peers cannot see you in their peers() list even though you are on the same LAN
-- You just started and want to make sure all peers can reach you
-- A peer explicitly says they cannot connect to you
-
-WHEN YOU DO NOT NEED THIS:
-- You can already see peers in peers() \u2014 the connection is working
-- You are connecting outbound to others (outbound connections do not require firewall rules)
-
-WHAT HAPPENS:
-- On most systems: the rule is applied immediately (terminal is already elevated)
-- On standard Windows: a UAC popup appears \u2014 the user must click Yes
-- On VMs or headless setups: applied directly if running as Administrator
-
-The rule is named "claude-collab-{port}" and allows inbound TCP on your current listen port.
-Call firewall_close() when you are done to clean up the rule.`;
-function registerFirewallOpenTool(server, client) {
-  server.tool(
-    "firewall_open",
-    FIREWALL_OPEN_DESCRIPTION,
-    {
-      port: z.number().min(1024).max(65535).optional().describe(
-        "Port to open. Defaults to your current listen port \u2014 omit this unless you have a specific reason to override."
-      )
-    },
-    async ({ port }) => {
-      const targetPort = port ?? client.getInfo().port;
-      if (!targetPort) {
-        return {
-          content: [{ type: "text", text: "P2P node is not running yet \u2014 port unknown. Try again in a moment." }],
-          isError: true
-        };
-      }
-      try {
-        await addFirewallRule(targetPort);
-        return {
-          content: [{
-            type: "text",
-            text: [
-              `Firewall rule opened for port ${targetPort} (claude-collab-${targetPort}).`,
-              `Peers on the LAN can now connect to you inbound.`,
-              `Call firewall_close() when you are done with this session.`
-            ].join("\n")
-          }]
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{
-            type: "text",
-            text: [
-              `Failed to open firewall: ${msg}`,
-              ``,
-              `Try running your terminal as Administrator and call firewall_open() again.`
-            ].join("\n")
-          }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-var FIREWALL_CLOSE_DESCRIPTION = `Remove the Windows Firewall inbound rule that was opened by firewall_open().
+// src/presentation/mcp/tools/status.tool.ts
+var STATUS_DESCRIPTION = `Show your identity and network address on the collaboration network.
 
 WHEN TO USE:
-- At the end of a collaboration session to clean up
-- When you no longer want to accept inbound peer connections
-- As general hygiene \u2014 open firewall rules should not be left indefinitely
-
-WHAT HAPPENS:
-- The inbound TCP rule "claude-collab-{port}" is deleted from Windows Firewall
-- Existing active connections are not dropped \u2014 only new inbound connections are blocked
-- On standard Windows: a UAC popup appears \u2014 the user must click Yes
-- On VMs or admin terminals: applied directly without a popup
+- To find your LAN IP so teammates can connect to you via connect(ip)
+- To verify your node started correctly
+- To see how many peers are currently connected
 
-NOTE: Because ports are random each session, each startup creates a new rule name.
-Old rules from previous sessions can be removed by passing the port explicitly.`;
-function registerFirewallCloseTool(server, client) {
-  server.tool(
-    "firewall_close",
-    FIREWALL_CLOSE_DESCRIPTION,
-    {
-      port: z.number().min(1024).max(65535).optional().describe(
-        "Port whose rule to remove. Defaults to your current listen port. Pass a specific port to clean up a rule from a previous session."
-      )
-    },
-    async ({ port }) => {
-      const targetPort = port ?? client.getInfo().port;
-      if (!targetPort) {
-        return {
-          content: [{ type: "text", text: "P2P node is not running yet \u2014 port unknown. Try again in a moment." }],
-          isError: true
-        };
-      }
-      try {
-        await removeFirewallRule(targetPort);
-        return {
-          content: [{
-            type: "text",
-            text: `Firewall rule removed for port ${targetPort} (claude-collab-${targetPort}).`
-          }]
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{
-            type: "text",
-            text: [
-              `Failed to remove firewall rule: ${msg}`,
-              ``,
-              `The rule may not exist (if firewall_open was never called this session), or try running as Administrator.`
-            ].join("\n")
-          }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-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.`
-      ];
+SHARE YOUR IP:
+- Tell your teammate the IP shown here, they call connect("<your IP>")`;
+function registerStatusTool(server, client) {
+  server.tool("status", STATUS_DESCRIPTION, {}, async () => {
+    const info = client.getInfo();
+    const myName = info.teamName ?? "(starting...)";
+    const port = info.port ?? "?";
+    if (!client.isConnected) {
       return {
-        content: [{ type: "text", text: lines.join("\n") }]
+        content: [{
+          type: "text",
+          text: `Node is not running yet. Port ${port} may be in use \u2014 check MCP process logs.`
+        }],
+        isError: true
       };
     }
-  );
+    let ips = [];
+    if (client instanceof P2PNode) {
+      ips = client.getLocalIps();
+    }
+    const ipLine = ips.length > 0 ? ips.join(", ") : "(could not detect \u2014 check your network interface)";
+    const peerCount = info.connectedPeers.length;
+    const peerLine = peerCount === 0 ? "No peers connected yet. Share your IP so others can connect(ip)." : `Connected to ${peerCount} peer(s): ${info.connectedPeers.map((n) => `"${n}"`).join(", ")}`;
+    return {
+      content: [{
+        type: "text",
+        text: [
+          `Name:  ${myName}`,
+          `IP:    ${ipLine}`,
+          `Port:  ${port}`,
+          ``,
+          peerLine
+        ].join("\n")
+      }]
+    };
+  });
 }
 
 // src/presentation/mcp/server.ts
@@ -1252,13 +1088,12 @@ function createMcpServer(options) {
     name: "claude-collab",
     version: "0.1.0"
   });
+  registerConnectTool(server, client);
+  registerStatusTool(server, client);
   registerAskTool(server, client);
   registerReplyTool(server, client);
   registerPeersTool(server, client);
   registerHistoryTool(server, client);
-  registerFirewallOpenTool(server, client);
-  registerFirewallCloseTool(server, client);
-  registerPeerFindTool(server, client);
   return server;
 }
 async function startMcpServer(options) {
@@ -1269,11 +1104,12 @@ async function startMcpServer(options) {
 
 // src/cli.ts
 var program = new Command();
-program.name("claude-collab").description("P2P collaboration between Claude Code terminals via MCP").version("0.1.0").requiredOption("--name <name>", 'Your name on the network (e.g. "alice")').action(async (options) => {
+program.name("claude-collab").description("Collaboration between Claude Code terminals via MCP").version("0.1.0").requiredOption("--name <name>", 'Your name on the network (e.g. "alice")').action(async (options) => {
   const node = new P2PNode();
   const mcpReady = startMcpServer({ client: node });
   node.join(options.name, options.name).catch((err) => {
-    console.error(`[cli] P2P server failed to start: ${err.message}`);
+    console.error(`[cli] Failed to start on port 12345: ${err.message}`);
+    console.error(`[cli] Make sure port 12345 is not already in use.`);
   });
   await mcpReady;
 });