@dolusoft/claude-collab 1.3.1 → 1.4.2

package/dist/mcp-main.js

@@ -1,169 +1,15 @@
 #!/usr/bin/env node
 import { WebSocketServer, WebSocket } from 'ws';
-import { createServer } from 'net';
 import { v4 } from 'uuid';
-import multicastDns from 'multicast-dns';
-import { tmpdir, networkInterfaces } from 'os';
 import { EventEmitter } from 'events';
 import { execFile } from 'child_process';
 import { unlinkSync } from 'fs';
+import { tmpdir } from 'os';
 import { join } from 'path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-function getLocalIp() {
-  const nets = networkInterfaces();
-  for (const name of Object.keys(nets)) {
-    for (const net of nets[name] ?? []) {
-      if (net.family === "IPv4" && !net.internal) {
-        return net.address;
-      }
-    }
-  }
-  return "127.0.0.1";
-}
-var SERVICE_TYPE = "_claude-collab._tcp.local";
-var MdnsDiscovery = class {
-  mdns;
-  announced = false;
-  port = 0;
-  teamName = "";
-  memberId = "";
-  peersByTeam = /* @__PURE__ */ new Map();
-  peersByMemberId = /* @__PURE__ */ new Map();
-  onPeerFoundCb;
-  onPeerLostCb;
-  constructor() {
-    this.mdns = multicastDns();
-    this.setupHandlers();
-  }
-  get serviceName() {
-    return `${this.memberId}.${SERVICE_TYPE}`;
-  }
-  buildAnswers() {
-    return [
-      {
-        name: SERVICE_TYPE,
-        type: "PTR",
-        ttl: 300,
-        data: this.serviceName
-      },
-      {
-        name: this.serviceName,
-        type: "SRV",
-        ttl: 300,
-        data: {
-          priority: 0,
-          weight: 0,
-          port: this.port,
-          target: getLocalIp()
-        }
-      },
-      {
-        name: this.serviceName,
-        type: "TXT",
-        ttl: 300,
-        data: [
-          Buffer.from(`team=${this.teamName}`),
-          Buffer.from(`memberId=${this.memberId}`),
-          Buffer.from("ver=1")
-        ]
-      }
-    ];
-  }
-  setupHandlers() {
-    this.mdns.on("query", (query) => {
-      if (!this.announced) return;
-      const questions = query.questions ?? [];
-      const ptrQuery = questions.find(
-        (q) => q.type === "PTR" && q.name === SERVICE_TYPE
-      );
-      if (!ptrQuery) return;
-      this.mdns.respond({ answers: this.buildAnswers() });
-    });
-    this.mdns.on("response", (response) => {
-      this.parseResponse(response);
-    });
-  }
-  parseResponse(response) {
-    const allRecords = [
-      ...response.answers ?? [],
-      ...response.additionals ?? []
-    ];
-    const ptrRecords = allRecords.filter(
-      (r) => r.type === "PTR" && r.name === SERVICE_TYPE
-    );
-    for (const ptr of ptrRecords) {
-      const instanceName = ptr.data;
-      const srv = allRecords.find(
-        (r) => r.type === "SRV" && r.name === instanceName
-      );
-      const txt = allRecords.find(
-        (r) => r.type === "TXT" && r.name === instanceName
-      );
-      if (!srv) continue;
-      const port = srv.data.port;
-      const host = srv.data.target || "127.0.0.1";
-      let teamName = "";
-      let memberId = "";
-      if (txt) {
-        const txtData = txt.data ?? [];
-        for (const entry of txtData) {
-          const str = Buffer.isBuffer(entry) ? entry.toString() : String(entry);
-          if (str.startsWith("team=")) teamName = str.slice(5);
-          if (str.startsWith("memberId=")) memberId = str.slice(9);
-        }
-      }
-      if (!teamName || !memberId) continue;
-      if (memberId === this.memberId) continue;
-      const ptrTtl = ptr.ttl ?? 300;
-      const srvTtl = srv.ttl ?? 300;
-      if (ptrTtl === 0 || srvTtl === 0) {
-        this.peersByTeam.delete(teamName);
-        this.peersByMemberId.delete(memberId);
-        this.onPeerLostCb?.(memberId);
-        continue;
-      }
-      const peer = { host, port, teamName, memberId };
-      this.peersByTeam.set(teamName, peer);
-      this.peersByMemberId.set(memberId, peer);
-      this.onPeerFoundCb?.(peer);
-    }
-  }
-  /**
-   * Announce this node's service via mDNS.
-   * Sends an unsolicited response so existing peers notice immediately.
-   */
-  announce(port, teamName, memberId) {
-    this.port = port;
-    this.teamName = teamName;
-    this.memberId = memberId;
-    this.announced = true;
-    this.mdns.respond({ answers: this.buildAnswers() });
-  }
-  /**
-   * Send a PTR query to discover existing peers.
-   */
-  discover() {
-    this.mdns.query({
-      questions: [{ name: SERVICE_TYPE, type: "PTR" }]
-    });
-  }
-  getPeerByTeam(teamName) {
-    return this.peersByTeam.get(teamName);
-  }
-  onPeerFound(cb) {
-    this.onPeerFoundCb = cb;
-  }
-  onPeerLost(cb) {
-    this.onPeerLostCb = cb;
-  }
-  destroy() {
-    this.mdns.destroy();
-  }
-};
-
 // src/infrastructure/p2p/p2p-message-protocol.ts
 function serializeP2PMsg(msg) {
   return JSON.stringify(msg);
@@ -179,8 +25,6 @@ using System.Runtime.InteropServices;
 public class ConInject {
     [DllImport("kernel32.dll")] public static extern bool FreeConsole();
     [DllImport("kernel32.dll")] public static extern bool AttachConsole(uint pid);
-    [DllImport("kernel32.dll")] public static extern IntPtr GetConsoleWindow();
-    [DllImport("user32.dll")]   public static extern bool SetForegroundWindow(IntPtr hwnd);
     [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
     public static extern IntPtr CreateFile(
         string lpFileName, uint dwDesiredAccess, uint dwShareMode,
@@ -209,7 +53,7 @@ public class ConInject {
         return CreateFile("CONIN$", 0xC0000000, 3, IntPtr.Zero, 3, 0, IntPtr.Zero);
     }
 
-    // Inject only text characters into console input buffer (no Ctrl keys, no Enter)
+    // Inject plain text characters into console input buffer
     public static int InjectText(uint pid, string text) {
         IntPtr hIn = OpenConin(pid);
         if (hIn == new IntPtr(-1)) return -1;
@@ -227,13 +71,56 @@ public class ConInject {
         return ok ? (int)written : -2;
     }
 
-    // Focus the console window for WScript.Shell.SendKeys
-    public static IntPtr FocusConsole(uint pid) {
-        FreeConsole();
-        if (!AttachConsole(pid)) return IntPtr.Zero;
-        IntPtr hwnd = GetConsoleWindow();
-        if (hwnd != IntPtr.Zero) SetForegroundWindow(hwnd);
-        return hwnd;
+    // Inject Enter (VK_RETURN = 0x0D)
+    public static int InjectEnter(uint pid) {
+        IntPtr hIn = OpenConin(pid);
+        if (hIn == new IntPtr(-1)) return -1;
+
+        var records = new INPUT_RECORD[] {
+            new INPUT_RECORD { EventType=1, bKeyDown=1, wRepeatCount=1, wVirtualKeyCode=0x0D, UnicodeChar=0x0D },
+            new INPUT_RECORD { EventType=1, bKeyDown=0, wRepeatCount=1, wVirtualKeyCode=0x0D, UnicodeChar=0x0D }
+        };
+
+        uint written;
+        bool ok = WriteConsoleInput(hIn, records, (uint)records.Length, out written);
+        CloseHandle(hIn);
+        return ok ? (int)written : -2;
+    }
+
+    // Inject Ctrl+U (VK_U = 0x55, char = 0x15)
+    public static int InjectCtrlU(uint pid) {
+        IntPtr hIn = OpenConin(pid);
+        if (hIn == new IntPtr(-1)) return -1;
+
+        var records = new INPUT_RECORD[] {
+            new INPUT_RECORD { EventType=1, bKeyDown=1, wRepeatCount=1, wVirtualKeyCode=0xA2, dwControlKeyState=LEFT_CTRL },
+            new INPUT_RECORD { EventType=1, bKeyDown=1, wRepeatCount=1, wVirtualKeyCode=0x55, UnicodeChar=0x15, dwControlKeyState=LEFT_CTRL },
+            new INPUT_RECORD { EventType=1, bKeyDown=0, wRepeatCount=1, wVirtualKeyCode=0x55, UnicodeChar=0x15, dwControlKeyState=LEFT_CTRL },
+            new INPUT_RECORD { EventType=1, bKeyDown=0, wRepeatCount=1, wVirtualKeyCode=0xA2, dwControlKeyState=0 }
+        };
+
+        uint written;
+        bool ok = WriteConsoleInput(hIn, records, (uint)records.Length, out written);
+        CloseHandle(hIn);
+        return ok ? (int)written : -2;
+    }
+
+    // Inject Ctrl+Y (VK_Y = 0x59, char = 0x19)
+    public static int InjectCtrlY(uint pid) {
+        IntPtr hIn = OpenConin(pid);
+        if (hIn == new IntPtr(-1)) return -1;
+
+        var records = new INPUT_RECORD[] {
+            new INPUT_RECORD { EventType=1, bKeyDown=1, wRepeatCount=1, wVirtualKeyCode=0xA2, dwControlKeyState=LEFT_CTRL },
+            new INPUT_RECORD { EventType=1, bKeyDown=1, wRepeatCount=1, wVirtualKeyCode=0x59, UnicodeChar=0x19, dwControlKeyState=LEFT_CTRL },
+            new INPUT_RECORD { EventType=1, bKeyDown=0, wRepeatCount=1, wVirtualKeyCode=0x59, UnicodeChar=0x19, dwControlKeyState=LEFT_CTRL },
+            new INPUT_RECORD { EventType=1, bKeyDown=0, wRepeatCount=1, wVirtualKeyCode=0xA2, dwControlKeyState=0 }
+        };
+
+        uint written;
+        bool ok = WriteConsoleInput(hIn, records, (uint)records.Length, out written);
+        CloseHandle(hIn);
+        return ok ? (int)written : -2;
     }
 }
 `;
@@ -271,33 +158,24 @@ async function windowsInject(text) {
   const script = buildScript(claudePid, `
 $textBytes = [System.Convert]::FromBase64String('${textB64}')
 $text = [System.Text.Encoding]::Unicode.GetString($textBytes)
-$wsh = New-Object -ComObject WScript.Shell
 
-# 1. Focus console and send Ctrl+U to save user's current text to kill ring
-$hwnd = [ConInject]::FocusConsole([uint32]$claudePid)
-Start-Sleep -Milliseconds 150
-$wsh.SendKeys('^u')
-Start-Sleep -Milliseconds 150
+# 1. Ctrl+U to save user's current text to kill ring
+[ConInject]::InjectCtrlU([uint32]$claudePid) | Out-Null
+Start-Sleep -Milliseconds 100
 
 # 2. Write question text into console input buffer
 [ConInject]::InjectText([uint32]$claudePid, $text) | Out-Null
+Start-Sleep -Milliseconds 50
 
-# 3. Re-focus (InjectText calls FreeConsole internally, focus may be lost)
-[ConInject]::FocusConsole([uint32]$claudePid) | Out-Null
-Start-Sleep -Milliseconds 150
-
-# 4. Send Enter
-$wsh.SendKeys('~')
+# 3. Send Enter
+[ConInject]::InjectEnter([uint32]$claudePid) | Out-Null
 `);
   await run(script);
 }
 async function windowsInjectCtrlY() {
   const claudePid = process.ppid;
   const script = buildScript(claudePid, `
-$wsh = New-Object -ComObject WScript.Shell
-$hwnd = [ConInject]::FocusConsole([uint32]$claudePid)
-Start-Sleep -Milliseconds 150
-$wsh.SendKeys('^y')
+[ConInject]::InjectCtrlY([uint32]$claudePid) | Out-Null
 `);
   await run(script);
 }
@@ -364,35 +242,18 @@ var config = {
    */
   p2p: {
     /**
-     * Minimum port for the random WS server port range
+     * Fixed port for the WS server. Override with CLAUDE_COLLAB_PORT env var.
      */
-    portRangeMin: 1e4,
-    /**
-     * Maximum port for the random WS server port range
-     */
-    portRangeMax: 19999
+    port: Number(process.env["CLAUDE_COLLAB_PORT"] ?? 11777)
   }};
 
 // src/infrastructure/p2p/p2p-node.ts
-function getRandomPort(min, max) {
-  return new Promise((resolve) => {
-    const port = Math.floor(Math.random() * (max - min + 1)) + min;
-    const server = createServer();
-    server.listen(port, () => {
-      server.close(() => resolve(port));
-    });
-    server.on("error", () => {
-      resolve(getRandomPort(min, max));
-    });
-  });
-}
 var P2PNode = class {
   wss = null;
-  mdnsDiscovery = null;
   port = 0;
   // Connections indexed by remote team name
   peerConns = /* @__PURE__ */ new Map();
-  // Reverse lookup: ws → teamName (for cleanup on incoming connections)
+  // Reverse lookup: ws → teamName (for cleanup)
   wsToTeam = /* @__PURE__ */ new Map();
   // Questions we received from remote peers (our inbox)
   incomingQuestions = /* @__PURE__ */ new Map();
@@ -411,14 +272,13 @@ var P2PNode = class {
     return this.localMember?.teamName;
   }
   /**
-   * Starts the WS server on a random port and initialises mDNS.
+   * Starts the WS server on the configured fixed port.
    * Called automatically from join() if not yet started.
    */
   async start() {
-    this.port = await getRandomPort(config.p2p.portRangeMin, config.p2p.portRangeMax);
+    this.port = config.p2p.port;
     this.wss = new WebSocketServer({ port: this.port });
     this.setupWssHandlers();
-    this.mdnsDiscovery = new MdnsDiscovery();
     this._isStarted = true;
     console.error(`P2P node started on port ${this.port}`);
   }
@@ -428,17 +288,60 @@ var P2PNode = class {
     }
     const memberId = v4();
     this.localMember = { memberId, teamName, displayName };
-    this.mdnsDiscovery.onPeerFound((peer) => {
-      if (peer.teamName !== teamName) {
-        console.error(`Discovered peer '${peer.teamName}' at ${peer.host}:${peer.port}`);
-        this.connectToPeer(peer.teamName, peer.host, peer.port).catch((err) => {
-          console.error(`Could not eagerly connect to ${peer.teamName}:`, err);
-        });
+    return { memberId, teamId: teamName, teamName, displayName, status: "ONLINE" };
+  }
+  /**
+   * Connects to a peer at the given IP and port.
+   * Performs a bidirectional HELLO handshake and returns the peer's team name.
+   */
+  async connectPeer(ip, port) {
+    if (!this.localMember) {
+      throw new Error("Must call join() before connectPeer()");
+    }
+    const targetPort = port ?? config.p2p.port;
+    const ws = new WebSocket(`ws://${ip}:${targetPort}`);
+    ws.on("message", (data) => {
+      try {
+        const msg = parseP2PMsg(data.toString());
+        this.handleMessage(ws, msg);
+      } catch (err) {
+        console.error("Failed to parse P2P message:", err);
       }
     });
-    this.mdnsDiscovery.announce(this.port, teamName, memberId);
-    this.mdnsDiscovery.discover();
-    return { memberId, teamId: teamName, teamName, displayName, status: "ONLINE" };
+    ws.on("close", () => {
+      const team = this.wsToTeam.get(ws);
+      if (team) {
+        if (this.peerConns.get(team) === ws) {
+          this.peerConns.delete(team);
+        }
+        this.wsToTeam.delete(ws);
+      }
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error(`Connection timeout to ${ip}:${targetPort}`)),
+        5e3
+      );
+      ws.on("open", () => {
+        clearTimeout(timeout);
+        const hello = {
+          type: "P2P_HELLO",
+          fromTeam: this.localMember.teamName,
+          fromMemberId: this.localMember.memberId
+        };
+        ws.send(serializeP2PMsg(hello));
+        resolve();
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+    const helloMsg = await this.waitForResponse(
+      (m) => m.type === "P2P_HELLO",
+      1e4
+    );
+    return helloMsg.fromTeam;
   }
   async ask(toTeam, content, format) {
     const ws = await this.getPeerConnection(toTeam);
@@ -544,7 +447,6 @@ var P2PNode = class {
     };
   }
   async disconnect() {
-    this.mdnsDiscovery?.destroy();
     for (const ws of this.peerConns.values()) {
       ws.close();
     }
@@ -566,6 +468,14 @@ var P2PNode = class {
       ws.on("message", (data) => {
         try {
           const msg = parseP2PMsg(data.toString());
+          if (msg.type === "P2P_HELLO" && this.localMember) {
+            const hello = {
+              type: "P2P_HELLO",
+              fromTeam: this.localMember.teamName,
+              fromMemberId: this.localMember.memberId
+            };
+            ws.send(serializeP2PMsg(hello));
+          }
           this.handleMessage(ws, msg);
         } catch (err) {
           console.error("Failed to parse incoming P2P message:", err);
@@ -583,7 +493,7 @@ var P2PNode = class {
     });
   }
   // ---------------------------------------------------------------------------
-  // Private: unified message handler (used for both incoming & outgoing sockets)
+  // Private: unified message handler
   // ---------------------------------------------------------------------------
   handleMessage(ws, msg) {
     for (const handler of this.pendingHandlers) {
@@ -678,78 +588,9 @@ var P2PNode = class {
     if (existing && existing.readyState === WebSocket.OPEN) {
       return existing;
     }
-    let peer = this.mdnsDiscovery?.getPeerByTeam(teamName);
-    if (!peer) {
-      this.mdnsDiscovery?.discover();
-      await this.waitForMdnsPeer(teamName, 1e4);
-      peer = this.mdnsDiscovery?.getPeerByTeam(teamName);
-    }
-    if (!peer) {
-      throw new Error(
-        `Peer for team '${teamName}' not found via mDNS. Make sure the other terminal has joined with that team name.`
-      );
-    }
-    return this.connectToPeer(teamName, peer.host, peer.port);
-  }
-  async connectToPeer(teamName, host, port) {
-    const existing = this.peerConns.get(teamName);
-    if (existing && existing.readyState === WebSocket.OPEN) {
-      return existing;
-    }
-    const ws = new WebSocket(`ws://${host}:${port}`);
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error(`Connection timeout to team '${teamName}'`)),
-        5e3
-      );
-      ws.on("open", () => {
-        clearTimeout(timeout);
-        const hello = {
-          type: "P2P_HELLO",
-          fromTeam: this.localMember?.teamName ?? "unknown",
-          fromMemberId: this.localMember?.memberId ?? "unknown"
-        };
-        ws.send(serializeP2PMsg(hello));
-        resolve();
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-    });
-    ws.on("message", (data) => {
-      try {
-        const msg = parseP2PMsg(data.toString());
-        this.handleMessage(ws, msg);
-      } catch (err) {
-        console.error("Failed to parse P2P message:", err);
-      }
-    });
-    ws.on("close", () => {
-      if (this.peerConns.get(teamName) === ws) {
-        this.peerConns.delete(teamName);
-      }
-    });
-    this.peerConns.set(teamName, ws);
-    return ws;
-  }
-  waitForMdnsPeer(teamName, timeoutMs) {
-    return new Promise((resolve, reject) => {
-      const deadline = Date.now() + timeoutMs;
-      const check = () => {
-        if (this.mdnsDiscovery?.getPeerByTeam(teamName)) {
-          resolve();
-          return;
-        }
-        if (Date.now() >= deadline) {
-          reject(new Error(`mDNS timeout: team '${teamName}' not found`));
-          return;
-        }
-        this.mdnsDiscovery?.discover();
-        setTimeout(check, 500);
-      };
-      check();
-    });
+    throw new Error(
+      `No connection to team '${teamName}'. Use the connect_peer tool to connect first.`
+    );
   }
   waitForResponse(filter, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -773,9 +614,9 @@ var joinSchema = {
   displayName: z.string().optional().describe('Display name for this terminal (default: team + " Claude")')
 };
 function registerJoinTool(server, client) {
-  server.tool("join", joinSchema, async (args2) => {
-    const teamName = args2.team;
-    const displayName = args2.displayName ?? `${teamName} Claude`;
+  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 {
@@ -804,14 +645,45 @@ Status: ${member.status}`
     }
   });
 }
+var connectPeerSchema = {
+  ip: z.string().describe('IP address of the peer to connect to (e.g., "172.16.40.137")'),
+  port: z.number().optional().describe(`Port the peer is listening on (default: ${config.p2p.port})`)
+};
+function registerConnectPeerTool(server, client) {
+  server.tool("connect_peer", connectPeerSchema, async (args) => {
+    const targetPort = args.port ?? config.p2p.port;
+    try {
+      const peerTeam = await client.connectPeer(args.ip, args.port);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Connected to peer "${peerTeam}" at ${args.ip}:${targetPort}.`
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to connect to ${args.ip}:${targetPort}: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
 var askSchema = {
   team: z.string().describe('Target team name to ask (e.g., "backend", "frontend")'),
   question: z.string().describe("The question to ask (supports markdown)")
 };
 function registerAskTool(server, client) {
-  server.tool("ask", askSchema, async (args2) => {
-    const targetTeam = args2.team;
-    const question = args2.question;
+  server.tool("ask", askSchema, async (args) => {
+    const targetTeam = args.team;
+    const question = args.question;
     try {
       if (!client.currentTeamId) {
         return {
@@ -873,8 +745,8 @@ 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 (args2) => {
-    const questionId = args2.question_id;
+  server.tool("check_answer", checkAnswerSchema, async (args) => {
+    const questionId = args.question_id;
     try {
       if (!client.currentTeamId) {
         return {
@@ -992,9 +864,9 @@ var replySchema = {
   answer: z.string().describe("Your answer to the question (supports markdown)")
 };
 function registerReplyTool(server, client) {
-  server.tool("reply", replySchema, async (args2) => {
-    const questionId = args2.questionId;
-    const answer = args2.answer;
+  server.tool("reply", replySchema, async (args) => {
+    const questionId = args.questionId;
+    const answer = args.answer;
     try {
       if (!client.currentTeamId) {
         return {
@@ -1050,6 +922,7 @@ function createMcpServer(options) {
     }
   );
   registerJoinTool(server, client);
+  registerConnectPeerTool(server, client);
   registerAskTool(server, client);
   registerCheckAnswerTool(server, client);
   registerInboxTool(server, client);
@@ -1085,40 +958,10 @@ async function startMcpServer(options) {
 }
 
 // src/mcp-main.ts
-var args = process.argv.slice(2);
-function parseArgs() {
-  const options = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const nextArg = args[i + 1];
-    if (arg === "--team" && nextArg) {
-      options.team = nextArg;
-      i++;
-    } else if (arg === "-h" || arg === "--help") {
-      console.error(`
-Claude Collab MCP Client (P2P mode)
-
-Usage:
-  mcp-main [options]
-
-Options:
-  --team <team>   Team to auto-join (optional)
-  -h, --help      Show this help message
-`);
-      process.exit(0);
-    }
-  }
-  return options;
-}
 async function main() {
-  const options = parseArgs();
   const p2pNode = new P2PNode();
   try {
     await p2pNode.start();
-    if (options.team) {
-      await p2pNode.join(options.team, `${options.team} Claude`);
-      console.error(`Auto-joined team: ${options.team}`);
-    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     console.error(`Failed to start P2P node: ${errorMessage}`);