agentic-qe 1.8.3 → 1.9.0

package/dist/visualization/api/WebSocketServer.d.ts

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview WebSocket server for real-time event streaming
+ * @module visualization/api/WebSocketServer
+ */
+import { EventEmitter } from 'events';
+import { EventStore } from '../../persistence/event-store';
+import { ReasoningStore } from '../../persistence/reasoning-store';
+import { RealtimeEventMessage, SubscriptionOptions } from '../types';
+import * as http from 'http';
+/**
+ * WebSocket server configuration
+ */
+export interface WebSocketServerConfig {
+    /** HTTP server to attach to */
+    server?: http.Server;
+    /** Port to listen on (if no server provided) */
+    port?: number;
+    /** Heartbeat interval in milliseconds */
+    heartbeatInterval?: number;
+    /** Client timeout in milliseconds */
+    clientTimeout?: number;
+    /** Maximum backlog size per client */
+    maxBacklogSize?: number;
+    /** Enable message compression */
+    compression?: boolean;
+}
+/**
+ * WebSocket server for real-time visualization event streaming
+ *
+ * Features:
+ * - Real-time event streaming with <500ms latency
+ * - Client subscription management with filtering
+ * - Backpressure handling for high-throughput scenarios
+ * - Automatic heartbeat and connection management
+ * - Message types: event, reasoning, metrics, heartbeat
+ *
+ * @example
+ * ```typescript
+ * const wsServer = new WebSocketServer(eventStore, reasoningStore, {
+ *   port: 8080,
+ *   heartbeatInterval: 30000,
+ *   maxBacklogSize: 1000
+ * });
+ *
+ * await wsServer.start();
+ *
+ * // Broadcast event to subscribed clients
+ * wsServer.broadcastEvent({
+ *   type: 'event',
+ *   timestamp: new Date().toISOString(),
+ *   data: { agent_id: 'test-gen', event_type: 'test_generated' }
+ * });
+ * ```
+ */
+export declare class WebSocketServer extends EventEmitter {
+    private clients;
+    private eventStore;
+    private reasoningStore;
+    private transformer;
+    private config;
+    private heartbeatTimer?;
+    private isRunning;
+    private messageQueue;
+    private wss?;
+    private httpServer?;
+    /**
+     * Default configuration
+     */
+    private static readonly DEFAULT_CONFIG;
+    constructor(eventStore: EventStore, reasoningStore: ReasoningStore, config?: WebSocketServerConfig);
+    /**
+     * Start the WebSocket server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the WebSocket server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle new WebSocket connection
+     */
+    private handleConnection;
+    /**
+     * Send initial data to newly connected client
+     */
+    private sendInitialData;
+    /**
+     * Handle incoming message from client
+     */
+    private handleMessage;
+    /**
+     * Handle client disconnection
+     */
+    private handleDisconnect;
+    /**
+     * Handle client error
+     */
+    private handleError;
+    /**
+     * Handle pong response (heartbeat)
+     */
+    private handlePong;
+    /**
+     * Disconnect a client
+     */
+    private disconnectClient;
+    /**
+     * Update client subscription
+     */
+    private updateSubscription;
+    /**
+     * Remove client subscription
+     */
+    private removeSubscription;
+    /**
+     * Broadcast event to all subscribed clients
+     * @param message - Event message to broadcast
+     */
+    broadcastEvent(message: RealtimeEventMessage): void;
+    /**
+     * Send message to specific client with backpressure handling
+     */
+    private sendMessage;
+    /**
+     * Flush message queue for a client
+     */
+    private flushMessageQueue;
+    /**
+     * Check if message should be sent to client based on subscriptions
+     */
+    private shouldSendToClient;
+    /**
+     * Start heartbeat timer
+     */
+    private startHeartbeat;
+    /**
+     * Stop heartbeat timer
+     */
+    private stopHeartbeat;
+    /**
+     * Generate unique client ID
+     */
+    private generateClientId;
+    /**
+     * Parse subscription options from URL query parameters
+     */
+    private parseSubscriptionOptions;
+    /**
+     * Get server statistics
+     */
+    getStatistics(): {
+        isRunning: boolean;
+        connectedClients: number;
+        totalMessagesSent: number;
+        averageQueueSize: number;
+    };
+    /**
+     * Get connected clients
+     */
+    getConnectedClients(): Array<{
+        id: string;
+        subscriptions: SubscriptionOptions;
+    }>;
+}
+//# sourceMappingURL=WebSocketServer.d.ts.map

