@principal-ai/control-tower-core 0.1.9 → 0.1.11

package/dist/index.mjs

@@ -3927,8 +3927,8 @@ var import_sender = __toESM(require_sender(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
-// src/adapters/websocket/WebSocketTransportAdapter.ts
-class WebSocketTransportAdapter {
+// src/adapters/websocket/WebSocketServerTransportAdapter.ts
+class WebSocketServerTransportAdapter {
   state = "disconnected";
   messageHandlers = new Set;
   errorHandlers = new Set;
@@ -4275,6 +4275,186 @@ class WebSocketTransportAdapter {
     return Math.random().toString(36).substring(2) + Date.now().toString(36);
   }
 }
+// src/adapters/websocket/WebSocketClientTransportAdapter.ts
+class WebSocketClientTransportAdapter {
+  ws;
+  state = "disconnected";
+  messageHandlers = new Set;
+  errorHandlers = new Set;
+  closeHandlers = new Set;
+  config;
+  heartbeatTimer;
+  connectionTimer;
+  constructor(config) {
+    this.config = {
+      headers: config?.headers ?? {},
+      connectionTimeout: config?.connectionTimeout ?? 30000,
+      enableHeartbeat: config?.enableHeartbeat ?? true,
+      heartbeatInterval: config?.heartbeatInterval ?? 30000
+    };
+  }
+  async connect(url, options) {
+    if (this.state === "connected" || this.state === "connecting") {
+      throw new Error("Already connected or connecting");
+    }
+    this.state = "connecting";
+    return new Promise((resolve, reject) => {
+      try {
+        const wsOptions = {};
+        if (Object.keys(this.config.headers).length > 0) {
+          wsOptions.headers = this.config.headers;
+        }
+        this.ws = new import_websocket.default(url, wsOptions);
+        this.connectionTimer = setTimeout(() => {
+          if (this.state === "connecting") {
+            this.ws?.terminate();
+            this.state = "disconnected";
+            const error = new Error("Connection timeout");
+            this.errorHandlers.forEach((handler) => handler(error));
+            reject(error);
+          }
+        }, this.config.connectionTimeout);
+        this.ws.on("open", () => {
+          if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+          }
+          this.state = "connected";
+          if (this.config.enableHeartbeat) {
+            this.startHeartbeat();
+          }
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const message = JSON.parse(data.toString());
+            this.messageHandlers.forEach((handler) => handler(message));
+          } catch (error) {
+            this.errorHandlers.forEach((handler) => handler(error));
+          }
+        });
+        this.ws.on("error", (error) => {
+          if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+          }
+          this.errorHandlers.forEach((handler) => handler(error));
+          if (this.state === "connecting") {
+            this.state = "disconnected";
+            reject(error);
+          }
+        });
+        this.ws.on("close", (code, reason) => {
+          if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+          }
+          this.stopHeartbeat();
+          const wasConnected = this.state === "connected";
+          this.state = "disconnected";
+          if (wasConnected) {
+            this.closeHandlers.forEach((handler) => handler(code, reason.toString()));
+          }
+        });
+        if (this.config.enableHeartbeat) {
+          this.ws.on("pong", () => {});
+        }
+      } catch (error) {
+        if (this.connectionTimer) {
+          clearTimeout(this.connectionTimer);
+          this.connectionTimer = undefined;
+        }
+        this.state = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  async disconnect() {
+    if (this.state === "disconnected") {
+      return;
+    }
+    this.state = "disconnecting";
+    this.stopHeartbeat();
+    if (this.connectionTimer) {
+      clearTimeout(this.connectionTimer);
+      this.connectionTimer = undefined;
+    }
+    if (this.ws) {
+      this.ws.close(1000, "Client disconnecting");
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          this.ws?.terminate();
+          resolve();
+        }, 5000);
+        const onClose = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        this.ws?.once("close", onClose);
+      });
+      this.ws = undefined;
+    }
+    this.state = "disconnected";
+  }
+  async send(message) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected");
+    }
+    if (!this.ws || this.ws.readyState !== import_websocket.default.OPEN) {
+      throw new Error("WebSocket connection is not open");
+    }
+    try {
+      const data = JSON.stringify(message);
+      this.ws.send(data);
+    } catch (error) {
+      this.errorHandlers.forEach((handler) => handler(error));
+      throw error;
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+  }
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+  }
+  getState() {
+    return this.state;
+  }
+  isConnected() {
+    return this.state === "connected" && this.ws?.readyState === import_websocket.default.OPEN;
+  }
+  getWebSocket() {
+    return this.ws;
+  }
+  setHeaders(headers) {
+    if (this.state !== "disconnected") {
+      throw new Error("Cannot set headers while connected");
+    }
+    this.config.headers = { ...this.config.headers, ...headers };
+  }
+  setAuthToken(token) {
+    this.setHeaders({ Authorization: `Bearer ${token}` });
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === import_websocket.default.OPEN) {
+        this.ws.ping();
+      }
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = undefined;
+    }
+  }
+}
 // src/client/BaseClient.ts
 class BaseClient extends TypedEventEmitter {
   transport;
@@ -4313,6 +4493,9 @@ class BaseClient extends TypedEventEmitter {
         if (authResult.success && authResult.token) {
           this.authToken = authResult.token;
           this.userId = authResult.user?.userId || authResult.userId || "";
+          if (typeof this.transport.setAuthToken === "function") {
+            this.transport.setAuthToken(authResult.token);
+          }
         }
       }
       const options = {
@@ -5408,7 +5591,8 @@ class ServerBuilder {
   }
 }
 export {
-  WebSocketTransportAdapter,
+  WebSocketServerTransportAdapter,
+  WebSocketClientTransportAdapter,
   TypedEventEmitter,
   ServerBuilder,
   RoomManager,
@@ -5427,4 +5611,4 @@ export {
   BaseClient
 };
 
-//# debugId=68127252D0E6EA6864756E2164756E21
+//# debugId=FF090C02C3545A4B64756E2164756E21