chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/proxy/server/ConnectionPool.js

@@ -0,0 +1,430 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionPool = void 0;
+const ws_1 = __importDefault(require("ws"));
+const ConnectionManager_1 = require("../../connection/ConnectionManager");
+const logger_1 = require("../../utils/logger");
+class ConnectionPool {
+    constructor(eventMonitor, messageStore, config) {
+        this.connections = new Map();
+        this.connectionsByKey = new Map();
+        this.reconnectionAttempts = new Map();
+        this.reconnectionTimers = new Map();
+        this.connectionManager = new ConnectionManager_1.ConnectionManager();
+        this.logger = (0, logger_1.createLogger)({ component: 'ConnectionPool' });
+        this.eventMonitor = eventMonitor;
+        this.messageStore = messageStore;
+        this.config = {
+            reconnectMaxAttempts: 5,
+            reconnectBackoffMs: 1000,
+            ...config
+        };
+    }
+    async getOrCreateConnection(host, port, targetId) {
+        try {
+            const targets = await this.connectionManager.discoverTargets(host, port);
+            if (targets.length === 0) {
+                throw new Error(`No Chrome targets found at ${host}:${port}`);
+            }
+            let target;
+            if (targetId) {
+                const foundTarget = targets.find(t => t.id === targetId);
+                if (!foundTarget) {
+                    throw new Error(`Target ${targetId} not found`);
+                }
+                target = foundTarget;
+            }
+            else {
+                const pageTarget = targets.find(t => t.type === 'page');
+                if (!pageTarget) {
+                    throw new Error('No page targets available');
+                }
+                target = pageTarget;
+            }
+            const connectionKey = this.createConnectionKey(host, port, target.id);
+            const existingConnectionId = this.connectionsByKey.get(connectionKey);
+            if (existingConnectionId) {
+                const existingConnection = this.connections.get(existingConnectionId);
+                if (existingConnection && existingConnection.isHealthy) {
+                    existingConnection.lastUsed = Date.now();
+                    existingConnection.clientCount++;
+                    this.logger.logConnectionEvent('established', existingConnectionId, `Reusing existing connection for ${connectionKey}`, {
+                        connectionKey,
+                        clientCount: existingConnection.clientCount,
+                        target: {
+                            id: target.id,
+                            title: target.title,
+                            url: target.url
+                        }
+                    });
+                    return existingConnection;
+                }
+                else {
+                    if (existingConnection) {
+                        await this.closeConnection(existingConnectionId);
+                    }
+                }
+            }
+            const connectionId = this.generateConnectionId();
+            const wsUrl = target.webSocketDebuggerUrl;
+            if (!wsUrl) {
+                throw new Error(`No WebSocket URL available for target ${target.id}`);
+            }
+            this.logger.logConnectionEvent('established', connectionId, `Creating new CDP connection to ${wsUrl}`, {
+                connectionKey,
+                wsUrl,
+                target: {
+                    id: target.id,
+                    title: target.title,
+                    url: target.url,
+                    type: target.type
+                }
+            });
+            const ws = new ws_1.default(wsUrl);
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Connection timeout'));
+                }, 10000);
+                ws.on('open', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                ws.on('error', (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+            });
+            const connectionInfo = {
+                id: connectionId,
+                host,
+                port,
+                targetId: target.id,
+                wsUrl,
+                connection: ws,
+                createdAt: Date.now(),
+                lastUsed: Date.now(),
+                isHealthy: true,
+                clientCount: 1
+            };
+            this.connections.set(connectionId, connectionInfo);
+            this.connectionsByKey.set(connectionKey, connectionId);
+            this.setupConnectionHandlers(connectionInfo);
+            if (this.eventMonitor) {
+                try {
+                    await this.eventMonitor.startMonitoring(connectionInfo);
+                }
+                catch (error) {
+                    this.logger.logConnectionEvent('established', connectionId, 'Failed to start event monitoring', { connectionKey }, error);
+                }
+            }
+            this.logger.logConnectionEvent('established', connectionId, 'CDP connection established successfully', {
+                connectionKey,
+                clientCount: connectionInfo.clientCount,
+                monitoringEnabled: !!this.eventMonitor
+            });
+            return connectionInfo;
+        }
+        catch (error) {
+            const errorConnectionId = 'unknown';
+            const errorConnectionKey = `${host}:${port}:${targetId}`;
+            this.logger.logConnectionEvent('established', errorConnectionId, `Failed to create connection for ${host}:${port}:${targetId}`, { connectionKey: errorConnectionKey, host, port, targetId }, error);
+            throw error;
+        }
+    }
+    async closeConnection(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (!connection) {
+            this.logger.warn(`Connection ${connectionId} not found for closing`);
+            return;
+        }
+        try {
+            this.logger.info(`Closing CDP connection ${connectionId}`);
+            this.reconnectionAttempts.delete(connectionId);
+            this.clearReconnectionTimer(connectionId);
+            if (this.eventMonitor) {
+                await this.eventMonitor.stopMonitoring(connectionId);
+            }
+            if (this.messageStore) {
+                this.messageStore.cleanupConnection(connectionId);
+            }
+            if (connection.connection.readyState === ws_1.default.OPEN) {
+                connection.connection.close();
+            }
+            const connectionKey = this.createConnectionKey(connection.host, connection.port, connection.targetId);
+            this.connections.delete(connectionId);
+            this.connectionsByKey.delete(connectionKey);
+            this.logger.info(`CDP connection ${connectionId} closed successfully`);
+        }
+        catch (error) {
+            this.logger.error(`Error closing connection ${connectionId}:`, error);
+        }
+    }
+    async healthCheck(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (!connection) {
+            return false;
+        }
+        try {
+            if (connection.connection.readyState !== ws_1.default.OPEN) {
+                connection.isHealthy = false;
+                return false;
+            }
+            const messageId = Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 1000);
+            const testMessage = {
+                id: messageId,
+                method: 'Runtime.evaluate',
+                params: { expression: '1+1' }
+            };
+            const healthCheckPromise = new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    resolve(false);
+                }, 5000);
+                const messageHandler = (data) => {
+                    try {
+                        const response = JSON.parse(data.toString());
+                        if (response.id === testMessage.id) {
+                            clearTimeout(timeout);
+                            connection.connection.off('message', messageHandler);
+                            resolve(response.result && !response.error);
+                        }
+                    }
+                    catch (error) {
+                    }
+                };
+                connection.connection.on('message', messageHandler);
+                connection.connection.send(JSON.stringify(testMessage));
+            });
+            const isHealthy = await healthCheckPromise;
+            connection.isHealthy = isHealthy;
+            if (!isHealthy) {
+                this.logger.warn(`Health check failed for connection ${connectionId}`);
+            }
+            return isHealthy;
+        }
+        catch (error) {
+            this.logger.error(`Health check error for connection ${connectionId}:`, error);
+            connection.isHealthy = false;
+            return false;
+        }
+    }
+    async reconnect(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (!connection) {
+            this.logger.warn(`Cannot reconnect: connection ${connectionId} not found`);
+            return false;
+        }
+        const currentAttempts = this.reconnectionAttempts.get(connectionId) || 0;
+        const maxAttempts = this.config.reconnectMaxAttempts || 5;
+        if (currentAttempts >= maxAttempts) {
+            this.logger.error(`Maximum reconnection attempts (${maxAttempts}) exceeded for connection ${connectionId}`);
+            await this.handleReconnectionFailure(connectionId);
+            return false;
+        }
+        this.reconnectionAttempts.set(connectionId, currentAttempts + 1);
+        try {
+            this.logger.info(`Attempting reconnection ${currentAttempts + 1}/${maxAttempts} for connection ${connectionId}`);
+            const baseDelay = this.config.reconnectBackoffMs || 1000;
+            const delay = baseDelay * Math.pow(2, currentAttempts);
+            const jitter = Math.random() * 0.1 * delay;
+            const totalDelay = delay + jitter;
+            this.logger.debug(`Waiting ${Math.round(totalDelay)}ms before reconnection attempt`);
+            await new Promise(resolve => setTimeout(resolve, totalDelay));
+            const preservedData = this.preserveConnectionData(connectionId);
+            await this.closeExistingConnection(connection);
+            const success = await this.establishNewConnection(connection);
+            if (success) {
+                await this.restoreConnectionData(connectionId, preservedData);
+                this.reconnectionAttempts.delete(connectionId);
+                this.clearReconnectionTimer(connectionId);
+                this.logger.info(`Connection ${connectionId} reconnected successfully after ${currentAttempts + 1} attempts`);
+                return true;
+            }
+            else {
+                this.scheduleReconnectionAttempt(connectionId);
+                return false;
+            }
+        }
+        catch (error) {
+            this.logger.error(`Reconnection attempt ${currentAttempts + 1} failed for connection ${connectionId}:`, error);
+            connection.isHealthy = false;
+            this.scheduleReconnectionAttempt(connectionId);
+            return false;
+        }
+    }
+    scheduleReconnectionAttempt(connectionId) {
+        this.clearReconnectionTimer(connectionId);
+        const currentAttempts = this.reconnectionAttempts.get(connectionId) || 0;
+        const maxAttempts = this.config.reconnectMaxAttempts || 5;
+        if (currentAttempts < maxAttempts) {
+            const baseDelay = this.config.reconnectBackoffMs || 1000;
+            const delay = baseDelay * Math.pow(2, currentAttempts);
+            this.logger.debug(`Scheduling next reconnection attempt for connection ${connectionId} in ${delay}ms`);
+            const timer = setTimeout(async () => {
+                await this.reconnect(connectionId);
+            }, delay);
+            this.reconnectionTimers.set(connectionId, timer);
+        }
+        else {
+            this.logger.error(`All reconnection attempts exhausted for connection ${connectionId}`);
+            this.handleReconnectionFailure(connectionId);
+        }
+    }
+    preserveConnectionData(connectionId) {
+        const preservedData = {};
+        if (this.messageStore) {
+            try {
+                preservedData.consoleMessages = this.messageStore.getConsoleMessages(connectionId);
+                preservedData.networkRequests = this.messageStore.getNetworkRequests(connectionId);
+                this.logger.debug(`Preserved ${preservedData.consoleMessages.length} console messages and ${preservedData.networkRequests.length} network requests for connection ${connectionId}`);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to preserve data for connection ${connectionId}:`, error);
+            }
+        }
+        return preservedData;
+    }
+    async restoreConnectionData(connectionId, preservedData) {
+        if (!this.messageStore || !preservedData) {
+            return;
+        }
+        try {
+            this.logger.debug(`Data preservation verified for connection ${connectionId}`);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to restore data for connection ${connectionId}:`, error);
+        }
+    }
+    async closeExistingConnection(connection) {
+        try {
+            if (connection.connection.readyState === ws_1.default.OPEN) {
+                connection.connection.close(1000, 'Reconnecting');
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        catch (error) {
+            this.logger.warn(`Error during graceful connection closure:`, error);
+        }
+    }
+    async establishNewConnection(connection) {
+        try {
+            const ws = new ws_1.default(connection.wsUrl);
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Reconnection timeout after 10 seconds'));
+                }, 10000);
+                ws.on('open', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                ws.on('error', (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+            });
+            connection.connection = ws;
+            connection.isHealthy = true;
+            connection.lastUsed = Date.now();
+            this.setupConnectionHandlers(connection);
+            if (this.eventMonitor) {
+                try {
+                    await this.eventMonitor.startMonitoring(connection);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to restart event monitoring for connection ${connection.id}:`, error);
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Failed to establish new connection:`, error);
+            connection.isHealthy = false;
+            return false;
+        }
+    }
+    async handleReconnectionFailure(connectionId) {
+        this.logger.error(`Reconnection failed permanently for connection ${connectionId}, cleaning up`);
+        this.reconnectionAttempts.delete(connectionId);
+        this.clearReconnectionTimer(connectionId);
+        const connection = this.connections.get(connectionId);
+        if (connection) {
+            connection.isHealthy = false;
+        }
+    }
+    clearReconnectionTimer(connectionId) {
+        const timer = this.reconnectionTimers.get(connectionId);
+        if (timer) {
+            clearTimeout(timer);
+            this.reconnectionTimers.delete(connectionId);
+        }
+    }
+    getReconnectionStatus(connectionId) {
+        return {
+            isReconnecting: this.reconnectionTimers.has(connectionId),
+            attempts: this.reconnectionAttempts.get(connectionId) || 0,
+            maxAttempts: this.config.reconnectMaxAttempts || 5
+        };
+    }
+    getConnectionInfo(connectionId) {
+        return this.connections.get(connectionId) || null;
+    }
+    getAllConnections() {
+        return Array.from(this.connections.values());
+    }
+    async cleanupUnusedConnections(maxIdleTime) {
+        const now = Date.now();
+        const connectionsToClose = [];
+        for (const [connectionId, connection] of Array.from(this.connections.entries())) {
+            if (connection.clientCount === 0 && (now - connection.lastUsed) > maxIdleTime) {
+                connectionsToClose.push(connectionId);
+            }
+        }
+        for (const connectionId of connectionsToClose) {
+            this.logger.info(`Cleaning up unused connection ${connectionId}`);
+            await this.closeConnection(connectionId);
+        }
+    }
+    decrementClientCount(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (connection && connection.clientCount > 0) {
+            connection.clientCount--;
+            connection.lastUsed = Date.now();
+        }
+    }
+    setupConnectionHandlers(connectionInfo) {
+        const { connection, id } = connectionInfo;
+        connection.on('close', () => {
+            this.logger.warn(`CDP connection ${id} closed unexpectedly`);
+            connectionInfo.isHealthy = false;
+        });
+        connection.on('error', (error) => {
+            this.logger.error(`CDP connection ${id} error:`, error);
+            connectionInfo.isHealthy = false;
+        });
+    }
+    createConnectionKey(host, port, targetId) {
+        return `${host}:${port}:${targetId}`;
+    }
+    generateConnectionId() {
+        return `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    cleanup() {
+        this.logger.info('Cleaning up ConnectionPool resources');
+        for (const timer of this.reconnectionTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.reconnectionTimers.clear();
+        this.reconnectionAttempts.clear();
+        this.logger.debug('ConnectionPool cleanup completed');
+    }
+    getAllReconnectionStatuses() {
+        const statuses = new Map();
+        for (const connectionId of this.connections.keys()) {
+            statuses.set(connectionId, this.getReconnectionStatus(connectionId));
+        }
+        return statuses;
+    }
+}
+exports.ConnectionPool = ConnectionPool;