chrome-cdp-cli 2.1.1 → 2.1.3

package/dist/cli/OutputManager.js

@@ -10,7 +10,7 @@ class OutputManager {
         this.currentOperation = {
             name: operationName,
             startTime: Date.now(),
-            command
+            command,
         };
     }
     endOperation(result) {
@@ -23,17 +23,17 @@ class OutputManager {
             metadata = {
                 command: this.currentOperation.command.name,
                 args: this.currentOperation.command.args,
-                config: this.currentOperation.command.config
+                config: this.currentOperation.command.config,
             };
             operationConfig = this.currentOperation.command.config;
             this.currentOperation = undefined;
         }
         else {
             operationConfig = {
-                outputFormat: 'text',
+                outputFormat: "text",
                 quiet: false,
                 verbose: false,
-                debug: false
+                debug: false,
             };
         }
         const enhancedResult = (0, OutputFormatter_1.enhanceCommandResult)(result, timing, metadata);
@@ -51,7 +51,7 @@ class OutputManager {
         const result = {
             success: false,
             error,
-            exitCode
+            exitCode,
         };
         const options = (0, OutputFormatter_1.createOutputOptions)(config, false, false);
         return this.formatter.formatOutput(result, options);
@@ -59,7 +59,7 @@ class OutputManager {
     formatSuccess(config, data) {
         const result = {
             success: true,
-            data
+            data,
         };
         const options = (0, OutputFormatter_1.createOutputOptions)(config, false, false);
         return this.formatter.formatOutput(result, options);
@@ -69,14 +69,16 @@ class OutputManager {
             name,
             description,
             template,
-            variables
+            variables,
         });
     }
     getAvailableTemplates() {
         return this.formatter.getAvailableTemplates();
     }
     shouldSuppressOutput(config, result) {
-        return config.quiet && result.success && (result.data === undefined || result.data === null);
+        return (config.quiet &&
+            result.success &&
+            (result.data === undefined || result.data === null));
     }
     getTimingInfo(startTime, endTime, operationName) {
         const duration = endTime - startTime;
@@ -84,14 +86,12 @@ class OutputManager {
     }
     formatDataSourceInfo(dataSource, hasHistoricalData) {
         if (!dataSource)
-            return '';
-        const sourceIcon = dataSource === 'proxy' ? '📊' : '⚠️';
-        const sourceText = dataSource === 'proxy'
-            ? 'Data from proxy server'
-            : 'Data from direct connection';
+            return "";
+        const sourceIcon = "⚠️";
+        const sourceText = "Data from direct connection";
         const historyText = hasHistoricalData
-            ? '(includes historical data)'
-            : '(new data only)';
+            ? "(includes historical data)"
+            : "(new data only)";
         return `${sourceIcon} ${sourceText} ${historyText}`;
     }
     createProgressIndicator(message) {
@@ -99,8 +99,8 @@ class OutputManager {
     }
     formatValidationErrors(errors) {
         if (errors.length === 0)
-            return '';
-        let output = '❌ Validation Errors:\n\n';
+            return "";
+        let output = "❌ Validation Errors:\n\n";
         errors.forEach((error, index) => {
             output += `${index + 1}. ${error.field}: ${error.message}\n`;
             if (error.suggestion) {
@@ -112,7 +112,7 @@ class OutputManager {
     formatHelpInfo(title, content, examples) {
         let output = `📖 ${title}\n\n${content}\n`;
         if (examples && examples.length > 0) {
-            output += '\n💡 Examples:\n';
+            output += "\n💡 Examples:\n";
             examples.forEach((example, index) => {
                 output += `${index + 1}. ${example}\n`;
             });
@@ -127,7 +127,7 @@ class ProgressIndicator {
         this.startTime = Date.now();
     }
     start() {
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         let frameIndex = 0;
         this.interval = setInterval(() => {
             const elapsed = Date.now() - this.startTime;
@@ -141,7 +141,7 @@ class ProgressIndicator {
             clearInterval(this.interval);
             this.interval = undefined;
         }
-        process.stdout.write('\r\x1b[K');
+        process.stdout.write("\r\x1b[K");
     }
     updateMessage(message) {
         this.message = message;

package/dist/client/index.js

@@ -15,4 +15,3 @@ 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,18 +1,11 @@
 "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 logger_1 = require("../utils/logger");
 const fs_1 = require("fs");
-const node_fetch_1 = __importDefault(require("node-fetch"));
 class EvaluateScriptHandler {
-    constructor(useProxy = false, debug = false) {
-        this.name = 'eval';
-        this.proxyClient = new ProxyClient_1.ProxyClient();
-        this.useProxy = useProxy;
+    constructor(debug = false) {
+        this.name = "eval";
         this.logger = new logger_1.Logger();
         if (debug) {
             this.logger.setLevel(3);
@@ -22,55 +15,24 @@ class EvaluateScriptHandler {
         }
     }
     setDebug(debug) {
-        if (debug) {
-            this.logger.setLevel(3);
-        }
-        else {
-            this.logger.setLevel(2);
-        }
+        this.logger.setLevel(debug ? 3 : 2);
     }
     async execute(client, args) {
-        this.logger.debug('EvaluateScriptHandler.execute called with args:', args);
+        this.logger.debug("EvaluateScriptHandler.execute called with args:", args);
         const scriptArgs = args;
         if (!scriptArgs.expression && !scriptArgs.file) {
             return {
                 success: false,
-                error: 'Either "expression" or "file" argument is required'
+                error: 'Either "expression" or "file" argument is required',
             };
         }
         if (scriptArgs.expression && scriptArgs.file) {
             return {
                 success: false,
-                error: 'Cannot specify both "expression" and "file" arguments'
+                error: 'Cannot specify both "expression" and "file" arguments',
             };
         }
-        this.logger.debug('Arguments validated, useProxy:', this.useProxy);
         try {
-            if (this.useProxy) {
-                this.logger.debug('Checking proxy availability...');
-                const proxyAvailable = await this.proxyClient.isProxyAvailable();
-                this.logger.debug('Proxy available:', proxyAvailable);
-                if (proxyAvailable) {
-                    console.log('[INFO] Using proxy connection for script evaluation');
-                    this.logger.debug('About to call executeWithProxy...');
-                    const result = await this.executeWithProxy(scriptArgs);
-                    this.logger.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);
-        }
-        this.logger.debug('Falling back to direct CDP');
-        return await this.executeWithDirectCDP(client, scriptArgs);
-    }
-    async executeWithProxy(scriptArgs) {
-        try {
-            this.logger.debug('Starting executeWithProxy');
             let expression;
             if (scriptArgs.file) {
                 expression = await this.readScriptFile(scriptArgs.file);
@@ -78,128 +40,18 @@ class EvaluateScriptHandler {
             else {
                 expression = scriptArgs.expression;
             }
-            this.logger.debug('Expression to execute:', expression.substring(0, 100));
-            this.logger.debug('Creating new proxy connection...');
-            const connectionId = await this.proxyClient.connect('localhost', 9222);
-            this.logger.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();
-            }
+            return await this.executeWithTimeout(client, expression, scriptArgs);
         }
         catch (error) {
-            this.logger.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 = '';
-                }
-                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) {
-                expression = await this.readScriptFile(scriptArgs.file);
-            }
-            else {
-                expression = scriptArgs.expression;
-            }
-            const result = await this.executeWithTimeout(client, expression, scriptArgs);
-            return result;
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             };
         }
     }
     async readScriptFile(filePath) {
         try {
-            const content = await fs_1.promises.readFile(filePath, 'utf-8');
-            return content;
+            return await fs_1.promises.readFile(filePath, "utf-8");
         }
         catch (error) {
             throw new Error(`Failed to read script file "${filePath}": ${error instanceof Error ? error.message : String(error)}`);
@@ -210,171 +62,133 @@ class EvaluateScriptHandler {
         const awaitPromise = args.awaitPromise ?? true;
         const returnByValue = args.returnByValue ?? true;
         const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`Script execution timeout after ${timeout}ms`));
-            }, timeout);
+            setTimeout(() => reject(new Error(`Script execution timeout after ${timeout}ms`)), timeout);
         });
         const executionPromise = this.executeScript(client, expression, awaitPromise, returnByValue);
         try {
-            const result = await Promise.race([executionPromise, timeoutPromise]);
-            return result;
+            return await Promise.race([executionPromise, timeoutPromise]);
         }
         catch (error) {
             return {
                 success: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             };
         }
     }
     async executeScript(client, expression, awaitPromise, returnByValue) {
-        const consoleHandler = (params) => {
-            this.handleConsoleOutput(params);
-        };
-        client.on('Runtime.consoleAPICalled', consoleHandler);
+        const consoleHandler = (params) => this.handleConsoleOutput(params);
+        client.on("Runtime.consoleAPICalled", consoleHandler);
         try {
-            const response = (await client.send('Runtime.evaluate', {
+            const response = (await client.send("Runtime.evaluate", {
                 expression,
                 awaitPromise,
                 returnByValue,
                 userGesture: true,
-                generatePreview: false
+                generatePreview: false,
             }));
             if (!response) {
-                return {
-                    success: false,
-                    error: 'CDP returned empty response'
-                };
+                return { success: false, error: "CDP returned empty response" };
             }
             if (response.exceptionDetails) {
                 return this.formatException(response.exceptionDetails);
             }
             if (!response.result) {
-                return {
-                    success: false,
-                    error: 'CDP response missing result field'
-                };
+                return { success: false, error: "CDP response missing result field" };
             }
-            return {
-                success: true,
-                data: this.formatResult(response.result)
-            };
+            return { success: true, data: this.formatResult(response.result) };
         }
         catch (error) {
             return {
                 success: false,
-                error: `CDP command failed: ${error instanceof Error ? error.message : String(error)}`
+                error: `CDP command failed: ${error instanceof Error ? error.message : String(error)}`,
             };
         }
         finally {
-            client.off('Runtime.consoleAPICalled', consoleHandler);
+            client.off("Runtime.consoleAPICalled", consoleHandler);
         }
     }
     handleConsoleOutput(params) {
         try {
-            const consoleParams = params;
-            const messageText = this.formatConsoleArgs(consoleParams.args || []);
-            const messageType = this.mapConsoleType(consoleParams.type);
-            if (messageType === 'log' || messageType === 'info' || messageType === 'debug') {
-                process.stdout.write(messageText + '\n');
+            const p = params;
+            const text = (p.args || [])
+                .map((a) => a.value !== undefined
+                ? typeof a.value === "string"
+                    ? a.value
+                    : JSON.stringify(a.value)
+                : a.description || "")
+                .join(" ");
+            const type = this.mapConsoleType(p.type);
+            if (type === "warn" || type === "error") {
+                process.stderr.write(text + "\n");
             }
             else {
-                process.stderr.write(messageText + '\n');
+                process.stdout.write(text + "\n");
             }
         }
-        catch (error) {
-            this.logger.debug('Error handling console output:', error);
+        catch {
         }
     }
-    formatConsoleArgs(args) {
-        return args.map(arg => {
-            if (arg.value !== undefined) {
-                if (typeof arg.value === 'string') {
-                    return arg.value;
-                }
-                return JSON.stringify(arg.value);
-            }
-            return arg.description || '';
-        }).join(' ');
-    }
     mapConsoleType(cdpType) {
         switch (cdpType) {
-            case 'log':
-                return 'log';
-            case 'info':
-                return 'info';
-            case 'warning':
-                return 'warn';
-            case 'error':
-                return 'error';
-            case 'debug':
-                return 'debug';
+            case "warning":
+                return "warn";
+            case "error":
+                return "error";
+            case "info":
+                return "info";
+            case "debug":
+                return "debug";
             default:
-                return 'log';
+                return "log";
         }
     }
     formatException(exceptionDetails) {
         if (!exceptionDetails) {
-            return {
-                success: false,
-                error: 'Unknown JavaScript error'
-            };
+            return { success: false, error: "Unknown JavaScript error" };
         }
-        const exception = exceptionDetails.exception;
-        const errorMessage = exception?.description || exceptionDetails.text;
-        let stackTrace = '';
+        const errorMessage = exceptionDetails.exception?.description || exceptionDetails.text;
+        let stackTrace = "";
         if (exceptionDetails.stackTrace?.callFrames) {
-            stackTrace = '\nStack trace:\n' +
-                exceptionDetails.stackTrace.callFrames
-                    .map(frame => `  at ${frame.functionName || '<anonymous>'} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})`)
-                    .join('\n');
+            stackTrace =
+                "\nStack trace:\n" +
+                    exceptionDetails.stackTrace.callFrames
+                        .map((f) => `  at ${f.functionName || "<anonymous>"} (${f.url}:${f.lineNumber}:${f.columnNumber})`)
+                        .join("\n");
         }
         return {
             success: false,
-            error: `JavaScript error at line ${exceptionDetails.lineNumber}, column ${exceptionDetails.columnNumber}: ${errorMessage}${stackTrace}`
+            error: `JavaScript error at line ${exceptionDetails.lineNumber}, column ${exceptionDetails.columnNumber}: ${errorMessage}${stackTrace}`,
         };
     }
     formatResult(result) {
-        if (!result) {
-            return '';
-        }
-        if (result.type === 'undefined') {
-            return '';
-        }
-        if (result.value !== undefined) {
+        if (!result || result.type === "undefined")
+            return "";
+        if (result.value !== undefined)
             return result.value;
-        }
-        if (result.objectId) {
+        if (result.objectId)
             return {
                 type: result.type,
                 description: result.description,
-                objectId: result.objectId
+                objectId: result.objectId,
             };
-        }
         return result.description || result.type;
     }
     validateArgs(args) {
-        if (typeof args !== 'object' || args === null) {
+        if (typeof args !== "object" || args === null)
             return false;
-        }
-        const scriptArgs = args;
-        if (!scriptArgs.expression && !scriptArgs.file) {
+        const a = args;
+        if (!a.expression && !a.file)
             return false;
-        }
-        if (scriptArgs.expression && scriptArgs.file) {
+        if (a.expression && a.file)
             return false;
-        }
-        if (scriptArgs.expression && typeof scriptArgs.expression !== 'string') {
+        if (a.expression && typeof a.expression !== "string")
             return false;
-        }
-        if (scriptArgs.file && typeof scriptArgs.file !== 'string') {
+        if (a.file && typeof a.file !== "string")
             return false;
-        }
-        if (scriptArgs.awaitPromise !== undefined && typeof scriptArgs.awaitPromise !== 'boolean') {
+        if (a.awaitPromise !== undefined && typeof a.awaitPromise !== "boolean")
             return false;
-        }
-        if (scriptArgs.timeout !== undefined && typeof scriptArgs.timeout !== 'number') {
+        if (a.timeout !== undefined && typeof a.timeout !== "number")
             return false;
-        }
         return true;
     }
     getHelp() {
@@ -382,13 +196,13 @@ class EvaluateScriptHandler {
 eval - Execute JavaScript code in the browser context
 
 Usage:
-  eval "console.log('Hello')"
-  eval --file script.js
-  eval "fetch('/api')" --await-promise
-  eval "longRunning()" --timeout 60000
+  cdp eval "document.title"
+  cdp eval --file script.js
+  cdp eval "await fetch('/api').then(r => r.json())"
+  cdp eval "heavyComputation()" --timeout 60000
 
 Arguments:
-  <expression>            JavaScript code to execute (direct argument)
+  <expression>            JavaScript code to execute
   --expression <code>     JavaScript code to execute (explicit flag)
   --file <path>           Path to JavaScript file to execute
   --await-promise         Wait for Promise resolution (default: true)
@@ -396,20 +210,10 @@ Arguments:
   --return-by-value       Return result by value (default: true)
 
 Examples:
-  # Execute simple expression (recommended)
-  eval "2 + 2"
-
-  # Execute with explicit flag
-  eval --expression "2 + 2"
-
-  # Execute async code
-  eval "await fetch('/api').then(r => r.json())"
-
-  # Execute from file
-  eval --file ./scripts/init.js
-
-  # Set custom timeout
-  eval "heavyComputation()" --timeout 120000
+  cdp eval "2 + 2"
+  cdp eval "Array.from(document.links).map(l => l.href)"
+  cdp eval --file ./scripts/init.js
+  cdp eval "await new Promise(r => setTimeout(r, 5000))" --timeout 10000
 `;
     }
 }