chrome-cdp-cli 1.6.0 → 1.7.0

package/dist/cli/CLIApplication.js

@@ -37,19 +37,26 @@ class CLIApplication {
     }
     async run(argv) {
         try {
+            console.log('[DEBUG] CLIApplication.run called with argv:', argv);
             const command = this.cli.parseArgs(argv);
+            console.log('[DEBUG] Parsed command:', command);
             if (command.config.verbose) {
                 this.proxyManager.setLogging(true);
             }
+            console.log('[DEBUG] Ensuring proxy is ready...');
             await this.ensureProxyReady();
             if (this.needsConnection(command.name)) {
+                console.log('[DEBUG] Command needs connection, ensuring connection...');
                 await this.ensureConnection(command);
             }
+            console.log('[DEBUG] Executing command via CLI interface...');
             const result = await this.cli.execute(command);
+            console.log('[DEBUG] Command execution result:', result);
             this.outputResult(result, command);
             return result.exitCode || (result.success ? CommandRouter_1.ExitCode.SUCCESS : CommandRouter_1.ExitCode.GENERAL_ERROR);
         }
         catch (error) {
+            console.log('[DEBUG] Error in CLIApplication.run:', error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.error(`Error: ${errorMessage}`);
             return CommandRouter_1.ExitCode.GENERAL_ERROR;

package/dist/cli/CommandRouter.js

@@ -169,14 +169,18 @@ class CommandRouter {
     }
     async executeWithTimeout(handler, command) {
         const timeout = command.config.timeout;
+        console.log(`[DEBUG] CommandRouter.executeWithTimeout called for command: ${command.name}, timeout: ${timeout}ms`);
         const timeoutPromise = new Promise((_, reject) => {
             setTimeout(() => {
+                console.log(`[DEBUG] Command timeout reached for: ${command.name} after ${timeout}ms`);
                 reject(new Error(`Command timeout after ${timeout}ms`));
             }, timeout);
         });
+        console.log(`[DEBUG] Starting handler execution for: ${command.name}`);
         const executionPromise = handler.execute(this.client, command.args);
         try {
             const result = await Promise.race([executionPromise, timeoutPromise]);
+            console.log(`[DEBUG] Command completed successfully for: ${command.name}`);
             if (!result || typeof result !== 'object') {
                 return {
                     success: false,
@@ -190,6 +194,7 @@ class CommandRouter {
             return result;
         }
         catch (error) {
+            console.log(`[DEBUG] Command execution error for: ${command.name}:`, error);
             if (error instanceof Error && error.message.includes('timeout')) {
                 return {
                     success: false,

package/dist/client/ProxyClient.js

@@ -172,25 +172,32 @@ class ProxyClient {
         if (!this.connectionId) {
             throw new Error('No active connection. Call connect() first.');
         }
+        console.log(`[DEBUG] Creating WebSocket proxy for connection: ${this.connectionId}`);
         try {
             const wsUrl = this.config.proxyUrl.replace('http://', 'ws://').replace('https://', 'wss://');
-            const ws = new ws_1.WebSocket(`${wsUrl}/ws/${this.connectionId}`);
+            const fullWsUrl = `${wsUrl}/ws/${this.connectionId}`;
+            console.log(`[DEBUG] WebSocket URL: ${fullWsUrl}`);
+            const ws = new ws_1.WebSocket(fullWsUrl);
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
+                    console.log(`[DEBUG] WebSocket connection timeout for ${this.connectionId}`);
                     reject(new Error('WebSocket connection timeout'));
                 }, 10000);
                 ws.on('open', () => {
+                    console.log(`[DEBUG] WebSocket connection opened for ${this.connectionId}`);
                     clearTimeout(timeout);
                     this.wsConnection = ws;
                     resolve(ws);
                 });
                 ws.on('error', (error) => {
+                    console.log(`[DEBUG] WebSocket connection error for ${this.connectionId}:`, error);
                     clearTimeout(timeout);
                     reject(error);
                 });
             });
         }
         catch (error) {
+            console.log(`[DEBUG] Failed to create WebSocket proxy for ${this.connectionId}:`, error);
             throw new Error(`Failed to create WebSocket proxy: ${error instanceof Error ? error.message : error}`);
         }
     }
@@ -222,6 +229,23 @@ class ProxyClient {
     }
     async disconnect() {
         try {
+            if (this.connectionId) {
+                try {
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), 5000);
+                    await (0, node_fetch_1.default)(`${this.config.proxyUrl}/api/client/release`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'x-client-id': `proxy_client_${Date.now()}`
+                        },
+                        signal: controller.signal
+                    });
+                    clearTimeout(timeout);
+                }
+                catch (error) {
+                }
+            }
             if (this.wsConnection) {
                 this.wsConnection.close();
                 this.wsConnection = undefined;

package/dist/handlers/EvaluateScriptHandler.js

@@ -8,12 +8,13 @@ const ProxyClient_1 = require("../client/ProxyClient");
 const fs_1 = require("fs");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 class EvaluateScriptHandler {
-    constructor(useProxy = true) {
+    constructor(useProxy = false) {
         this.name = 'eval';
         this.proxyClient = new ProxyClient_1.ProxyClient();
         this.useProxy = useProxy;
     }
     async execute(client, args) {
+        console.log('[DEBUG] EvaluateScriptHandler.execute called with args:', args);
         const scriptArgs = args;
         if (!scriptArgs.expression && !scriptArgs.file) {
             return {
@@ -27,12 +28,18 @@ class EvaluateScriptHandler {
                 error: 'Cannot specify both "expression" and "file" arguments'
             };
         }
+        console.log('[DEBUG] Arguments validated, useProxy:', this.useProxy);
         try {
             if (this.useProxy) {
+                console.log('[DEBUG] Checking proxy availability...');
                 const proxyAvailable = await this.proxyClient.isProxyAvailable();
+                console.log('[DEBUG] Proxy available:', proxyAvailable);
                 if (proxyAvailable) {
                     console.log('[INFO] Using proxy connection for script evaluation');
-                    return await this.executeWithProxy(scriptArgs);
+                    console.log('[DEBUG] About to call executeWithProxy...');
+                    const result = await this.executeWithProxy(scriptArgs);
+                    console.log('[DEBUG] executeWithProxy returned:', result);
+                    return result;
                 }
                 else {
                     console.warn('[WARN] Proxy not available, falling back to direct CDP connection');
@@ -42,10 +49,12 @@ class EvaluateScriptHandler {
         catch (error) {
             console.warn('[WARN] Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
         }
+        console.log('[DEBUG] Falling back to direct CDP');
         return await this.executeWithDirectCDP(client, scriptArgs);
     }
     async executeWithProxy(scriptArgs) {
         try {
+            console.log('[DEBUG] Starting executeWithProxy');
             let expression;
             if (scriptArgs.file) {
                 expression = await this.readScriptFile(scriptArgs.file);
@@ -53,83 +62,38 @@ class EvaluateScriptHandler {
             else {
                 expression = scriptArgs.expression;
             }
-            const response = await (0, node_fetch_1.default)('http://localhost:9223/api/connections');
-            if (!response.ok) {
-                throw new Error('Failed to get proxy connections');
-            }
-            const result = await response.json();
-            if (!result.success || !result.data.connections || result.data.connections.length === 0) {
-                throw new Error('No active proxy connections found');
-            }
-            const connection = result.data.connections.find((conn) => conn.isHealthy);
-            if (!connection) {
-                throw new Error('No healthy proxy connections found');
-            }
-            console.log(`[INFO] Using existing proxy connection: ${connection.id}`);
-            this.proxyClient.connectionId = connection.id;
-            const ws = await this.proxyClient.createWebSocketProxy();
+            console.log('[DEBUG] Expression to execute:', expression.substring(0, 100));
+            console.log('[DEBUG] Creating new proxy connection...');
+            const connectionId = await this.proxyClient.connect('localhost', 9222);
+            console.log(`[DEBUG] Created new proxy connection: ${connectionId}`);
             try {
-                const result = await this.executeScriptThroughProxy(ws, expression, scriptArgs);
+                const result = await this.executeScriptThroughHTTP(connectionId, expression, scriptArgs);
                 return {
                     success: true,
                     data: result
                 };
             }
             finally {
-                ws.close();
+                await this.proxyClient.disconnect();
             }
         }
         catch (error) {
+            console.log('[DEBUG] Error in executeWithProxy:', error);
             return {
                 success: false,
                 error: error instanceof Error ? error.message : String(error)
             };
         }
     }
-    async executeScriptThroughProxy(ws, expression, args) {
-        return new Promise((resolve, reject) => {
-            const commandId = Date.now();
-            const timeout = args.timeout || 30000;
-            const awaitPromise = args.awaitPromise ?? true;
-            const returnByValue = args.returnByValue ?? true;
-            const timeoutHandle = setTimeout(() => {
-                reject(new Error(`Script execution timeout after ${timeout}ms`));
-            }, timeout);
-            ws.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data.toString());
-                    if (response.id === commandId) {
-                        clearTimeout(timeoutHandle);
-                        if (response.error) {
-                            reject(new Error(`CDP Error: ${response.error.message}`));
-                            return;
-                        }
-                        const result = response.result;
-                        if (result.exceptionDetails) {
-                            const error = new Error(result.result?.description || 'Script execution failed');
-                            error.exceptionDetails = result.exceptionDetails;
-                            reject(error);
-                            return;
-                        }
-                        let value = result.result?.value;
-                        if (result.result?.type === 'undefined') {
-                            value = undefined;
-                        }
-                        else if (result.result?.unserializableValue) {
-                            value = result.result.unserializableValue;
-                        }
-                        resolve(value);
-                    }
-                }
-                catch (error) {
-                    clearTimeout(timeoutHandle);
-                    reject(new Error(`Failed to parse CDP response: ${error instanceof Error ? error.message : error}`));
-                }
-            });
-            ws.on('error', (error) => {
-                clearTimeout(timeoutHandle);
-                reject(new Error(`WebSocket error: ${error.message}`));
-            });
+    async executeScriptThroughHTTP(connectionId, expression, args) {
+        const timeout = args.timeout || 30000;
+        const awaitPromise = args.awaitPromise ?? true;
+        const returnByValue = args.returnByValue ?? true;
+        console.log(`[DEBUG] Starting HTTP script execution, timeout: ${timeout}ms`);
+        console.log(`[DEBUG] Expression: ${expression.substring(0, 100)}${expression.length > 100 ? '...' : ''}`);
+        try {
+            const proxyUrl = this.proxyClient.getConfig().proxyUrl;
+            const commandId = Date.now() + Math.floor(Math.random() * 10000);
             const command = {
                 id: commandId,
                 method: 'Runtime.evaluate',
@@ -141,8 +105,61 @@ class EvaluateScriptHandler {
                     generatePreview: false
                 }
             };
-            ws.send(JSON.stringify(command));
-        });
+            console.log(`[DEBUG] Sending HTTP command to ${proxyUrl}/api/execute/${connectionId}`);
+            const controller = new AbortController();
+            const timeoutHandle = setTimeout(() => controller.abort(), timeout);
+            try {
+                const response = await (0, node_fetch_1.default)(`${proxyUrl}/api/execute/${connectionId}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-client-id': `eval_handler_${Date.now()}`
+                    },
+                    body: JSON.stringify({
+                        command,
+                        timeout
+                    }),
+                    signal: controller.signal
+                });
+                clearTimeout(timeoutHandle);
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(`HTTP ${response.status}: ${errorData.error || response.statusText}`);
+                }
+                const result = await response.json();
+                console.log(`[DEBUG] HTTP command response:`, result);
+                if (!result.success) {
+                    throw new Error(`Command execution failed: ${result.error || 'Unknown error'}`);
+                }
+                const commandResult = result.data.result;
+                if (result.data.error) {
+                    throw new Error(`CDP Error: ${result.data.error.message}`);
+                }
+                if (commandResult.exceptionDetails) {
+                    console.log(`[DEBUG] Exception details:`, commandResult.exceptionDetails);
+                    const error = new Error(commandResult.result?.description || 'Script execution failed');
+                    error.exceptionDetails = commandResult.exceptionDetails;
+                    throw error;
+                }
+                let value = commandResult.result?.value;
+                if (commandResult.result?.type === 'undefined') {
+                    value = undefined;
+                }
+                else if (commandResult.result?.unserializableValue) {
+                    value = commandResult.result.unserializableValue;
+                }
+                console.log(`[DEBUG] Successful HTTP result:`, value);
+                return value;
+            }
+            catch (error) {
+                clearTimeout(timeoutHandle);
+                throw error;
+            }
+        }
+        catch (error) {
+            console.log(`[DEBUG] Error in HTTP script execution:`, error);
+            throw error;
+        }
     }
     async executeWithDirectCDP(client, scriptArgs) {
         try {

package/dist/proxy/server/CDPProxyServer.js

@@ -157,6 +157,7 @@ class CDPProxyServer {
             this.performanceMonitor.stop();
             await this.eventMonitor.stopAllMonitoring();
             this.wsProxy.stop();
+            this.apiServer.cleanup();
             if (this.wsServer) {
                 this.wsServer.close();
             }

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;

package/dist/proxy/server/ConnectionPool.js

@@ -172,29 +172,36 @@ class ConnectionPool {
                 connection.isHealthy = false;
                 return false;
             }
-            const messageId = Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 1000);
+            const messageId = Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 10000);
             const testMessage = {
                 id: messageId,
                 method: 'Runtime.evaluate',
                 params: { expression: '1+1' }
             };
+            console.log(`[DEBUG] Health check starting for connection ${connectionId} with message ID: ${messageId}`);
             const healthCheckPromise = new Promise((resolve) => {
                 const timeout = setTimeout(() => {
+                    console.log(`[DEBUG] Health check timeout for connection ${connectionId}, message ID: ${messageId}`);
                     resolve(false);
                 }, 5000);
                 const messageHandler = (data) => {
                     try {
                         const response = JSON.parse(data.toString());
+                        console.log(`[DEBUG] Health check received message for connection ${connectionId}, response ID: ${response.id}, expected: ${messageId}`);
                         if (response.id === testMessage.id) {
                             clearTimeout(timeout);
                             connection.connection.off('message', messageHandler);
-                            resolve(response.result && !response.error);
+                            const isHealthy = response.result && !response.error;
+                            console.log(`[DEBUG] Health check result for connection ${connectionId}: ${isHealthy}`);
+                            resolve(isHealthy);
                         }
                     }
                     catch (error) {
+                        console.log(`[DEBUG] Health check message parsing error for connection ${connectionId}:`, error);
                     }
                 };
                 connection.connection.on('message', messageHandler);
+                console.log(`[DEBUG] Sending health check command for connection ${connectionId}:`, testMessage);
                 connection.connection.send(JSON.stringify(testMessage));
             });
             const isHealthy = await healthCheckPromise;

package/dist/proxy/server/ProxyAPIServer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyAPIServer = void 0;
 const SecurityManager_1 = require("./SecurityManager");
+const CommandExecutionService_1 = require("./CommandExecutionService");
 const logger_1 = require("../../utils/logger");
 class ProxyAPIServer {
     constructor(connectionPool, messageStore, healthMonitor, performanceMonitor, securityManager) {
@@ -10,6 +11,7 @@ class ProxyAPIServer {
         this.healthMonitor = healthMonitor;
         this.performanceMonitor = performanceMonitor;
         this.securityManager = securityManager || new SecurityManager_1.SecurityManager();
+        this.commandExecutionService = new CommandExecutionService_1.CommandExecutionService(connectionPool);
         this.logger = new logger_1.Logger();
     }
     setupRoutes(app) {
@@ -20,6 +22,9 @@ class ProxyAPIServer {
         app.get('/api/console/:connectionId', this.validateConnectionId.bind(this), this.handleGetConsoleMessages.bind(this));
         app.get('/api/network/:connectionId', this.validateConnectionId.bind(this), this.handleGetNetworkRequests.bind(this));
         app.get('/api/health/:connectionId', this.validateConnectionId.bind(this), this.handleHealthCheck.bind(this));
+        app.post('/api/execute/:connectionId', this.securityManager.getStrictRateLimiter(), this.validateConnectionId.bind(this), this.validateCommandExecutionRequest.bind(this), this.handleCommandExecution.bind(this));
+        app.post('/api/client/release', this.handleReleaseCLIClient.bind(this));
+        app.get('/api/client/status', this.handleGetCLIClientStatus.bind(this));
         app.get('/api/health', this.handleServerHealth.bind(this));
         app.get('/api/health/detailed', this.handleDetailedHealthCheck.bind(this));
         app.get('/api/health/statistics', this.handleHealthStatistics.bind(this));
@@ -33,6 +38,13 @@ class ProxyAPIServer {
         app.get('/api/status', this.handleServerStatus.bind(this));
         this.logger.info('API routes configured with enhanced security measures');
     }
+    cleanup() {
+        this.commandExecutionService.cleanup();
+        this.logger.info('ProxyAPIServer cleanup completed');
+    }
+    getCommandExecutionService() {
+        return this.commandExecutionService;
+    }
     async handleConnect(req, res) {
         try {
             const { host, port, targetId } = req.body;
@@ -245,6 +257,78 @@ class ProxyAPIServer {
             });
         }
     }
+    async handleCommandExecution(req, res) {
+        try {
+            const { connectionId } = req.params;
+            const { command, timeout } = req.body;
+            const clientId = req.headers['x-client-id'] || `client_${req.ip}_${Date.now()}`;
+            const connection = this.connectionPool.getConnectionInfo(connectionId);
+            if (!connection) {
+                res.status(404).json({
+                    success: false,
+                    error: 'Connection not found',
+                    timestamp: Date.now()
+                });
+                return;
+            }
+            if (!connection.isHealthy) {
+                res.status(503).json({
+                    success: false,
+                    error: 'Connection is not healthy',
+                    timestamp: Date.now()
+                });
+                return;
+            }
+            this.logger.debug(`Executing CDP command: ${command.method}`, {
+                connectionId,
+                method: command.method,
+                hasParams: !!command.params,
+                timeout: timeout || 30000,
+                clientId
+            });
+            const executionRequest = {
+                connectionId,
+                command,
+                timeout
+            };
+            const result = await this.commandExecutionService.executeCommand(executionRequest, clientId);
+            const statusCode = result.success ? 200 : (result.error?.code || 500);
+            res.status(statusCode).json({
+                success: result.success,
+                data: result,
+                timestamp: Date.now()
+            });
+            this.logger.debug(`CDP command execution completed: ${command.method}`, {
+                connectionId,
+                success: result.success,
+                executionTime: result.executionTime,
+                statusCode,
+                clientId
+            });
+        }
+        catch (error) {
+            this.logger.error('Command execution API error:', error);
+            let statusCode = 500;
+            let errorMessage = error instanceof Error ? error.message : 'Command execution failed';
+            if (errorMessage.includes('Another CLI client')) {
+                statusCode = 409;
+            }
+            else if (errorMessage.includes('timeout')) {
+                statusCode = 408;
+            }
+            else if (errorMessage.includes('not found')) {
+                statusCode = 404;
+            }
+            else if (errorMessage.includes('not healthy')) {
+                statusCode = 503;
+            }
+            res.status(statusCode).json({
+                success: false,
+                error: errorMessage,
+                timestamp: Date.now()
+            });
+        }
+    }
     async handleListConnections(_req, res) {
         try {
             const connections = this.connectionPool.getAllConnections();
@@ -665,6 +749,85 @@ class ProxyAPIServer {
         }
         next();
     }
+    validateCommandExecutionRequest(req, res, next) {
+        const { command, timeout } = req.body;
+        if (!command || typeof command !== 'object') {
+            this.logger.logSecurityEvent('invalid_command_request', 'Missing or invalid command object', {
+                command,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command is required and must be an object',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (!command.method || typeof command.method !== 'string' || command.method.trim() === '') {
+            this.logger.logSecurityEvent('invalid_command_request', 'Missing or invalid command method', {
+                method: command.method,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command method is required and must be a non-empty string',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        const methodRegex = /^[A-Za-z][A-Za-z0-9]*\.[A-Za-z][A-Za-z0-9]*$/;
+        if (!methodRegex.test(command.method)) {
+            this.logger.logSecurityEvent('invalid_command_method', 'Command method has invalid format', {
+                method: command.method,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command method must be in format "Domain.method" (e.g., "Runtime.evaluate")',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (command.id !== undefined && (typeof command.id !== 'number' && typeof command.id !== 'string')) {
+            this.logger.logSecurityEvent('invalid_command_request', 'Invalid command ID type', {
+                commandId: command.id,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command ID must be a number or string if provided',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (timeout !== undefined) {
+            if (typeof timeout !== 'number' || timeout <= 0 || timeout > 300000) {
+                this.logger.logSecurityEvent('invalid_command_request', 'Invalid timeout value', {
+                    timeout,
+                    ip: req.ip
+                });
+                res.status(400).json({
+                    success: false,
+                    error: 'Timeout must be a positive number between 1 and 300000 (5 minutes)',
+                    timestamp: Date.now()
+                });
+                return;
+            }
+        }
+        if (command.params !== undefined && (command.params === null || (typeof command.params !== 'object' && !Array.isArray(command.params)))) {
+            this.logger.logSecurityEvent('invalid_command_request', 'Invalid command params', {
+                paramsType: typeof command.params,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command params must be an object or array if provided',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        next();
+    }
     parseConsoleMessageFilter(query) {
         try {
             const filter = {};
@@ -905,5 +1068,53 @@ class ProxyAPIServer {
             return `${minutes} minute${minutes > 1 ? 's' : ''}`;
         }
     }
+    async handleReleaseCLIClient(req, res) {
+        try {
+            const clientId = req.headers['x-client-id'] || `client_${req.ip}_${Date.now()}`;
+            this.commandExecutionService.releaseActiveCLIClient(clientId);
+            this.logger.info(`CLI client released: ${clientId}`);
+            res.json({
+                success: true,
+                data: {
+                    message: 'CLI client released successfully',
+                    clientId
+                },
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            this.logger.error('Release CLI client API error:', error);
+            res.status(500).json({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to release CLI client',
+                timestamp: Date.now()
+            });
+        }
+    }
+    async handleGetCLIClientStatus(_req, res) {
+        try {
+            const activeCLIClient = this.commandExecutionService.getActiveCLIClient();
+            const hasActiveClient = this.commandExecutionService.hasActiveCLIClient();
+            const pendingCommandsCount = this.commandExecutionService.getPendingCommandsCount();
+            res.json({
+                success: true,
+                data: {
+                    hasActiveClient,
+                    activeCLIClient,
+                    pendingCommandsCount,
+                    singleClientMode: true
+                },
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            this.logger.error('Get CLI client status API error:', error);
+            res.status(500).json({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get CLI client status',
+                timestamp: Date.now()
+            });
+        }
+    }
 }
 exports.ProxyAPIServer = ProxyAPIServer;

package/dist/proxy/server/WSProxy.js

@@ -236,9 +236,11 @@ class WSProxy {
                 if (cdpConnection.connection.readyState === WebSocket.OPEN) {
                     cdpConnection.connection.send(message);
                     proxyConnection.messageCount++;
+                    console.log(`[DEBUG] Forwarded CDP command from client ${proxyConnection.id}: ${cdpCommand.method} (id: ${cdpCommand.id})`);
                     this.logger.debug(`Forwarded CDP command from client ${proxyConnection.id}: ${cdpCommand.method} (id: ${cdpCommand.id})`);
                 }
                 else {
+                    console.log(`[DEBUG] CDP connection ${connectionId} is not open, readyState: ${cdpConnection.connection.readyState}`);
                     this.logger.warn(`CDP connection ${connectionId} is not open, cannot forward command`);
                     clientWs.send(JSON.stringify({
                         error: { code: -32001, message: 'CDP connection unavailable' },
@@ -266,20 +268,30 @@ class WSProxy {
                     return;
                 }
                 if (this.isCDPResponse(cdpMessage)) {
+                    console.log(`[DEBUG] Received CDP response for client ${proxyConnection.id}: id ${cdpMessage.id}`);
                     if (clientWs.readyState === WebSocket.OPEN) {
                         clientWs.send(message);
                         proxyConnection.messageCount++;
+                        console.log(`[DEBUG] Forwarded CDP response to client ${proxyConnection.id}: id ${cdpMessage.id}`);
                         this.logger.debug(`Forwarded CDP response to client ${proxyConnection.id}: id ${cdpMessage.id}`);
                     }
+                    else {
+                        console.log(`[DEBUG] Client WebSocket is not open for ${proxyConnection.id}, readyState: ${clientWs.readyState}`);
+                    }
                 }
                 else if (this.isCDPEvent(cdpMessage)) {
+                    console.log(`[DEBUG] Received CDP event: ${cdpMessage.method}`);
                     this.forwardEventToSubscribedClients(connectionId, cdpMessage, message);
                 }
+                else {
+                    console.log(`[DEBUG] Received unknown CDP message type:`, cdpMessage);
+                }
             }
             catch (error) {
                 this.logger.error(`Error forwarding message to client ${proxyConnection.id}:`, error);
             }
         };
+        console.log(`[DEBUG] Adding message handler to CDP connection ${connectionId} for proxy ${proxyConnection.id}`);
         cdpConnection.connection.on('message', cdpMessageHandler);
         clientWs.on('close', () => {
             cdpConnection.connection.off('message', cdpMessageHandler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-cdp-cli",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "LLM-first browser automation CLI via Chrome DevTools Protocol. Eval-first design optimized for AI assistants - LLMs write JavaScript scripts for rapid validation. Features: JavaScript execution, element interaction, screenshots, DOM snapshots, console/network monitoring. Built-in IDE integration for Cursor and Claude.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",