@principal-ai/control-tower-core 0.4.0 → 0.4.1

package/dist/index.mjs

@@ -3501,6 +3501,128 @@ class DefaultPresenceManager extends PresenceManager {
   getUniqueUserCount() {
     return this.userPresences.size + this.gracePeriodEntries.size;
   }
+  serializePresence(presence) {
+    const { devices, extended, ...rest } = presence;
+    return {
+      ...rest,
+      devices: Object.fromEntries(devices),
+      ...extended || {}
+    };
+  }
+  async handlePresenceMessage(userId, deviceId, message, sendResponse) {
+    switch (message.type) {
+      case "presence:get_users": {
+        const onlineUsers = await this.getOnlineUsers();
+        const users = onlineUsers.map((u) => this.serializePresence(u));
+        const response = {
+          users,
+          stats: {
+            totalOnline: users.length
+          }
+        };
+        await sendResponse({ type: "presence:get_users", payload: response });
+        return true;
+      }
+      case "presence:get_user": {
+        const { userId: targetUserId } = message.payload;
+        const userPresence = await this.getUserPresence(targetUserId);
+        const response = {
+          user: userPresence ? this.serializePresence(userPresence) : null
+        };
+        await sendResponse({ type: "presence:get_user", payload: response });
+        return true;
+      }
+      case "presence:set_status": {
+        const { status, statusMessage } = message.payload;
+        await this.setUserStatus(userId, status);
+        if (this.config.broadcastPresenceUpdates && this.server) {
+          const experimental = this.server.experimental;
+          await experimental?.broadcastAuthenticated({
+            type: "presence:status_changed",
+            payload: { userId, status, statusMessage }
+          });
+        }
+        const response = { success: true };
+        await sendResponse({ type: "presence:set_status", payload: response });
+        return true;
+      }
+      case "presence:set_visibility": {
+        const { visible } = message.payload;
+        for (const ext of this.extensions) {
+          if (typeof ext.setVisibility === "function") {
+            ext.setVisibility(userId, visible);
+            break;
+          }
+        }
+        const response = { success: true };
+        await sendResponse({ type: "presence:set_visibility", payload: response });
+        return true;
+      }
+      case "presence:repo_status_update": {
+        const { repoId, gitStatus } = message.payload;
+        let updated = false;
+        for (const ext of this.extensions) {
+          if (typeof ext.updateRepositoryGitStatus === "function") {
+            updated = ext.updateRepositoryGitStatus(userId, repoId, deviceId, gitStatus);
+            break;
+          }
+        }
+        if (!updated) {
+          const response2 = {
+            success: false,
+            message: "Repository session not found"
+          };
+          await sendResponse({ type: "presence:repo_status_update", payload: response2 });
+          return true;
+        }
+        if (this.config.broadcastPresenceUpdates && this.server) {
+          let visible = true;
+          for (const ext of this.extensions) {
+            const shouldShow = await ext.shouldBeVisible?.(userId);
+            if (shouldShow === false) {
+              visible = false;
+              break;
+            }
+          }
+          if (visible) {
+            const experimental = this.server.experimental;
+            await experimental?.broadcastAuthenticated({
+              type: "presence:repo_status_changed",
+              payload: { userId, repoId, deviceId, gitStatus }
+            });
+          }
+        }
+        const response = {
+          success: true,
+          message: "Status updated"
+        };
+        await sendResponse({ type: "presence:repo_status_update", payload: response });
+        return true;
+      }
+      default: {
+        for (const ext of this.extensions) {
+          if (ext.handleMessage) {
+            const result = await ext.handleMessage(userId, deviceId, message.type, message.payload);
+            if (result) {
+              await sendResponse({
+                type: message.type,
+                payload: result.response
+              });
+              if (result.broadcast && this.server) {
+                const experimental = this.server.experimental;
+                await experimental?.broadcastAuthenticated({
+                  type: result.broadcast.type,
+                  payload: result.broadcast.payload
+                });
+              }
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+    }
+  }
 }
 // src/abstractions/EventEmitter.ts
 class TypedEventEmitter {
@@ -7112,4 +7234,4 @@ export {
   BaseClient
 };
 
-//# debugId=83C48EE48B6503C464756E2164756E21
+//# debugId=1FAB6CDDEC349C3164756E2164756E21