@dolusoft/claude-collab 0.1.3 → 1.3.0

package/dist/hub-main.js

@@ -1,1586 +0,0 @@
-#!/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
-function log(level, message, data) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const prefix = `[${timestamp}] [HUB-${level}]`;
-  if (data) {
-    console.log(`${prefix} ${message}`, JSON.stringify(data, null, 2));
-  } else {
-    console.log(`${prefix} ${message}`);
-  }
-}
-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) => {
-          log("ERROR", "Hub server error", { error: error.message, stack: error.stack });
-          reject(error);
-        });
-        this.wss.on("listening", () => {
-          log("INFO", `Hub server started successfully`, { 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;
-          log("INFO", "Hub server stopped gracefully");
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
-  handleConnection(ws) {
-    const connection = {
-      ws,
-      lastPing: /* @__PURE__ */ new Date()
-    };
-    this.clients.set(ws, connection);
-    log("INFO", "New client connected", { totalClients: this.clients.size });
-    ws.on("message", async (data) => {
-      await this.handleMessage(ws, data.toString());
-    });
-    ws.on("close", async () => {
-      await this.handleDisconnect(ws);
-    });
-    ws.on("error", (error) => {
-      log("ERROR", "Client connection error", { error: error.message });
-    });
-  }
-  async handleMessage(ws, data) {
-    const connection = this.clients.get(ws);
-    if (!connection) return;
-    try {
-      const message = parseClientMessage(data);
-      connection.lastPing = /* @__PURE__ */ new Date();
-      log("DEBUG", `Received message from client`, {
-        type: message.type,
-        memberId: connection.memberId
-      });
-      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";
-      log("ERROR", "Failed to handle message", {
-        error: errorMessage,
-        memberId: connection.memberId
-      });
-      this.send(ws, createErrorMessage("INVALID_MESSAGE", errorMessage));
-    }
-  }
-  async handleJoin(ws, connection, teamName, displayName) {
-    try {
-      log("INFO", "Member attempting to join", { teamName, displayName });
-      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
-      });
-      log("INFO", "Member joined successfully", {
-        memberId: result.memberId,
-        teamName,
-        displayName,
-        memberCount: result.memberCount
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Join failed";
-      log("ERROR", "Member join failed", { teamName, displayName, error: errorMessage });
-      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) {
-      log("WARN", "ASK attempt without joining team", { toTeam: message.toTeam });
-      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first", message.requestId));
-      return;
-    }
-    try {
-      log("INFO", "Question asked", {
-        fromMemberId: connection.memberId,
-        toTeam: message.toTeam,
-        contentPreview: message.content.substring(0, 50) + "..."
-      });
-      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
-      });
-      log("INFO", "Question sent successfully", {
-        questionId: result.questionId,
-        fromMemberId: connection.memberId,
-        toTeamId: result.toTeamId
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Ask failed";
-      log("ERROR", "Question failed", {
-        fromMemberId: connection.memberId,
-        toTeam: message.toTeam,
-        error: errorMessage
-      });
-      this.send(ws, createErrorMessage("ASK_FAILED", errorMessage, message.requestId));
-    }
-  }
-  async handleReply(ws, connection, message) {
-    if (!connection.memberId) {
-      log("WARN", "REPLY attempt without joining team", { questionId: message.questionId });
-      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first"));
-      return;
-    }
-    try {
-      log("INFO", "Reply received", {
-        fromMemberId: connection.memberId,
-        questionId: message.questionId,
-        contentPreview: message.content.substring(0, 50) + "..."
-      });
-      await this.replyQuestionUseCase.execute({
-        fromMemberId: connection.memberId,
-        questionId: message.questionId,
-        content: message.content,
-        format: message.format
-      });
-      log("INFO", "Reply delivered successfully", {
-        fromMemberId: connection.memberId,
-        questionId: message.questionId
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Reply failed";
-      log("ERROR", "Reply failed", {
-        fromMemberId: connection.memberId,
-        questionId: message.questionId,
-        error: errorMessage
-      });
-      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) {
-      log("INFO", "Client disconnecting", {
-        memberId: connection.memberId,
-        teamId: connection.teamId
-      });
-      await this.removeMember(connection.memberId, connection.teamId);
-      this.memberToWs.delete(connection.memberId);
-    }
-    this.clients.delete(ws);
-    log("INFO", "Client disconnected", { totalClients: this.clients.size });
-  }
-  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) {
-      log("WARN", "Cannot deliver question - team not found", { toTeamId: question.toTeamId });
-      return;
-    }
-    const fromMember = await this.memberRepository.findById(question.fromMemberId);
-    if (!fromMember) {
-      log("WARN", "Cannot deliver question - from member not found", {
-        fromMemberId: question.fromMemberId
-      });
-      return;
-    }
-    const memberInfo = await this.getMemberInfo(question.fromMemberId);
-    let deliveredCount = 0;
-    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()
-        });
-        deliveredCount++;
-      }
-    }
-    log("INFO", "Question delivered to team", {
-      questionId: question.id,
-      toTeamId: question.toTeamId,
-      teamSize: team.memberIds.size,
-      deliveredCount
-    });
-  }
-  async deliverAnswer(question, answer, answeredByMemberId) {
-    const ws = this.memberToWs.get(question.fromMemberId);
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
-      log("WARN", "Cannot deliver answer - questioner not connected", {
-        questionId: question.id,
-        fromMemberId: question.fromMemberId
-      });
-      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()
-    });
-    log("INFO", "Answer delivered", {
-      questionId: question.id,
-      answeredBy: answeredByMemberId,
-      deliveredTo: question.fromMemberId
-    });
-  }
-  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