@dolusoft/claude-collab 0.1.0 → 0.1.2

package/dist/hub-main.js

@@ -1064,6 +1064,15 @@ function createErrorMessage(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;
@@ -1137,11 +1146,11 @@ var HubServer = class {
           this.handleConnection(ws);
         });
         this.wss.on("error", (error) => {
-          console.error("Hub server error:", error);
+          log("ERROR", "Hub server error", { error: error.message, stack: error.stack });
           reject(error);
         });
         this.wss.on("listening", () => {
-          console.log(`Hub server listening on ${host}:${port}`);
+          log("INFO", `Hub server started successfully`, { host, port });
           this.startHeartbeat();
           this.startTimeoutCheck();
           resolve();
@@ -1172,7 +1181,7 @@ var HubServer = class {
         this.memberToWs.clear();
         this.wss.close(() => {
           this.wss = null;
-          console.log("Hub server stopped");
+          log("INFO", "Hub server stopped gracefully");
           resolve();
         });
       } else {
@@ -1186,6 +1195,7 @@ var HubServer = class {
       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());
     });
@@ -1193,7 +1203,7 @@ var HubServer = class {
       await this.handleDisconnect(ws);
     });
     ws.on("error", (error) => {
-      console.error("Client connection error:", error);
+      log("ERROR", "Client connection error", { error: error.message });
     });
   }
   async handleMessage(ws, data) {
@@ -1202,6 +1212,10 @@ var HubServer = class {
     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);
@@ -1224,11 +1238,16 @@ var HubServer = class {
       }
     } 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;
@@ -1239,8 +1258,15 @@ var HubServer = class {
         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));
     }
   }
@@ -1254,10 +1280,16 @@ var HubServer = class {
   }
   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,
@@ -1271,25 +1303,50 @@ var HubServer = class {
         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));
     }
   }
@@ -1329,10 +1386,15 @@ var HubServer = class {
   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);
@@ -1353,10 +1415,19 @@ var HubServer = class {
   }
   async deliverQuestion(question) {
     const team = await this.teamRepository.findById(question.toTeamId);
-    if (!team) return;
+    if (!team) {
+      log("WARN", "Cannot deliver question - team not found", { toTeamId: question.toTeamId });
+      return;
+    }
     const fromMember = await this.memberRepository.findById(question.fromMemberId);
-    if (!fromMember) return;
+    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) {
@@ -1368,12 +1439,25 @@ var HubServer = class {
           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) return;
+    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",
@@ -1383,6 +1467,11 @@ var HubServer = class {
       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);