@principal-ai/control-tower-core 0.1.7 → 0.1.8

package/dist/index.mjs

@@ -3170,6 +3170,255 @@ class DefaultLockManager extends LockManager {
     }
   }
 }
+// src/abstractions/PresenceManager.ts
+class PresenceManager {
+  config;
+  constructor(config) {
+    this.config = {
+      enabled: config?.enabled ?? false,
+      heartbeatInterval: config?.heartbeatInterval ?? 30000,
+      awayThreshold: config?.awayThreshold ?? 2,
+      disconnectThreshold: config?.disconnectThreshold ?? 3,
+      gracePeriod: config?.gracePeriod ?? 30000,
+      trackDeviceActivity: config?.trackDeviceActivity ?? true,
+      broadcastPresenceUpdates: config?.broadcastPresenceUpdates ?? true
+    };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  calculatePresenceStatus(devices, now = Date.now()) {
+    if (devices.size === 0) {
+      return "offline";
+    }
+    const heartbeatTimeout = this.config.heartbeatInterval * this.config.awayThreshold;
+    for (const device of devices.values()) {
+      const timeSinceActivity = now - device.lastActivity;
+      if (timeSinceActivity < heartbeatTimeout) {
+        return "online";
+      }
+    }
+    return "away";
+  }
+  shouldDisconnectDevice(device, now = Date.now()) {
+    const timeout = this.config.heartbeatInterval * this.config.disconnectThreshold;
+    return now - device.lastActivity > timeout;
+  }
+}
+// src/abstractions/DefaultPresenceManager.ts
+class DefaultPresenceManager extends PresenceManager {
+  userPresences = new Map;
+  deviceToUser = new Map;
+  gracePeriodEntries = new Map;
+  constructor(config) {
+    super(config);
+  }
+  async connectDevice(userId, deviceId, deviceInfo) {
+    const now = Date.now();
+    const gracePeriodEntry = this.gracePeriodEntries.get(userId);
+    if (gracePeriodEntry) {
+      this.gracePeriodEntries.delete(userId);
+      const presence2 = gracePeriodEntry.previousPresence;
+      const device2 = {
+        deviceId,
+        type: deviceInfo?.type,
+        connectedAt: now,
+        lastActivity: now,
+        metadata: deviceInfo?.metadata
+      };
+      presence2.devices.set(deviceId, device2);
+      presence2.status = "online";
+      presence2.lastActivity = now;
+      this.userPresences.set(userId, presence2);
+      this.deviceToUser.set(deviceId, userId);
+      return presence2;
+    }
+    let presence = this.userPresences.get(userId);
+    if (!presence) {
+      presence = {
+        userId,
+        status: "online",
+        devices: new Map,
+        firstConnectedAt: now,
+        lastActivity: now,
+        metadata: {}
+      };
+      this.userPresences.set(userId, presence);
+    }
+    const device = {
+      deviceId,
+      type: deviceInfo?.type,
+      connectedAt: now,
+      lastActivity: now,
+      metadata: deviceInfo?.metadata
+    };
+    presence.devices.set(deviceId, device);
+    presence.status = this.calculatePresenceStatus(presence.devices, now);
+    presence.lastActivity = now;
+    this.deviceToUser.set(deviceId, userId);
+    return presence;
+  }
+  async disconnectDevice(userId, deviceId) {
+    const presence = this.userPresences.get(userId);
+    if (!presence) {
+      return null;
+    }
+    presence.devices.delete(deviceId);
+    this.deviceToUser.delete(deviceId);
+    const now = Date.now();
+    if (presence.devices.size === 0) {
+      if (this.config.gracePeriod > 0) {
+        this.gracePeriodEntries.set(userId, {
+          userId,
+          disconnectedAt: now,
+          previousPresence: presence
+        });
+        this.userPresences.delete(userId);
+        return null;
+      } else {
+        this.userPresences.delete(userId);
+        return null;
+      }
+    }
+    presence.status = this.calculatePresenceStatus(presence.devices, now);
+    let mostRecentActivity = 0;
+    for (const device of presence.devices.values()) {
+      if (device.lastActivity > mostRecentActivity) {
+        mostRecentActivity = device.lastActivity;
+      }
+    }
+    presence.lastActivity = mostRecentActivity;
+    return presence;
+  }
+  async updateActivity(update) {
+    const { userId, deviceId, timestamp } = update;
+    const presence = this.userPresences.get(userId);
+    if (!presence) {
+      throw new Error(`User ${userId} not found in presence system`);
+    }
+    const device = presence.devices.get(deviceId);
+    if (!device) {
+      throw new Error(`Device ${deviceId} not found for user ${userId}`);
+    }
+    device.lastActivity = timestamp;
+    if (timestamp > presence.lastActivity) {
+      presence.lastActivity = timestamp;
+    }
+    const previousStatus = presence.status;
+    presence.status = this.calculatePresenceStatus(presence.devices, timestamp);
+    return presence;
+  }
+  async getUserPresence(userId) {
+    return this.userPresences.get(userId) || null;
+  }
+  async getUsersPresence(userIds) {
+    const result = new Map;
+    for (const userId of userIds) {
+      const presence = this.userPresences.get(userId);
+      if (presence) {
+        result.set(userId, presence);
+      }
+    }
+    return result;
+  }
+  async getOnlineUsers() {
+    const online = [];
+    for (const presence of this.userPresences.values()) {
+      if (presence.status === "online") {
+        online.push(presence);
+      }
+    }
+    return online;
+  }
+  async getUserDevices(userId) {
+    const presence = this.userPresences.get(userId);
+    if (!presence) {
+      return [];
+    }
+    return Array.from(presence.devices.values());
+  }
+  async setUserStatus(userId, status) {
+    const presence = this.userPresences.get(userId);
+    if (!presence) {
+      throw new Error(`User ${userId} not found in presence system`);
+    }
+    presence.status = status;
+    return presence;
+  }
+  async processHeartbeats() {
+    const now = Date.now();
+    const changes = [];
+    for (const [userId, presence] of this.userPresences.entries()) {
+      const devicesToRemove = [];
+      for (const [deviceId, device] of presence.devices.entries()) {
+        if (this.shouldDisconnectDevice(device, now)) {
+          devicesToRemove.push(deviceId);
+        }
+      }
+      for (const deviceId of devicesToRemove) {
+        presence.devices.delete(deviceId);
+        this.deviceToUser.delete(deviceId);
+      }
+      const previousStatus = presence.status;
+      const newStatus = this.calculatePresenceStatus(presence.devices, now);
+      if (newStatus !== previousStatus) {
+        presence.status = newStatus;
+        changes.push({
+          userId,
+          previousStatus,
+          status: newStatus,
+          timestamp: now,
+          reason: "heartbeat_timeout"
+        });
+      }
+      if (presence.devices.size === 0) {
+        if (this.config.gracePeriod > 0) {
+          this.gracePeriodEntries.set(userId, {
+            userId,
+            disconnectedAt: now,
+            previousPresence: presence
+          });
+        }
+        this.userPresences.delete(userId);
+      }
+    }
+    const expiredGracePeriods = [];
+    for (const [userId, entry] of this.gracePeriodEntries.entries()) {
+      const gracePeriodElapsed = now - entry.disconnectedAt;
+      if (gracePeriodElapsed > this.config.gracePeriod) {
+        expiredGracePeriods.push(userId);
+        changes.push({
+          userId,
+          previousStatus: entry.previousPresence.status,
+          status: "offline",
+          timestamp: now,
+          reason: "grace_period_expired"
+        });
+      }
+    }
+    for (const userId of expiredGracePeriods) {
+      this.gracePeriodEntries.delete(userId);
+    }
+    return changes;
+  }
+  async clear() {
+    this.userPresences.clear();
+    this.deviceToUser.clear();
+    this.gracePeriodEntries.clear();
+  }
+  getGracePeriodCount() {
+    return this.gracePeriodEntries.size;
+  }
+  getConnectedDeviceCount() {
+    return this.deviceToUser.size;
+  }
+  getUniqueUserCount() {
+    return this.userPresences.size + this.gracePeriodEntries.size;
+  }
+}
 // src/adapters/mock/MockTransportAdapter.ts
 class MockTransportAdapter {
   state = "disconnected";
@@ -3180,11 +3429,13 @@ class MockTransportAdapter {
   simulateLatency = 0;
   shouldFailConnection = false;
   connectedUrl = null;
+  connectionAttempts = 0;
   constructor(options) {
     this.simulateLatency = options?.simulateLatency ?? 0;
     this.shouldFailConnection = options?.shouldFailConnection ?? false;
   }
   async connect(url, _options) {
+    this.connectionAttempts++;
     if (this.shouldFailConnection) {
       this.state = "disconnected";
       const error = new Error("Mock connection failed");
@@ -3234,8 +3485,8 @@ class MockTransportAdapter {
   isConnected() {
     return this.state === "connected";
   }
-  simulateMessage(message) {
-    if (this.state !== "connected") {
+  simulateMessage(message, bypassConnectionCheck = false) {
+    if (!bypassConnectionCheck && this.state !== "connected") {
       throw new Error("Cannot simulate message when not connected");
     }
     this.messageHandlers.forEach((handler) => handler(message));
@@ -3256,6 +3507,72 @@ class MockTransportAdapter {
   getConnectedUrl() {
     return this.connectedUrl;
   }
+  getConnectionAttempts() {
+    return this.connectionAttempts;
+  }
+  resetConnectionAttempts() {
+    this.connectionAttempts = 0;
+  }
+  async simulateConnection(clientId, options = {}) {
+    if (this.state !== "connected") {
+      this.state = "connected";
+    }
+    const message = {
+      id: `conn-${clientId}`,
+      type: "connection",
+      payload: {
+        clientId,
+        authenticated: options.authenticated ?? false,
+        userId: options.userId,
+        metadata: options.metadata
+      },
+      timestamp: Date.now()
+    };
+    this.simulateMessage(message, true);
+  }
+  async simulateDisconnect(clientId, reason = "Normal closure") {
+    const message = {
+      id: `disconnect-${clientId}`,
+      type: "disconnect",
+      payload: {
+        clientId,
+        reason
+      },
+      timestamp: Date.now()
+    };
+    this.simulateMessage(message, true);
+  }
+  async simulateClientMessage(clientId, messageType, messagePayload = {}) {
+    const message = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      type: "server_message",
+      payload: {
+        clientId,
+        type: messageType,
+        ...messagePayload
+      },
+      timestamp: Date.now()
+    };
+    this.simulateMessage(message, true);
+  }
+  getSentMessages(clientId) {
+    return this.messageQueue.filter((msg) => {
+      const payload = msg.payload;
+      return payload?.clientId === clientId;
+    }).map((msg) => {
+      const { clientId: _, ...rest } = msg.payload;
+      return rest;
+    });
+  }
+  simulateIncomingMessage(message) {
+    const fullMessage = {
+      id: message.id || `msg-${Date.now()}`,
+      type: message.type,
+      payload: message.payload || {},
+      timestamp: message.timestamp || Date.now()
+    };
+    this.messageHandlers.forEach((handler) => handler(fullMessage));
+  }
 }
 // src/adapters/mock/MockStorageAdapter.ts
 class MockStorageAdapter {
@@ -3635,10 +3952,10 @@ class WebSocketTransportAdapter {
   }
   setAuthAdapter(auth) {
     this.authAdapter = auth;
-    if (auth.isAuthRequired) {
+    if (auth.isAuthRequired && !this.config.requireAuth) {
       this.config.requireAuth = auth.isAuthRequired();
     }
-    if (auth.getAuthTimeout) {
+    if (auth.getAuthTimeout && this.config.authTimeout === 5000) {
       this.config.authTimeout = auth.getAuthTimeout();
     }
   }
@@ -4400,12 +4717,14 @@ class BaseServer extends TypedEventEmitter {
   storage;
   roomManager;
   lockManager;
+  presenceManager;
   config;
   clients = new Map;
   clientMessageHandlers = new Map;
   running = false;
   initialized = false;
   mode;
+  heartbeatIntervalId;
   experimental;
   constructor(config) {
     super();
@@ -4415,6 +4734,7 @@ class BaseServer extends TypedEventEmitter {
     this.storage = config.storage;
     this.roomManager = config.roomManager;
     this.lockManager = config.lockManager;
+    this.presenceManager = config.presenceManager;
     this.experimental = new ExperimentalAPI({
       config: config.experimental || {
         enableBroadcast: false,
@@ -4438,6 +4758,50 @@ class BaseServer extends TypedEventEmitter {
     this.transport.onMessage(this.handleTransportMessage.bind(this));
     this.transport.onError(this.handleTransportError.bind(this));
     this.transport.onClose(this.handleTransportClose.bind(this));
+    if (this.presenceManager?.isEnabled()) {
+      this.startHeartbeatProcessor();
+    }
+  }
+  startHeartbeatProcessor() {
+    if (!this.presenceManager) {
+      return;
+    }
+    const config = this.presenceManager.getConfig();
+    const interval = config.heartbeatInterval;
+    this.heartbeatIntervalId = setInterval(async () => {
+      try {
+        const changes = await this.presenceManager.processHeartbeats();
+        for (const change of changes) {
+          await this.emit("presence_changed", {
+            userId: change.userId,
+            status: change.status,
+            timestamp: change.timestamp
+          });
+          if (config.broadcastPresenceUpdates) {
+            await this.experimental.broadcastAuthenticated({
+              type: "presence:status_changed",
+              payload: {
+                userId: change.userId,
+                status: change.status,
+                previousStatus: change.previousStatus,
+                reason: change.reason
+              }
+            });
+          }
+        }
+      } catch (error) {
+        await this.emit("error", {
+          error,
+          context: "heartbeat_processor"
+        });
+      }
+    }, interval);
+  }
+  stopHeartbeatProcessor() {
+    if (this.heartbeatIntervalId) {
+      clearInterval(this.heartbeatIntervalId);
+      this.heartbeatIntervalId = undefined;
+    }
   }
   async start(port) {
     if (this.mode === "integration") {
@@ -4496,6 +4860,7 @@ class BaseServer extends TypedEventEmitter {
       return;
     }
     this.running = false;
+    this.stopHeartbeatProcessor();
     for (const [clientId] of Array.from(this.clients)) {
       await this.disconnectClient(clientId, "Server shutting down");
     }
@@ -4506,6 +4871,9 @@ class BaseServer extends TypedEventEmitter {
     }
     this.clients.clear();
     this.clientMessageHandlers.clear();
+    if (this.presenceManager) {
+      await this.presenceManager.clear();
+    }
     await this.emit("stopped", {});
   }
   async handleTransportMessage(message) {
@@ -4517,11 +4885,16 @@ class BaseServer extends TypedEventEmitter {
       await this.handleClientAuthenticatedMessage(message);
       return;
     }
+    if (message.type === "disconnect") {
+      const payload2 = message.payload;
+      await this.disconnectClient(payload2.clientId, payload2.reason || "Client disconnected");
+      return;
+    }
     const payload = message.payload;
-    const { clientId, ...clientMessage } = payload;
+    const { clientId, type, ...clientMessage } = payload;
     const clientMsg = {
       id: message.id,
-      type: message.type,
+      type: type || message.type,
       payload: clientMessage,
       timestamp: message.timestamp
     };
@@ -4544,16 +4917,50 @@ class BaseServer extends TypedEventEmitter {
   }
   async handleConnectionMessage(message) {
     const payload = message.payload;
+    const roomIds = new Set;
     const client = {
       id: payload.clientId,
       userId: payload.userId || "",
-      roomId: null,
+      roomIds,
+      get roomId() {
+        return roomIds.size > 0 ? roomIds.values().next().value || null : null;
+      },
       authenticated: payload.authenticated,
       connectedAt: Date.now()
     };
     this.clients.set(payload.clientId, client);
     this.clientMessageHandlers.set(payload.clientId, this.createClientMessageHandler(payload.clientId));
     await this.emit("client_connected", { client });
+    if (payload.authenticated && this.presenceManager?.isEnabled() && payload.userId) {
+      try {
+        await this.presenceManager.connectDevice(payload.userId, payload.clientId, {
+          connectedAt: Date.now(),
+          lastActivity: Date.now(),
+          metadata: payload.metadata
+        });
+        await this.emit("presence_device_connected", {
+          userId: payload.userId,
+          deviceId: payload.clientId,
+          timestamp: Date.now()
+        });
+        const presenceConfig = this.presenceManager.getConfig();
+        if (presenceConfig.broadcastPresenceUpdates) {
+          await this.experimental.broadcastAuthenticated({
+            type: "presence:user_online",
+            payload: {
+              userId: payload.userId,
+              deviceId: payload.clientId,
+              status: "online"
+            }
+          });
+        }
+      } catch (error) {
+        await this.emit("error", {
+          error,
+          context: "presence_connect_device"
+        });
+      }
+    }
     if (payload.authenticated) {
       await this.emit("client_authenticated", {
         clientId: payload.clientId,
@@ -4582,10 +4989,14 @@ class BaseServer extends TypedEventEmitter {
     }
   }
   async addClient(clientId) {
+    const roomIds = new Set;
     const client = {
       id: clientId,
       userId: "",
-      roomId: null,
+      roomIds,
+      get roomId() {
+        return roomIds.size > 0 ? roomIds.values().next().value || null : null;
+      },
       authenticated: false,
       connectedAt: Date.now()
     };
@@ -4598,9 +5009,36 @@ class BaseServer extends TypedEventEmitter {
     if (!client) {
       return;
     }
-    if (client.roomId) {
-      await this.roomManager.leaveRoom(client.roomId, client.userId);
-      await this.emit("client_left_room", { clientId, roomId: client.roomId });
+    if (this.presenceManager?.isEnabled() && client.userId) {
+      try {
+        const presence = await this.presenceManager.disconnectDevice(client.userId, clientId);
+        await this.emit("presence_device_disconnected", {
+          userId: client.userId,
+          deviceId: clientId,
+          timestamp: Date.now()
+        });
+        const presenceConfig = this.presenceManager.getConfig();
+        if (presenceConfig.broadcastPresenceUpdates && (!presence || presence.status === "offline")) {
+          await this.experimental.broadcastAuthenticated({
+            type: "presence:user_offline",
+            payload: {
+              userId: client.userId,
+              deviceId: clientId,
+              status: presence?.status || "offline",
+              gracePeriod: presenceConfig.gracePeriod
+            }
+          });
+        }
+      } catch (error) {
+        await this.emit("error", {
+          error,
+          context: "presence_disconnect_device"
+        });
+      }
+    }
+    for (const roomId of client.roomIds) {
+      await this.roomManager.leaveRoom(roomId, client.userId);
+      await this.emit("client_left_room", { clientId, roomId });
     }
     await this.lockManager.releaseUserLocks(client.userId);
     this.clients.delete(clientId);
@@ -4622,7 +5060,7 @@ class BaseServer extends TypedEventEmitter {
             await this.handleJoinRoom(clientId, message.payload);
             break;
           case "leave_room":
-            await this.handleLeaveRoom(clientId);
+            await this.handleLeaveRoom(clientId, message.payload);
             break;
           case "broadcast_event":
             await this.handleBroadcastEvent(clientId, message.payload);
@@ -4635,6 +5073,9 @@ class BaseServer extends TypedEventEmitter {
             break;
           case "ping":
             await this.sendToClient(clientId, { type: "pong", timestamp: Date.now() });
+            if (this.presenceManager?.isEnabled() && client.userId) {
+              await this.updatePresenceActivity(client.userId, clientId, "heartbeat");
+            }
             break;
           default:
             await this.sendToClient(clientId, {
@@ -4682,9 +5123,9 @@ class BaseServer extends TypedEventEmitter {
       return;
     }
     try {
-      if (client.roomId) {
-        await this.roomManager.leaveRoom(client.roomId, client.userId);
-        await this.emit("client_left_room", { clientId, roomId: client.roomId });
+      if (client.roomIds.has(payload.roomId)) {
+        await this.sendToClient(clientId, { type: "error", error: "Already in this room" });
+        return;
       }
       let roomState = await this.roomManager.getRoomState(payload.roomId);
       if (!roomState) {
@@ -4705,7 +5146,7 @@ class BaseServer extends TypedEventEmitter {
         permissions: roomState.room.permissions || ["read", "write"]
       };
       await this.roomManager.joinRoom(payload.roomId, user);
-      client.roomId = payload.roomId;
+      client.roomIds.add(payload.roomId);
       await this.emit("client_joined_room", { clientId, roomId: payload.roomId });
       await this.sendToClient(clientId, {
         type: "room_joined",
@@ -4723,20 +5164,28 @@ class BaseServer extends TypedEventEmitter {
       await this.sendToClient(clientId, { type: "error", error: error.message });
     }
   }
-  async handleLeaveRoom(clientId) {
+  async handleLeaveRoom(clientId, payload) {
     const client = this.clients.get(clientId);
-    if (!client || !client.roomId) {
+    if (!client) {
       return;
     }
-    const roomId = client.roomId;
-    await this.roomManager.leaveRoom(roomId, client.userId);
-    client.roomId = null;
-    await this.emit("client_left_room", { clientId, roomId });
-    await this.sendToClient(clientId, { type: "room_left", roomId });
+    const roomsToLeave = payload?.roomId ? [payload.roomId] : Array.from(client.roomIds);
+    if (roomsToLeave.length === 0) {
+      return;
+    }
+    for (const roomId of roomsToLeave) {
+      if (!client.roomIds.has(roomId)) {
+        continue;
+      }
+      await this.roomManager.leaveRoom(roomId, client.userId);
+      client.roomIds.delete(roomId);
+      await this.emit("client_left_room", { clientId, roomId });
+      await this.sendToClient(clientId, { type: "room_left", roomId });
+    }
   }
   async handleBroadcastEvent(clientId, payload) {
     const client = this.clients.get(clientId);
-    if (!client || client.roomId !== payload.roomId) {
+    if (!client || !client.roomIds.has(payload.roomId)) {
       await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
       return;
     }
@@ -4759,7 +5208,7 @@ class BaseServer extends TypedEventEmitter {
   }
   async handleLockRequest(clientId, payload) {
     const client = this.clients.get(clientId);
-    if (!client || client.roomId !== payload.roomId) {
+    if (!client || !client.roomIds.has(payload.roomId)) {
       await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
       return;
     }
@@ -4789,15 +5238,15 @@ class BaseServer extends TypedEventEmitter {
       await this.lockManager.releaseLock(payload.lockId);
       await this.emit("lock_released", { lockId: payload.lockId, clientId });
       await this.sendToClient(clientId, { type: "lock_released", lockId: payload.lockId });
-      if (client.roomId) {
-        await this.roomManager.broadcastToRoom(client.roomId, {
+      for (const roomId of client.roomIds) {
+        await this.roomManager.broadcastToRoom(roomId, {
           id: this.generateId(),
           type: "lock_status",
           timestamp: Date.now(),
           userId: client.userId,
-          roomId: client.roomId,
+          roomId,
           data: { lockId: payload.lockId, action: "released" },
-          metadata: { userId: client.userId, timestamp: Date.now(), roomId: client.roomId }
+          metadata: { userId: client.userId, timestamp: Date.now(), roomId }
         });
       }
     } catch (error) {
@@ -4840,6 +5289,32 @@ class BaseServer extends TypedEventEmitter {
   isInitialized() {
     return this.initialized;
   }
+  async updatePresenceActivity(userId, deviceId, activityType) {
+    if (!this.presenceManager?.isEnabled()) {
+      return;
+    }
+    try {
+      await this.presenceManager.updateActivity({
+        userId,
+        deviceId,
+        timestamp: Date.now(),
+        activityType
+      });
+      await this.emit("presence_activity", {
+        userId,
+        deviceId,
+        timestamp: Date.now()
+      });
+    } catch (error) {
+      await this.emit("error", {
+        error,
+        context: "presence_update_activity"
+      });
+    }
+  }
+  getPresenceManager() {
+    return this.presenceManager;
+  }
 }
 // src/server/ServerBuilder.ts
 class ServerBuilder {
@@ -4848,6 +5323,7 @@ class ServerBuilder {
   storage;
   roomManager;
   lockManager;
+  presenceManager;
   defaultRoomConfig;
   httpServer;
   webSocketPath;
@@ -4873,6 +5349,10 @@ class ServerBuilder {
     this.lockManager = lockManager;
     return this;
   }
+  withPresenceManager(presenceManager) {
+    this.presenceManager = presenceManager;
+    return this;
+  }
   withDefaultRoomConfig(config) {
     this.defaultRoomConfig = config;
     return this;
@@ -4909,6 +5389,7 @@ class ServerBuilder {
       storage: this.storage,
       roomManager: this.roomManager,
       lockManager: this.lockManager,
+      presenceManager: this.presenceManager,
       defaultRoomConfig: this.defaultRoomConfig || {
         maxUsers: 50,
         maxHistory: 100,
@@ -4944,4 +5425,4 @@ export {
   BaseClient
 };
 
-//# debugId=2DFFD564DA5ECE9B64756E2164756E21
+//# debugId=5B674B605D2E752364756E2164756E21