chrome-cdp-cli 2.1.1 → 2.1.2

package/dist/client/ProxyClient.js

@@ -1,278 +0,0 @@
-"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/handlers/RestartProxyHandler.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestartProxyHandler = void 0;
-const ProxyManager_1 = require("../proxy/ProxyManager");
-class RestartProxyHandler {
-    constructor() {
-        this.name = 'restart';
-    }
-    async execute(_client, args) {
-        try {
-            const params = args;
-            const proxyManager = ProxyManager_1.ProxyManager.getInstance();
-            const status = await proxyManager.getStatus();
-            if (status.isHealthy && !params.force) {
-                return {
-                    success: true,
-                    data: {
-                        message: 'Proxy server is already running and healthy',
-                        status: status
-                    }
-                };
-            }
-            const success = await proxyManager.restart();
-            if (success) {
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                const newStatus = await proxyManager.getStatus();
-                return {
-                    success: true,
-                    data: {
-                        message: 'Proxy server restarted successfully',
-                        status: newStatus
-                    }
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    error: 'Failed to restart proxy server. Check logs for details.'
-                };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred while restarting proxy'
-            };
-        }
-    }
-    validateArgs(args) {
-        if (typeof args !== 'object' || args === null) {
-            return false;
-        }
-        const params = args;
-        if ('force' in params && typeof params.force !== 'boolean') {
-            return false;
-        }
-        return true;
-    }
-    getHelp() {
-        return `
-restart - Restart the proxy server process
-
-Usage:
-  cdp restart
-  cdp restart --force
-
-Description:
-  Restarts the proxy server process. This will:
-  - Stop the current proxy server process
-  - Clear all stored console messages and network requests
-  - Start a new proxy server process
-
-When to use:
-  Use this command when console or network command output becomes stale:
-  - Console messages are not refreshing or showing old data
-  - Network requests are not updating or displaying outdated information
-  - Logs appear to be stuck or not reflecting current browser state
-  Restarting the proxy will clear the message store and start fresh monitoring.
-
-Options:
-  --force              Force restart even if proxy is healthy
-
-Examples:
-  # Restart the proxy server
-  cdp restart
-
-  # Force restart even if proxy is healthy
-  cdp restart --force
-
-Note:
-  - Restarting the proxy will clear all stored console messages and network requests
-  - The proxy server must be restarted if logs are not refreshing properly
-  - After restart, you may need to reconnect to Chrome DevTools
-`;
-    }
-}
-exports.RestartProxyHandler = RestartProxyHandler;

package/dist/proxy/ProxyManager.js

@@ -1,270 +0,0 @@
-"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 restart() {
-        return await this.startOrRestartProxy();
-    }
-    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;