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

package/dist/index.mjs

@@ -5485,6 +5485,7 @@ class BaseClient extends TypedEventEmitter {
   reconnectTimer = null;
   lastConnectionUrl = null;
   lastToken = null;
+  pendingRequests = new Map;
   constructor(config) {
     super();
     this.config = config;
@@ -5656,6 +5657,34 @@ class BaseClient extends TypedEventEmitter {
     };
     await this.transport.send(message);
   }
+  async request(type, payload, timeoutMs = 5000) {
+    if (this.connectionState !== "connected") {
+      throw new Error("Client must be connected to send requests");
+    }
+    const id = this.generateId();
+    const message = {
+      id,
+      type,
+      payload,
+      timestamp: Date.now()
+    };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request '${type}' timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timeout
+      });
+      this.transport.send(message).catch((error) => {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+  }
   getConnectionState() {
     return this.connectionState;
   }
@@ -5672,6 +5701,13 @@ class BaseClient extends TypedEventEmitter {
     return this.userId;
   }
   async handleMessage(message) {
+    if (message.id && this.pendingRequests.has(message.id)) {
+      const pending = this.pendingRequests.get(message.id);
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(message.id);
+      pending.resolve(message.payload);
+      return;
+    }
     try {
       switch (message.type) {
         case "auth_result":
@@ -5874,13 +5910,46 @@ class PresenceClient extends TypedEventEmitter {
     }
   }
   async getOnlineUsers() {
-    throw new Error("getOnlineUsers() requires a REST API endpoint. " + "Implement this method based on your server API.");
+    const response = await this.client.request("presence:get_users", {});
+    return response.users;
+  }
+  async getUserPresence(userId) {
+    const response = await this.client.request("presence:get_user", { userId });
+    return response.user;
+  }
+  async getRepoUsers(owner, repo) {
+    const response = await this.client.request("presence:get_repo_users", { owner, repo });
+    return response.users;
   }
-  async setStatus(status, message) {
-    throw new Error("setStatus() requires a REST API endpoint. " + "Implement this method based on your server API.");
+  async setStatus(status, statusMessage) {
+    const response = await this.client.request("presence:set_status", { status, statusMessage });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to set status");
+    }
   }
   async setVisibility(visible) {
-    throw new Error("setVisibility() requires a REST API endpoint. " + "Implement this method based on your server API.");
+    const response = await this.client.request("presence:set_visibility", { visible });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to set visibility");
+    }
+  }
+  async reportRepoOpened(repoId, branch) {
+    const response = await this.client.request("presence:repo_open", { repoId, branch });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to report repo opened");
+    }
+  }
+  async reportRepoClosed(repoId) {
+    const response = await this.client.request("presence:repo_close", { repoId });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to report repo closed");
+    }
+  }
+  async reportRepoFocused(repoId) {
+    const response = await this.client.request("presence:repo_focus", { repoId });
+    if (!response.success) {
+      throw new Error(response.error || "Failed to report repo focused");
+    }
   }
   getClient() {
     return this.client;
@@ -6309,7 +6378,6 @@ 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;
@@ -6389,7 +6457,6 @@ class BaseServer extends TypedEventEmitter {
     const client = {
       id: clientId,
       userId: "",
-      deviceId: clientId,
       roomIds,
       get roomId() {
         return roomIds.size > 0 ? roomIds.values().next().value || null : null;
@@ -6418,10 +6485,10 @@ class BaseServer extends TypedEventEmitter {
     }
     if (this.presenceManager?.isEnabled() && client.userId) {
       try {
-        const presence = await this.presenceManager.disconnectDevice(client.userId, client.deviceId);
+        const presence = await this.presenceManager.disconnectDevice(client.userId, clientId);
         await this.emit("presence_device_disconnected", {
           userId: client.userId,
-          deviceId: client.deviceId,
+          deviceId: clientId,
           timestamp: Date.now()
         });
         const presenceConfig = this.presenceManager.getConfig();
@@ -6430,7 +6497,7 @@ class BaseServer extends TypedEventEmitter {
             type: "presence:user_offline",
             payload: {
               userId: client.userId,
-              deviceId: client.deviceId,
+              deviceId: clientId,
               status: presence?.status || "offline",
               gracePeriod: presenceConfig.gracePeriod
             }
@@ -6444,17 +6511,6 @@ 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 });
     }
@@ -6471,7 +6527,7 @@ class BaseServer extends TypedEventEmitter {
           return;
         }
         if (this.presenceManager?.isEnabled() && client.userId && client.authenticated) {
-          await this.updatePresenceActivity(client.userId, client.deviceId, "message");
+          await this.updatePresenceActivity(client.userId, clientId, "message");
         }
         switch (message.type) {
           case "authenticate":
@@ -6504,11 +6560,23 @@ class BaseServer extends TypedEventEmitter {
               timestamp: Date.now()
             });
             break;
-          default:
+          default: {
+            if (this.config.customMessageHandler) {
+              const sendResponse = async (response) => {
+                await this.sendToClient(clientId, {
+                  id: message.id,
+                  ...response
+                });
+              };
+              const handled = await this.config.customMessageHandler(clientId, message, sendResponse);
+              if (handled)
+                break;
+            }
             await this.sendToClient(clientId, {
               type: "error",
               error: `Unknown message type: ${message.type}`
             });
+          }
         }
       } catch (error) {
         await this.sendToClient(clientId, {
@@ -6648,17 +6716,6 @@ 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 });
@@ -6831,16 +6888,7 @@ class BaseServer extends TypedEventEmitter {
     });
   }
   getDeviceIdFromClientId(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;
+    return clientId;
   }
 }
 // src/server/ServerBuilder.ts
@@ -6856,6 +6904,7 @@ class ServerBuilder {
   webSocketPath;
   webSocketServer;
   experimentalFeatures;
+  customMessageHandler;
   withTransport(transport) {
     this.transport = transport;
     return this;
@@ -6900,6 +6949,10 @@ class ServerBuilder {
     this.experimentalFeatures = features;
     return this;
   }
+  withCustomMessageHandler(handler) {
+    this.customMessageHandler = handler;
+    return this;
+  }
   build() {
     if (!this.transport) {
       throw new Error("Transport adapter is required");
@@ -6929,7 +6982,8 @@ class ServerBuilder {
         enableBroadcast: false,
         warnOnExperimentalUse: true,
         trackUsageMetrics: false
-      }
+      },
+      customMessageHandler: this.customMessageHandler
     };
     const server = new BaseServer(config);
     if (this.roomManager.constructor.name === "DefaultRoomManager") {
@@ -7003,4 +7057,4 @@ export {
   BaseClient
 };
 
-//# debugId=A5E31B6ED779287364756E2164756E21
+//# debugId=A1A2F55B1633C22A64756E2164756E21