chrome-cdp-cli 1.5.0 → 1.7.0

package/README.md

@@ -390,6 +390,18 @@ chrome-cdp-cli list_console_messages
 chrome-cdp-cli list_console_messages --filter '{"types":["error","warn"]}'
 ```
 
+**Note**: Console monitoring only captures messages generated *after* monitoring starts. For historical messages or immediate console operations, use the eval-first approach:
+
+```bash
+# Generate and capture console messages in one command
+chrome-cdp-cli eval "console.log('Test message'); console.warn('Warning'); 'Messages logged'"
+
+# Check for existing console history (if page maintains it)
+chrome-cdp-cli eval "window.consoleHistory || window._console_logs || 'No custom console history'"
+```
+
+See [Console Monitoring Documentation](docs/CONSOLE_MONITORING.md) for detailed solutions and workarounds.
+
 #### Network Monitoring
 ```bash
 # Get latest network request

package/dist/cli/CLIApplication.js

@@ -6,11 +6,13 @@ const ConnectionManager_1 = require("../connection/ConnectionManager");
 const handlers_1 = require("../handlers");
 const logger_1 = require("../utils/logger");
 const CommandRouter_1 = require("./CommandRouter");
+const ProxyManager_1 = require("../proxy/ProxyManager");
 class CLIApplication {
     constructor() {
         this.cli = new CLIInterface_1.CLIInterface();
         this.connectionManager = new ConnectionManager_1.ConnectionManager();
         this.logger = new logger_1.Logger();
+        this.proxyManager = ProxyManager_1.ProxyManager.getInstance();
         this.setupHandlers();
     }
     setupHandlers() {
@@ -35,20 +37,40 @@ 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;
         }
     }
