@dolusoft/claude-collab 1.7.1 → 1.8.0

package/dist/mcp-main.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { WebSocket } from 'ws';
+import { WebSocket, WebSocketServer } from 'ws';
 import { v4 } from 'uuid';
 import { EventEmitter } from 'events';
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { unlinkSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
+import { Bonjour } from 'bonjour-service';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
@@ -259,7 +260,9 @@ var HubClient = class {
   }
   async join(name, displayName) {
     this.myName = name;
-    await this.connectAndHello();
+    if (this.serverUrl) {
+      await this.connectAndHello();
+    }
     return {
       memberId: v4(),
       teamId: name,
@@ -269,6 +272,10 @@ var HubClient = class {
       port: 0
     };
   }
+  async connectToHub(url) {
+    this.serverUrl = url;
+    await this.connectAndHello();
+  }
   async ask(toPeer, content, format) {
     const questionId = v4();
     const requestId = v4();
@@ -549,6 +556,195 @@ 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 SERVICE_TYPE = "claude-collab";
+var MdnsAdvertiser = class {
+  bonjour = null;
+  start(port) {
+    this.bonjour = new Bonjour();
+    this.bonjour.publish({ name: "claude-collab-hub", type: SERVICE_TYPE, port });
+    console.error(`[mdns] advertising hub on port ${port}`);
+  }
+  stop() {
+    if (!this.bonjour) return;
+    this.bonjour.unpublishAll(() => {
+      this.bonjour?.destroy();
+    });
+    this.bonjour = null;
+    console.error("[mdns] stopped advertising");
+  }
+};
+
+// src/infrastructure/hub/hub-manager.ts
+var HubManager = class {
+  hubServer = null;
+  advertiser = 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;
+    await addFirewallRule(port);
+    const advertiser = new MdnsAdvertiser();
+    advertiser.start(port);
+    this.advertiser = advertiser;
+  }
+  async stop() {
+    if (!this.isRunning) throw new Error("Hub is not running");
+    if (this.advertiser) {
+      this.advertiser.stop();
+      this.advertiser = null;
+    }
+    const port = this.currentPort;
+    this.hubServer.stop();
+    this.hubServer = null;
+    this.currentPort = null;
+    await removeFirewallRule(port);
+  }
+};
+function runElevated(netshArgs) {
+  return new Promise((resolve, reject) => {
+    const ps = spawn("powershell", [
+      "-NoProfile",
+      "-Command",
+      `Start-Process -FilePath "netsh" -ArgumentList "${netshArgs}" -Verb RunAs -Wait`
+    ]);
+    ps.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Firewall command failed (exit code ${code}). User may have cancelled the UAC prompt.`));
+    });
+    ps.on("error", (err) => {
+      reject(new Error(`Failed to launch PowerShell for firewall elevation: ${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)")
@@ -710,10 +906,101 @@ ${answerLine}`;
     };
   });
 }
+function registerStartHubTool(server, client, hubManager) {
+  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) {
+        return {
+          content: [{
+            type: "text",
+            text: `Hub is already running on port ${hubManager.port}.`
+          }]
+        };
+      }
+      try {
+        await hubManager.start(port);
+      } 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}`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: [
+            `Hub started on port ${port}.`,
+            `Firewall rule added (claude-collab-${port}).`,
+            `Others on the LAN will auto-discover and connect \u2014 no IP sharing needed.`,
+            `Use stop_hub when you are done to close the hub and remove the firewall rule.`
+          ].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) {
+        return {
+          content: [{
+            type: "text",
+            text: "No hub is currently running on this machine."
+          }]
+        };
+      }
+      const port = hubManager.port;
+      try {
+        await hubManager.stop();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to stop hub: ${msg}`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: [
+            `Hub stopped (was on port ${port}).`,
+            `Firewall rule removed (claude-collab-${port}).`,
+            `All peers have been disconnected.`
+          ].join("\n")
+        }]
+      };
+    }
+  );
+}
 
 // src/presentation/mcp/server.ts
 function createMcpServer(options) {
-  const { client } = options;
+  const { client, hubManager } = options;
   const server = new McpServer({
     name: "claude-collab",
     version: "0.1.0"
@@ -722,6 +1009,8 @@ function createMcpServer(options) {
   registerReplyTool(server, client);
   registerPeersTool(server, client);
   registerHistoryTool(server, client);
+  registerStartHubTool(server, client, hubManager);
+  registerStopHubTool(server, hubManager);
   return server;
 }
 async function startMcpServer(options) {
@@ -729,6 +1018,37 @@ async function startMcpServer(options) {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
+var SERVICE_TYPE2 = "claude-collab";
+function discoverHub(timeoutMs = 5e3) {
+  return new Promise((resolve) => {
+    const bonjour = new Bonjour();
+    const browser = bonjour.find({ type: SERVICE_TYPE2 });
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      browser.stop();
+      bonjour.destroy();
+      resolve(result);
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    browser.on("up", (svc) => {
+      finish({ host: svc.host, port: svc.port });
+    });
+  });
+}
+function watchForHub(onFound) {
+  const bonjour = new Bonjour();
+  const browser = bonjour.find({ type: SERVICE_TYPE2 });
+  browser.on("up", (svc) => {
+    onFound({ host: svc.host, port: svc.port });
+  });
+  return () => {
+    browser.stop();
+    bonjour.destroy();
+  };
+}
 
 // src/mcp-main.ts
 function getArg(flag) {
@@ -742,15 +1062,38 @@ async function main() {
     console.error("--name is required");
     process.exit(1);
   }
-  if (!server) {
-    console.error("--server is required");
-    process.exit(1);
-  }
-  const url = server.startsWith("ws") ? server : `ws://${server}`;
+  const hubManager = new HubManager();
   const client = new HubClient();
-  client.setServerUrl(url);
-  await client.join(name, name);
-  await startMcpServer({ client });
+  if (server) {
+    const url = server.startsWith("ws") ? server : `ws://${server}`;
+    client.setServerUrl(url);
+    await client.join(name, name);
+  } else {
+    await client.join(name, name);
+    console.error("[mcp-main] no --server given, searching for hub on LAN (5s)...");
+    const hub = await discoverHub(5e3);
+    if (hub) {
+      console.error(`[mcp-main] hub found at ${hub.host}:${hub.port}, connecting...`);
+      await client.connectToHub(`ws://${hub.host}:${hub.port}`);
+    } else {
+      console.error("[mcp-main] no hub found. Use start_hub tool to host, or wait \u2014 auto-connect will happen when a hub appears.");
+      const stopWatch = watchForHub(async (hub2) => {
+        if (client.isConnected) {
+          stopWatch();
+          return;
+        }
+        try {
+          console.error(`[mcp-main] hub appeared at ${hub2.host}:${hub2.port}, connecting...`);
+          await client.connectToHub(`ws://${hub2.host}:${hub2.port}`);
+          stopWatch();
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[mcp-main] auto-connect failed: ${msg}`);
+        }
+      });
+    }
+  }
+  await startMcpServer({ client, hubManager });
 }
 main().catch((error) => {
   console.error("Unexpected error:", error);