@principal-ai/control-tower-core 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -2856,6 +2856,134 @@ var require_websocket_server = __commonJS((exports, module) => {
     }
   }
 });
+// src/abstractions/RoomManager.ts
+class RoomManager {
+  rooms = new Map;
+}
+
+// src/abstractions/DefaultRoomManager.ts
+class DefaultRoomManager extends RoomManager {
+  async createRoom(id, config) {
+    const room = {
+      id,
+      name: config.name || id,
+      createdAt: Date.now(),
+      maxUsers: config.maxUsers,
+      maxHistory: config.maxHistory,
+      permissions: config.permissions,
+      metadata: config.metadata || {}
+    };
+    const roomState = {
+      room,
+      users: new Map,
+      eventHistory: [],
+      locks: new Map
+    };
+    this.rooms.set(id, roomState);
+    return room;
+  }
+  async deleteRoom(id) {
+    this.rooms.delete(id);
+  }
+  async joinRoom(roomId, user) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    if (roomState.room.maxUsers && roomState.users.size >= roomState.room.maxUsers) {
+      throw new Error(`Room ${roomId} is full`);
+    }
+    roomState.users.set(user.id, user);
+  }
+  async leaveRoom(roomId, userId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return;
+    }
+    roomState.users.delete(userId);
+  }
+  async broadcastToRoom(roomId, event, _excludeUserId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    await this.addEventToHistory(roomId, event);
+  }
+  async getRoomState(roomId) {
+    return this.rooms.get(roomId) || null;
+  }
+  async getUsersInRoom(roomId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return [];
+    }
+    return Array.from(roomState.users.values());
+  }
+  async addEventToHistory(roomId, event) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    roomState.eventHistory.push(event);
+    if (roomState.room.maxHistory && roomState.eventHistory.length > roomState.room.maxHistory) {
+      roomState.eventHistory = roomState.eventHistory.slice(-roomState.room.maxHistory);
+    }
+  }
+  async getEventHistory(roomId, limit) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return [];
+    }
+    const history = roomState.eventHistory;
+    return limit ? history.slice(-limit) : history;
+  }
+  async updateUserStatus(roomId, userId, status) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    const user = roomState.users.get(userId);
+    if (user) {
+      user.status = status;
+      user.lastActivity = Date.now();
+    }
+  }
+}
+
+// src/abstractions/ConnectedRoomManager.ts
+class ConnectedRoomManager extends DefaultRoomManager {
+  sendToClient;
+  getClientIdsInRoom;
+  constructor(sendToClient, getClientIdsInRoom) {
+    super();
+    this.sendToClient = sendToClient;
+    this.getClientIdsInRoom = getClientIdsInRoom;
+  }
+  async broadcastToRoom(roomId, event, excludeUserId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    await this.addEventToHistory(roomId, event);
+    const users = Array.from(roomState.users.values());
+    const sendPromises = [];
+    for (const user of users) {
+      if (excludeUserId && user.id === excludeUserId) {
+        continue;
+      }
+      const clientIds = this.getClientIdsInRoom(roomId, user.id);
+      for (const clientId of clientIds) {
+        sendPromises.push(this.sendToClient(clientId, {
+          type: "event_received",
+          event
+        }).catch((error) => {
+          console.error(`[ConnectedRoomManager] Failed to send event to client ${clientId}:`, error);
+        }));
+      }
+    }
+    await Promise.all(sendPromises);
+  }
+}
 // src/abstractions/LockManager.ts
 class LockManager {
   lockState = {
@@ -3374,99 +3502,6 @@ class DefaultPresenceManager extends PresenceManager {
     return this.userPresences.size + this.gracePeriodEntries.size;
   }
 }
-// src/abstractions/RoomManager.ts
-class RoomManager {
-  rooms = new Map;
-}
-
-// src/abstractions/DefaultRoomManager.ts
-class DefaultRoomManager extends RoomManager {
-  async createRoom(id, config) {
-    const room = {
-      id,
-      name: config.name || id,
-      createdAt: Date.now(),
-      maxUsers: config.maxUsers,
-      maxHistory: config.maxHistory,
-      permissions: config.permissions,
-      metadata: config.metadata || {}
-    };
-    const roomState = {
-      room,
-      users: new Map,
-      eventHistory: [],
-      locks: new Map
-    };
-    this.rooms.set(id, roomState);
-    return room;
-  }
-  async deleteRoom(id) {
-    this.rooms.delete(id);
-  }
-  async joinRoom(roomId, user) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    if (roomState.room.maxUsers && roomState.users.size >= roomState.room.maxUsers) {
-      throw new Error(`Room ${roomId} is full`);
-    }
-    roomState.users.set(user.id, user);
-  }
-  async leaveRoom(roomId, userId) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      return;
-    }
-    roomState.users.delete(userId);
-  }
-  async broadcastToRoom(roomId, event, _excludeUserId) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    await this.addEventToHistory(roomId, event);
-  }
-  async getRoomState(roomId) {
-    return this.rooms.get(roomId) || null;
-  }
-  async getUsersInRoom(roomId) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      return [];
-    }
-    return Array.from(roomState.users.values());
-  }
-  async addEventToHistory(roomId, event) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    roomState.eventHistory.push(event);
-    if (roomState.room.maxHistory && roomState.eventHistory.length > roomState.room.maxHistory) {
-      roomState.eventHistory = roomState.eventHistory.slice(-roomState.room.maxHistory);
-    }
-  }
-  async getEventHistory(roomId, limit) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      return [];
-    }
-    const history = roomState.eventHistory;
-    return limit ? history.slice(-limit) : history;
-  }
-  async updateUserStatus(roomId, userId, status) {
-    const roomState = this.rooms.get(roomId);
-    if (!roomState) {
-      throw new Error(`Room ${roomId} not found`);
-    }
-    const user = roomState.users.get(userId);
-    if (user) {
-      user.status = status;
-      user.lastActivity = Date.now();
-    }
-  }
-}
 // src/abstractions/EventEmitter.ts
 class TypedEventEmitter {
   listeners = new Map;
@@ -6274,6 +6309,7 @@ class BaseServer extends TypedEventEmitter {
     const client = {
       id: payload.clientId,
       userId: payload.userId || "",
+      deviceId: payload.clientId,
       roomIds,
       get roomId() {
         return roomIds.size > 0 ? roomIds.values().next().value || null : null;
@@ -6353,6 +6389,7 @@ class BaseServer extends TypedEventEmitter {
     const client = {
       id: clientId,
       userId: "",
+      deviceId: clientId,
       roomIds,
       get roomId() {
         return roomIds.size > 0 ? roomIds.values().next().value || null : null;
@@ -6381,10 +6418,10 @@ class BaseServer extends TypedEventEmitter {
     }
     if (this.presenceManager?.isEnabled() && client.userId) {
       try {
-        const presence = await this.presenceManager.disconnectDevice(client.userId, clientId);
+        const presence = await this.presenceManager.disconnectDevice(client.userId, client.deviceId);
         await this.emit("presence_device_disconnected", {
           userId: client.userId,
-          deviceId: clientId,
+          deviceId: client.deviceId,
           timestamp: Date.now()
         });
         const presenceConfig = this.presenceManager.getConfig();
@@ -6393,7 +6430,7 @@ class BaseServer extends TypedEventEmitter {
             type: "presence:user_offline",
             payload: {
               userId: client.userId,
-              deviceId: clientId,
+              deviceId: client.deviceId,
               status: presence?.status || "offline",
               gracePeriod: presenceConfig.gracePeriod
             }
@@ -6407,6 +6444,17 @@ class BaseServer extends TypedEventEmitter {
       }
     }
     for (const roomId of client.roomIds) {
+      try {
+        await this.experimental.broadcastWhere((c) => c.roomIds.has(roomId) && c.id !== clientId, {
+          type: "member_left",
+          payload: {
+            roomId,
+            userId: client.userId,
+            clientId,
+            timestamp: Date.now()
+          }
+        });
+      } catch {}
       await this.roomManager.leaveRoom(roomId, client.userId);
       await this.emit("client_left_room", { clientId, roomId });
     }
@@ -6423,7 +6471,7 @@ class BaseServer extends TypedEventEmitter {
           return;
         }
         if (this.presenceManager?.isEnabled() && client.userId && client.authenticated) {
-          await this.updatePresenceActivity(client.userId, clientId, "message");
+          await this.updatePresenceActivity(client.userId, client.deviceId, "message");
         }
         switch (message.type) {
           case "authenticate":
@@ -6600,6 +6648,17 @@ class BaseServer extends TypedEventEmitter {
       if (!client.roomIds.has(roomId)) {
         continue;
       }
+      try {
+        await this.experimental.broadcastWhere((c) => c.roomIds.has(roomId) && c.id !== clientId, {
+          type: "member_left",
+          payload: {
+            roomId,
+            userId: client.userId,
+            clientId,
+            timestamp: Date.now()
+          }
+        });
+      } catch {}
       await this.roomManager.leaveRoom(roomId, client.userId);
       client.roomIds.delete(roomId);
       await this.emit("client_left_room", { clientId, roomId });
@@ -6764,8 +6823,24 @@ class BaseServer extends TypedEventEmitter {
   getClientIdsForUser(userId) {
     return Array.from(this.userClientMap.get(userId) || []);
   }
+  getClientIdsInRoom(roomId, userId) {
+    const allClientIds = this.getClientIdsForUser(userId);
+    return allClientIds.filter((clientId) => {
+      const client = this.clients.get(clientId);
+      return client && client.roomIds.has(roomId);
+    });
+  }
   getDeviceIdFromClientId(clientId) {
-    return clientId;
+    const client = this.clients.get(clientId);
+    return client?.deviceId ?? clientId;
+  }
+  setClientDeviceId(clientId, deviceId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      client.deviceId = deviceId;
+      return true;
+    }
+    return false;
   }
 }
 // src/server/ServerBuilder.ts
@@ -6857,6 +6932,11 @@ class ServerBuilder {
       }
     };
     const server = new BaseServer(config);
+    if (this.roomManager.constructor.name === "DefaultRoomManager") {
+      const connectedManager = new ConnectedRoomManager((clientId, message) => server.sendToClient(clientId, message), (roomId, userId) => server.getClientIdsInRoom(roomId, userId));
+      connectedManager.rooms = this.roomManager.rooms;
+      server.roomManager = connectedManager;
+    }
     if (this.presenceManager instanceof DefaultPresenceManager) {
       this.presenceManager.setServer(server);
     }
@@ -6916,10 +6996,11 @@ export {
   DefaultRoomManager,
   DefaultPresenceManager,
   DefaultLockManager,
+  ConnectedRoomManager,
   ClientBuilder,
   BrowserWebSocketTransportAdapter,
   BaseServer,
   BaseClient
 };
 
-//# debugId=94389897A03B4D7064756E2164756E21
+//# debugId=A5E31B6ED779287364756E2164756E21