chrome-cdp-cli 1.5.0 → 1.7.0

package/dist/proxy/server/CommandExecutionService.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandExecutionService = void 0;
+const logger_1 = require("../../utils/logger");
+class CommandExecutionService {
+    constructor(connectionPool) {
+        this.pendingCommands = new Map();
+        this.commandMetrics = {
+            totalCommands: 0,
+            successfulCommands: 0,
+            failedCommands: 0,
+            averageExecutionTime: 0,
+            timeoutCount: 0
+        };
+        this.messageHandlers = new Map();
+        this.activeCLIClient = null;
+        this.connectionPool = connectionPool;
+        this.logger = (0, logger_1.createLogger)({ component: 'CommandExecutionService' });
+    }
+    async executeCommand(request, clientId) {
+        const startTime = Date.now();
+        const commandId = this.generateCommandId();
+        const timeout = request.timeout || 30000;
+        try {
+            if (this.activeCLIClient && clientId && this.activeCLIClient !== clientId) {
+                throw new Error('Another CLI client is already connected. Only one CLI client can use the proxy at a time.');
+            }
+            if (clientId && !this.activeCLIClient) {
+                this.activeCLIClient = clientId;
+                this.logger.info(`CLI client ${clientId} is now the active client`);
+            }
+            const connection = this.connectionPool.getConnectionInfo(request.connectionId);
+            if (!connection) {
+                throw new Error(`Connection ${request.connectionId} not found`);
+            }
+            if (!connection.isHealthy) {
+                throw new Error(`Connection ${request.connectionId} is not healthy`);
+            }
+            this.logger.debug(`Executing CDP command: ${request.command.method}`, {
+                connectionId: request.connectionId,
+                commandId,
+                method: request.command.method,
+                timeout,
+                clientId: clientId || 'unknown'
+            });
+            const cdpMessage = {
+                id: typeof request.command.id === 'number' ? request.command.id : this.generateCDPMessageId(),
+                method: request.command.method,
+                params: request.command.params
+            };
+            const result = await this.sendCDPCommand(request.connectionId, cdpMessage, timeout);
+            const executionTime = Date.now() - startTime;
+            this.updateMetrics(true, executionTime);
+            this.logger.debug(`CDP command executed successfully: ${request.command.method}`, {
+                connectionId: request.connectionId,
+                commandId,
+                executionTime,
+                clientId: clientId || 'unknown'
+            });
+            return {
+                success: true,
+                result,
+                executionTime
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            this.updateMetrics(false, executionTime);
+            this.logger.error(`CDP command execution failed: ${request.command.method}`, {
+                connectionId: request.connectionId,
+                commandId,
+                executionTime,
+                clientId: clientId || 'unknown',
+                error: error instanceof Error ? error.message : String(error)
+            });
+            let errorCode = 500;
+            let errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (errorMessage.includes('Another CLI client')) {
+                errorCode = 409;
+            }
+            else if (errorMessage.includes('timeout')) {
+                errorCode = 408;
+                this.commandMetrics.timeoutCount++;
+            }
+            else if (errorMessage.includes('not found')) {
+                errorCode = 404;
+            }
+            else if (errorMessage.includes('not healthy')) {
+                errorCode = 503;
+            }
+            return {
+                success: false,
+                error: {
+                    code: errorCode,
+                    message: errorMessage
+                },
+                executionTime
+            };
+        }
+    }
+    async sendCDPCommand(connectionId, command, timeout) {
+        const connection = this.connectionPool.getConnectionInfo(connectionId);
+        if (!connection) {
+            throw new Error(`Connection ${connectionId} not found`);
+        }
+        return new Promise((resolve, reject) => {
+            const commandKey = `${connectionId}:${command.id}`;
+            const pendingCommand = {
+                id: commandKey,
+                connectionId,
+                command,
+                timestamp: Date.now(),
+                timeout,
+                resolve,
+                reject
+            };
+            this.pendingCommands.set(commandKey, pendingCommand);
+            this.setupMessageHandler(connectionId);
+            const timeoutHandle = setTimeout(() => {
+                if (this.pendingCommands.has(commandKey)) {
+                    this.pendingCommands.delete(commandKey);
+                    reject(new Error(`Command timeout after ${timeout}ms: ${command.method}`));
+                }
+            }, timeout);
+            pendingCommand.resolve = (value) => {
+                clearTimeout(timeoutHandle);
+                resolve(value);
+            };
+            pendingCommand.reject = (error) => {
+                clearTimeout(timeoutHandle);
+                reject(error);
+            };
+            try {
+                const messageStr = JSON.stringify(command);
+                connection.connection.send(messageStr);
+                this.logger.debug(`Sent CDP command to Chrome: ${command.method}`, {
+                    connectionId,
+                    commandId: command.id,
+                    messageLength: messageStr.length
+                });
+            }
+            catch (error) {
+                clearTimeout(timeoutHandle);
+                this.pendingCommands.delete(commandKey);
+                reject(new Error(`Failed to send command: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+    }
+    setupMessageHandler(connectionId) {
+        if (this.messageHandlers.has(connectionId)) {
+            return;
+        }
+        const connection = this.connectionPool.getConnectionInfo(connectionId);
+        if (!connection) {
+            return;
+        }
+        const messageHandler = (data) => {
+            try {
+                const message = data.toString();
+                let cdpResponse;
+                try {
+                    cdpResponse = JSON.parse(message);
+                }
+                catch (parseError) {
+                    this.logger.warn(`Invalid JSON from CDP connection ${connectionId}: ${message.substring(0, 100)}`);
+                    return;
+                }
+                if (typeof cdpResponse.id === 'undefined') {
+                    return;
+                }
+                const commandKey = `${connectionId}:${cdpResponse.id}`;
+                const pendingCommand = this.pendingCommands.get(commandKey);
+                if (pendingCommand) {
+                    this.pendingCommands.delete(commandKey);
+                    this.logger.debug(`Received CDP response for command: ${pendingCommand.command.method}`, {
+                        connectionId,
+                        commandId: cdpResponse.id,
+                        hasResult: !!cdpResponse.result,
+                        hasError: !!cdpResponse.error
+                    });
+                    if (cdpResponse.error) {
+                        pendingCommand.reject(new Error(`CDP Error: ${cdpResponse.error.message} (Code: ${cdpResponse.error.code})`));
+                    }
+                    else {
+                        pendingCommand.resolve(cdpResponse.result);
+                    }
+                }
+                else {
+                    this.logger.debug(`Received CDP response for unknown command ID: ${cdpResponse.id}`, {
+                        connectionId
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error handling CDP message for connection ${connectionId}:`, error);
+            }
+        };
+        connection.connection.on('message', messageHandler);
+        this.messageHandlers.set(connectionId, messageHandler);
+        this.logger.debug(`Set up message handler for connection: ${connectionId}`);
+        connection.connection.on('close', () => {
+            this.cleanupMessageHandler(connectionId);
+        });
+    }
+    cleanupMessageHandler(connectionId) {
+        const handler = this.messageHandlers.get(connectionId);
+        if (handler) {
+            const connection = this.connectionPool.getConnectionInfo(connectionId);
+            if (connection) {
+                connection.connection.off('message', handler);
+            }
+            this.messageHandlers.delete(connectionId);
+            this.logger.debug(`Cleaned up message handler for connection: ${connectionId}`);
+        }
+        const commandsToCleanup = [];
+        for (const [, pendingCommand] of this.pendingCommands.entries()) {
+            if (pendingCommand.connectionId === connectionId) {
+                commandsToCleanup.push(pendingCommand.id);
+                pendingCommand.reject(new Error('Connection closed'));
+            }
+        }
+        for (const commandKey of commandsToCleanup) {
+            this.pendingCommands.delete(commandKey);
+        }
+        if (commandsToCleanup.length > 0) {
+            this.logger.debug(`Cleaned up ${commandsToCleanup.length} pending commands for connection: ${connectionId}`);
+        }
+    }
+    getMetrics() {
+        return { ...this.commandMetrics };
+    }
+    getPendingCommandsCount() {
+        return this.pendingCommands.size;
+    }
+    getPendingCommandsForConnection(connectionId) {
+        let count = 0;
+        for (const pendingCommand of this.pendingCommands.values()) {
+            if (pendingCommand.connectionId === connectionId) {
+                count++;
+            }
+        }
+        return count;
+    }
+    setActiveCLIClient(clientId) {
+        if (this.activeCLIClient && this.activeCLIClient !== clientId) {
+            this.logger.warn(`Replacing active CLI client ${this.activeCLIClient} with ${clientId}`);
+        }
+        this.activeCLIClient = clientId;
+        this.logger.info(`CLI client ${clientId} is now the active client`);
+    }
+    releaseActiveCLIClient(clientId) {
+        if (clientId && this.activeCLIClient !== clientId) {
+            this.logger.warn(`Attempted to release CLI client ${clientId}, but active client is ${this.activeCLIClient}`);
+            return;
+        }
+        const previousClient = this.activeCLIClient;
+        this.activeCLIClient = null;
+        if (previousClient) {
+            this.logger.info(`Released active CLI client: ${previousClient}`);
+        }
+    }
+    getActiveCLIClient() {
+        return this.activeCLIClient;
+    }
+    hasActiveCLIClient() {
+        return this.activeCLIClient !== null;
+    }
+    cleanup() {
+        for (const [, pendingCommand] of this.pendingCommands.entries()) {
+            pendingCommand.reject(new Error('Service shutting down'));
+        }
+        this.pendingCommands.clear();
+        for (const connectionId of this.messageHandlers.keys()) {
+            this.cleanupMessageHandler(connectionId);
+        }
+        this.activeCLIClient = null;
+        this.logger.info('CommandExecutionService cleanup completed');
+    }
+    generateCommandId() {
+        return `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateCDPMessageId() {
+        return Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 10000);
+    }
+    updateMetrics(success, executionTime) {
+        this.commandMetrics.totalCommands++;
+        if (success) {
+            this.commandMetrics.successfulCommands++;
+        }
+        else {
+            this.commandMetrics.failedCommands++;
+        }
+        const totalTime = this.commandMetrics.averageExecutionTime * (this.commandMetrics.totalCommands - 1) + executionTime;
+        this.commandMetrics.averageExecutionTime = totalTime / this.commandMetrics.totalCommands;
+    }
+}
+exports.CommandExecutionService = CommandExecutionService;