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

package/dist/telemetry-example.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Example: Using Generated Event Types
+ *
+ * This demonstrates how to use the generated types for type-safe telemetry
+ * in the Control Tower server.
+ */
+/**
+ * Example usage in message handler
+ */
+export declare class MessageHandlerWithTelemetry {
+    private emit;
+    handleMessage(clientId: string, messageType: string, messageSize: number): void;
+    private validateMessage;
+}
+/**
+ * Example usage in client lifecycle manager
+ */
+export declare class ClientLifecycleWithTelemetry {
+    private emit;
+    handleConnect(clientId: string, transportType: string): void;
+    handleAuthentication(clientId: string, userId: string, authMethod: string): void;
+    handleDisconnect(clientId: string, reason?: string, duration?: number): void;
+}
+/**
+ * Example with multiple event type handlers
+ */
+export declare class ControlTowerWithTelemetry {
+    private messageEmit;
+    private clientEmit;
+    handleNewClient(clientId: string, transportType: string): void;
+    handleMessage(clientId: string, messageType: string): void;
+}
+//# sourceMappingURL=telemetry-example.d.ts.map

package/dist/telemetry-example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry-example.d.ts","sourceRoot":"","sources":["../src/telemetry-example.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA+BH;;GAEG;AACH,qBAAa,2BAA2B;IACtC,OAAO,CAAC,IAAI,CAAiC;IAE7C,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IA0BxE,OAAO,CAAC,eAAe;CAIxB;AAED;;GAEG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,IAAI,CAAkC;IAE9C,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IASrD,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IASzE,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAQtE;AAED;;GAEG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,UAAU,CAAkC;IAEpD,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IASvD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAWpD"}

package/dist/telemetry-example.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Example: Using Generated Event Types
+ *
+ * This demonstrates how to use the generated types for type-safe telemetry
+ * in the Control Tower server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlTowerWithTelemetry = exports.ClientLifecycleWithTelemetry = exports.MessageHandlerWithTelemetry = void 0;
+/**
+ * Type-safe emitter for message handler events
+ */
+function createMessageHandlerEmitter() {
+    return (eventName, attributes) => {
+        // In production, this would emit to OpenTelemetry or your observability platform
+        console.log(`[MessageHandler] ${eventName}`, attributes);
+    };
+}
+/**
+ * Type-safe emitter for client lifecycle events
+ */
+function createClientLifecycleEmitter() {
+    return (eventName, attributes) => {
+        console.log(`[ClientLifecycle] ${eventName}`, attributes);
+    };
+}
+/**
+ * Example usage in message handler
+ */
+class MessageHandlerWithTelemetry {
+    constructor() {
+        this.emit = createMessageHandlerEmitter();
+    }
+    handleMessage(clientId, messageType, messageSize) {
+        // ✅ Type-safe: TypeScript knows the exact attributes for this event
+        this.emit('message.received', {
+            'client.id': clientId,
+            'message.type': messageType,
+            'message.size': messageSize, // Optional field
+        });
+        // Validate message...
+        const isValid = this.validateMessage(messageType);
+        if (isValid) {
+            this.emit('message.validated', {
+                'client.id': clientId,
+                'message.type': messageType,
+            });
+        }
+        else {
+            this.emit('message.validation_failed', {
+                'client.id': clientId,
+                'message.type': messageType,
+                'error.message': 'Invalid message schema',
+                'error.field': 'payload', // Optional field
+            });
+        }
+    }
+    validateMessage(messageType) {
+        // Mock validation
+        return messageType !== 'invalid';
+    }
+}
+exports.MessageHandlerWithTelemetry = MessageHandlerWithTelemetry;
+/**
+ * Example usage in client lifecycle manager
+ */
+class ClientLifecycleWithTelemetry {
+    constructor() {
+        this.emit = createClientLifecycleEmitter();
+    }
+    handleConnect(clientId, transportType) {
+        // ✅ Type-safe connection event
+        this.emit('client.connected', {
+            'client.id': clientId,
+            'transport.type': transportType,
+            'connection.time': Date.now(),
+        });
+    }
+    handleAuthentication(clientId, userId, authMethod) {
+        // ✅ Type-safe authentication event
+        this.emit('client.authenticated', {
+            'client.id': clientId,
+            'user.id': userId,
+            'auth.method': authMethod, // Optional field
+        });
+    }
+    handleDisconnect(clientId, reason, duration) {
+        // ✅ Type-safe disconnection event
+        this.emit('client.disconnected', {
+            'client.id': clientId,
+            'disconnect.reason': reason, // Optional field
+            'session.duration': duration, // Optional field
+        });
+    }
+}
+exports.ClientLifecycleWithTelemetry = ClientLifecycleWithTelemetry;
+/**
+ * Example with multiple event type handlers
+ */
+class ControlTowerWithTelemetry {
+    constructor() {
+        this.messageEmit = createMessageHandlerEmitter();
+        this.clientEmit = createClientLifecycleEmitter();
+        // ❌ TypeScript error: can't use client events with message emitter
+        // handleWrongEvent() {
+        //   this.messageEmit('client.connected', { ... }); // Error!
+        // }
+    }
+    handleNewClient(clientId, transportType) {
+        // Each emitter is type-safe to its specific events
+        this.clientEmit('client.connected', {
+            'client.id': clientId,
+            'transport.type': transportType,
+            'connection.time': Date.now(),
+        });
+    }
+    handleMessage(clientId, messageType) {
+        this.messageEmit('message.received', {
+            'client.id': clientId,
+            'message.type': messageType,
+        });
+    }
+}
+exports.ControlTowerWithTelemetry = ControlTowerWithTelemetry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principal-ai/control-tower-core",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Centralized, runtime-agnostic library for real-time collaboration and synchronization",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/dist/adapters/websocket/WebSocketTransportAdapter.d.ts

