@principal-ai/control-tower-core 0.2.1 → 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 setStatus(status, message) {
-    throw new Error("setStatus() requires a REST API endpoint. " + "Implement this method based on your server API.");
+  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, 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;
@@ -6491,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, {
@@ -6823,6 +6904,7 @@ class ServerBuilder {
   webSocketPath;
   webSocketServer;
   experimentalFeatures;
+  customMessageHandler;
   withTransport(transport) {
     this.transport = transport;
     return this;
@@ -6867,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");
@@ -6896,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") {
@@ -6970,4 +7057,4 @@ export {
   BaseClient
 };
 
-//# debugId=AC1FE1DD89B6DDC464756E2164756E21
+//# debugId=A1A2F55B1633C22A64756E2164756E21