+    async ensureProxyReady() {
+        try {
+            const isReady = await this.proxyManager.ensureProxyReady();
+            if (!isReady) {
+            }
+        }
+        catch (error) {
+        }
+    }
     needsConnection(commandName) {
         const noConnectionCommands = [
             'help',
@@ -104,6 +126,12 @@ class CLIApplication {
                 this.logger.error('Error during shutdown:', error);
             }
         }
+        try {
+            await this.proxyManager.shutdown();
+        }
+        catch (error) {
+            this.logger.error('Error shutting down proxy manager:', error);
+        }
     }
     getCLI() {
         return this.cli;

package/dist/cli/CLIInterface.js

@@ -39,6 +39,7 @@ const path = __importStar(require("path"));
 const CLIInterface_1 = require("../interfaces/CLIInterface");
 const CommandRegistry_1 = require("./CommandRegistry");
 const CommandRouter_1 = require("./CommandRouter");
+const packageJson = require('../../package.json');
 class CLIInterface {
     constructor() {
         this.program = new commander_1.Command();
@@ -50,7 +51,7 @@ class CLIInterface {
         this.program
             .name('chrome-cdp-cli')
             .description('Command-line tool for controlling Chrome browser via DevTools Protocol')
-            .version('1.0.0')
+            .version(packageJson.version)
             .allowUnknownOption(true)
             .allowExcessArguments(true);
         this.program
@@ -65,6 +66,10 @@ class CLIInterface {
     parseArgs(argv) {
         try {
             const args = argv.slice(2);
+            if (args.includes('--version') || args.includes('-V')) {
+                console.log(packageJson.version);
+                process.exit(0);
+            }
             const options = {};
             const commandArgs = [];
             let i = 0;
@@ -341,6 +346,65 @@ class CLIInterface {
         if (result.data === undefined || result.data === null) {
             return 'Success';
         }
+        let output = '';
+        let dataSourceInfo = '';
+        if (result.dataSource === 'proxy' && result.hasHistoricalData) {
+            dataSourceInfo = '📊 Data from proxy server (includes historical data)\n';
+        }
+        else if (result.dataSource === 'direct' && result.hasHistoricalData === false) {
+            dataSourceInfo = '⚠️  Data from direct connection (new messages only, no historical data)\n';
+        }
+        if (result.data && typeof result.data === 'object') {
+            const data = result.data;
+            if (data.messages && Array.isArray(data.messages)) {
+                output += dataSourceInfo;
+                if (data.messages.length === 0) {
+                    output += 'No console messages found.';
+                }
+                else {
+                    output += `Found ${data.messages.length} console message(s):\n\n`;
+                    data.messages.forEach((msg, index) => {
+                        const timestamp = new Date(msg.timestamp).toISOString();
+                        output += `[${index + 1}] ${timestamp} [${msg.type.toUpperCase()}] ${msg.text}\n`;
+                        if (msg.args && msg.args.length > 0) {
+                            output += `    Args: ${JSON.stringify(msg.args)}\n`;
+                        }
+                    });
+                }
+                return output.trim();
+            }
+            if (data.requests && Array.isArray(data.requests)) {
+                output += dataSourceInfo;
+                if (data.requests.length === 0) {
+                    output += 'No network requests found.';
+                }
+                else {
+                    output += `Found ${data.requests.length} network request(s):\n\n`;
+                    data.requests.forEach((req, index) => {
+                        const timestamp = new Date(req.timestamp).toISOString();
+                        const status = req.status ? ` [${req.status}]` : ' [pending]';
+                        output += `[${index + 1}] ${timestamp} ${req.method} ${req.url}${status}\n`;
+                    });
+                }
+                return output.trim();
+            }
+            if (data.type && data.text !== undefined && data.timestamp) {
+                output += dataSourceInfo;
+                const timestamp = new Date(data.timestamp).toISOString();
+                output += `${timestamp} [${data.type.toUpperCase()}] ${data.text}`;
+                if (data.args && data.args.length > 0) {
+                    output += `\nArgs: ${JSON.stringify(data.args)}`;
+                }
+                return output;
+            }
+            if (data.requestId && data.url && data.method) {
+                output += dataSourceInfo;
+                const timestamp = new Date(data.timestamp).toISOString();
+                const status = data.status ? ` [${data.status}]` : ' [pending]';
+                output += `${timestamp} ${data.method} ${data.url}${status}`;
+                return output;
+            }
+        }
         if (typeof result.data === 'string') {
             return result.data;
         }

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,
@@ -214,6 +219,7 @@ Global Options:
   -q, --quiet              Enable quiet mode
   -t, --timeout <ms>       Command timeout in milliseconds (default: 30000)
   -c, --config <path>      Configuration file path
+  -V, --version            Show version number
 
 Available Commands:
 ${commands.map(cmd => `  ${cmd.padEnd(20)} - ${this.getCommandDescription(cmd)}`).join('\n')}

package/dist/client/ProxyClient.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyClient = void 0;
+const ws_1 = require("ws");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const ProxyManager_1 = require("../proxy/ProxyManager");
+class ProxyClient {
+    constructor(config) {
+        this.config = {
+            proxyUrl: 'http://localhost:9223',
+            fallbackToDirect: true,
+            startProxyIfNeeded: true,
+            ...config
+        };
+        this.proxyManager = ProxyManager_1.ProxyManager.getInstance();
+    }
+    async ensureProxyRunning() {
+        if (this.config.startProxyIfNeeded) {
+            return await this.proxyManager.ensureProxyReady();
+        }
+        return await this.isProxyRunning();
+    }
+    async isProxyAvailable() {
+        return await this.isProxyRunning();
+    }
+    async isProxyRunning() {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            const response = await (0, node_fetch_1.default)(`${this.config.proxyUrl}/api/health`, {
+                method: 'GET',
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            return response.ok;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async connect(host, port, targetId) {
+        const request = {
+            host,
+            port,
+            targetId
+        };
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 30000);
+            const response = await (0, node_fetch_1.default)(`${this.config.proxyUrl}/api/connect`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(request),
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`Proxy connect failed: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (!result.success) {
+                throw new Error(`Proxy connect failed: ${result.error}`);
+            }
+            this.connectionId = result.data.connectionId;
+            return this.connectionId;
+        }
+        catch (error) {
+            throw new Error(`Failed to connect through proxy: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async getConsoleMessages(filter) {
+        if (!this.connectionId) {
+            throw new Error('No active connection. Call connect() first.');
+        }
+        try {
+            const url = new URL(`${this.config.proxyUrl}/api/console/${this.connectionId}`);
+            if (filter) {
+                if (filter.types) {
+                    url.searchParams.set('types', filter.types.join(','));
+                }
+                if (filter.textPattern) {
+                    url.searchParams.set('textPattern', filter.textPattern);
+                }
+                if (filter.maxMessages) {
+                    url.searchParams.set('maxMessages', filter.maxMessages.toString());
+                }
+                if (filter.startTime) {
+                    url.searchParams.set('startTime', filter.startTime.toString());
+                }
+                if (filter.endTime) {
+                    url.searchParams.set('endTime', filter.endTime.toString());
+                }
+                if (filter.source) {
+                    url.searchParams.set('source', filter.source);
+                }
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const response = await (0, node_fetch_1.default)(url.toString(), {
+                method: 'GET',
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`Failed to get console messages: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (!result.success) {
+                throw new Error(`Failed to get console messages: ${result.error}`);
+            }
+            return result.data?.messages || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get console messages: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async getNetworkRequests(filter) {
+        if (!this.connectionId) {
+            throw new Error('No active connection. Call connect() first.');
+        }
+        try {
+            const url = new URL(`${this.config.proxyUrl}/api/network/${this.connectionId}`);
+            if (filter) {
+                if (filter.methods) {
+                    url.searchParams.set('methods', filter.methods.join(','));
+                }
+                if (filter.statusCodes) {
+                    url.searchParams.set('statusCodes', filter.statusCodes.join(','));
+                }
+                if (filter.urlPattern) {
+                    url.searchParams.set('urlPattern', filter.urlPattern);
+                }
+                if (filter.maxRequests) {
+                    url.searchParams.set('maxRequests', filter.maxRequests.toString());
+                }
+                if (filter.startTime) {
+                    url.searchParams.set('startTime', filter.startTime.toString());
+                }
+                if (filter.endTime) {
+                    url.searchParams.set('endTime', filter.endTime.toString());
+                }
+                if (filter.includeResponseBody !== undefined) {
+                    url.searchParams.set('includeResponseBody', filter.includeResponseBody.toString());
+                }
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const response = await (0, node_fetch_1.default)(url.toString(), {
+                method: 'GET',
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`Failed to get network requests: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (!result.success) {
+                throw new Error(`Failed to get network requests: ${result.error}`);
+            }
+            return result.data?.requests || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get network requests: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async createWebSocketProxy() {
+        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 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}`);
+        }
+    }
+    async healthCheck() {
+        if (!this.connectionId) {
+            return null;
+        }
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const response = await (0, node_fetch_1.default)(`${this.config.proxyUrl}/api/health/${this.connectionId}`, {
+                method: 'GET',
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`Health check failed: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (!result.success) {
+                throw new Error(`Health check failed: ${result.error}`);
+            }
+            return result.data || null;
+        }
+        catch (error) {
+            console.warn('Health check failed:', error instanceof Error ? error.message : error);
+            return null;
+        }
+    }
+    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;
+            }
+            if (this.connectionId) {
+                try {
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), 5000);
+                    await (0, node_fetch_1.default)(`${this.config.proxyUrl}/api/connection/${this.connectionId}`, {
+                        method: 'DELETE',
+                        signal: controller.signal
+                    });
+                    clearTimeout(timeout);
+                }
+                catch (error) {
+                }
+                this.connectionId = undefined;
+            }
+        }
+        catch (error) {
+        }
+    }
+    getConnectionId() {
+        return this.connectionId;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.ProxyClient = ProxyClient;

package/dist/client/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CDPClient"), exports);
+__exportStar(require("./ProxyClient"), exports);

package/dist/handlers/EvaluateScriptHandler.js

@@ -1,12 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluateScriptHandler = void 0;
+const ProxyClient_1 = require("../client/ProxyClient");
 const fs_1 = require("fs");
+const node_fetch_1 = __importDefault(require("node-fetch"));
 class EvaluateScriptHandler {
-    constructor() {
+    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 {
@@ -20,6 +28,140 @@ 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');
+                    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');
+                }
+            }
+        }
+        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);
+            }
+            else {
+                expression = scriptArgs.expression;
+            }
+            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.executeScriptThroughHTTP(connectionId, expression, scriptArgs);
+                return {
+                    success: true,
+                    data: result
+                };
+            }
+            finally {
+                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 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',
+                params: {
+                    expression: expression,
+                    awaitPromise: awaitPromise,
+                    returnByValue: returnByValue,
+                    userGesture: true,
+                    generatePreview: false
+                }
+            };
+            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 {
             let expression;
             if (scriptArgs.file) {