@@ -1,60 +0,0 @@
-import type { ITransportAdapter } from '../../abstractions/TransportAdapter.js';
-import type { IAuthAdapter } from '../../abstractions/AuthAdapter.js';
-import type { ConnectionState, ConnectionOptions, Message, MessageHandler, ErrorHandler, CloseHandler } from '../../types/index.js';
-import type { Server as HttpServer } from 'http';
-import type { Server as HttpsServer } from 'https';
-import { WebSocketServer, WebSocket } from 'ws';
-interface ClientConnection {
-    id: string;
-    ws: WebSocket;
-    userId?: string;
-    authenticated: boolean;
-    metadata?: Record<string, unknown>;
-    authTimeout?: NodeJS.Timeout;
-    connectedAt: number;
-}
-export interface WebSocketTransportConfig {
-    authTimeout?: number;
-    closeOnAuthFailure?: boolean;
-    requireAuth?: boolean;
-}
-export declare class WebSocketTransportAdapter implements ITransportAdapter {
-    private state;
-    private messageHandlers;
-    private errorHandlers;
-    private closeHandlers;
-    private wss?;
-    private serverUrl?;
-    private attachedServer?;
-    private attachedWss?;
-    private webSocketPath?;
-    private clients;
-    private mode;
-    private authAdapter?;
-    private config;
-    constructor(config?: WebSocketTransportConfig);
-    setAuthAdapter(auth: IAuthAdapter): void;
-    connect(url: string, _options?: ConnectionOptions): Promise<void>;
-    attach(server: HttpServer | HttpsServer, path?: string): Promise<void>;
-    attachToWebSocketServer(wss: WebSocketServer): Promise<void>;
-    private handleConnection;
-    private handleClientMessage;
-    private handleAuthMessage;
-    private extractBearerToken;
-    private sendToClient;
-    disconnect(): Promise<void>;
-    send(message: Message): Promise<void>;
-    onMessage(handler: MessageHandler): void;
-    onError(handler: ErrorHandler): void;
-    onClose(handler: CloseHandler): void;
-    getState(): ConnectionState;
-    isConnected(): boolean;
-    getConnectedClients(): ClientConnection[];
-    getAuthenticatedClients(): ClientConnection[];
-    getClientCount(): number;
-    getMode(): 'standalone' | 'integration';
-    isAuthRequired(): boolean;
-    private generateId;
-}
-export {};
-//# sourceMappingURL=WebSocketTransportAdapter.d.ts.map