package/dist/visualization/api/WebSocketServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketServer.d.ts","sourceRoot":"","sources":["../../../src/visualization/api/WebSocketServer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEnE,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAa7B;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,+BAA+B;IAC/B,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC;IACrB,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qCAAqC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iCAAiC;IACjC,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,YAAY,CAAsC;IAC1D,OAAO,CAAC,GAAG,CAAC,CAAW;IACvB,OAAO,CAAC,UAAU,CAAC,CAAc;IAEjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAOpC;gBAGA,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,cAAc,EAC9B,MAAM,GAAE,qBAA0B;IAYpC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAqD5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAqC3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuCxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAmCvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAkBnD;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8BzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAiCtB;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAchC;;OAEG;IACH,aAAa,IAAI;QACf,SAAS,EAAE,OAAO,CAAC;QACnB,gBAAgB,EAAE,MAAM,CAAC;QACzB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,gBAAgB,EAAE,MAAM,CAAC;KAC1B;IAcD;;OAEG;IACH,mBAAmB,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,mBAAmB,CAAA;KAAE,CAAC;CAMjF"}

package/dist/visualization/api/WebSocketServer.js

@@ -0,0 +1,518 @@
+"use strict";
+/**
+ * @fileoverview WebSocket server for real-time event streaming
+ * @module visualization/api/WebSocketServer
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServer = void 0;
+const events_1 = require("events");
+const DataTransformer_1 = require("../core/DataTransformer");
+const http = __importStar(require("http"));
+const ws_1 = require("ws");
+/**
+ * WebSocket server for real-time visualization event streaming
+ *
+ * Features:
+ * - Real-time event streaming with <500ms latency
+ * - Client subscription management with filtering
+ * - Backpressure handling for high-throughput scenarios
+ * - Automatic heartbeat and connection management
+ * - Message types: event, reasoning, metrics, heartbeat
+ *
+ * @example
+ * ```typescript
+ * const wsServer = new WebSocketServer(eventStore, reasoningStore, {
+ *   port: 8080,
+ *   heartbeatInterval: 30000,
+ *   maxBacklogSize: 1000
+ * });
+ *
+ * await wsServer.start();
+ *
+ * // Broadcast event to subscribed clients
+ * wsServer.broadcastEvent({
+ *   type: 'event',
+ *   timestamp: new Date().toISOString(),
+ *   data: { agent_id: 'test-gen', event_type: 'test_generated' }
+ * });
+ * ```
+ */
+class WebSocketServer extends events_1.EventEmitter {
+    constructor(eventStore, reasoningStore, config = {}) {
+        super();
+        this.eventStore = eventStore;
+        this.reasoningStore = reasoningStore;
+        this.transformer = new DataTransformer_1.DataTransformer(eventStore, reasoningStore);
+        this.config = { ...WebSocketServer.DEFAULT_CONFIG, ...config };
+        this.clients = new Map();
+        this.messageQueue = new Map();
+        this.isRunning = false;
+    }
+    /**
+     * Start the WebSocket server
+     */
+    async start() {
+        if (this.isRunning) {
+            throw new Error('WebSocket server is already running');
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                // Create HTTP server if not provided
+                this.httpServer = this.config.server || http.createServer();
+                // Create WebSocket server
+                this.wss = new ws_1.WebSocketServer({
+                    server: this.httpServer,
+                    perMessageDeflate: this.config.compression,
+                });
+                // Handle WebSocket connections
+                this.wss.on('connection', (socket, req) => {
+                    this.handleConnection(socket, req);
+                });
+                // Handle WebSocket server errors
+                this.wss.on('error', (error) => {
+                    this.emit('error', { error: error.message, source: 'wss' });
+                });
+                // Start HTTP server if we created it
+                if (!this.config.server) {
+                    this.httpServer.listen(this.config.port, () => {
+                        console.log(`WebSocket server listening on port ${this.config.port}`);
+                        this.startHeartbeat();
+                        this.isRunning = true;
+                        this.emit('started', { port: this.config.port });
+                        resolve();
+                    });
+                    this.httpServer.on('error', (error) => {
+                        this.emit('error', { error: error.message, source: 'http' });
+                        reject(error);
+                    });
+                }
+                else {
+                    // Server already listening, just start heartbeat
+                    this.startHeartbeat();
+                    this.isRunning = true;
+                    this.emit('started', { port: this.config.port });
+                    resolve();
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Stop the WebSocket server
+     */
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.stopHeartbeat();
+        // Close all client connections
+        for (const client of this.clients.values()) {
+            this.disconnectClient(client.id, 'Server shutting down');
+        }
+        // Close WebSocket server
+        return new Promise((resolve) => {
+            if (this.wss) {
+                this.wss.close(() => {
+                    // Close HTTP server if we created it
+                    if (this.httpServer && !this.config.server) {
+                        this.httpServer.close(() => {
+                            this.isRunning = false;
+                            this.emit('stopped');
+                            resolve();
+                        });
+                    }
+                    else {
+                        this.isRunning = false;
+                        this.emit('stopped');
+                        resolve();
+                    }
+                });
+            }
+            else {
+                this.isRunning = false;
+                this.emit('stopped');
+                resolve();
+            }
+        });
+    }
+    /**
+     * Handle new WebSocket connection
+     */
+    handleConnection(socket, request) {
+        const clientId = this.generateClientId();
+        const client = {
+            id: clientId,
+            socket,
+            subscriptions: this.parseSubscriptionOptions(request.url),
+            lastHeartbeat: Date.now(),
+        };
+        this.clients.set(clientId, client);
+        this.messageQueue.set(clientId, []);
+        // Setup WebSocket event handlers
+        socket.on('message', (data) => {
+            try {
+                this.handleMessage(clientId, data);
+            }
+            catch (error) {
+                this.emit('error', { clientId, error, source: 'message_handler' });
+            }
+        });
+        socket.on('close', () => {
+            this.handleDisconnect(clientId);
+        });
+        socket.on('error', (error) => {
+            this.handleError(clientId, error);
+        });
+        socket.on('pong', () => {
+            this.handlePong(clientId);
+        });
+        this.emit('client_connected', { clientId, subscriptions: client.subscriptions });
+        // Send initial data based on subscriptions
+        this.sendInitialData(client);
+    }
+    /**
+     * Send initial data to newly connected client
+     */
+    sendInitialData(client) {
+        const { session_id, agent_id, since } = client.subscriptions;
+        // Send recent events
+        if (session_id) {
+            const events = this.eventStore.getEventsBySession(session_id);
+            const filteredEvents = since
+                ? events.filter(e => e.timestamp >= since)
+                : events.slice(-50); // Last 50 events
+            for (const event of filteredEvents) {
+                this.sendMessage(client.id, {
+                    type: 'event',
+                    timestamp: event.timestamp,
+                    data: event,
+                });
+            }
+        }
+        // Send reasoning chains
+        if (session_id) {
+            const chains = this.reasoningStore.getChainsBySession(session_id, { limit: 10 });
+            for (const chain of chains) {
+                const tree = this.transformer.buildReasoningTree(chain.id);
+                if (tree) {
+                    this.sendMessage(client.id, {
+                        type: 'reasoning',
+                        timestamp: chain.created_at,
+                        data: tree,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Handle incoming message from client
+     */
+    handleMessage(clientId, data) {
+        try {
+            const message = JSON.parse(data.toString());
+            if (message.type === 'subscribe') {
+                this.updateSubscription(clientId, message.options);
+            }
+            else if (message.type === 'unsubscribe') {
+                this.removeSubscription(clientId);
+            }
+            else if (message.type === 'ping') {
+                this.sendMessage(clientId, {
+                    type: 'heartbeat',
+                    timestamp: new Date().toISOString(),
+                    data: { status: 'pong' },
+                });
+            }
+        }
+        catch (error) {
+            this.emit('error', { clientId, error });
+        }
+    }
+    /**
+     * Handle client disconnection
+     */
+    handleDisconnect(clientId) {
+        this.disconnectClient(clientId, 'Client disconnected');
+    }
+    /**
+     * Handle client error
+     */
+    handleError(clientId, error) {
+        this.emit('error', { clientId, error });
+        this.disconnectClient(clientId, `Error: ${error.message}`);
+    }
+    /**
+     * Handle pong response (heartbeat)
+     */
+    handlePong(clientId) {
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.lastHeartbeat = Date.now();
+        }
+    }
+    /**
+     * Disconnect a client
+     */
+    disconnectClient(clientId, reason) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        try {
+            // Close the WebSocket connection
+            if (client.socket.readyState === ws_1.WebSocket.OPEN || client.socket.readyState === ws_1.WebSocket.CONNECTING) {
+                client.socket.close(1000, reason);
+            }
+        }
+        catch (error) {
+            this.emit('error', { clientId, error, source: 'disconnect' });
+        }
+        this.clients.delete(clientId);
+        this.messageQueue.delete(clientId);
+        this.emit('client_disconnected', { clientId, reason });
+    }
+    /**
+     * Update client subscription
+     */
+    updateSubscription(clientId, options) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        client.subscriptions = { ...client.subscriptions, ...options };
+        this.emit('subscription_updated', { clientId, subscriptions: client.subscriptions });
+    }
+    /**
+     * Remove client subscription
+     */
+    removeSubscription(clientId) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        client.subscriptions = {};
+        this.emit('subscription_removed', { clientId });
+    }
+    /**
+     * Broadcast event to all subscribed clients
+     * @param message - Event message to broadcast
+     */
+    broadcastEvent(message) {
+        const startTime = Date.now();
+        for (const client of this.clients.values()) {
+            if (this.shouldSendToClient(client, message)) {
+                this.sendMessage(client.id, message);
+            }
+        }
+        const latency = Date.now() - startTime;
+        this.emit('broadcast_complete', { latency, clientCount: this.clients.size });
+        // Emit warning if latency exceeds 500ms threshold
+        if (latency > 500) {
+            this.emit('latency_warning', { latency, threshold: 500 });
+        }
+    }
+    /**
+     * Send message to specific client with backpressure handling
+     */
+    sendMessage(clientId, message) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        const queue = this.messageQueue.get(clientId);
+        // Check backlog size
+        if (queue.length >= this.config.maxBacklogSize) {
+            // Drop oldest message (FIFO)
+            queue.shift();
+            this.emit('backpressure', { clientId, queueSize: queue.length });
+        }
+        queue.push(message);
+        // Attempt to flush queue
+        this.flushMessageQueue(clientId);
+    }
+    /**
+     * Flush message queue for a client
+     */
+    flushMessageQueue(clientId) {
+        const client = this.clients.get(clientId);
+        const queue = this.messageQueue.get(clientId);
+        if (!client || !queue)
+            return;
+        while (queue.length > 0) {
+            const message = queue[0];
+            // Check if socket is open
+            if (client.socket.readyState !== ws_1.WebSocket.OPEN) {
+                break;
+            }
+            // Check for backpressure (buffered data)
+            if (client.socket.bufferedAmount > 0) {
+                // Socket buffer is full, wait for next flush
+                break;
+            }
+            // Send message
+            try {
+                client.socket.send(JSON.stringify(message));
+                queue.shift();
+            }
+            catch (error) {
+                this.emit('send_error', { clientId, error });
+                break;
+            }
+        }
+    }
+    /**
+     * Check if message should be sent to client based on subscriptions
+     */
+    shouldSendToClient(client, message) {
+        const { session_id, agent_id, event_types, since } = client.subscriptions;
+        // Check timestamp filter
+        if (since && message.timestamp < since) {
+            return false;
+        }
+        // Check event-specific filters
+        if (message.type === 'event') {
+            const eventData = message.data;
+            if (session_id && eventData.session_id !== session_id) {
+                return false;
+            }
+            if (agent_id && eventData.agent_id !== agent_id) {
+                return false;
+            }
+            if (event_types && eventData.event_type && !event_types.includes(eventData.event_type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Start heartbeat timer
+     */
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            const now = Date.now();
+            for (const client of this.clients.values()) {
+                // Check for timeout
+                if (now - client.lastHeartbeat > this.config.clientTimeout) {
+                    this.disconnectClient(client.id, 'Heartbeat timeout');
+                    continue;
+                }
+                // Send WebSocket ping frame
+                try {
+                    if (client.socket.readyState === ws_1.WebSocket.OPEN) {
+                        client.socket.ping();
+                    }
+                }
+                catch (error) {
+                    this.emit('error', { clientId: client.id, error, source: 'ping' });
+                }
+                // Send heartbeat message
+                this.sendMessage(client.id, {
+                    type: 'heartbeat',
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        connected_clients: this.clients.size,
+                        uptime_ms: now - (client.lastHeartbeat - this.config.heartbeatInterval),
+                    },
+                });
+            }
+        }, this.config.heartbeatInterval);
+    }
+    /**
+     * Stop heartbeat timer
+     */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+    }
+    /**
+     * Generate unique client ID
+     */
+    generateClientId() {
+        return `client-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Parse subscription options from URL query parameters
+     */
+    parseSubscriptionOptions(url) {
+        if (!url)
+            return {};
+        const urlObj = new URL(url, 'http://localhost');
+        const params = urlObj.searchParams;
+        return {
+            session_id: params.get('session_id') || undefined,
+            agent_id: params.get('agent_id') || undefined,
+            event_types: params.get('event_types')?.split(','),
+            since: params.get('since') || undefined,
+        };
+    }
+    /**
+     * Get server statistics
+     */
+    getStatistics() {
+        let totalQueueSize = 0;
+        for (const queue of this.messageQueue.values()) {
+            totalQueueSize += queue.length;
+        }
+        return {
+            isRunning: this.isRunning,
+            connectedClients: this.clients.size,
+            totalMessagesSent: 0, // Would track in real implementation
+            averageQueueSize: this.clients.size > 0 ? totalQueueSize / this.clients.size : 0,
+        };
+    }
+    /**
+     * Get connected clients
+     */
+    getConnectedClients() {
+        return Array.from(this.clients.values()).map(client => ({
+            id: client.id,
+            subscriptions: client.subscriptions,
+        }));
+    }
+}
+exports.WebSocketServer = WebSocketServer;
+/**
+ * Default configuration
+ */
+WebSocketServer.DEFAULT_CONFIG = {
+    server: undefined,
+    port: 8080,
+    heartbeatInterval: 30000, // 30 seconds
+    clientTimeout: 60000, // 60 seconds
+    maxBacklogSize: 1000,
+    compression: true,
+};
+//# sourceMappingURL=WebSocketServer.js.map