@principal-ai/control-tower-core 0.1.12 → 0.1.13

package/dist/index.mjs

@@ -3213,11 +3213,28 @@ class DefaultPresenceManager extends PresenceManager {
   userPresences = new Map;
   deviceToUser = new Map;
   gracePeriodEntries = new Map;
+  extensions = [];
+  server;
   constructor(config) {
     super(config);
+    this.extensions = config?.extensions || [];
+  }
+  setServer(server) {
+    this.server = server;
+  }
+  async initializeExtensions() {
+    for (const ext of this.extensions) {
+      await ext.initialize?.();
+    }
+  }
+  async destroyExtensions() {
+    for (const ext of this.extensions) {
+      await ext.destroy?.();
+    }
   }
   async connectDevice(userId, deviceId, deviceInfo) {
     const now = Date.now();
+    const isFirstDevice = !this.userPresences.has(userId) && !this.gracePeriodEntries.has(userId);
     const gracePeriodEntry = this.gracePeriodEntries.get(userId);
     if (gracePeriodEntry) {
       this.gracePeriodEntries.delete(userId);
@@ -3234,9 +3251,31 @@ class DefaultPresenceManager extends PresenceManager {
       presence2.lastActivity = now;
       this.userPresences.set(userId, presence2);
       this.deviceToUser.set(deviceId, userId);
+      if (isFirstDevice) {
+        for (const ext of this.extensions) {
+          await ext.onUserOnline?.(userId, deviceId, deviceInfo?.metadata || {});
+        }
+      } else {
+        for (const ext of this.extensions) {
+          await ext.onDeviceConnected?.(userId, deviceId, deviceInfo?.metadata || {});
+        }
+      }
+      if (this.config.broadcastPresenceUpdates && this.server) {
+        const experimental = this.server.experimental;
+        await experimental?.broadcastAuthenticated({
+          type: "presence:user_online",
+          payload: {
+            userId,
+            deviceId,
+            status: "online",
+            timestamp: now
+          }
+        });
+      }
       return presence2;
     }
     let presence = this.userPresences.get(userId);
+    const wasOnline = presence !== undefined;
     if (!presence) {
       presence = {
         userId,
@@ -3259,6 +3298,27 @@ class DefaultPresenceManager extends PresenceManager {
     presence.status = this.calculatePresenceStatus(presence.devices, now);
     presence.lastActivity = now;
     this.deviceToUser.set(deviceId, userId);
+    if (!wasOnline) {
+      for (const ext of this.extensions) {
+        await ext.onUserOnline?.(userId, deviceId, deviceInfo?.metadata || {});
+      }
+    } else {
+      for (const ext of this.extensions) {
+        await ext.onDeviceConnected?.(userId, deviceId, deviceInfo?.metadata || {});
+      }
+    }
+    if (!wasOnline && this.config.broadcastPresenceUpdates && this.server) {
+      const experimental = this.server.experimental;
+      await experimental?.broadcastAuthenticated({
+        type: "presence:user_online",
+        payload: {
+          userId,
+          deviceId,
+          status: "online",
+          timestamp: now
+        }
+      });
+    }
     return presence;
   }
   async disconnectDevice(userId, deviceId) {
@@ -3269,7 +3329,24 @@ class DefaultPresenceManager extends PresenceManager {
     presence.devices.delete(deviceId);
     this.deviceToUser.delete(deviceId);
     const now = Date.now();
-    if (presence.devices.size === 0) {
+    const isLastDevice = presence.devices.size === 0;
+    if (isLastDevice) {
+      for (const ext of this.extensions) {
+        await ext.onUserOffline?.(userId, deviceId);
+      }
+      if (this.config.broadcastPresenceUpdates && this.server) {
+        const experimental = this.server.experimental;
+        await experimental?.broadcastAuthenticated({
+          type: "presence:user_offline",
+          payload: {
+            userId,
+            deviceId,
+            status: "offline",
+            timestamp: now,
+            gracePeriod: this.config.gracePeriod
+          }
+        });
+      }
       if (this.config.gracePeriod > 0) {
         this.gracePeriodEntries.set(userId, {
           userId,
@@ -3283,6 +3360,9 @@ class DefaultPresenceManager extends PresenceManager {
         return null;
       }
     }
+    for (const ext of this.extensions) {
+      await ext.onDeviceDisconnected?.(userId, deviceId);
+    }
     presence.status = this.calculatePresenceStatus(presence.devices, now);
     let mostRecentActivity = 0;
     for (const device of presence.devices.values()) {
@@ -3294,7 +3374,7 @@ class DefaultPresenceManager extends PresenceManager {
     return presence;
   }
   async updateActivity(update) {
-    const { userId, deviceId, timestamp } = update;
+    const { userId, deviceId, timestamp, activityType } = update;
     const presence = this.userPresences.get(userId);
     if (!presence) {
       throw new Error(`User ${userId} not found in presence system`);
@@ -3309,10 +3389,30 @@ class DefaultPresenceManager extends PresenceManager {
     }
     const previousStatus = presence.status;
     presence.status = this.calculatePresenceStatus(presence.devices, timestamp);
+    for (const ext of this.extensions) {
+      await ext.onActivity?.(userId, deviceId, activityType || "heartbeat");
+    }
     return presence;
   }
   async getUserPresence(userId) {
-    return this.userPresences.get(userId) || null;
+    const basePresence = this.userPresences.get(userId);
+    if (!basePresence) {
+      return null;
+    }
+    if (this.extensions.length > 0) {
+      const extendedData = {};
+      for (const ext of this.extensions) {
+        const data = await ext.getExtendedData?.(userId);
+        if (data) {
+          Object.assign(extendedData, data);
+        }
+      }
+      return {
+        ...basePresence,
+        extended: extendedData
+      };
+    }
+    return basePresence;
   }
   async getUsersPresence(userIds) {
     const result = new Map;
@@ -3328,7 +3428,20 @@ class DefaultPresenceManager extends PresenceManager {
     const online = [];
     for (const presence of this.userPresences.values()) {
       if (presence.status === "online") {
-        online.push(presence);
+        let visible = true;
+        for (const ext of this.extensions) {
+          const shouldShow = await ext.shouldBeVisible?.(presence.userId);
+          if (shouldShow === false) {
+            visible = false;
+            break;
+          }
+        }
+        if (visible) {
+          const fullPresence = await this.getUserPresence(presence.userId);
+          if (fullPresence) {
+            online.push(fullPresence);
+          }
+        }
       }
     }
     return online;
@@ -3405,6 +3518,7 @@ class DefaultPresenceManager extends PresenceManager {
     return changes;
   }
   async clear() {
+    await this.destroyExtensions();
     this.userPresences.clear();
     this.deviceToUser.clear();
     this.gracePeriodEntries.clear();
@@ -4778,6 +4892,107 @@ class ClientBuilder {
     return new BaseClient(config);
   }
 }
+// src/client/PresenceClient.ts
+class PresenceClient extends TypedEventEmitter {
+  client;
+  wsUrl;
+  autoReconnectEnabled;
+  globalRoomId;
+  reconnectTimeout;
+  constructor(config) {
+    super();
+    this.wsUrl = config.wsUrl;
+    this.autoReconnectEnabled = config.autoReconnect ?? true;
+    this.globalRoomId = config.globalRoomId ?? "__global_presence__";
+    this.client = new BaseClient(config.clientConfig);
+    this.setupEventForwarding();
+    if (config.autoConnect) {
+      this.connect();
+    }
+  }
+  async connect() {
+    try {
+      await this.client.connect(this.wsUrl);
+      await this.client.joinRoom(this.globalRoomId);
+      await this.emit("connected", {});
+    } catch (error) {
+      await this.emit("error", { error });
+      throw error;
+    }
+  }
+  async disconnect() {
+    this.autoReconnectEnabled = false;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = undefined;
+    }
+    try {
+      await this.client.leaveRoom();
+      await this.client.disconnect();
+      await this.emit("disconnected", {});
+    } catch (error) {
+      await this.emit("error", { error });
+    }
+  }
+  async getOnlineUsers() {
+    throw new Error("getOnlineUsers() requires a REST API endpoint. " + "Implement this method based on your server API.");
+  }
+  async setStatus(status, message) {
+    throw new Error("setStatus() requires a REST API endpoint. " + "Implement this method based on your server API.");
+  }
+  async setVisibility(visible) {
+    throw new Error("setVisibility() requires a REST API endpoint. " + "Implement this method based on your server API.");
+  }
+  getClient() {
+    return this.client;
+  }
+  isConnected() {
+    return this.client.connectionState === "connected";
+  }
+  setupEventForwarding() {
+    this.client.on("presence:user_online", (data) => {
+      if (data && typeof data === "object") {
+        const payload = data;
+        this.emit("userOnline", {
+          userId: payload.userId,
+          devices: payload.devices || []
+        });
+      }
+    });
+    this.client.on("presence:user_offline", (data) => {
+      if (data && typeof data === "object") {
+        const payload = data;
+        this.emit("userOffline", { userId: payload.userId });
+      }
+    });
+    this.client.on("presence:status_changed", (data) => {
+      if (data && typeof data === "object") {
+        const payload = data;
+        this.emit("statusChanged", {
+          userId: payload.userId,
+          status: payload.status,
+          statusMessage: payload.statusMessage
+        });
+      }
+    });
+    this.client.on("disconnected", () => {
+      this.emit("disconnected", {});
+      if (this.autoReconnectEnabled) {
+        this.reconnectTimeout = setTimeout(() => {
+          this.connect().catch((error) => {
+            this.emit("error", { error });
+          });
+        }, 5000);
+      }
+    });
+    this.client.on("error", (data) => {
+      if (data && typeof data === "object" && "error" in data) {
+        const payload = data;
+        this.emit("error", { error: payload.error });
+      }
+    });
+  }
+}
 // src/server/ExperimentalAPI.ts
 class ExperimentalAPI {
   config;
@@ -4916,6 +5131,8 @@ class BaseServer extends TypedEventEmitter {
   config;
   clients = new Map;
   clientMessageHandlers = new Map;
+  clientUserMap = new Map;
+  userClientMap = new Map;
   running = false;
   initialized = false;
   mode;
@@ -5066,6 +5283,8 @@ class BaseServer extends TypedEventEmitter {
     }
     this.clients.clear();
     this.clientMessageHandlers.clear();
+    this.clientUserMap.clear();
+    this.userClientMap.clear();
     if (this.presenceManager) {
       await this.presenceManager.clear();
     }
@@ -5169,6 +5388,11 @@ class BaseServer extends TypedEventEmitter {
     if (client) {
       client.authenticated = true;
       client.userId = payload.userId;
+      this.clientUserMap.set(payload.clientId, payload.userId);
+      if (!this.userClientMap.has(payload.userId)) {
+        this.userClientMap.set(payload.userId, new Set);
+      }
+      this.userClientMap.get(payload.userId).add(payload.clientId);
       await this.emit("client_authenticated", {
         clientId: payload.clientId,
         userId: payload.userId
@@ -5204,6 +5428,16 @@ class BaseServer extends TypedEventEmitter {
     if (!client) {
       return;
     }
+    if (client.userId) {
+      this.clientUserMap.delete(clientId);
+      const clientSet = this.userClientMap.get(client.userId);
+      if (clientSet) {
+        clientSet.delete(clientId);
+        if (clientSet.size === 0) {
+          this.userClientMap.delete(client.userId);
+        }
+      }
+    }
     if (this.presenceManager?.isEnabled() && client.userId) {
       try {
         const presence = await this.presenceManager.disconnectDevice(client.userId, clientId);
@@ -5247,6 +5481,9 @@ class BaseServer extends TypedEventEmitter {
         if (!client) {
           return;
         }
+        if (this.presenceManager?.isEnabled() && client.userId && client.authenticated) {
+          await this.updatePresenceActivity(client.userId, clientId, "message");
+        }
         switch (message.type) {
           case "authenticate":
             await this.handleAuthenticate(clientId, message.payload);
@@ -5268,9 +5505,6 @@ 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, {
@@ -5510,6 +5744,15 @@ class BaseServer extends TypedEventEmitter {
   getPresenceManager() {
     return this.presenceManager;
   }
+  getUserIdFromClientId(clientId) {
+    return this.clientUserMap.get(clientId);
+  }
+  getClientIdsForUser(userId) {
+    return Array.from(this.userClientMap.get(userId) || []);
+  }
+  getDeviceIdFromClientId(clientId) {
+    return clientId;
+  }
 }
 // src/server/ServerBuilder.ts
 class ServerBuilder {
@@ -5599,7 +5842,44 @@ class ServerBuilder {
         trackUsageMetrics: false
       }
     };
-    return new BaseServer(config);
+    const server = new BaseServer(config);
+    if (this.presenceManager instanceof DefaultPresenceManager) {
+      this.presenceManager.setServer(server);
+    }
+    if (this.presenceManager instanceof DefaultPresenceManager) {
+      this.wirePresenceExtensionHooks(server, this.presenceManager);
+    }
+    return server;
+  }
+  wirePresenceExtensionHooks(server, presenceManager) {
+    server.on("started", async () => {
+      await presenceManager.initializeExtensions();
+    });
+    server.on("client_joined_room", async ({ clientId, roomId }) => {
+      const userId = server.getUserIdFromClientId(clientId);
+      if (userId && presenceManager.isEnabled()) {
+        const extensions = presenceManager.extensions;
+        if (extensions) {
+          for (const ext of extensions) {
+            await ext.onRoomJoined?.(userId, roomId, clientId);
+          }
+        }
+      }
+    });
+    server.on("client_left_room", async ({ clientId, roomId }) => {
+      const userId = server.getUserIdFromClientId(clientId);
+      if (userId && presenceManager.isEnabled()) {
+        const extensions = presenceManager.extensions;
+        if (extensions) {
+          for (const ext of extensions) {
+            await ext.onRoomLeft?.(userId, roomId, clientId);
+          }
+        }
+      }
+    });
+    server.on("stopped", async () => {
+      await presenceManager.destroyExtensions();
+    });
   }
 }
 export {
@@ -5609,6 +5889,7 @@ export {
   ServerBuilder,
   RoomManager,
   PresenceManager,
+  PresenceClient,
   MockTransportAdapter,
   MockStorageAdapter,
   MockAuthAdapter,
@@ -5623,4 +5904,4 @@ export {
   BaseClient
 };
 
-//# debugId=202CBDD84215CE1F64756E2164756E21
+//# debugId=205D80A7D7E855D364756E2164756E21