package/dist/adapters/websocket/WebSocketTransportAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebSocketTransportAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/websocket/WebSocketTransportAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,OAAO,EACP,cAAc,EACd,YAAY,EACZ,YAAY,EAGb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,OAAO,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEhD,UAAU,gBAAgB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,qBAAa,yBAA0B,YAAW,iBAAiB;IACjE,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,aAAa,CAAgC;IAGrD,OAAO,CAAC,GAAG,CAAC,CAAkB;IAC9B,OAAO,CAAC,SAAS,CAAC,CAAS;IAG3B,OAAO,CAAC,cAAc,CAAC,CAA2B;IAClD,OAAO,CAAC,WAAW,CAAC,CAAkB;IACtC,OAAO,CAAC,aAAa,CAAC,CAAS;IAG/B,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,IAAI,CAA8C;IAG1D,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,MAAM,CAA2B;gBAE7B,MAAM,CAAC,EAAE,wBAAwB;IAU7C,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAclC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCjE,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,EAAE,IAAI,GAAE,MAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAiC7E,uBAAuB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;YA2BpD,gBAAgB;YA6EhB,mBAAmB;YAuCnB,iBAAiB;IA4E/B,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,YAAY;IAMd,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC3B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B3C,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIxC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,QAAQ,IAAI,eAAe;IAI3B,WAAW,IAAI,OAAO;IAKtB,mBAAmB,IAAI,gBAAgB,EAAE;IAIzC,uBAAuB,IAAI,gBAAgB,EAAE;IAI7C,cAAc,IAAI,MAAM;IAIxB,OAAO,IAAI,YAAY,GAAG,aAAa;IAIvC,cAAc,IAAI,OAAO;IAIzB,OAAO,CAAC,UAAU;CAGnB"}

package/dist/adapters/websocket/WebSocketTransportAdapter.js

