@dolusoft/claude-collab 1.4.4 → 1.5.1

package/dist/mcp-main.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { WebSocketServer, 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, networkInterfaces } from 'os';
 import { join } from 'path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -17,6 +18,122 @@ function serializeP2PMsg(msg) {
 function parseP2PMsg(data) {
   return JSON.parse(data);
 }
+var BROADCAST_ADDR = "255.255.255.255";
+var BROADCAST_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("[discovery] socket error:", err.message);
+    });
+    socket.on("message", (buf, rinfo) => {
+      try {
+        const msg = JSON.parse(buf.toString());
+        this.handleMessage(msg, rinfo.address);
+      } catch {
+      }
+    });
+    socket.bind(BROADCAST_PORT, () => {
+      socket.setBroadcast(true);
+      this.announce();
+      this.heartbeatTimer = setInterval(() => this.announce(), HEARTBEAT_INTERVAL_MS);
+      this.timeoutTimer = setInterval(() => this.checkTimeouts(), 1e4);
+      console.error(`[discovery] broadcasting on port ${BROADCAST_PORT}`);
+    });
+  }
+  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.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, BROADCAST_PORT, BROADCAST_ADDR, (err) => {
+      if (err) console.error("[discovery] send error:", err.message);
+    });
+  }
+  handleMessage(msg, fromIp) {
+    if (msg.type === "ANNOUNCE") {
+      if (msg.name === this.myName && fromIp === this.myIp) 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(`[discovery] found 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(`[discovery] 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(`[discovery] 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;
@@ -252,16 +369,23 @@ var config = {
 var P2PNode = class {
   wss = null;
   port = 0;
-  // Connections indexed by remote team name
+  discovery = new MulticastDiscovery();
+  // Connections indexed by remote peer name
   peerConns = /* @__PURE__ */ new Map();
-  // Reverse lookup: ws → teamName (for cleanup)
-  wsToTeam = /* @__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)
   incomingQuestions = /* @__PURE__ */ new Map();
   // Answers we received for questions we asked
   receivedAnswers = /* @__PURE__ */ new Map();
-  // Maps questionId → remote teamName (so we know who to poll)
-  questionToTeam = /* @__PURE__ */ new Map();
+  // Maps questionId → remote peer name (so we know who to poll)
+  questionToName = /* @__PURE__ */ new Map();
+  // Questions we sent — for history
+  sentQuestions = /* @__PURE__ */ new Map();
   // Pending response handlers (request-response correlation by filter)
   pendingHandlers = /* @__PURE__ */ new Set();
   localMember = null;
@@ -270,7 +394,7 @@ var P2PNode = class {
     return this._isStarted;
   }
   get currentTeamId() {
-    return this.localMember?.teamName;
+    return this.localMember?.name;
   }
   /**
    * Starts the WS server on a random available port within the configured range.
@@ -307,71 +431,31 @@ var P2PNode = class {
       wss.once("error", () => resolve(false));
     });
   }
-  async join(teamName, displayName) {
+  async join(name, displayName) {
     if (!this._isStarted) {
       await this.start();
     }
     const memberId = v4();
-    this.localMember = { memberId, teamName, displayName };
-    return { memberId, teamId: teamName, teamName, displayName, status: "ONLINE", port: this.port };
-  }
-  /**
-   * Connects to a peer at the given IP and port.
-   * Performs a bidirectional HELLO handshake and returns the peer's team name.
-   */
-  async connectPeer(ip, port) {
-    if (!this.localMember) {
-      throw new Error("Must call join() before connectPeer()");
-    }
-    const ws = new WebSocket(`ws://${ip}:${port}`);
-    ws.on("message", (data) => {
-      try {
-        const msg = parseP2PMsg(data.toString());
-        this.handleMessage(ws, msg);
-      } catch (err) {
-        console.error("Failed to parse P2P message:", err);
-      }
+    this.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);
     });
-    ws.on("close", () => {
-      const team = this.wsToTeam.get(ws);
-      if (team) {
-        if (this.peerConns.get(team) === ws) {
-          this.peerConns.delete(team);
-        }
-        this.wsToTeam.delete(ws);
+    this.discovery.on("peer-lost", (peerName) => {
+      const ws = this.peerConns.get(peerName);
+      if (ws) {
+        ws.close();
+        this.peerConns.delete(peerName);
       }
     });
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error(`Connection timeout to ${ip}:${port}`)),
-        5e3
-      );
-      ws.on("open", () => {
-        clearTimeout(timeout);
-        const hello = {
-          type: "P2P_HELLO",
-          fromTeam: this.localMember.teamName,
-          fromMemberId: this.localMember.memberId
-        };
-        ws.send(serializeP2PMsg(hello));
-        resolve();
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-    });
-    const helloMsg = await this.waitForResponse(
-      (m) => m.type === "P2P_HELLO",
-      1e4
-    );
-    return helloMsg.fromTeam;
+    return { memberId, teamId: name, teamName: name, displayName, status: "ONLINE", port: this.port };
   }
-  async ask(toTeam, content, format) {
-    const ws = await this.getPeerConnection(toTeam);
+  async ask(toName, content, format) {
+    const ws = await this.getPeerConnection(toName);
     const questionId = v4();
     const requestId = v4();
-    this.questionToTeam.set(questionId, toTeam);
+    this.questionToName.set(questionId, toName);
+    this.sentQuestions.set(questionId, { toPeer: toName, content, askedAt: (/* @__PURE__ */ new Date()).toISOString() });
     const ackPromise = this.waitForResponse(
       (m) => m.type === "P2P_ASK_ACK" && m.requestId === requestId,
       5e3
@@ -380,8 +464,8 @@ var P2PNode = class {
       type: "P2P_ASK",
       questionId,
       fromMemberId: this.localMember.memberId,
-      fromTeam: this.localMember.teamName,
-      toTeam,
+      fromTeam: this.localMember.name,
+      toTeam: toName,
       content,
       format,
       requestId
@@ -401,9 +485,9 @@ var P2PNode = class {
         answeredAt: cached.answeredAt
       };
     }
-    const toTeam = this.questionToTeam.get(questionId);
-    if (!toTeam) return null;
-    const ws = this.peerConns.get(toTeam);
+    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 requestId = v4();
     const responsePromise = this.waitForResponse(
@@ -446,7 +530,7 @@ var P2PNode = class {
       content,
       format,
       answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fromTeam: this.localMember.teamName,
+      fromTeam: this.localMember.name,
       fromMemberId: this.localMember.memberId
     };
     if (question.ws.readyState === WebSocket.OPEN) {
@@ -472,12 +556,40 @@ var P2PNode = class {
   }
   getInfo() {
     return {
-      teamName: this.localMember?.teamName,
+      teamName: this.localMember?.name,
       port: this._isStarted ? this.port : void 0,
       connectedPeers: [...this.peerConns.keys()]
     };
   }
+  getHistory() {
+    const entries = [];
+    for (const [questionId, sent] of this.sentQuestions) {
+      const answer = this.receivedAnswers.get(questionId);
+      entries.push({
+        direction: "sent",
+        questionId,
+        peer: sent.toPeer,
+        question: sent.content,
+        answer: answer?.content,
+        askedAt: sent.askedAt,
+        answeredAt: answer?.answeredAt
+      });
+    }
+    for (const [questionId, incoming] of this.incomingQuestions) {
+      entries.push({
+        direction: "received",
+        questionId,
+        peer: incoming.fromTeam,
+        question: incoming.content,
+        answer: incoming.answered ? incoming.answerContent : void 0,
+        askedAt: incoming.createdAt.toISOString(),
+        answeredAt: incoming.answered ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+      });
+    }
+    return entries.sort((a, b) => a.askedAt.localeCompare(b.askedAt));
+  }
   async disconnect() {
+    this.discovery.stop();
     for (const ws of this.peerConns.values()) {
       ws.close();
     }
@@ -492,35 +604,88 @@ var P2PNode = class {
     this._isStarted = false;
   }
   // ---------------------------------------------------------------------------
+  // Private: auto-connect from multicast discovery
+  // ---------------------------------------------------------------------------
+  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);
+    ws.on("message", (data) => {
+      try {
+        const msg = parseP2PMsg(data.toString());
+        this.handleMessage(ws, msg);
+      } catch (err) {
+        console.error("[p2p] Failed to parse message:", err);
+      }
+    });
+    ws.on("close", () => this.cleanupWs(ws));
+    ws.on("error", (err) => console.error("[p2p] ws error:", err.message));
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error(`Connection timeout to ${ip}:${port}`)),
+        5e3
+      );
+      ws.on("open", () => {
+        clearTimeout(timeout);
+        const hello = {
+          type: "P2P_HELLO",
+          fromTeam: this.localMember.name,
+          fromMemberId: this.localMember.memberId
+        };
+        ws.send(serializeP2PMsg(hello));
+        resolve();
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+    const helloMsg = await this.waitForResponse(
+      (m) => m.type === "P2P_HELLO",
+      1e4
+    );
+    return helloMsg.fromTeam;
+  }
+  // ---------------------------------------------------------------------------
   // Private: WebSocket server setup
   // ---------------------------------------------------------------------------
   setupWssHandlers() {
-    this.wss.on("connection", (ws) => {
+    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.teamName,
+              fromTeam: this.localMember.name,
               fromMemberId: this.localMember.memberId
             };
             ws.send(serializeP2PMsg(hello));
           }
           this.handleMessage(ws, msg);
         } catch (err) {
-          console.error("Failed to parse incoming P2P message:", err);
-        }
-      });
-      ws.on("close", () => {
-        const team = this.wsToTeam.get(ws);
-        if (team) {
-          if (this.peerConns.get(team) === ws) {
-            this.peerConns.delete(team);
-          }
-          this.wsToTeam.delete(ws);
+          console.error("[p2p] Failed to parse incoming message:", err);
         }
       });
+      ws.on("close", () => this.cleanupWs(ws));
     });
   }
   // ---------------------------------------------------------------------------
@@ -532,9 +697,7 @@ var P2PNode = class {
     }
     switch (msg.type) {
       case "P2P_HELLO":
-        this.wsToTeam.set(ws, msg.fromTeam);
-        this.peerConns.set(msg.fromTeam, ws);
-        console.error(`Peer identified: ${msg.fromTeam}`);
+        this.handleHello(ws, msg);
         break;
       case "P2P_ASK":
         this.handleIncomingAsk(ws, msg);
@@ -558,6 +721,28 @@ var P2PNode = class {
         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) {
     this.incomingQuestions.set(msg.questionId, {
       questionId: msg.questionId,
@@ -605,7 +790,7 @@ var P2PNode = class {
       content: question.answerContent,
       format: question.answerFormat,
       answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fromTeam: this.localMember.teamName,
+      fromTeam: this.localMember.name,
       fromMemberId: this.localMember.memberId,
       requestId: msg.requestId
     };
@@ -614,13 +799,24 @@ var P2PNode = class {
   // ---------------------------------------------------------------------------
   // Private: peer connection management
   // ---------------------------------------------------------------------------
-  async getPeerConnection(teamName) {
-    const existing = this.peerConns.get(teamName);
+  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;
     }
     throw new Error(
-      `No connection to team '${teamName}'. Use the connect_peer tool to connect first.`
+      `No connection to peer '${name}'. They may not be on the network yet \u2014 wait a moment and try again.`
     );
   }
   waitForResponse(filter, timeoutMs) {
@@ -640,115 +836,13 @@ var P2PNode = class {
     });
   }
 };
-var joinSchema = {
-  team: z.string().describe('Team name to join (e.g., "frontend", "backend", "devops")'),
-  displayName: z.string().optional().describe('Display name for this terminal (default: team + " Claude")')
-};
-function registerJoinTool(server, client) {
-  server.tool("join", joinSchema, async (args) => {
-    const teamName = args.team;
-    const displayName = args.displayName ?? `${teamName} Claude`;
-    try {
-      const member = await client.join(teamName, displayName);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Successfully joined team "${member.teamName}" as "${member.displayName}".
-
-Your member ID: ${member.memberId}
-Status: ${member.status}
-Listening on port: ${member.port}
-
-Share this port with the other terminal so they can run: connect_peer("<your-ip>", ${member.port})`
-          }
-        ]
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to join team: ${errorMessage}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-}
-var connectPeerSchema = {
-  ip: z.string().describe('IP address of the peer to connect to (e.g., "172.16.40.137")'),
-  port: z.number().describe("Port the peer is listening on (shown in their join response)")
-};
-function registerConnectPeerTool(server, client) {
-  server.tool("connect_peer", connectPeerSchema, async (args) => {
-    try {
-      const peerTeam = await client.connectPeer(args.ip, args.port);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Connected to peer "${peerTeam}" at ${args.ip}:${args.port}.`
-          }
-        ]
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to connect to ${args.ip}:${args.port}: ${errorMessage}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-}
-function getLocalIPs() {
-  const ips = [];
-  for (const iface of Object.values(networkInterfaces())) {
-    for (const net of iface ?? []) {
-      if (net.family === "IPv4" && !net.internal) {
-        ips.push(net.address);
-      }
-    }
-  }
-  return ips;
-}
-function registerGetInfoTool(server, client) {
-  server.tool("get_info", {}, async () => {
-    const info = client.getInfo();
-    const ips = getLocalIPs();
-    const lines = [];
-    lines.push(`Team: ${info.teamName ?? "(not joined yet)"}`);
-    lines.push(`Port: ${info.port ?? "(not started yet)"}`);
-    lines.push(`Local IPs: ${ips.length > 0 ? ips.join(", ") : "(none found)"}`);
-    if (info.connectedPeers.length > 0) {
-      lines.push(`Connected peers: ${info.connectedPeers.join(", ")}`);
-    } else {
-      lines.push(`Connected peers: (none)`);
-    }
-    if (info.port && ips.length > 0) {
-      lines.push(`
-Other terminal can connect with:
-  connect_peer("${ips[0]}", ${info.port})`);
-    }
-    return {
-      content: [{ type: "text", text: lines.join("\n") }]
-    };
-  });
-}
 var askSchema = {
-  team: z.string().describe('Target team name to ask (e.g., "backend", "frontend")'),
+  peer: z.string().describe('Name of the peer to ask (e.g., "alice", "backend")'),
   question: z.string().describe("The question to ask (supports markdown)")
 };
 function registerAskTool(server, client) {
   server.tool("ask", askSchema, async (args) => {
-    const targetTeam = args.team;
+    const targetPeer = args.peer;
     const question = args.question;
     try {
       if (!client.currentTeamId) {
@@ -756,13 +850,13 @@ function registerAskTool(server, client) {
           content: [
             {
               type: "text",
-              text: 'You must join a team first. Use the "join" tool to join a team.'
+              text: "Node is not ready yet. Wait a moment and try again."
             }
           ],
           isError: true
         };
       }
-      const questionId = await client.ask(targetTeam, question, "markdown");
+      const questionId = await client.ask(targetPeer, question, "markdown");
       const POLL_INTERVAL_MS = 5e3;
       const MAX_WAIT_MS = 5 * 60 * 1e3;
       const deadline = Date.now() + MAX_WAIT_MS;
@@ -807,124 +901,6 @@ Manuel kontrol i\xE7in "check_answer" tool'unu kullanabilirsin.`
     }
   });
 }
-var checkAnswerSchema = {
-  question_id: z.string().describe('The question ID returned by the "ask" tool')
-};
-function registerCheckAnswerTool(server, client) {
-  server.tool("check_answer", checkAnswerSchema, async (args) => {
-    const questionId = args.question_id;
-    try {
-      if (!client.currentTeamId) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: 'You must join a team first. Use the "join" tool to join a team.'
-            }
-          ],
-          isError: true
-        };
-      }
-      const answer = await client.checkAnswer(questionId);
-      if (!answer) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No answer yet for question \`${questionId}\`. The other team hasn't replied yet. You can continue working and check again later.`
-            }
-          ]
-        };
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `**Answer from ${answer.from.displayName} (${answer.from.teamName}):**
-
-${answer.content}`
-          }
-        ]
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to check answer: ${errorMessage}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-}
-
-// src/presentation/mcp/tools/inbox.tool.ts
-var inboxSchema = {};
-function registerInboxTool(server, client) {
-  server.tool("inbox", inboxSchema, async () => {
-    try {
-      if (!client.currentTeamId) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: 'You must join a team first. Use the "join" tool to join a team.'
-            }
-          ],
-          isError: true
-        };
-      }
-      const inbox = await client.getInbox();
-      if (inbox.questions.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No pending questions in your inbox."
-            }
-          ]
-        };
-      }
-      const questionsList = inbox.questions.map((q, i) => {
-        const ageSeconds = Math.floor(q.ageMs / 1e3);
-        const ageStr = ageSeconds < 60 ? `${ageSeconds}s ago` : `${Math.floor(ageSeconds / 60)}m ago`;
-        return `### ${i + 1}. Question from ${q.from.displayName} (${q.from.teamName}) - ${ageStr}
-**ID:** \`${q.questionId}\`
-**Status:** ${q.status}
-
-${q.content}
-
----`;
-      }).join("\n\n");
-      return {
-        content: [
-          {
-            type: "text",
-            text: `# Inbox (${inbox.pendingCount} pending, ${inbox.totalCount} total)
-
-${questionsList}
-
-Use the "reply" tool with the question ID to answer a question.`
-          }
-        ]
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to get inbox: ${errorMessage}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-}
 var replySchema = {
   questionId: z.string().describe("The ID of the question to reply to (from inbox)"),
   answer: z.string().describe("Your answer to the question (supports markdown)")
@@ -970,52 +946,69 @@ function registerReplyTool(server, client) {
   });
 }
 
