@dolusoft/claude-collab 0.1.0

package/dist/mcp-main.js

@@ -0,0 +1,684 @@
+#!/usr/bin/env node
+import WebSocket from 'ws';
+import { v4 } from 'uuid';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import { createConnection } from 'net';
+
+// src/config/index.ts
+var config = {
+  /**
+   * WebSocket Hub configuration
+   */
+  hub: {
+    /**
+     * Default port for the Hub server
+     */
+    port: parseInt(process.env["CLAUDE_COLLAB_PORT"] ?? "9999", 10),
+    /**
+     * Host to bind the Hub server to
+     */
+    host: process.env["CLAUDE_COLLAB_HOST"] ?? "localhost",
+    /**
+     * Heartbeat interval in milliseconds
+     */
+    heartbeatInterval: 3e4},
+  /**
+   * Communication configuration
+   */
+  communication: {
+    /**
+     * Default timeout for waiting for an answer (in milliseconds)
+     */
+    defaultTimeout: 3e4},
+  /**
+   * Auto-start configuration
+   */
+  autoStart: {
+    /**
+     * Maximum retries when connecting to hub
+     */
+    maxRetries: 3,
+    /**
+     * Delay between retries in milliseconds
+     */
+    retryDelay: 1e3
+  }
+};
+
+// src/infrastructure/websocket/message-protocol.ts
+function serializeMessage(message) {
+  return JSON.stringify(message);
+}
+function parseHubMessage(data) {
+  return JSON.parse(data);
+}
+
+// src/infrastructure/websocket/hub-client.ts
+var HubClient = class {
+  constructor(options = {}, events = {}) {
+    this.options = options;
+    this.events = events;
+  }
+  ws = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  isClosing = false;
+  memberId;
+  teamId;
+  teamName;
+  displayName;
+  /**
+   * Connects to the Hub server
+   */
+  async connect() {
+    const host = this.options.host ?? config.hub.host;
+    const port = this.options.port ?? config.hub.port;
+    const url = `ws://${host}:${port}`;
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(url);
+        this.ws.on("open", () => {
+          this.reconnectAttempts = 0;
+          this.startPingInterval();
+          this.events.onConnected?.();
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          this.handleMessage(data.toString());
+        });
+        this.ws.on("close", () => {
+          this.handleDisconnect();
+        });
+        this.ws.on("error", (error) => {
+          this.events.onError?.(error);
+          if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            reject(error);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnects from the Hub server
+   */
+  async disconnect() {
+    this.isClosing = true;
+    if (this.memberId) {
+      this.send({ type: "LEAVE" });
+    }
+    return new Promise((resolve) => {
+      if (this.ws) {
+        this.ws.close();
+        this.ws = null;
+      }
+      this.isClosing = false;
+      resolve();
+    });
+  }
+  /**
+   * Joins a team
+   */
+  async join(teamName, displayName) {
+    v4();
+    this.send({
+      type: "JOIN",
+      teamName,
+      displayName
+    });
+    const response = await this.waitForResponse(
+      (msg) => msg.type === "JOINED",
+      3e4
+    );
+    this.memberId = response.member.memberId;
+    this.teamId = response.member.teamId;
+    this.teamName = teamName;
+    this.displayName = displayName;
+    return response.member;
+  }
+  /**
+   * Asks a question to another team
+   */
+  async ask(toTeam, content, format = "markdown", timeoutMs = config.communication.defaultTimeout) {
+    const requestId = v4();
+    this.send({
+      type: "ASK",
+      toTeam,
+      content,
+      format,
+      requestId
+    });
+    await this.waitForResponse(
+      (msg) => msg.type === "QUESTION_SENT" && "requestId" in msg && msg.requestId === requestId,
+      5e3
+    );
+    const answer = await this.waitForResponse(
+      (msg) => msg.type === "ANSWER",
+      timeoutMs
+    );
+    return answer;
+  }
+  /**
+   * Gets the inbox (pending questions)
+   */
+  async getInbox() {
+    const requestId = v4();
+    this.send({
+      type: "GET_INBOX",
+      requestId
+    });
+    return this.waitForResponse(
+      (msg) => msg.type === "INBOX" && msg.requestId === requestId,
+      5e3
+    );
+  }
+  /**
+   * Replies to a question
+   */
+  async reply(questionId, content, format = "markdown") {
+    this.send({
+      type: "REPLY",
+      questionId,
+      content,
+      format
+    });
+  }
+  /**
+   * Checks if connected
+   */
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Gets the current member ID
+   */
+  get currentMemberId() {
+    return this.memberId;
+  }
+  /**
+   * Gets the current team ID
+   */
+  get currentTeamId() {
+    return this.teamId;
+  }
+  send(message) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(serializeMessage(message));
+    }
+  }
+  handleMessage(data) {
+    try {
+      const message = parseHubMessage(data);
+      for (const [requestId, pending] of this.pendingRequests) {
+      }
+      switch (message.type) {
+        case "QUESTION":
+          this.events.onQuestion?.(message);
+          break;
+        case "ANSWER":
+          this.events.onAnswer?.(message);
+          break;
+        case "MEMBER_JOINED":
+          this.events.onMemberJoined?.(message.member);
+          break;
+        case "MEMBER_LEFT":
+          this.events.onMemberLeft?.(message.memberId, message.teamId);
+          break;
+        case "ERROR":
+          this.events.onError?.(new Error(`${message.code}: ${message.message}`));
+          break;
+      }
+      this.resolvePendingRequest(message);
+    } catch (error) {
+      console.error("Failed to parse message:", error);
+    }
+  }
+  resolvePendingRequest(message) {
+    for (const [requestId, pending] of this.pendingRequests) {
+      this.pendingRequests.delete(requestId);
+      clearTimeout(pending.timeout);
+      pending.resolve(message);
+      break;
+    }
+  }
+  waitForResponse(filter, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const requestId = v4();
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error("Request timed out"));
+      }, timeoutMs);
+      const pending = {
+        resolve: (msg) => {
+          if (filter(msg)) {
+            resolve(msg);
+          }
+        },
+        reject,
+        timeout,
+        filter
+      };
+      this.pendingRequests.set(requestId, pending);
+      const originalHandler = this.handleMessage.bind(this);
+      const checkFilter = (data) => {
+        try {
+          const message = parseHubMessage(data);
+          if (filter(message)) {
+            this.pendingRequests.delete(requestId);
+            clearTimeout(timeout);
+            resolve(message);
+          }
+        } catch {
+        }
+        originalHandler(data);
+      };
+      if (this.ws) {
+        this.ws.removeAllListeners("message");
+        this.ws.on("message", (data) => checkFilter(data.toString()));
+      }
+    });
+  }
+  handleDisconnect() {
+    this.events.onDisconnected?.();
+    if (this.isClosing) return;
+    const shouldReconnect = this.options.reconnect ?? true;
+    const maxAttempts = this.options.maxReconnectAttempts ?? config.autoStart.maxRetries;
+    if (shouldReconnect && this.reconnectAttempts < maxAttempts) {
+      this.reconnectAttempts++;
+      const delay = this.options.reconnectDelay ?? config.autoStart.retryDelay;
+      setTimeout(() => {
+        this.connect().then(() => {
+          if (this.teamName && this.displayName) {
+            return this.join(this.teamName, this.displayName);
+          }
+        }).catch((error) => {
+          this.events.onError?.(error);
+        });
+      }, delay);
+    }
+  }
+  pingInterval = null;
+  startPingInterval() {
+    this.pingInterval = setInterval(() => {
+      this.send({ type: "PING" });
+    }, config.hub.heartbeatInterval);
+  }
+};
+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, hubClient) {
+  server.tool("join", joinSchema, async (args2) => {
+    const teamName = args2.team;
+    const displayName = args2.displayName ?? `${teamName} Claude`;
+    try {
+      if (!hubClient.isConnected) {
+        await hubClient.connect();
+      }
+      const member = await hubClient.join(teamName, displayName);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully joined team "${member.teamName}" as "${member.displayName}".
+
+Your member ID: ${member.memberId}
+Team ID: ${member.teamId}
+Status: ${member.status}`
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to join team: ${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)"),
+  timeout: z.number().optional().describe(`Timeout in seconds to wait for answer (default: ${config.communication.defaultTimeout / 1e3}s)`)
+};
+function registerAskTool(server, hubClient) {
+  server.tool("ask", askSchema, async (args2) => {
+    const targetTeam = args2.team;
+    const question = args2.question;
+    const timeoutMs = (args2.timeout ?? config.communication.defaultTimeout / 1e3) * 1e3;
+    try {
+      if (!hubClient.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 hubClient.ask(targetTeam, question, "markdown", timeoutMs);
+      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";
+      if (errorMessage.includes("timed out")) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No response received from team "${targetTeam}" within ${timeoutMs / 1e3} seconds. The question has been delivered but no one answered yet.`
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to ask question: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+
+// src/presentation/mcp/tools/inbox.tool.ts
+var inboxSchema = {};
+function registerInboxTool(server, hubClient) {
+  server.tool("inbox", inboxSchema, async () => {
+    try {
+      if (!hubClient.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 hubClient.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)")
+};
+function registerReplyTool(server, hubClient) {
+  server.tool("reply", replySchema, async (args2) => {
+    const questionId = args2.questionId;
+    const answer = args2.answer;
+    try {
+      if (!hubClient.currentTeamId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: 'You must join a team first. Use the "join" tool to join a team.'
+            }
+          ],
+          isError: true
+        };
+      }
+      await hubClient.reply(questionId, answer, "markdown");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Reply sent successfully to question \`${questionId}\`.`
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to send reply: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+
+// src/presentation/mcp/server.ts
+function createMcpServer(options) {
+  const server = new McpServer({
+    name: "claude-collab",
+    version: "0.1.0"
+  });
+  registerJoinTool(server, options.hubClient);
+  registerAskTool(server, options.hubClient);
+  registerInboxTool(server, options.hubClient);
+  registerReplyTool(server, options.hubClient);
+  return server;
+}
+async function startMcpServer(options) {
+  const server = createMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+async function isHubRunning(host = config.hub.host, port = config.hub.port) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ host, port }, () => {
+      socket.end();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      resolve(false);
+    });
+    socket.setTimeout(1e3, () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+async function waitForHub(host = config.hub.host, port = config.hub.port, maxRetries = config.autoStart.maxRetries, retryDelay = config.autoStart.retryDelay) {
+  for (let i = 0; i < maxRetries; i++) {
+    if (await isHubRunning(host, port)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+  }
+  return false;
+}
+function startHubProcess(options = {}) {
+  const host = options.host ?? config.hub.host;
+  const port = options.port ?? config.hub.port;
+  const hubProcess = spawn(
+    process.execPath,
+    [
+      "--experimental-specifier-resolution=node",
+      new URL("../../hub-main.js", import.meta.url).pathname,
+      "--host",
+      host,
+      "--port",
+      port.toString()
+    ],
+    {
+      detached: true,
+      stdio: "ignore"
+    }
+  );
+  hubProcess.unref();
+  return hubProcess;
+}
+async function ensureHubRunning(options = {}) {
+  const host = options.host ?? config.hub.host;
+  const port = options.port ?? config.hub.port;
+  const maxRetries = options.maxRetries ?? config.autoStart.maxRetries;
+  const retryDelay = options.retryDelay ?? config.autoStart.retryDelay;
+  if (await isHubRunning(host, port)) {
+    return true;
+  }
+  console.log(`Hub not running. Starting hub on ${host}:${port}...`);
+  startHubProcess({ host, port });
+  const isRunning = await waitForHub(host, port, maxRetries, retryDelay);
+  if (isRunning) {
+    console.log("Hub started successfully");
+  } else {
+    console.error("Failed to start hub");
+  }
+  return isRunning;
+}
+
+// src/mcp-main.ts
+var args = process.argv.slice(2);
+function parseArgs() {
+  const options = {
+    host: config.hub.host,
+    port: config.hub.port,
+    autoHub: false
+  };
+  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 === "--host" && nextArg) {
+      options.host = nextArg;
+      i++;
+    } else if (arg === "--port" && nextArg) {
+      options.port = parseInt(nextArg, 10);
+      i++;
+    } else if (arg === "--auto-hub") {
+      options.autoHub = true;
+    } else if (arg === "-h" || arg === "--help") {
+      console.error(`
+Claude Collab MCP Client
+
+Usage:
+  mcp-main [options]
+
+Options:
+  --team <team>   Team to auto-join (optional)
+  --host <host>   Hub host (default: ${config.hub.host})
+  --port <port>   Hub port (default: ${config.hub.port})
+  --auto-hub      Auto-start hub if not running
+  -h, --help      Show this help message
+`);
+      process.exit(0);
+    }
+  }
+  return options;
+}
+async function main() {
+  const options = parseArgs();
+  if (options.autoHub) {
+    const hubRunning = await ensureHubRunning({
+      host: options.host,
+      port: options.port
+    });
+    if (!hubRunning) {
+      console.error("Failed to start hub server. Exiting.");
+      process.exit(1);
+    }
+  }
+  const hubClient = new HubClient(
+    {
+      host: options.host,
+      port: options.port,
+      reconnect: true
+    },
+    {
+      onError: (error) => {
+        console.error("Hub client error:", error.message);
+      },
+      onQuestion: (question) => {
+        console.error(`[Question received from ${question.from.displayName}]`);
+      }
+    }
+  );
+  try {
+    await hubClient.connect();
+    if (options.team) {
+      await hubClient.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 connect to hub: ${errorMessage}`);
+    console.error("Make sure the hub server is running or use --auto-hub flag.");
+    process.exit(1);
+  }
+  await startMcpServer({ hubClient });
+}
+main().catch((error) => {
+  console.error("Unexpected error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp-main.js.map
+//# sourceMappingURL=mcp-main.js.map