@@ -1,386 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketTransportAdapter = void 0;
-const ws_1 = require("ws");
-class WebSocketTransportAdapter {
-    constructor(config) {
-        this.state = 'disconnected';
-        this.messageHandlers = new Set();
-        this.errorHandlers = new Set();
-        this.closeHandlers = new Set();
-        // Client management
-        this.clients = new Map();
-        this.mode = 'standalone';
-        this.config = {
-            authTimeout: config?.authTimeout ?? 5000,
-            closeOnAuthFailure: config?.closeOnAuthFailure ?? false,
-            requireAuth: config?.requireAuth ?? false,
-            ...config
-        };
-    }
-    // Set the auth adapter
-    setAuthAdapter(auth) {
-        this.authAdapter = auth;
-        // Use auth adapter's preference only if requireAuth is not already true
-        // This allows explicit requireAuth: true in config to take precedence
-        if (auth.isAuthRequired && !this.config.requireAuth) {
-            this.config.requireAuth = auth.isAuthRequired();
-        }
-        // For authTimeout, use adapter's value if not explicitly set (not matching default)
-        if (auth.getAuthTimeout && this.config.authTimeout === 5000) {
-            this.config.authTimeout = auth.getAuthTimeout();
-        }
-    }
-    // Standalone mode implementation
-    async connect(url, _options) {
-        if (this.state === 'connected' || this.state === 'connecting') {
-            throw new Error('Already connected or connecting');
-        }
-        this.state = 'connecting';
-        this.serverUrl = url;
-        this.mode = 'standalone';
-        try {
-            // Extract port from URL
-            const urlObj = new URL(url);
-            const port = parseInt(urlObj.port) || (urlObj.protocol === 'wss:' ? 443 : 80);
-            // Create WebSocket server
-            this.wss = new ws_1.WebSocketServer({ port });
-            this.wss.on('connection', (ws, req) => {
-                this.handleConnection(ws, req);
-            });
-            this.wss.on('error', (error) => {
-                this.errorHandlers.forEach(handler => handler(error));
-            });
-            this.wss.on('close', () => {
-                this.state = 'disconnected';
-                this.closeHandlers.forEach(handler => handler(1000, 'Server closed'));
-            });
-            this.state = 'connected';
-        }
-        catch (error) {
-            this.state = 'disconnected';
-            throw error;
-        }
-    }
-    // Integration mode implementation
-    async attach(server, path = '/ws') {
-        if (this.state === 'connected' || this.state === 'connecting') {
-            throw new Error('Already connected or connecting');
-        }
-        this.state = 'connecting';
-        this.attachedServer = server;
-        this.webSocketPath = path;
-        this.mode = 'integration';
-        try {
-            // Create WebSocket server attached to the existing HTTP server
-            this.wss = new ws_1.WebSocketServer({
-                server,
-                path,
-                perMessageDeflate: false
-            });
-            this.wss.on('connection', (ws, req) => {
-                this.handleConnection(ws, req);
-            });
-            this.wss.on('error', (error) => {
-                this.errorHandlers.forEach(handler => handler(error));
-            });
-            this.state = 'connected';
-        }
-        catch (error) {
-            this.state = 'disconnected';
-            throw error;
-        }
-    }
-    async attachToWebSocketServer(wss) {
-        if (this.state === 'connected' || this.state === 'connecting') {
-            throw new Error('Already connected or connecting');
-        }
-        this.state = 'connecting';
-        this.attachedWss = wss;
-        this.mode = 'integration';
-        try {
-            this.wss = wss;
-            this.wss.on('connection', (ws, req) => {
-                this.handleConnection(ws, req);
-            });
-            this.wss.on('error', (error) => {
-                this.errorHandlers.forEach(handler => handler(error));
-            });
-            this.state = 'connected';
-        }
-        catch (error) {
-            this.state = 'disconnected';
-            throw error;
-        }
-    }
-    async handleConnection(ws, req) {
-        const clientId = this.generateId();
-        // Step 1: Try header authentication if auth adapter is available
-        let authenticated = false;
-        let authResult = null;
-        if (this.authAdapter && req.headers.authorization) {
-            const token = this.extractBearerToken(req.headers.authorization);
-            if (token) {
-                try {
-                    authResult = await this.authAdapter.authenticate({
-                        type: 'bearer',
-                        token: token
-                    });
-                    authenticated = authResult.success;
-                }
-                catch {
-                    // Header auth failed but don't reject connection
-                }
-            }
-        }
-        // Step 2: Create client with auth state
-        const client = {
-            id: clientId,
-            ws,
-            authenticated,
-            userId: authResult?.userId || (authResult?.user?.userId),
-            metadata: authResult?.metadata || authResult?.user?.metadata,
-            connectedAt: Date.now()
-        };
-        this.clients.set(clientId, client);
-        // Step 3: Set up message handling
-        ws.on('message', (data) => {
-            this.handleClientMessage(clientId, data);
-        });
-        ws.on('error', (error) => {
-            this.errorHandlers.forEach(handler => handler(error));
-        });
-        ws.on('close', (_code, _reason) => {
-            // Clear auth timeout if exists
-            if (client.authTimeout) {
-                clearTimeout(client.authTimeout);
-            }
-            this.clients.delete(clientId);
-        });
-        // Step 4: Set auth timeout if not authenticated and auth is required
-        if (!authenticated && this.config.requireAuth && this.authAdapter) {
-            client.authTimeout = setTimeout(() => {
-                if (!client.authenticated) {
-                    ws.close(1008, 'Authentication timeout');
-                    this.clients.delete(clientId);
-                }
-            }, this.config.authTimeout);
-        }
-        // Step 5: Notify about connection (with auth status)
-        const connectionMessage = {
-            id: this.generateId(),
-            type: 'connection',
-            payload: {
-                clientId,
-                authenticated,
-                userId: client.userId,
-                metadata: client.metadata
-            },
-            timestamp: Date.now()
-        };
-        this.messageHandlers.forEach(handler => handler(connectionMessage));
-    }
-    async handleClientMessage(clientId, data) {
-        const client = this.clients.get(clientId);
-        if (!client)
-            return;
-        try {
-            const message = JSON.parse(data.toString());
-            // Special handling for authentication messages
-            if (message.type === 'authenticate' && !client.authenticated && this.authAdapter) {
-                await this.handleAuthMessage(client, message);
-                return;
-            }
-            // Reject messages from unauthenticated clients if auth is required
-            if (this.config.requireAuth && !client.authenticated) {
-                this.sendToClient(client, {
-                    id: this.generateId(),
-                    type: 'error',
-                    payload: { error: 'Authentication required' },
-                    timestamp: Date.now()
-                });
-                return;
-            }
-            // Add clientId to message payload for routing
-            const enrichedMessage = {
-                ...message,
-                payload: {
-                    ...message.payload,
-                    clientId
-                }
-            };
-            this.messageHandlers.forEach(handler => handler(enrichedMessage));
-        }
-        catch (error) {
-            this.errorHandlers.forEach(handler => handler(error));
-        }
-    }
-    async handleAuthMessage(client, message) {
-        if (!this.authAdapter) {
-            this.sendToClient(client, {
-                id: this.generateId(),
-                type: 'auth_error',
-                payload: { error: 'No auth adapter configured' },
-                timestamp: Date.now()
-            });
-            return;
-        }
-        try {
-            const credentials = message.payload;
-            const result = await this.authAdapter.authenticate(credentials);
-            if (result.success) {
-                // Clear auth timeout
-                if (client.authTimeout) {
-                    clearTimeout(client.authTimeout);
-                    client.authTimeout = undefined;
-                }
-                // Update client state
-                client.authenticated = true;
-                client.userId = result.userId || result.user?.userId;
-                client.metadata = result.metadata || result.user?.metadata;
-                // Send success response
-                this.sendToClient(client, {
-                    id: this.generateId(),
-                    type: 'auth_success',
-                    payload: {
-                        userId: client.userId,
-                        metadata: client.metadata
-                    },
-                    timestamp: Date.now()
-                });
-                // Notify handlers about authentication
-                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 {
-                // Send error response
-                this.sendToClient(client, {
-                    id: this.generateId(),
-                    type: 'auth_error',
-                    payload: { error: result.error || 'Authentication failed' },
-                    timestamp: Date.now()
-                });
-                // Optionally close connection
-                if (this.config.closeOnAuthFailure) {
-                    client.ws.close(1008, 'Authentication failed');
-                    this.clients.delete(client.id);
-                }
-            }
-        }
-        catch (error) {
-            this.sendToClient(client, {
-                id: this.generateId(),
-                type: 'auth_error',
-                payload: { error: error.message },
-                timestamp: Date.now()
-            });
-        }
-    }
-    extractBearerToken(authHeader) {
-        if (authHeader.startsWith('Bearer ')) {
-            return authHeader.substring(7);
-        }
-        return null;
-    }
-    sendToClient(client, message) {
-        if (client.ws.readyState === ws_1.WebSocket.OPEN) {
-            client.ws.send(JSON.stringify(message));
-        }
-    }
-    async disconnect() {
-        if (this.state === 'disconnected') {
-            return;
-        }
-        this.state = 'disconnecting';
-        // Close all client connections
-        for (const [_clientId, client] of this.clients) {
-            try {
-                if (client.authTimeout) {
-                    clearTimeout(client.authTimeout);
-                }
-                client.ws.close(1000, 'Server shutting down');
-            }
-            catch {
-                // Ignore errors when closing individual connections
-            }
-        }
-        this.clients.clear();
-        // Close the WebSocket server (only if we created it)
-        if (this.wss && this.mode === 'standalone') {
-            await new Promise((resolve) => {
-                this.wss.close(() => resolve());
-            });
-        }
-        this.state = 'disconnected';
-        this.wss = undefined;
-        this.attachedServer = undefined;
-        this.attachedWss = undefined;
-    }
-    async send(message) {
-        if (this.state !== 'connected') {
-            throw new Error('Not connected');
-        }
-        // Extract clientId from message payload for routing
-        const payload = message.payload;
-        const { clientId, ...clientMessage } = payload;
-        if (!clientId) {
-            throw new Error('Message must contain clientId in payload for routing');
-        }
-        const client = this.clients.get(clientId);
-        if (!client) {
-            throw new Error(`Client ${clientId} not found`);
-        }
-        if (client.ws.readyState !== ws_1.WebSocket.OPEN) {
-            throw new Error(`Client ${clientId} connection is not open`);
-        }
-        const messageToSend = {
-            ...message,
-            payload: clientMessage
-        };
-        client.ws.send(JSON.stringify(messageToSend));
-    }
-    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';
-    }
-    // Utility methods
-    getConnectedClients() {
-        return Array.from(this.clients.values());
-    }
-    getAuthenticatedClients() {
-        return Array.from(this.clients.values()).filter(c => c.authenticated);
-    }
-    getClientCount() {
-        return this.clients.size;
-    }
-    getMode() {
-        return this.mode;
-    }
-    isAuthRequired() {
-        return this.config.requireAuth ?? false;
-    }
-    generateId() {
-        return Math.random().toString(36).substring(2) + Date.now().toString(36);
-    }
-}
-exports.WebSocketTransportAdapter = WebSocketTransportAdapter;