@principal-ai/control-tower-core 0.1.21 → 0.1.22

package/dist/index.mjs

@@ -3859,25 +3859,13 @@ class MockStorageAdapter {
 class MockAuthAdapter {
   tokens = new Map;
   revokedTokens = new Set;
-  users = new Map;
   simulateLatency = 0;
   shouldFailAuth = false;
   tokenCounter = 0;
+  currentToken = null;
   constructor(options) {
     this.simulateLatency = options?.simulateLatency ?? 0;
     this.shouldFailAuth = options?.shouldFailAuth ?? false;
-    this.addUser("testuser", "password123", {
-      userId: "user-1",
-      email: "test@example.com",
-      username: "testuser",
-      permissions: ["read", "write"]
-    });
-    this.addUser("admin", "admin123", {
-      userId: "user-admin",
-      email: "admin@example.com",
-      username: "admin",
-      permissions: ["read", "write", "admin"]
-    });
   }
   async validateToken(token) {
     await this.simulateDelay();
@@ -3928,94 +3916,8 @@ class MockAuthAdapter {
     this.tokens.delete(token);
     this.revokedTokens.add(token);
   }
-  async authenticate(credentials) {
-    await this.simulateDelay();
-    if (this.shouldFailAuth) {
-      return {
-        success: false,
-        error: "Mock authentication failed"
-      };
-    }
-    switch (credentials.type) {
-      case "password": {
-        if (!credentials.username || !credentials.password) {
-          return {
-            success: false,
-            error: "Username and password required"
-          };
-        }
-        const user = this.users.get(credentials.username);
-        if (!user || user.password !== credentials.password) {
-          return {
-            success: false,
-            error: "Invalid credentials"
-          };
-        }
-        const token = await this.generateToken(user.payload);
-        const refreshToken = `refresh-${token}`;
-        this.tokens.set(refreshToken, user.payload);
-        return {
-          success: true,
-          token,
-          refreshToken,
-          user: user.payload,
-          userId: user.payload.userId,
-          expiresIn: 3600
-        };
-      }
-      case "token":
-      case "jwt":
-      case "bearer": {
-        if (!credentials.token) {
-          return {
-            success: false,
-            error: "Token required"
-          };
-        }
-        try {
-          const payload = await this.validateToken(credentials.token);
-          return {
-            success: true,
-            token: credentials.token,
-            user: payload,
-            userId: payload.userId,
-            expiresIn: 3600
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message
-          };
-        }
-      }
-      case "oauth": {
-        if (!credentials.code) {
-          return {
-            success: false,
-            error: "OAuth code required"
-          };
-        }
-        const payload = {
-          userId: `oauth-user-${Date.now()}`,
-          email: "oauth@example.com",
-          username: "oauthuser",
-          permissions: ["read", "write"]
-        };
-        const token = await this.generateToken(payload);
-        return {
-          success: true,
-          token,
-          user: payload,
-          userId: payload.userId,
-          expiresIn: 3600
-        };
-      }
-      default:
-        return {
-          success: false,
-          error: "Unsupported credential type"
-        };
-    }
+  getCurrentToken() {
+    return this.currentToken;
   }
   isAuthRequired() {
     return false;
@@ -4023,19 +3925,21 @@ class MockAuthAdapter {
   getAuthTimeout() {
     return 1e4;
   }
-  getSupportedCredentialTypes() {
-    return ["password", "token", "jwt", "bearer", "oauth"];
-  }
   async simulateDelay() {
     if (this.simulateLatency > 0) {
       await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
     }
   }
-  addUser(username, password, payload) {
-    this.users.set(username, { password, payload });
-  }
-  removeUser(username) {
-    this.users.delete(username);
+  async createTestToken(userId, options) {
+    const payload = {
+      userId,
+      permissions: options?.permissions ?? ["read", "write"],
+      metadata: options?.metadata,
+      expiresAt: options?.expiresIn ? Date.now() + options.expiresIn : undefined
+    };
+    const token = await this.generateToken(payload);
+    this.currentToken = token;
+    return token;
   }
   getTokenCount() {
     return this.tokens.size;
@@ -4046,10 +3950,14 @@ class MockAuthAdapter {
   clearTokens() {
     this.tokens.clear();
     this.revokedTokens.clear();
+    this.currentToken = null;
   }
   setFailAuth(fail) {
     this.shouldFailAuth = fail;
   }
+  setCurrentToken(token) {
+    this.currentToken = token;
+  }
 }
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -4167,16 +4075,16 @@ class WebSocketServerTransportAdapter {
   async handleConnection(ws, req) {
     const clientId = this.generateId();
     let authenticated = false;
-    let authResult = null;
+    let userId;
+    let metadata;
     if (this.authAdapter && req.headers.authorization) {
       const token = this.extractBearerToken(req.headers.authorization);
       if (token) {
         try {
-          authResult = await this.authAdapter.authenticate({
-            type: "bearer",
-            token
-          });
-          authenticated = authResult.success;
+          const tokenPayload = await this.authAdapter.validateToken(token);
+          authenticated = true;
+          userId = tokenPayload.userId;
+          metadata = tokenPayload.metadata;
         } catch {}
       }
     }
@@ -4184,8 +4092,8 @@ class WebSocketServerTransportAdapter {
       id: clientId,
       ws,
       authenticated,
-      userId: authResult?.userId || authResult?.user?.userId,
-      metadata: authResult?.metadata || authResult?.user?.metadata,
+      userId,
+      metadata,
       connectedAt: Date.now()
     };
     this.clients.set(clientId, client);
@@ -4257,107 +4165,65 @@ class WebSocketServerTransportAdapter {
     if (!this.authAdapter) {
       this.sendToClient(client, {
         id: this.generateId(),
-        type: "auth_error",
-        payload: { error: "No auth adapter configured" },
+        type: "auth_result",
+        payload: { success: false, error: "No auth adapter configured" },
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const payload = message.payload;
+    if (!payload.token || typeof payload.token !== "string") {
+      this.sendToClient(client, {
+        id: this.generateId(),
+        type: "auth_result",
+        payload: { success: false, error: "Token required for authentication" },
         timestamp: Date.now()
       });
       return;
     }
     try {
-      const payload = message.payload;
-      if (payload.token && typeof payload.token === "string") {
-        try {
-          const tokenPayload = await this.authAdapter.validateToken(payload.token);
-          if (client.authTimeout) {
-            clearTimeout(client.authTimeout);
-            client.authTimeout = undefined;
-          }
-          client.authenticated = true;
-          client.userId = tokenPayload.userId;
-          client.metadata = tokenPayload.metadata;
-          this.sendToClient(client, {
-            id: this.generateId(),
-            type: "auth_result",
-            payload: {
-              success: true,
-              userId: client.userId
-            },
-            timestamp: Date.now()
-          });
-          const authMessage = {
-            id: this.generateId(),
-            type: "client_authenticated",
-            payload: {
-              clientId: client.id,
-              userId: client.userId,
-              metadata: client.metadata
-            },
-            timestamp: Date.now()
-          };
-          this.messageHandlers.forEach((handler) => handler(authMessage));
-          return;
-        } catch (error) {
-          this.sendToClient(client, {
-            id: this.generateId(),
-            type: "auth_result",
-            payload: {
-              success: false,
-              error: error.message
-            },
-            timestamp: Date.now()
-          });
-          return;
-        }
-      }
-      const credentials = payload;
-      const result = await this.authAdapter.authenticate(credentials);
-      if (result.success) {
-        if (client.authTimeout) {
-          clearTimeout(client.authTimeout);
-          client.authTimeout = undefined;
-        }
-        client.authenticated = true;
-        client.userId = result.userId || result.user?.userId;
-        client.metadata = result.metadata || result.user?.metadata;
-        this.sendToClient(client, {
-          id: this.generateId(),
-          type: "auth_success",
-          payload: {
-            userId: client.userId,
-            metadata: client.metadata
-          },
-          timestamp: Date.now()
-        });
-        const authMessage = {
-          id: this.generateId(),
-          type: "client_authenticated",
-          payload: {
-            clientId: client.id,
-            userId: client.userId,
-            metadata: client.metadata
-          },
-          timestamp: Date.now()
-        };
-        this.messageHandlers.forEach((handler) => handler(authMessage));
-      } else {
-        this.sendToClient(client, {
-          id: this.generateId(),
-          type: "auth_error",
-          payload: { error: result.error || "Authentication failed" },
-          timestamp: Date.now()
-        });
-        if (this.config.closeOnAuthFailure) {
-          client.ws.close(1008, "Authentication failed");
-          this.clients.delete(client.id);
-        }
+      const tokenPayload = await this.authAdapter.validateToken(payload.token);
+      if (client.authTimeout) {
+        clearTimeout(client.authTimeout);
+        client.authTimeout = undefined;
       }
+      client.authenticated = true;
+      client.userId = tokenPayload.userId;
+      client.metadata = tokenPayload.metadata;
+      this.sendToClient(client, {
+        id: this.generateId(),
+        type: "auth_result",
+        payload: {
+          success: true,
+          userId: client.userId
+        },
+        timestamp: Date.now()
+      });
+      const authMessage = {
+        id: this.generateId(),
+        type: "client_authenticated",
+        payload: {
+          clientId: client.id,
+          userId: client.userId,
+          metadata: client.metadata
+        },
+        timestamp: Date.now()
+      };
+      this.messageHandlers.forEach((handler) => handler(authMessage));
     } catch (error) {
       this.sendToClient(client, {
         id: this.generateId(),
-        type: "auth_error",
-        payload: { error: error.message },
+        type: "auth_result",
+        payload: {
+          success: false,
+          error: error.message
+        },
         timestamp: Date.now()
       });
+      if (this.config.closeOnAuthFailure) {
+        client.ws.close(1008, "Authentication failed");
+        this.clients.delete(client.id);
+      }
     }
   }
   extractBearerToken(authHeader) {
@@ -4653,7 +4519,7 @@ class BaseClient extends TypedEventEmitter {
   reconnectAttempts = 0;
   reconnectTimer = null;
   lastConnectionUrl = null;
-  lastCredentials = null;
+  lastToken = null;
   constructor(config) {
     super();
     this.config = config;
@@ -4664,35 +4530,29 @@ class BaseClient extends TypedEventEmitter {
     this.transport.onError(this.handleError.bind(this));
     this.transport.onClose(this.handleClose.bind(this));
   }
-  async connect(url, credentials) {
+  async connect(url, token) {
     if (this.connectionState !== "disconnected") {
       throw new Error("Client is already connected or connecting");
     }
     this.connectionState = "connecting";
     this.lastConnectionUrl = url;
-    this.lastCredentials = credentials || null;
+    this.lastToken = token || null;
     try {
-      let tokenToApply = null;
-      if (credentials && this.auth) {
-        const authResult = await this.auth.authenticate(credentials);
-        if (authResult.success && authResult.token) {
-          this.authToken = authResult.token;
-          this.userId = authResult.user?.userId || authResult.userId || "";
-          tokenToApply = authResult.token;
-        }
-      } else if (this.auth && typeof this.auth.getCurrentToken === "function") {
-        const currentToken = this.auth.getCurrentToken();
-        if (currentToken) {
-          this.authToken = currentToken;
-          tokenToApply = currentToken;
+      let tokenToApply = token || null;
+      if (!tokenToApply && this.auth && typeof this.auth.getCurrentToken === "function") {
+        tokenToApply = this.auth.getCurrentToken();
+      }
+      if (tokenToApply) {
+        this.authToken = tokenToApply;
+        if (this.auth) {
           try {
-            const payload = await this.auth.validateToken(currentToken);
+            const payload = await this.auth.validateToken(tokenToApply);
             this.userId = payload.userId;
           } catch {}
         }
-      }
-      if (tokenToApply && typeof this.transport.setAuthToken === "function") {
-        this.transport.setAuthToken(tokenToApply);
+        if (typeof this.transport.setAuthToken === "function") {
+          this.transport.setAuthToken(tokenToApply);
+        }
       }
       const options = {
         url,
@@ -4739,7 +4599,7 @@ class BaseClient extends TypedEventEmitter {
     if (this.connectionState !== "disconnected") {
       await this.disconnect();
     }
-    await this.connect(this.lastConnectionUrl, this.lastCredentials || undefined);
+    await this.connect(this.lastConnectionUrl, this.lastToken || undefined);
   }
   async authenticate(options) {
     if (this.connectionState !== "connected") {
@@ -6021,4 +5881,4 @@ export {
   BaseClient
 };
 
-//# debugId=8D71D2794ACED82564756E2164756E21
+//# debugId=26EFA411F64C29E464756E2164756E21