+// src/presentation/mcp/tools/peers.tool.ts
+function registerPeersTool(server, client) {
+  server.tool("peers", {}, async () => {
+    const info = client.getInfo();
+    const myName = info.teamName ?? "(starting...)";
+    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.`
+        }]
+      };
+    }
+    const list = connected.map((name) => `  \u2022 ${name}`).join("\n");
+    return {
+      content: [{
+        type: "text",
+        text: `You are "${myName}". Connected peers (${connected.length}):
+${list}`
+      }]
+    };
+  });
+}
+
+// src/presentation/mcp/tools/history.tool.ts
+function registerHistoryTool(server, client) {
+  server.tool("history", {}, async () => {
+    const entries = client.getHistory();
+    if (entries.length === 0) {
+      return {
+        content: [{ type: "text", text: "No questions yet this session." }]
+      };
+    }
+    const lines = entries.map((e) => {
+      const time = new Date(e.askedAt).toLocaleTimeString();
+      if (e.direction === "sent") {
+        const answerLine = e.answer ? `  \u21B3 ${e.peer}: ${e.answer}` : `  \u21B3 (no answer yet)`;
+        return `[${time}] \u2192 ${e.peer}: ${e.question}
+${answerLine}`;
+      } else {
+        const answerLine = e.answer ? `  \u21B3 you: ${e.answer}` : `  \u21B3 (not replied yet)`;
+        return `[${time}] \u2190 ${e.peer}: ${e.question}
+${answerLine}`;
+      }
+    });
+    return {
+      content: [{ type: "text", text: lines.join("\n\n") }]
+    };
+  });
+}
+
 // src/presentation/mcp/server.ts
 function createMcpServer(options) {
   const { client } = options;
-  const server = new McpServer(
-    {
-      name: "claude-collab",
-      version: "0.1.2"
-    },
-    {
-      capabilities: {
-        resources: {
-          subscribe: true,
-          listChanged: true
-        }
-      }
-    }
-  );
-  registerJoinTool(server, client);
-  registerConnectPeerTool(server, client);
-  registerGetInfoTool(server, client);
+  const server = new McpServer({
+    name: "claude-collab",
+    version: "0.1.0"
+  });
   registerAskTool(server, client);
-  registerCheckAnswerTool(server, client);
-  registerInboxTool(server, client);
   registerReplyTool(server, client);
-  server.resource(
-    "inbox-questions",
-    "inbox://questions",
-    { description: "Your inbox of pending questions from other teams", mimeType: "application/json" },
-    async () => {
-      try {
-        const inbox = await client.getInbox();
-        return {
-          contents: [
-            {
-              uri: "inbox://questions",
-              mimeType: "application/json",
-              text: JSON.stringify(inbox, null, 2)
-            }
-          ]
-        };
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        throw new Error(`Failed to read inbox: ${errorMessage}`);
-      }
-    }
-  );
+  registerPeersTool(server, client);
+  registerHistoryTool(server, client);
   return server;
 }
 async function startMcpServer(options) {
@@ -1025,8 +1018,19 @@ 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);
+}
 async function main() {
+  const name = parseName();
   const p2pNode = new P2PNode();
+  await p2pNode.join(name, name);
   await startMcpServer({ client: p2pNode });
 }
 main().catch((error) => {