chrome-cdp-cli 1.0.0

package/dist/client/CDPClient.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class CDPClient {
+    constructor() {
+        this.ws = null;
+        this.messageId = 0;
+        this.pendingRequests = new Map();
+        this.eventListeners = new Map();
+        this.connectionStatus = 'disconnected';
+    }
+    async connect(host, port, targetId) {
+        this.connectionStatus = 'connecting';
+        try {
+            if (!targetId) {
+                const targets = await this.discoverTargets(host, port);
+                const pageTarget = targets.find(t => t.type === 'page');
+                if (!pageTarget) {
+                    throw new Error('No page targets found');
+                }
+                targetId = pageTarget.id;
+            }
+            const wsUrl = await this.getWebSocketUrl(host, port, targetId);
+            this.ws = new ws_1.default(wsUrl);
+            return new Promise((resolve, reject) => {
+                if (!this.ws) {
+                    reject(new Error('WebSocket not initialized'));
+                    return;
+                }
+                this.ws.on('open', async () => {
+                    this.connectionStatus = 'connected';
+                    try {
+                        await this.send('Runtime.enable');
+                        resolve();
+                    }
+                    catch (error) {
+                        console.error('Failed to enable Runtime domain:', error);
+                        reject(error);
+                    }
+                });
+                this.ws.on('message', (data) => {
+                    this.handleMessage(data.toString());
+                });
+                this.ws.on('error', (error) => {
+                    this.connectionStatus = 'error';
+                    console.error('WebSocket error:', error);
+                    reject(error);
+                });
+                this.ws.on('close', () => {
+                    this.connectionStatus = 'disconnected';
+                });
+            });
+        }
+        catch (error) {
+            this.connectionStatus = 'error';
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connectionStatus = 'disconnected';
+        this.pendingRequests.clear();
+    }
+    async send(method, params) {
+        if (!this.ws || this.connectionStatus !== 'connected') {
+            throw new Error('Not connected to CDP endpoint');
+        }
+        const id = ++this.messageId;
+        const message = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            if (this.ws) {
+                this.ws.send(JSON.stringify(message));
+            }
+            else {
+                reject(new Error('WebSocket connection lost'));
+            }
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request timeout for method: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    on(event, callback) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, []);
+        }
+        this.eventListeners.get(event).push(callback);
+    }
+    off(event, callback) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            const index = listeners.indexOf(callback);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+        }
+    }
+    isConnected() {
+        return this.connectionStatus === 'connected';
+    }
+    getConnectionStatus() {
+        return this.connectionStatus;
+    }
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.id !== undefined) {
+                const response = message;
+                const pending = this.pendingRequests.get(response.id);
+                if (pending) {
+                    this.pendingRequests.delete(response.id);
+                    if (response.error) {
+                        pending.reject(new Error(`CDP Error: ${response.error.message}`));
+                    }
+                    else {
+                        pending.resolve(response.result);
+                    }
+                }
+            }
+            else if (message.method) {
+                const event = message;
+                const listeners = this.eventListeners.get(event.method);
+                if (listeners) {
+                    listeners.forEach(callback => callback(event.params));
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error parsing CDP message:', error);
+        }
+    }
+    async discoverTargets(host, port) {
+        const response = await (0, node_fetch_1.default)(`http://${host}:${port}/json/list`);
+        if (!response.ok) {
+            throw new Error(`Failed to discover targets: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    async getWebSocketUrl(host, port, targetId) {
+        const targets = await this.discoverTargets(host, port);
+        const target = targets.find(t => t.id === targetId);
+        if (!target) {
+            throw new Error(`Target not found: ${targetId}`);
+        }
+        return target.webSocketDebuggerUrl;
+    }
+}
+exports.CDPClient = CDPClient;

package/dist/client/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CDPClient"), exports);

package/dist/connection/ConnectionManager.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+const logger_1 = require("../utils/logger");
+class ConnectionManager {
+    constructor(logger) {
+        this.activeConnections = [];
+        this.DEFAULT_RETRY_DELAY = 1000;
+        this.MAX_RETRY_DELAY = 30000;
+        this.RETRY_MULTIPLIER = 2;
+        this.logger = logger || new logger_1.Logger();
+    }
+    async discoverTargets(host, port) {
+        const url = `http://${host}:${port}/json/list`;
+        try {
+            this.logger.debug(`Discovering targets at ${url}`);
+            const http = await Promise.resolve().then(() => __importStar(require('http')));
+            return new Promise((resolve, reject) => {
+                const request = http.get(url, (response) => {
+                    let data = '';
+                    response.on('data', (chunk) => {
+                        data += chunk;
+                    });
+                    response.on('end', () => {
+                        try {
+                            if (response.statusCode !== 200) {
+                                reject(new Error(`HTTP ${response.statusCode}: Failed to discover targets`));
+                                return;
+                            }
+                            const targets = JSON.parse(data);
+                            this.logger.debug(`Discovered ${targets.length} targets`);
+                            const validTargets = targets.filter(target => target.webSocketDebuggerUrl &&
+                                target.id &&
+                                target.type);
+                            resolve(validTargets);
+                        }
+                        catch (error) {
+                            reject(new Error(`Failed to parse targets response: ${error instanceof Error ? error.message : 'Unknown error'}`));
+                        }
+                    });
+                });
+                request.on('error', (error) => {
+                    reject(new Error(`Failed to connect to Chrome DevTools at ${url}: ${error.message}`));
+                });
+                request.setTimeout(5000, () => {
+                    request.destroy();
+                    reject(new Error(`Timeout connecting to Chrome DevTools at ${url}`));
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(`Target discovery failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async connectToTarget(target) {
+        try {
+            this.logger.debug(`Connecting to target: ${target.id} (${target.title})`);
+            const client = await this.createCDPClient(target);
+            this.activeConnections.push(client);
+            this.logger.info(`Successfully connected to target: ${target.id}`);
+            return client;
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to target ${target.id}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async reconnect(client, maxRetries) {
+        let retryCount = 0;
+        let delay = this.DEFAULT_RETRY_DELAY;
+        while (retryCount < maxRetries) {
+            try {
+                this.logger.debug(`Reconnection attempt ${retryCount + 1}/${maxRetries}`);
+                await this.attemptReconnection(client);
+                this.logger.info(`Successfully reconnected after ${retryCount + 1} attempts`);
+                return;
+            }
+            catch (error) {
+                retryCount++;
+                if (retryCount >= maxRetries) {
+                    throw new Error(`Failed to reconnect after ${maxRetries} attempts: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+                this.logger.warn(`Reconnection attempt ${retryCount} failed, retrying in ${delay}ms: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                await this.sleep(delay);
+                delay = Math.min(delay * this.RETRY_MULTIPLIER, this.MAX_RETRY_DELAY);
+            }
+        }
+    }
+    getActiveConnections() {
+        return [...this.activeConnections];
+    }
+    async closeAllConnections() {
+        this.logger.debug(`Closing ${this.activeConnections.length} active connections`);
+        const closePromises = this.activeConnections.map(async (client) => {
+            try {
+                await client.disconnect();
+            }
+            catch (error) {
+                this.logger.warn(`Error closing connection: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        });
+        await Promise.allSettled(closePromises);
+        this.activeConnections = [];
+        this.logger.info('All connections closed');
+    }
+    async createCDPClient(target) {
+        const { CDPClient } = await Promise.resolve().then(() => __importStar(require('../client/CDPClient')));
+        const client = new CDPClient();
+        const wsUrl = target.webSocketDebuggerUrl;
+        if (!wsUrl) {
+            throw new Error(`Target ${target.id} does not have a WebSocket URL`);
+        }
+        const urlMatch = wsUrl.match(/ws:\/\/([^:]+):(\d+)/);
+        if (!urlMatch) {
+            throw new Error(`Invalid WebSocket URL format: ${wsUrl}`);
+        }
+        const host = urlMatch[1];
+        const port = parseInt(urlMatch[2], 10);
+        await client.connect(host, port, target.id);
+        return client;
+    }
+    async attemptReconnection(client) {
+        if (client.isConnected()) {
+            return;
+        }
+        throw new Error('Reconnection not yet implemented - depends on CDPClient');
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.ConnectionManager = ConnectionManager;

package/dist/connection/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+var ConnectionManager_1 = require("./ConnectionManager");
+Object.defineProperty(exports, "ConnectionManager", { enumerable: true, get: function () { return ConnectionManager_1.ConnectionManager; } });

package/dist/handlers/EvaluateScriptHandler.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateScriptHandler = void 0;
+const fs_1 = require("fs");
+class EvaluateScriptHandler {
+    constructor() {
+        this.name = 'eval';
+    }
+    async execute(client, args) {
+        const scriptArgs = args;
+        if (!scriptArgs.expression && !scriptArgs.file) {
+            return {
+                success: false,
+                error: 'Either "expression" or "file" argument is required'
+            };
+        }
+        if (scriptArgs.expression && scriptArgs.file) {
+            return {
+                success: false,
+                error: 'Cannot specify both "expression" and "file" arguments'
+            };
+        }
+        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)
+            };
+        }
+    }
+    async readScriptFile(filePath) {
+        try {
+            const content = await fs_1.promises.readFile(filePath, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            throw new Error(`Failed to read script file "${filePath}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async executeWithTimeout(client, expression, args) {
+        const timeout = args.timeout || 30000;
+        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);
+        });
+        const executionPromise = this.executeScript(client, expression, awaitPromise, returnByValue);
+        try {
+            const result = await Promise.race([executionPromise, timeoutPromise]);
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async executeScript(client, expression, awaitPromise, returnByValue) {
+        try {
+            const response = (await client.send('Runtime.evaluate', {
+                expression,
+                awaitPromise,
+                returnByValue,
+                userGesture: true,
+                generatePreview: false
+            }));
+            if (!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: true,
+                data: this.formatResult(response.result)
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `CDP command failed: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    formatException(exceptionDetails) {
+        if (!exceptionDetails) {
+            return {
+                success: false,
+                error: 'Unknown JavaScript error'
+            };
+        }
+        const exception = exceptionDetails.exception;
+        const errorMessage = 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');
+        }
+        return {
+            success: false,
+            error: `JavaScript error at line ${exceptionDetails.lineNumber}, column ${exceptionDetails.columnNumber}: ${errorMessage}${stackTrace}`
+        };
+    }
+    formatResult(result) {
+        if (!result) {
+            return 'undefined';
+        }
+        if (result.value !== undefined) {
+            return result.value;
+        }
+        if (result.objectId) {
+            return {
+                type: result.type,
+                description: result.description,
+                objectId: result.objectId
+            };
+        }
+        return result.description || result.type;
+    }
+    validateArgs(args) {
+        if (typeof args !== 'object' || args === null) {
+            return false;
+        }
+        const scriptArgs = args;
+        if (!scriptArgs.expression && !scriptArgs.file) {
+            return false;
+        }
+        if (scriptArgs.expression && scriptArgs.file) {
+            return false;
+        }
+        if (scriptArgs.expression && typeof scriptArgs.expression !== 'string') {
+            return false;
+        }
+        if (scriptArgs.file && typeof scriptArgs.file !== 'string') {
+            return false;
+        }
+        if (scriptArgs.awaitPromise !== undefined && typeof scriptArgs.awaitPromise !== 'boolean') {
+            return false;
+        }
+        if (scriptArgs.timeout !== undefined && typeof scriptArgs.timeout !== 'number') {
+            return false;
+        }
+        return true;
+    }
+    getHelp() {
+        return `
+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
+
+Arguments:
+  <expression>            JavaScript code to execute (direct argument)
+  --expression <code>     JavaScript code to execute (explicit flag)
+  --file <path>           Path to JavaScript file to execute
+  --await-promise         Wait for Promise resolution (default: true)
+  --timeout <ms>          Execution timeout in milliseconds (default: 30000)
+  --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
+`;
+    }
+}
+exports.EvaluateScriptHandler = EvaluateScriptHandler;

package/dist/handlers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EvaluateScriptHandler"), exports);

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CLIApplication_1 = require("./cli/CLIApplication");
+__exportStar(require("./types"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./connection"), exports);
+__exportStar(require("./handlers"), exports);
+__exportStar(require("./cli"), exports);
+async function main() {
+    const app = new CLIApplication_1.CLIApplication();
+    process.on('SIGINT', async () => {
+        console.log('\nShutting down...');
+        await app.shutdown();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await app.shutdown();
+        process.exit(0);
+    });
+    const exitCode = await app.run(process.argv);
+    process.exit(exitCode);
+}
+if (require.main === module) {
+    main().catch((error) => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}

package/dist/interfaces/CDPClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/CLIInterface.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLI_CONFIG = void 0;
+exports.DEFAULT_CLI_CONFIG = {
+    host: 'localhost',
+    port: 9222,
+    outputFormat: 'text',
+    verbose: false,
+    quiet: false,
+    timeout: 30000
+};

package/dist/interfaces/CommandHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/ConnectionManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CLIInterface"), exports);
+__exportStar(require("./CDPClient"), exports);
+__exportStar(require("./ConnectionManager"), exports);
+__exportStar(require("./CommandHandler"), exports);

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });