@dolusoft/claude-collab 0.1.0

package/dist/cli.js

@@ -0,0 +1,2064 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import WebSocket2, { WebSocketServer, 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/domain/entities/member.entity.ts
+var Member = class _Member {
+  _id;
+  _teamId;
+  _displayName;
+  _connectedAt;
+  _status;
+  _lastActivityAt;
+  constructor(props) {
+    this._id = props.id;
+    this._teamId = props.teamId;
+    this._displayName = props.displayName;
+    this._connectedAt = props.connectedAt;
+    this._status = props.status;
+    this._lastActivityAt = props.connectedAt;
+  }
+  /**
+   * Creates a new Member instance
+   */
+  static create(props) {
+    if (!props.displayName.trim()) {
+      throw new Error("Display name cannot be empty");
+    }
+    return new _Member(props);
+  }
+  /**
+   * Reconstitutes a Member from persistence
+   */
+  static reconstitute(props) {
+    const member = new _Member(props);
+    member._lastActivityAt = props.lastActivityAt;
+    return member;
+  }
+  // Getters
+  get id() {
+    return this._id;
+  }
+  get teamId() {
+    return this._teamId;
+  }
+  get displayName() {
+    return this._displayName;
+  }
+  get connectedAt() {
+    return this._connectedAt;
+  }
+  get status() {
+    return this._status;
+  }
+  get lastActivityAt() {
+    return this._lastActivityAt;
+  }
+  get isOnline() {
+    return this._status === "ONLINE" /* ONLINE */ || this._status === "IDLE" /* IDLE */;
+  }
+  // Behaviors
+  /**
+   * Marks the member as online
+   */
+  goOnline() {
+    this._status = "ONLINE" /* ONLINE */;
+    this._lastActivityAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Marks the member as idle
+   */
+  goIdle() {
+    this._status = "IDLE" /* IDLE */;
+  }
+  /**
+   * Marks the member as offline
+   */
+  goOffline() {
+    this._status = "OFFLINE" /* OFFLINE */;
+  }
+  /**
+   * Records activity from this member
+   */
+  recordActivity() {
+    this._lastActivityAt = /* @__PURE__ */ new Date();
+    if (this._status === "IDLE" /* IDLE */) {
+      this._status = "ONLINE" /* ONLINE */;
+    }
+  }
+  /**
+   * Converts entity to plain object for serialization
+   */
+  toJSON() {
+    return {
+      id: this._id,
+      teamId: this._teamId,
+      displayName: this._displayName,
+      connectedAt: this._connectedAt,
+      status: this._status,
+      lastActivityAt: this._lastActivityAt
+    };
+  }
+};
+var BaseDomainEvent = class {
+  eventId;
+  timestamp;
+  constructor() {
+    this.eventId = v4();
+    this.timestamp = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Converts event to JSON
+   */
+  toJSON() {
+    return {
+      eventId: this.eventId,
+      eventType: this.eventType,
+      timestamp: this.timestamp,
+      payload: this.payload
+    };
+  }
+};
+
+// src/domain/events/member-joined.event.ts
+var MemberJoinedEvent = class _MemberJoinedEvent extends BaseDomainEvent {
+  constructor(memberId, teamId, displayName) {
+    super();
+    this.memberId = memberId;
+    this.teamId = teamId;
+    this.displayName = displayName;
+  }
+  static EVENT_TYPE = "MEMBER_JOINED";
+  get eventType() {
+    return _MemberJoinedEvent.EVENT_TYPE;
+  }
+  get payload() {
+    return {
+      memberId: this.memberId,
+      teamId: this.teamId,
+      displayName: this.displayName
+    };
+  }
+};
+
+// src/shared/types/branded-types.ts
+var MemberId = {
+  create: (id) => id,
+  isValid: (id) => id.length > 0
+};
+var TeamId = {
+  create: (id) => id.toLowerCase().trim(),
+  isValid: (id) => /^[a-z][a-z0-9-]*$/.test(id.toLowerCase().trim())
+};
+var QuestionId = {
+  create: (id) => id,
+  isValid: (id) => id.length > 0
+};
+var AnswerId = {
+  create: (id) => id,
+  isValid: (id) => id.length > 0
+};
+
+// src/shared/utils/id-generator.ts
+function generateMemberId() {
+  return MemberId.create(v4());
+}
+function createTeamId(name) {
+  return TeamId.create(name);
+}
+function generateQuestionId() {
+  return QuestionId.create(`q_${v4()}`);
+}
+function generateAnswerId() {
+  return AnswerId.create(`a_${v4()}`);
+}
+
+// src/shared/errors/domain-errors.ts
+var DomainError = class extends Error {
+  code;
+  timestamp;
+  constructor(message, code) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.timestamp = /* @__PURE__ */ new Date();
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var TeamNotFoundError = class extends DomainError {
+  constructor(teamId) {
+    super(`Team '${teamId}' not found`, "TEAM_NOT_FOUND");
+  }
+};
+var MemberNotFoundError = class extends DomainError {
+  constructor(memberId) {
+    super(`Member '${memberId}' not found`, "MEMBER_NOT_FOUND");
+  }
+};
+var QuestionNotFoundError = class extends DomainError {
+  constructor(questionId) {
+    super(`Question '${questionId}' not found`, "QUESTION_NOT_FOUND");
+  }
+};
+var QuestionAlreadyAnsweredError = class extends DomainError {
+  constructor(questionId) {
+    super(`Question '${questionId}' has already been answered`, "QUESTION_ALREADY_ANSWERED");
+  }
+};
+var ValidationError = class extends DomainError {
+  field;
+  constructor(field, message) {
+    super(message, "VALIDATION_ERROR");
+    this.field = field;
+  }
+};
+
+// src/application/use-cases/join-team.use-case.ts
+var JoinTeamUseCase = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Executes the use case
+   */
+  async execute(input) {
+    if (!input.teamName.trim()) {
+      throw new ValidationError("teamName", "Team name cannot be empty");
+    }
+    if (!input.displayName.trim()) {
+      throw new ValidationError("displayName", "Display name cannot be empty");
+    }
+    const team = await this.deps.teamRepository.getOrCreate(input.teamName);
+    const memberId = generateMemberId();
+    const member = Member.create({
+      id: memberId,
+      teamId: team.id,
+      displayName: input.displayName.trim(),
+      connectedAt: /* @__PURE__ */ new Date(),
+      status: "ONLINE" /* ONLINE */
+    });
+    await this.deps.memberRepository.save(member);
+    team.addMember(memberId);
+    await this.deps.teamRepository.save(team);
+    if (this.deps.onMemberJoined) {
+      const event = new MemberJoinedEvent(memberId, team.id, member.displayName);
+      await this.deps.onMemberJoined(event);
+    }
+    return {
+      memberId,
+      teamId: team.id,
+      teamName: team.name,
+      displayName: member.displayName,
+      status: member.status,
+      memberCount: team.memberCount
+    };
+  }
+};
+
+// src/domain/entities/question.entity.ts
+var Question = class _Question {
+  _id;
+  _fromMemberId;
+  _toTeamId;
+  _content;
+  _createdAt;
+  _status;
+  _answeredAt;
+  _answeredByMemberId;
+  constructor(props) {
+    this._id = props.id;
+    this._fromMemberId = props.fromMemberId;
+    this._toTeamId = props.toTeamId;
+    this._content = props.content;
+    this._createdAt = props.createdAt;
+    this._status = props.status;
+    this._answeredAt = props.answeredAt;
+    this._answeredByMemberId = props.answeredByMemberId;
+  }
+  /**
+   * Creates a new Question instance
+   */
+  static create(props) {
+    return new _Question({
+      ...props,
+      status: "PENDING" /* PENDING */
+    });
+  }
+  /**
+   * Reconstitutes a Question from persistence
+   */
+  static reconstitute(props) {
+    return new _Question(props);
+  }
+  // Getters
+  get id() {
+    return this._id;
+  }
+  get fromMemberId() {
+    return this._fromMemberId;
+  }
+  get toTeamId() {
+    return this._toTeamId;
+  }
+  get content() {
+    return this._content;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get status() {
+    return this._status;
+  }
+  get answeredAt() {
+    return this._answeredAt;
+  }
+  get answeredByMemberId() {
+    return this._answeredByMemberId;
+  }
+  get isPending() {
+    return this._status === "PENDING" /* PENDING */;
+  }
+  get isAnswered() {
+    return this._status === "ANSWERED" /* ANSWERED */;
+  }
+  get isTimedOut() {
+    return this._status === "TIMEOUT" /* TIMEOUT */;
+  }
+  get isCancelled() {
+    return this._status === "CANCELLED" /* CANCELLED */;
+  }
+  get canBeAnswered() {
+    return this._status === "PENDING" /* PENDING */;
+  }
+  /**
+   * Calculates the age of the question in milliseconds
+   */
+  get ageMs() {
+    return Date.now() - this._createdAt.getTime();
+  }
+  // Behaviors
+  /**
+   * Marks the question as answered
+   * @throws QuestionAlreadyAnsweredError if already answered
+   */
+  markAsAnswered(answeredByMemberId) {
+    if (!this.canBeAnswered) {
+      throw new QuestionAlreadyAnsweredError(this._id);
+    }
+    this._status = "ANSWERED" /* ANSWERED */;
+    this._answeredAt = /* @__PURE__ */ new Date();
+    this._answeredByMemberId = answeredByMemberId;
+  }
+  /**
+   * Marks the question as timed out
+   */
+  markAsTimedOut() {
+    if (this._status === "PENDING" /* PENDING */) {
+      this._status = "TIMEOUT" /* TIMEOUT */;
+    }
+  }
+  /**
+   * Marks the question as cancelled
+   */
+  markAsCancelled() {
+    if (this._status === "PENDING" /* PENDING */) {
+      this._status = "CANCELLED" /* CANCELLED */;
+    }
+  }
+  /**
+   * Converts entity to plain object for serialization
+   */
+  toJSON() {
+    return {
+      id: this._id,
+      fromMemberId: this._fromMemberId,
+      toTeamId: this._toTeamId,
+      content: this._content,
+      createdAt: this._createdAt,
+      status: this._status,
+      answeredAt: this._answeredAt,
+      answeredByMemberId: this._answeredByMemberId
+    };
+  }
+};
+
+// 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,
+    /**
+     * Client timeout in milliseconds (no heartbeat received)
+     */
+    clientTimeout: 6e4
+  },
+  /**
+   * Communication configuration
+   */
+  communication: {
+    /**
+     * Default timeout for waiting for an answer (in milliseconds)
+     */
+    defaultTimeout: 3e4,
+    /**
+     * Maximum message content length
+     */
+    maxMessageLength: 5e4
+  },
+  /**
+   * Auto-start configuration
+   */
+  autoStart: {
+    /**
+     * Maximum retries when connecting to hub
+     */
+    maxRetries: 3,
+    /**
+     * Delay between retries in milliseconds
+     */
+    retryDelay: 1e3
+  }
+};
+
+// src/domain/value-objects/message-content.vo.ts
+var MessageContent = class _MessageContent {
+  _text;
+  _format;
+  constructor(text, format) {
+    this._text = text;
+    this._format = format;
+  }
+  /**
+   * Creates a new MessageContent
+   * @throws ValidationError if content is invalid
+   */
+  static create(text, format = "markdown") {
+    const trimmedText = text.trim();
+    if (!trimmedText) {
+      throw new ValidationError("text", "Message content cannot be empty");
+    }
+    if (trimmedText.length > config.communication.maxMessageLength) {
+      throw new ValidationError(
+        "text",
+        `Message content exceeds maximum length of ${config.communication.maxMessageLength} characters`
+      );
+    }
+    return new _MessageContent(trimmedText, format);
+  }
+  /**
+   * Creates a plain text message
+   */
+  static plain(text) {
+    return _MessageContent.create(text, "plain");
+  }
+  /**
+   * Creates a markdown message
+   */
+  static markdown(text) {
+    return _MessageContent.create(text, "markdown");
+  }
+  /**
+   * Reconstitutes from persistence
+   */
+  static reconstitute(props) {
+    return new _MessageContent(props.text, props.format);
+  }
+  // Getters
+  get text() {
+    return this._text;
+  }
+  get format() {
+    return this._format;
+  }
+  get length() {
+    return this._text.length;
+  }
+  get isMarkdown() {
+    return this._format === "markdown";
+  }
+  get isPlain() {
+    return this._format === "plain";
+  }
+  /**
+   * Returns a preview of the content (first 100 chars)
+   */
+  get preview() {
+    if (this._text.length <= 100) {
+      return this._text;
+    }
+    return `${this._text.substring(0, 97)}...`;
+  }
+  /**
+   * Checks equality with another MessageContent
+   */
+  equals(other) {
+    return this._text === other._text && this._format === other._format;
+  }
+  /**
+   * Converts to plain object for serialization
+   */
+  toJSON() {
+    return {
+      text: this._text,
+      format: this._format
+    };
+  }
+  /**
+   * String representation
+   */
+  toString() {
+    return this._text;
+  }
+};
+
+// src/domain/events/question-asked.event.ts
+var QuestionAskedEvent = class _QuestionAskedEvent extends BaseDomainEvent {
+  constructor(questionId, fromMemberId, toTeamId, contentPreview) {
+    super();
+    this.questionId = questionId;
+    this.fromMemberId = fromMemberId;
+    this.toTeamId = toTeamId;
+    this.contentPreview = contentPreview;
+  }
+  static EVENT_TYPE = "QUESTION_ASKED";
+  get eventType() {
+    return _QuestionAskedEvent.EVENT_TYPE;
+  }
+  get payload() {
+    return {
+      questionId: this.questionId,
+      fromMemberId: this.fromMemberId,
+      toTeamId: this.toTeamId,
+      contentPreview: this.contentPreview
+    };
+  }
+};
+
+// src/application/use-cases/ask-question.use-case.ts
+var AskQuestionUseCase = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Executes the use case
+   */
+  async execute(input) {
+    const member = await this.deps.memberRepository.findById(input.fromMemberId);
+    if (!member) {
+      throw new MemberNotFoundError(input.fromMemberId);
+    }
+    const targetTeamId = createTeamId(input.toTeamName);
+    const targetTeam = await this.deps.teamRepository.findById(targetTeamId);
+    if (!targetTeam) {
+      throw new TeamNotFoundError(input.toTeamName);
+    }
+    if (member.teamId === targetTeamId) {
+      throw new ValidationError("toTeamName", "Cannot ask question to your own team");
+    }
+    const content = MessageContent.create(input.content, input.format ?? "markdown");
+    const questionId = generateQuestionId();
+    const question = Question.create({
+      id: questionId,
+      fromMemberId: input.fromMemberId,
+      toTeamId: targetTeamId,
+      content,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    await this.deps.questionRepository.save(question);
+    member.recordActivity();
+    await this.deps.memberRepository.save(member);
+    if (this.deps.onQuestionAsked) {
+      const event = new QuestionAskedEvent(
+        questionId,
+        input.fromMemberId,
+        targetTeamId,
+        content.preview
+      );
+      await this.deps.onQuestionAsked(event);
+    }
+    return {
+      questionId,
+      toTeamId: targetTeamId,
+      status: question.status,
+      createdAt: question.createdAt
+    };
+  }
+};
+
+// src/application/use-cases/get-inbox.use-case.ts
+var GetInboxUseCase = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Executes the use case
+   */
+  async execute(input) {
+    const member = await this.deps.memberRepository.findById(input.memberId);
+    if (!member) {
+      throw new MemberNotFoundError(input.memberId);
+    }
+    const team = await this.deps.teamRepository.findById(input.teamId);
+    if (!team) {
+      throw new TeamNotFoundError(input.teamId);
+    }
+    const allQuestions = await this.deps.questionRepository.findPendingByTeamId(input.teamId);
+    const questions = input.includeAnswered ? allQuestions : allQuestions.filter((q) => q.isPending);
+    const questionItems = [];
+    for (const question of questions) {
+      const fromMember = await this.deps.memberRepository.findById(question.fromMemberId);
+      const fromTeam = fromMember ? await this.deps.teamRepository.findById(fromMember.teamId) : null;
+      questionItems.push({
+        questionId: question.id,
+        fromMemberId: question.fromMemberId,
+        fromDisplayName: fromMember?.displayName ?? "Unknown",
+        fromTeamName: fromTeam?.name ?? "Unknown",
+        content: question.content.text,
+        format: question.content.format,
+        status: question.status,
+        createdAt: question.createdAt,
+        ageMs: question.ageMs
+      });
+    }
+    questionItems.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const pendingCount = questionItems.filter((q) => q.status === "PENDING" /* PENDING */).length;
+    return {
+      teamId: team.id,
+      teamName: team.name,
+      questions: questionItems,
+      totalCount: questionItems.length,
+      pendingCount
+    };
+  }
+};
+
+// src/domain/entities/answer.entity.ts
+var Answer = class _Answer {
+  _id;
+  _questionId;
+  _fromMemberId;
+  _content;
+  _createdAt;
+  constructor(props) {
+    this._id = props.id;
+    this._questionId = props.questionId;
+    this._fromMemberId = props.fromMemberId;
+    this._content = props.content;
+    this._createdAt = props.createdAt;
+  }
+  /**
+   * Creates a new Answer instance
+   */
+  static create(props) {
+    return new _Answer(props);
+  }
+  /**
+   * Reconstitutes an Answer from persistence
+   */
+  static reconstitute(props) {
+    return new _Answer(props);
+  }
+  // Getters
+  get id() {
+    return this._id;
+  }
+  get questionId() {
+    return this._questionId;
+  }
+  get fromMemberId() {
+    return this._fromMemberId;
+  }
+  get content() {
+    return this._content;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  /**
+   * Converts entity to plain object for serialization
+   */
+  toJSON() {
+    return {
+      id: this._id,
+      questionId: this._questionId,
+      fromMemberId: this._fromMemberId,
+      content: this._content,
+      createdAt: this._createdAt
+    };
+  }
+};
+
+// src/domain/events/question-answered.event.ts
+var QuestionAnsweredEvent = class _QuestionAnsweredEvent extends BaseDomainEvent {
+  constructor(questionId, answerId, answeredByMemberId, contentPreview) {
+    super();
+    this.questionId = questionId;
+    this.answerId = answerId;
+    this.answeredByMemberId = answeredByMemberId;
+    this.contentPreview = contentPreview;
+  }
+  static EVENT_TYPE = "QUESTION_ANSWERED";
+  get eventType() {
+    return _QuestionAnsweredEvent.EVENT_TYPE;
+  }
+  get payload() {
+    return {
+      questionId: this.questionId,
+      answerId: this.answerId,
+      answeredByMemberId: this.answeredByMemberId,
+      contentPreview: this.contentPreview
+    };
+  }
+};
+
+// src/application/use-cases/reply-question.use-case.ts
+var ReplyQuestionUseCase = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Executes the use case
+   */
+  async execute(input) {
+    const member = await this.deps.memberRepository.findById(input.fromMemberId);
+    if (!member) {
+      throw new MemberNotFoundError(input.fromMemberId);
+    }
+    const question = await this.deps.questionRepository.findById(input.questionId);
+    if (!question) {
+      throw new QuestionNotFoundError(input.questionId);
+    }
+    if (!question.canBeAnswered) {
+      throw new QuestionAlreadyAnsweredError(input.questionId);
+    }
+    const content = MessageContent.create(input.content, input.format ?? "markdown");
+    const answerId = generateAnswerId();
+    const answer = Answer.create({
+      id: answerId,
+      questionId: input.questionId,
+      fromMemberId: input.fromMemberId,
+      content,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    question.markAsAnswered(input.fromMemberId);
+    await this.deps.answerRepository.save(answer);
+    await this.deps.questionRepository.save(question);
+    member.recordActivity();
+    await this.deps.memberRepository.save(member);
+    if (this.deps.onQuestionAnswered) {
+      const event = new QuestionAnsweredEvent(
+        input.questionId,
+        answerId,
+        input.fromMemberId,
+        content.preview
+      );
+      await this.deps.onQuestionAnswered(event);
+    }
+    return {
+      answerId,
+      questionId: input.questionId,
+      deliveredToMemberId: question.fromMemberId,
+      createdAt: answer.createdAt
+    };
+  }
+};
+
+// src/infrastructure/repositories/in-memory-member.repository.ts
+var InMemoryMemberRepository = class {
+  members = /* @__PURE__ */ new Map();
+  async save(member) {
+    this.members.set(member.id, member);
+  }
+  async findById(id) {
+    return this.members.get(id) ?? null;
+  }
+  async findByTeamId(teamId) {
+    return [...this.members.values()].filter((m) => m.teamId === teamId);
+  }
+  async findOnlineByTeamId(teamId) {
+    return [...this.members.values()].filter((m) => m.teamId === teamId && m.isOnline);
+  }
+  async delete(id) {
+    return this.members.delete(id);
+  }
+  async exists(id) {
+    return this.members.has(id);
+  }
+  async findAll() {
+    return [...this.members.values()];
+  }
+  /**
+   * Clears all data (useful for testing)
+   */
+  clear() {
+    this.members.clear();
+  }
+  /**
+   * Gets the count of members
+   */
+  get count() {
+    return this.members.size;
+  }
+};
+
+// src/domain/entities/team.entity.ts
+var Team = class _Team {
+  _id;
+  _name;
+  _createdAt;
+  _memberIds;
+  constructor(props) {
+    this._id = props.id;
+    this._name = props.name;
+    this._createdAt = props.createdAt;
+    this._memberIds = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Creates a new Team instance
+   */
+  static create(props) {
+    if (!props.name.trim()) {
+      throw new Error("Team name cannot be empty");
+    }
+    return new _Team(props);
+  }
+  /**
+   * Reconstitutes a Team from persistence
+   */
+  static reconstitute(props) {
+    const team = new _Team(props);
+    for (const memberId of props.memberIds) {
+      team._memberIds.add(memberId);
+    }
+    return team;
+  }
+  // Getters
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return this._name;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get memberIds() {
+    return this._memberIds;
+  }
+  get memberCount() {
+    return this._memberIds.size;
+  }
+  get isEmpty() {
+    return this._memberIds.size === 0;
+  }
+  // Behaviors
+  /**
+   * Adds a member to the team
+   * @returns true if the member was added, false if already present
+   */
+  addMember(memberId) {
+    if (this._memberIds.has(memberId)) {
+      return false;
+    }
+    this._memberIds.add(memberId);
+    return true;
+  }
+  /**
+   * Removes a member from the team
+   * @returns true if the member was removed, false if not present
+   */
+  removeMember(memberId) {
+    return this._memberIds.delete(memberId);
+  }
+  /**
+   * Checks if a member is in the team
+   */
+  hasMember(memberId) {
+    return this._memberIds.has(memberId);
+  }
+  /**
+   * Gets all member IDs except the specified one
+   * Useful for broadcasting to other team members
+   */
+  getOtherMemberIds(excludeMemberId) {
+    return [...this._memberIds].filter((id) => id !== excludeMemberId);
+  }
+  /**
+   * Converts entity to plain object for serialization
+   */
+  toJSON() {
+    return {
+      id: this._id,
+      name: this._name,
+      createdAt: this._createdAt,
+      memberIds: [...this._memberIds]
+    };
+  }
+};
+
+// src/infrastructure/repositories/in-memory-team.repository.ts
+var InMemoryTeamRepository = class {
+  teams = /* @__PURE__ */ new Map();
+  async save(team) {
+    this.teams.set(team.id, team);
+  }
+  async findById(id) {
+    return this.teams.get(id) ?? null;
+  }
+  async findByName(name) {
+    const teamId = createTeamId(name);
+    return this.teams.get(teamId) ?? null;
+  }
+  async getOrCreate(name) {
+    const existing = await this.findByName(name);
+    if (existing) {
+      return existing;
+    }
+    const teamId = createTeamId(name);
+    const team = Team.create({
+      id: teamId,
+      name: name.trim(),
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    await this.save(team);
+    return team;
+  }
+  async delete(id) {
+    return this.teams.delete(id);
+  }
+  async exists(id) {
+    return this.teams.has(id);
+  }
+  async findAll() {
+    return [...this.teams.values()];
+  }
+  async findNonEmpty() {
+    return [...this.teams.values()].filter((t) => !t.isEmpty);
+  }
+  /**
+   * Clears all data (useful for testing)
+   */
+  clear() {
+    this.teams.clear();
+  }
+  /**
+   * Gets the count of teams
+   */
+  get count() {
+    return this.teams.size;
+  }
+};
+
+// src/infrastructure/repositories/in-memory-question.repository.ts
+var InMemoryQuestionRepository = class {
+  questions = /* @__PURE__ */ new Map();
+  async save(question) {
+    this.questions.set(question.id, question);
+  }
+  async findById(id) {
+    return this.questions.get(id) ?? null;
+  }
+  async findPendingByTeamId(teamId) {
+    return [...this.questions.values()].filter((q) => q.toTeamId === teamId && q.isPending);
+  }
+  async findByFromMemberId(memberId) {
+    return [...this.questions.values()].filter((q) => q.fromMemberId === memberId);
+  }
+  async findPendingByFromMemberId(memberId) {
+    return [...this.questions.values()].filter(
+      (q) => q.fromMemberId === memberId && q.isPending
+    );
+  }
+  async delete(id) {
+    return this.questions.delete(id);
+  }
+  async exists(id) {
+    return this.questions.has(id);
+  }
+  async findAll() {
+    return [...this.questions.values()];
+  }
+  async markTimedOut(olderThanMs) {
+    let count = 0;
+    const now = Date.now();
+    for (const question of this.questions.values()) {
+      if (question.isPending && now - question.createdAt.getTime() > olderThanMs) {
+        question.markAsTimedOut();
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Clears all data (useful for testing)
+   */
+  clear() {
+    this.questions.clear();
+  }
+  /**
+   * Gets the count of questions
+   */
+  get count() {
+    return this.questions.size;
+  }
+};
+
+// src/infrastructure/repositories/in-memory-answer.repository.ts
+var InMemoryAnswerRepository = class {
+  answers = /* @__PURE__ */ new Map();
+  async save(answer) {
+    this.answers.set(answer.id, answer);
+  }
+  async findById(id) {
+    return this.answers.get(id) ?? null;
+  }
+  async findByQuestionId(questionId) {
+    for (const answer of this.answers.values()) {
+      if (answer.questionId === questionId) {
+        return answer;
+      }
+    }
+    return null;
+  }
+  async findAll() {
+    return [...this.answers.values()];
+  }
+  /**
+   * Clears all data (useful for testing)
+   */
+  clear() {
+    this.answers.clear();
+  }
+  /**
+   * Gets the count of answers
+   */
+  get count() {
+    return this.answers.size;
+  }
+};
+
+// src/infrastructure/websocket/message-protocol.ts
+function serializeMessage(message) {
+  return JSON.stringify(message);
+}
+function parseClientMessage(data) {
+  const parsed = JSON.parse(data);
+  validateClientMessage(parsed);
+  return parsed;
+}
+function parseHubMessage(data) {
+  return JSON.parse(data);
+}
+function validateClientMessage(message) {
+  if (!message.type) {
+    throw new Error("Message must have a type");
+  }
+  const validTypes = ["JOIN", "LEAVE", "ASK", "REPLY", "PING", "GET_INBOX"];
+  if (!validTypes.includes(message.type)) {
+    throw new Error(`Invalid message type: ${message.type}`);
+  }
+}
+function createErrorMessage(code, message, requestId) {
+  return {
+    type: "ERROR",
+    code,
+    message,
+    requestId
+  };
+}
+
+// src/infrastructure/websocket/hub-server.ts
+var HubServer = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.initializeUseCases();
+  }
+  wss = null;
+  clients = /* @__PURE__ */ new Map();
+  memberToWs = /* @__PURE__ */ new Map();
+  // Repositories
+  memberRepository = new InMemoryMemberRepository();
+  teamRepository = new InMemoryTeamRepository();
+  questionRepository = new InMemoryQuestionRepository();
+  answerRepository = new InMemoryAnswerRepository();
+  // Use cases
+  joinTeamUseCase;
+  askQuestionUseCase;
+  getInboxUseCase;
+  replyQuestionUseCase;
+  heartbeatInterval = null;
+  timeoutCheckInterval = null;
+  initializeUseCases() {
+    this.joinTeamUseCase = new JoinTeamUseCase({
+      memberRepository: this.memberRepository,
+      teamRepository: this.teamRepository,
+      onMemberJoined: async (event) => {
+        await this.broadcastToTeam(event.teamId, event.memberId, {
+          type: "MEMBER_JOINED",
+          member: await this.getMemberInfo(event.memberId)
+        });
+      }
+    });
+    this.askQuestionUseCase = new AskQuestionUseCase({
+      memberRepository: this.memberRepository,
+      teamRepository: this.teamRepository,
+      questionRepository: this.questionRepository,
+      onQuestionAsked: async (event) => {
+        const question = await this.questionRepository.findById(event.questionId);
+        if (question) {
+          await this.deliverQuestion(question);
+        }
+      }
+    });
+    this.getInboxUseCase = new GetInboxUseCase({
+      memberRepository: this.memberRepository,
+      teamRepository: this.teamRepository,
+      questionRepository: this.questionRepository
+    });
+    this.replyQuestionUseCase = new ReplyQuestionUseCase({
+      memberRepository: this.memberRepository,
+      questionRepository: this.questionRepository,
+      answerRepository: this.answerRepository,
+      onQuestionAnswered: async (event) => {
+        const question = await this.questionRepository.findById(event.questionId);
+        const answer = await this.answerRepository.findByQuestionId(event.questionId);
+        if (question && answer) {
+          await this.deliverAnswer(question, answer, event.answeredByMemberId);
+        }
+      }
+    });
+  }
+  /**
+   * Starts the hub server
+   */
+  async start() {
+    const port = this.options.port ?? config.hub.port;
+    const host = this.options.host ?? config.hub.host;
+    return new Promise((resolve, reject) => {
+      try {
+        this.wss = new WebSocketServer({ port, host });
+        this.wss.on("connection", (ws) => {
+          this.handleConnection(ws);
+        });
+        this.wss.on("error", (error) => {
+          console.error("Hub server error:", error);
+          reject(error);
+        });
+        this.wss.on("listening", () => {
+          console.log(`Hub server listening on ${host}:${port}`);
+          this.startHeartbeat();
+          this.startTimeoutCheck();
+          resolve();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stops the hub server
+   */
+  async stop() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.timeoutCheckInterval) {
+      clearInterval(this.timeoutCheckInterval);
+      this.timeoutCheckInterval = null;
+    }
+    return new Promise((resolve) => {
+      if (this.wss) {
+        for (const [ws] of this.clients) {
+          ws.close();
+        }
+        this.clients.clear();
+        this.memberToWs.clear();
+        this.wss.close(() => {
+          this.wss = null;
+          console.log("Hub server stopped");
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  handleConnection(ws) {
+    const connection = {
+      ws,
+      lastPing: /* @__PURE__ */ new Date()
+    };
+    this.clients.set(ws, connection);
+    ws.on("message", async (data) => {
+      await this.handleMessage(ws, data.toString());
+    });
+    ws.on("close", async () => {
+      await this.handleDisconnect(ws);
+    });
+    ws.on("error", (error) => {
+      console.error("Client connection error:", error);
+    });
+  }
+  async handleMessage(ws, data) {
+    const connection = this.clients.get(ws);
+    if (!connection) return;
+    try {
+      const message = parseClientMessage(data);
+      connection.lastPing = /* @__PURE__ */ new Date();
+      switch (message.type) {
+        case "JOIN":
+          await this.handleJoin(ws, connection, message.teamName, message.displayName);
+          break;
+        case "LEAVE":
+          await this.handleLeave(ws, connection);
+          break;
+        case "ASK":
+          await this.handleAsk(ws, connection, message);
+          break;
+        case "REPLY":
+          await this.handleReply(ws, connection, message);
+          break;
+        case "GET_INBOX":
+          await this.handleGetInbox(ws, connection, message.requestId);
+          break;
+        case "PING":
+          this.send(ws, { type: "PONG", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+          break;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.send(ws, createErrorMessage("INVALID_MESSAGE", errorMessage));
+    }
+  }
+  async handleJoin(ws, connection, teamName, displayName) {
+    try {
+      const result = await this.joinTeamUseCase.execute({ teamName, displayName });
+      connection.memberId = result.memberId;
+      connection.teamId = result.teamId;
+      this.memberToWs.set(result.memberId, ws);
+      const memberInfo = await this.getMemberInfo(result.memberId);
+      this.send(ws, {
+        type: "JOINED",
+        member: memberInfo,
+        memberCount: result.memberCount
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Join failed";
+      this.send(ws, createErrorMessage("JOIN_FAILED", errorMessage));
+    }
+  }
+  async handleLeave(ws, connection) {
+    if (connection.memberId && connection.teamId) {
+      await this.removeMember(connection.memberId, connection.teamId);
+      connection.memberId = void 0;
+      connection.teamId = void 0;
+    }
+    this.send(ws, { type: "LEFT", memberId: connection.memberId });
+  }
+  async handleAsk(ws, connection, message) {
+    if (!connection.memberId) {
+      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first", message.requestId));
+      return;
+    }
+    try {
+      const result = await this.askQuestionUseCase.execute({
+        fromMemberId: connection.memberId,
+        toTeamName: message.toTeam,
+        content: message.content,
+        format: message.format
+      });
+      this.send(ws, {
+        type: "QUESTION_SENT",
+        questionId: result.questionId,
+        toTeamId: result.toTeamId,
+        status: result.status,
+        requestId: message.requestId
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Ask failed";
+      this.send(ws, createErrorMessage("ASK_FAILED", errorMessage, message.requestId));
+    }
+  }
+  async handleReply(ws, connection, message) {
+    if (!connection.memberId) {
+      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first"));
+      return;
+    }
+    try {
+      await this.replyQuestionUseCase.execute({
+        fromMemberId: connection.memberId,
+        questionId: message.questionId,
+        content: message.content,
+        format: message.format
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Reply failed";
+      this.send(ws, createErrorMessage("REPLY_FAILED", errorMessage));
+    }
+  }
+  async handleGetInbox(ws, connection, requestId) {
+    if (!connection.memberId || !connection.teamId) {
+      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first", requestId));
+      return;
+    }
+    try {
+      const result = await this.getInboxUseCase.execute({
+        memberId: connection.memberId,
+        teamId: connection.teamId
+      });
+      const questions = await Promise.all(
+        result.questions.map(async (q) => ({
+          questionId: q.questionId,
+          from: await this.getMemberInfo(q.fromMemberId),
+          content: q.content,
+          format: q.format,
+          status: q.status,
+          createdAt: q.createdAt.toISOString(),
+          ageMs: q.ageMs
+        }))
+      );
+      this.send(ws, {
+        type: "INBOX",
+        questions,
+        totalCount: result.totalCount,
+        pendingCount: result.pendingCount,
+        requestId
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Get inbox failed";
+      this.send(ws, createErrorMessage("INBOX_FAILED", errorMessage, requestId));
+    }
+  }
+  async handleDisconnect(ws) {
+    const connection = this.clients.get(ws);
+    if (connection?.memberId && connection.teamId) {
+      await this.removeMember(connection.memberId, connection.teamId);
+      this.memberToWs.delete(connection.memberId);
+    }
+    this.clients.delete(ws);
+  }
+  async removeMember(memberId, teamId) {
+    const member = await this.memberRepository.findById(memberId);
+    if (member) {
+      member.goOffline();
+      await this.memberRepository.save(member);
+    }
+    const team = await this.teamRepository.findById(teamId);
+    if (team) {
+      team.removeMember(memberId);
+      await this.teamRepository.save(team);
+      await this.broadcastToTeam(teamId, memberId, {
+        type: "MEMBER_LEFT",
+        memberId,
+        teamId
+      });
+    }
+  }
+  async deliverQuestion(question) {
+    const team = await this.teamRepository.findById(question.toTeamId);
+    if (!team) return;
+    const fromMember = await this.memberRepository.findById(question.fromMemberId);
+    if (!fromMember) return;
+    const memberInfo = await this.getMemberInfo(question.fromMemberId);
+    for (const memberId of team.memberIds) {
+      const ws = this.memberToWs.get(memberId);
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        this.send(ws, {
+          type: "QUESTION",
+          questionId: question.id,
+          from: memberInfo,
+          content: question.content.text,
+          format: question.content.format,
+          createdAt: question.createdAt.toISOString()
+        });
+      }
+    }
+  }
+  async deliverAnswer(question, answer, answeredByMemberId) {
+    const ws = this.memberToWs.get(question.fromMemberId);
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    const memberInfo = await this.getMemberInfo(answeredByMemberId);
+    this.send(ws, {
+      type: "ANSWER",
+      questionId: question.id,
+      from: memberInfo,
+      content: answer.content.text,
+      format: answer.content.format,
+      answeredAt: answer.createdAt.toISOString()
+    });
+  }
+  async broadcastToTeam(teamId, excludeMemberId, message) {
+    const team = await this.teamRepository.findById(teamId);
+    if (!team) return;
+    for (const memberId of team.getOtherMemberIds(excludeMemberId)) {
+      const ws = this.memberToWs.get(memberId);
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        this.send(ws, message);
+      }
+    }
+  }
+  async getMemberInfo(memberId) {
+    const member = await this.memberRepository.findById(memberId);
+    const team = member ? await this.teamRepository.findById(member.teamId) : null;
+    return {
+      memberId,
+      teamId: member?.teamId ?? "",
+      teamName: team?.name ?? "Unknown",
+      displayName: member?.displayName ?? "Unknown",
+      status: member?.status ?? "OFFLINE" /* OFFLINE */
+    };
+  }
+  send(ws, message) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(serializeMessage(message));
+    }
+  }
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      const now = /* @__PURE__ */ new Date();
+      for (const [ws, connection] of this.clients) {
+        const timeSinceLastPing = now.getTime() - connection.lastPing.getTime();
+        if (timeSinceLastPing > config.hub.clientTimeout) {
+          ws.terminate();
+        }
+      }
+    }, config.hub.heartbeatInterval);
+  }
+  startTimeoutCheck() {
+    this.timeoutCheckInterval = setInterval(async () => {
+      await this.questionRepository.markTimedOut(config.communication.defaultTimeout);
+    }, 5e3);
+  }
+  /**
+   * Gets the number of connected clients
+   */
+  get clientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Checks if the server is running
+   */
+  get isRunning() {
+    return this.wss !== null;
+  }
+};
+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 WebSocket2(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 !== WebSocket2.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 === WebSocket2.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 === WebSocket2.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 (args) => {
+    const teamName = args.team;
+    const displayName = args.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 (args) => {
+    const targetTeam = args.team;
+    const question = args.question;
+    const timeoutMs = (args.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 (args) => {
+    const questionId = args.questionId;
+    const answer = args.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/cli.ts
+var program = new Command();
+program.name("claude-collab").description("Real-time team collaboration between Claude Code terminals").version("0.1.0");
+var hubCmd = program.command("hub").description("Hub server commands");
+hubCmd.command("start").description("Start the Hub server").option("-p, --port <port>", "Port to listen on", String(config.hub.port)).option("--host <host>", "Host to bind to", config.hub.host).action(async (options) => {
+  const port = parseInt(options.port, 10);
+  const host = options.host;
+  const server = new HubServer({ host, port });
+  const shutdown = async () => {
+    console.log("\nShutting down hub server...");
+    await server.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await server.start();
+    console.log(`Claude Collab Hub Server running on ${host}:${port}`);
+  } catch (error) {
+    console.error("Failed to start hub server:", error);
+    process.exit(1);
+  }
+});
+program.command("client").description("Start MCP client (connects to Claude Code)").option("-t, --team <team>", "Team to auto-join (e.g., frontend, backend)").option("--auto-hub", "Auto-start hub if not running", false).option("-p, --port <port>", "Hub port to connect to", String(config.hub.port)).option("--host <host>", "Hub host to connect to", config.hub.host).action(
+  async (options) => {
+    const port = parseInt(options.port, 10);
+    const host = options.host;
+    if (options.autoHub) {
+      const hubRunning = await ensureHubRunning({ host, port });
+      if (!hubRunning) {
+        console.error("Failed to start hub server. Exiting.");
+        process.exit(1);
+      }
+    }
+    const hubClient = new HubClient(
+      { host, 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 });
+  }
+);
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map