@dolusoft/claude-collab 0.1.0

package/dist/hub-main.js

@@ -0,0 +1,1497 @@
+#!/usr/bin/env node
+import { WebSocketServer, WebSocket } from 'ws';
+import { v4 } from 'uuid';
+
+// 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
+  }};
+
+// 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 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;
+  }
+};
+
+// src/hub-main.ts
+var args = process.argv.slice(2);
+function parseArgs() {
+  let host = config.hub.host;
+  let port = config.hub.port;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    if (arg === "--host" && nextArg) {
+      host = nextArg;
+      i++;
+    } else if (arg === "--port" && nextArg) {
+      port = parseInt(nextArg, 10);
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      console.log(`
+Claude Collab Hub Server
+
+Usage:
+  hub-main [options]
+
+Options:
+  --host <host>   Host to bind to (default: ${config.hub.host})
+  --port <port>   Port to listen on (default: ${config.hub.port})
+  -h, --help      Show this help message
+`);
+      process.exit(0);
+    }
+  }
+  return { host, port };
+}
+async function main() {
+  const { host, port } = parseArgs();
+  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);
+  }
+}
+main().catch((error) => {
+  console.error("Unexpected error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=hub-main.js.map
+//# sourceMappingURL=hub-main.js.map