chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/proxy/ProxyManager.js

@@ -0,0 +1,267 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyManager = void 0;
+const ProxyClient_1 = require("../client/ProxyClient");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class ProxyManager {
+    constructor(config) {
+        this.isStarting = false;
+        this.lastHealthCheck = 0;
+        this.healthCheckCacheMs = 5000;
+        this.config = {
+            proxyUrl: 'http://localhost:9223',
+            maxRetries: 3,
+            retryDelayMs: 1000,
+            healthCheckTimeoutMs: 2000,
+            startupTimeoutMs: 10000,
+            enableLogging: false,
+            ...config
+        };
+    }
+    static getInstance(config) {
+        if (!ProxyManager.instance) {
+            ProxyManager.instance = new ProxyManager(config);
+        }
+        return ProxyManager.instance;
+    }
+    async ensureProxyReady() {
+        try {
+            if (await this.isProxyHealthy()) {
+                return true;
+            }
+            return await this.startOrRestartProxy();
+        }
+        catch (error) {
+            this.log(`Failed to ensure proxy ready: ${error instanceof Error ? error.message : error}`);
+            return false;
+        }
+    }
+    async isProxyHealthy() {
+        const now = Date.now();
+        if (now - this.lastHealthCheck < this.healthCheckCacheMs) {
+            return true;
+        }
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.config.healthCheckTimeoutMs);
+            const response = await (0, node_fetch_1.default)(`${this.config.proxyUrl}/api/health`, {
+                method: 'GET',
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (response.ok) {
+                this.lastHealthCheck = now;
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async startOrRestartProxy() {
+        if (this.isStarting) {
+            return await this.waitForStartup();
+        }
+        this.isStarting = true;
+        try {
+            await this.killExistingProxy();
+            const success = await this.startProxyProcess();
+            if (success) {
+                this.log('Proxy server started successfully');
+            }
+            else {
+                this.log('Failed to start proxy server');
+            }
+            return success;
+        }
+        finally {
+            this.isStarting = false;
+        }
+    }
+    async killExistingProxy() {
+        if (this.proxyProcess) {
+            try {
+                this.proxyProcess.kill('SIGTERM');
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                if (!this.proxyProcess.killed) {
+                    this.proxyProcess.kill('SIGKILL');
+                }
+            }
+            catch (error) {
+            }
+            this.proxyProcess = undefined;
+        }
+        try {
+            const { spawn } = require('child_process');
+            const port = new URL(this.config.proxyUrl).port || '9223';
+            const lsof = spawn('lsof', ['-ti', `:${port}`]);
+            let pids = '';
+            lsof.stdout.on('data', (data) => {
+                pids += data.toString();
+            });
+            lsof.on('close', (code) => {
+                if (code === 0 && pids.trim()) {
+                    const pidList = pids.trim().split('\n');
+                    pidList.forEach(pid => {
+                        try {
+                            process.kill(parseInt(pid), 'SIGTERM');
+                        }
+                        catch (error) {
+                        }
+                    });
+                }
+            });
+        }
+        catch (error) {
+        }
+    }
+    async startProxyProcess() {
+        try {
+            const proxyServerPath = this.findProxyServerExecutable();
+            if (!proxyServerPath) {
+                this.log('Proxy server executable not found');
+                return false;
+            }
+            this.log(`Starting proxy server: ${proxyServerPath}`);
+            this.proxyProcess = (0, child_process_1.spawn)('node', [proxyServerPath], {
+                detached: true,
+                stdio: this.config.enableLogging ? 'inherit' : 'ignore'
+            });
+            this.proxyProcess.unref();
+            this.proxyProcess.on('error', (error) => {
+                this.log(`Proxy process error: ${error.message}`);
+                this.proxyProcess = undefined;
+            });
+            this.proxyProcess.on('exit', (code, signal) => {
+                this.log(`Proxy process exited with code ${code}, signal ${signal}`);
+                this.proxyProcess = undefined;
+            });
+            return await this.waitForProxyStartup();
+        }
+        catch (error) {
+            this.log(`Failed to start proxy process: ${error instanceof Error ? error.message : error}`);
+            return false;
+        }
+    }
+    async waitForProxyStartup() {
+        const startTime = Date.now();
+        const maxWaitTime = this.config.startupTimeoutMs;
+        while (Date.now() - startTime < maxWaitTime) {
+            this.lastHealthCheck = 0;
+            if (await this.isProxyHealthy()) {
+                return true;
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        this.log(`Proxy startup timeout after ${maxWaitTime}ms`);
+        return false;
+    }
+    async waitForStartup() {
+        const maxWait = this.config.startupTimeoutMs;
+        const startTime = Date.now();
+        while (this.isStarting && Date.now() - startTime < maxWait) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        return !this.isStarting && await this.isProxyHealthy();
+    }
+    findProxyServerExecutable() {
+        const distPath = path.join(__dirname, '../../dist/proxy/index.js');
+        if (fs.existsSync(distPath)) {
+            return distPath;
+        }
+        const srcPath = path.join(__dirname, '../proxy/index.js');
+        if (fs.existsSync(srcPath)) {
+            return srcPath;
+        }
+        const currentDistPath = path.join(process.cwd(), 'dist/proxy/index.js');
+        if (fs.existsSync(currentDistPath)) {
+            return currentDistPath;
+        }
+        const nodeModulesPath = path.join(__dirname, '../../../node_modules/chrome-cdp-cli/dist/proxy/index.js');
+        if (fs.existsSync(nodeModulesPath)) {
+            return nodeModulesPath;
+        }
+        return null;
+    }
+    async getProxyClient() {
+        if (await this.ensureProxyReady()) {
+            return new ProxyClient_1.ProxyClient({
+                proxyUrl: this.config.proxyUrl,
+                fallbackToDirect: true,
+                startProxyIfNeeded: false
+            });
+        }
+        return null;
+    }
+    async shutdown() {
+        if (this.proxyProcess) {
+            try {
+                this.proxyProcess.kill('SIGTERM');
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                if (!this.proxyProcess.killed) {
+                    this.proxyProcess.kill('SIGKILL');
+                }
+            }
+            catch (error) {
+            }
+            this.proxyProcess = undefined;
+        }
+    }
+    setLogging(enabled) {
+        this.config.enableLogging = enabled;
+    }
+    log(message) {
+        if (this.config.enableLogging) {
+            console.log(`[ProxyManager] ${message}`);
+        }
+    }
+    async getStatus() {
+        return {
+            isHealthy: await this.isProxyHealthy(),
+            isStarting: this.isStarting,
+            hasProcess: !!this.proxyProcess,
+            lastHealthCheck: this.lastHealthCheck
+        };
+    }
+}
+exports.ProxyManager = ProxyManager;

package/dist/proxy/index.js

@@ -0,0 +1,60 @@
+"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 });
+exports.CDPProxyServer = void 0;
+exports.startProxyServer = startProxyServer;
+const CDPProxyServer_1 = require("./server/CDPProxyServer");
+Object.defineProperty(exports, "CDPProxyServer", { enumerable: true, get: function () { return CDPProxyServer_1.CDPProxyServer; } });
+const logger_1 = require("../utils/logger");
+const logger = new logger_1.Logger();
+async function startProxyServer(config) {
+    const server = new CDPProxyServer_1.CDPProxyServer();
+    try {
+        await server.start(config);
+        logger.info('Proxy server started successfully');
+        return server;
+    }
+    catch (error) {
+        logger.error('Failed to start proxy server:', error);
+        throw error;
+    }
+}
+async function main() {
+    if (require.main === module) {
+        try {
+            const server = await startProxyServer();
+            process.on('SIGINT', async () => {
+                logger.info('Received SIGINT, shutting down gracefully...');
+                await server.stop();
+                process.exit(0);
+            });
+            process.on('SIGTERM', async () => {
+                logger.info('Received SIGTERM, shutting down gracefully...');
+                await server.stop();
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            logger.error('Proxy server failed to start:', error);
+            process.exit(1);
+        }
+    }
+}
+__exportStar(require("./types/ProxyTypes"), exports);
+main().catch(error => {
+    console.error('Unhandled error:', error);
+    process.exit(1);
+});

package/dist/proxy/server/CDPEventMonitor.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPEventMonitor = void 0;
+const logger_1 = require("../../utils/logger");
+class CDPEventMonitor {
+    constructor(messageStore) {
+        this.monitoredConnections = new Map();
+        this.eventHandlers = new Map();
+        this.messageIdCounter = 1;
+        this.messageStore = messageStore;
+        this.logger = new logger_1.Logger();
+    }
+    async startMonitoring(connectionInfo) {
+        const { id: connectionId, connection } = connectionInfo;
+        if (this.monitoredConnections.has(connectionId)) {
+            this.logger.debug(`Already monitoring connection ${connectionId}`);
+            return;
+        }
+        try {
+            this.logger.info(`[DEBUG] Starting CDP event monitoring for connection ${connectionId}`);
+            this.logger.info(`[DEBUG] Connection WebSocket state: ${connection.readyState} (OPEN=1)`);
+            this.logger.info(`[DEBUG] Setting up event handlers for connection ${connectionId}`);
+            this.setupEventHandlers(connectionId, connection);
+            this.logger.info(`[DEBUG] Event handlers set up for connection ${connectionId}`);
+            this.logger.info(`[DEBUG] Enabling CDP domains for connection ${connectionId}`);
+            await this.enableCDPDomains(connection);
+            this.logger.info(`[DEBUG] CDP domains enabled for connection ${connectionId}`);
+            this.monitoredConnections.set(connectionId, connectionInfo);
+            this.logger.info(`[DEBUG] CDP event monitoring started for connection ${connectionId}`);
+        }
+        catch (error) {
+            this.logger.error(`[DEBUG] Failed to start monitoring for connection ${connectionId}:`, error);
+            throw error;
+        }
+    }
+    async stopMonitoring(connectionId) {
+        const connectionInfo = this.monitoredConnections.get(connectionId);
+        if (!connectionInfo) {
+            this.logger.debug(`Connection ${connectionId} not being monitored`);
+            return;
+        }
+        try {
+            this.logger.info(`Stopping CDP event monitoring for connection ${connectionId}`);
+            this.removeEventHandlers(connectionId, connectionInfo.connection);
+            this.monitoredConnections.delete(connectionId);
+            this.logger.info(`CDP event monitoring stopped for connection ${connectionId}`);
+        }
+        catch (error) {
+            this.logger.error(`Error stopping monitoring for connection ${connectionId}:`, error);
+        }
+    }
+    async stopAllMonitoring() {
+        const connectionIds = Array.from(this.monitoredConnections.keys());
+        for (const connectionId of connectionIds) {
+            await this.stopMonitoring(connectionId);
+        }
+    }
+    getMonitoredConnections() {
+        return Array.from(this.monitoredConnections.keys());
+    }
+    isMonitoring(connectionId) {
+        return this.monitoredConnections.has(connectionId);
+    }
+    async enableCDPDomains(connection) {
+        const commands = [
+            { method: 'Runtime.enable', params: {} },
+            { method: 'Log.enable', params: {} },
+            { method: 'Network.enable', params: {} }
+        ];
+        for (const command of commands) {
+            try {
+                this.logger.info(`[DEBUG] Sending CDP command: ${command.method}`);
+                const result = await this.sendCDPCommand(connection, command.method, command.params);
+                this.logger.info(`[DEBUG] Successfully enabled CDP domain: ${command.method}, result: ${JSON.stringify(result)}`);
+            }
+            catch (error) {
+                this.logger.warn(`[DEBUG] Failed to enable ${command.method}:`, error);
+            }
+        }
+    }
+    async sendCDPCommand(connection, method, params = {}) {
+        return new Promise((resolve, reject) => {
+            const id = this.messageIdCounter++;
+            const command = { id, method, params };
+            this.logger.info(`[DEBUG] sendCDPCommand: sending command id=${id}, method=${method}`);
+            const timeout = setTimeout(() => {
+                this.logger.warn(`[DEBUG] sendCDPCommand: timeout for command id=${id}, method=${method}`);
+                connection.off('message', messageHandler);
+                reject(new Error(`CDP command timeout: ${method}`));
+            }, 5000);
+            const messageHandler = (data) => {
+                try {
+                    const rawMessage = data.toString();
+                    const response = JSON.parse(rawMessage);
+                    this.logger.info(`[DEBUG] sendCDPCommand: received raw message: ${rawMessage.substring(0, 200)}`);
+                    this.logger.info(`[DEBUG] sendCDPCommand: parsed response, id=${response.id}, method=${response.method}, waiting for id=${id}`);
+                    if (response.id !== undefined && response.id === id) {
+                        this.logger.info(`[DEBUG] sendCDPCommand: matched response id=${id} for method=${method}`);
+                        clearTimeout(timeout);
+                        connection.off('message', messageHandler);
+                        if (response.error) {
+                            this.logger.error(`[DEBUG] sendCDPCommand: command error for method=${method}: ${response.error.message}`);
+                            reject(new Error(`CDP command error: ${response.error.message}`));
+                        }
+                        else {
+                            this.logger.info(`[DEBUG] sendCDPCommand: command success for method=${method}`);
+                            resolve(response.result);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`[DEBUG] sendCDPCommand: ignoring message with id=${response.id}, waiting for id=${id}`);
+                    }
+                }
+                catch (error) {
+                    this.logger.debug(`[DEBUG] sendCDPCommand: error parsing message:`, error);
+                }
+            };
+            connection.on('message', messageHandler);
+            this.logger.info(`[DEBUG] sendCDPCommand: handler registered, sending command`);
+            connection.send(JSON.stringify(command));
+            this.logger.info(`[DEBUG] sendCDPCommand: command sent`);
+        });
+    }
+    setupEventHandlers(connectionId, connection) {
+        const handlers = new Map();
+        const eventHandler = (data) => {
+            try {
+                const rawMessage = data.toString();
+                const message = JSON.parse(rawMessage);
+                this.logger.info(`[DEBUG] setupEventHandlers: received raw message: ${rawMessage.substring(0, 200)}`);
+                this.logger.info(`[DEBUG] setupEventHandlers: parsed message, id=${message.id}, method=${message.method || 'none'}, hasParams=${!!message.params}`);
+                if (message.method && message.params && message.id === undefined) {
+                    this.logger.info(`[DEBUG] setupEventHandlers: processing CDP event: ${message.method} for connection ${connectionId}`);
+                    this.handleCDPEvent(connectionId, message.method, message.params);
+                }
+                else if (message.id !== undefined) {
+                    this.logger.debug(`[DEBUG] setupEventHandlers: ignoring command response with id=${message.id}`);
+                }
+                else {
+                    this.logger.warn(`[DEBUG] setupEventHandlers: received unexpected message format: ${rawMessage.substring(0, 200)}`);
+                }
+            }
+            catch (error) {
+                this.logger.debug(`[DEBUG] Error parsing message for connection ${connectionId}:`, error);
+            }
+        };
+        handlers.set('message', eventHandler);
+        this.eventHandlers.set(connectionId, handlers);
+        connection.on('message', eventHandler);
+        this.logger.info(`[DEBUG] Event handler attached to connection ${connectionId}`);
+    }
+    removeEventHandlers(connectionId, connection) {
+        const handlers = this.eventHandlers.get(connectionId);
+        if (!handlers) {
+            return;
+        }
+        for (const [event, handler] of handlers) {
+            connection.off(event, handler);
+        }
+        this.eventHandlers.delete(connectionId);
+    }
+    handleCDPEvent(connectionId, method, params) {
+        try {
+            this.logger.info(`[DEBUG] handleCDPEvent called: method=${method}, connectionId=${connectionId}`);
+            switch (method) {
+                case 'Runtime.consoleAPICalled':
+                    this.logger.info(`[DEBUG] Processing Runtime.consoleAPICalled event for connection ${connectionId}`);
+                    this.handleConsoleAPIEvent(connectionId, params);
+                    break;
+                case 'Log.entryAdded':
+                    this.logger.info(`[DEBUG] Processing Log.entryAdded event for connection ${connectionId}`);
+                    this.handleLogEntryEvent(connectionId, params);
+                    break;
+                case 'Network.requestWillBeSent':
+                    this.logger.info(`[DEBUG] Processing Network.requestWillBeSent event for connection ${connectionId}`);
+                    this.handleNetworkRequestWillBeSent(connectionId, params);
+                    break;
+                case 'Network.responseReceived':
+                    this.logger.info(`[DEBUG] Processing Network.responseReceived event for connection ${connectionId}`);
+                    this.handleNetworkResponseReceived(connectionId, params);
+                    break;
+                case 'Network.loadingFinished':
+                    this.logger.info(`[DEBUG] Processing Network.loadingFinished event for connection ${connectionId}`);
+                    this.handleNetworkLoadingFinished(connectionId, params);
+                    break;
+                case 'Network.loadingFailed':
+                    this.logger.info(`[DEBUG] Processing Network.loadingFailed event for connection ${connectionId}`);
+                    this.handleNetworkLoadingFailed(connectionId, params);
+                    break;
+                default:
+                    this.logger.debug(`[DEBUG] Ignoring CDP event: ${method}`);
+                    break;
+            }
+        }
+        catch (error) {
+            this.logger.error(`[DEBUG] Error handling CDP event ${method} for connection ${connectionId}:`, error);
+        }
+    }
+    handleConsoleAPIEvent(connectionId, params) {
+        this.logger.info(`[DEBUG] handleConsoleAPIEvent called for connection ${connectionId}, params: ${JSON.stringify(params).substring(0, 200)}`);
+        this.messageStore.processConsoleAPIEvent(connectionId, params);
+        this.logger.info(`[DEBUG] handleConsoleAPIEvent completed for connection ${connectionId}`);
+    }
+    handleLogEntryEvent(connectionId, params) {
+        this.messageStore.processLogEntryEvent(connectionId, params);
+    }
+    handleNetworkRequestWillBeSent(connectionId, params) {
+        try {
+            this.logger.info(`[DEBUG] handleNetworkRequestWillBeSent called for connection ${connectionId}, url: ${params.request?.url}, method: ${params.request?.method}`);
+            const networkRequest = {
+                connectionId,
+                requestId: params.requestId,
+                url: params.request.url,
+                method: params.request.method,
+                headers: params.request.headers || {},
+                timestamp: params.wallTime ? params.wallTime * 1000 : Date.now(),
+                loadingFinished: false
+            };
+            this.logger.info(`[DEBUG] Created network request: ${JSON.stringify(networkRequest).substring(0, 200)}`);
+            this.messageStore.addNetworkRequest(connectionId, networkRequest);
+            this.logger.info(`[DEBUG] Network request added to store for connection ${connectionId}`);
+        }
+        catch (error) {
+            this.logger.error('[DEBUG] Error processing Network.requestWillBeSent:', error);
+        }
+    }
+    handleNetworkResponseReceived(connectionId, params) {
+        try {
+            const update = {
+                status: params.response.status,
+                responseHeaders: params.response.headers || {}
+            };
+            this.messageStore.updateNetworkRequest(connectionId, params.requestId, update);
+        }
+        catch (error) {
+            this.logger.error('Error processing Network.responseReceived:', error);
+        }
+    }
+    handleNetworkLoadingFinished(connectionId, params) {
+        try {
+            const update = {
+                loadingFinished: true
+            };
+            this.messageStore.updateNetworkRequest(connectionId, params.requestId, update);
+        }
+        catch (error) {
+            this.logger.error('Error processing Network.loadingFinished:', error);
+        }
+    }
+    handleNetworkLoadingFailed(connectionId, params) {
+        try {
+            const update = {
+                status: 0,
+                loadingFinished: true
+            };
+            this.messageStore.updateNetworkRequest(connectionId, params.requestId, update);
+        }
+        catch (error) {
+            this.logger.error('Error processing Network.loadingFailed:', error);
+        }
+    }
+}
+exports.CDPEventMonitor = CDPEventMonitor;