chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/handlers/GetConsoleMessageHandler.js

@@ -2,19 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetConsoleMessageHandler = void 0;
 const ConsoleMonitor_1 = require("../monitors/ConsoleMonitor");
+const ProxyClient_1 = require("../client/ProxyClient");
 class GetConsoleMessageHandler {
     constructor() {
         this.name = 'get_console_message';
         this.consoleMonitor = null;
+        this.proxyClient = null;
     }
     async execute(client, args) {
         try {
             const params = args;
-            if (!this.consoleMonitor) {
-                this.consoleMonitor = new ConsoleMonitor_1.ConsoleMonitor(client);
+            const proxyResult = await this.tryProxyExecution(params);
+            if (proxyResult) {
+                return proxyResult;
             }
-            if (params.startMonitoring || !this.consoleMonitor.isActive()) {
-                await this.consoleMonitor.startMonitoring();
+            return await this.executeDirectCDP(client, params);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    async tryProxyExecution(params) {
+        try {
+            if (!this.proxyClient) {
+                this.proxyClient = new ProxyClient_1.ProxyClient();
+            }
+            const isProxyAvailable = await this.proxyClient.isProxyAvailable();
+            if (!isProxyAvailable) {
+                console.warn('⚠️  Proxy server unavailable. Falling back to direct CDP connection.');
+                console.warn('⚠️  Note: Direct connection only captures NEW console messages, not historical data.');
+                return null;
+            }
+            if (!this.proxyClient.getConnectionId()) {
+                const host = params.host || 'localhost';
+                const port = params.port || 9222;
+                await this.proxyClient.connect(host, port, params.targetId);
             }
             const filter = {};
             if (params.type) {
@@ -23,11 +48,15 @@ class GetConsoleMessageHandler {
             if (params.textPattern) {
                 filter.textPattern = params.textPattern;
             }
-            const latestMessage = this.consoleMonitor.getLatestMessage(filter);
+            filter.maxMessages = 1;
+            const messages = await this.proxyClient.getConsoleMessages(filter);
+            const latestMessage = messages.length > 0 ? messages[messages.length - 1] : null;
             if (!latestMessage) {
                 return {
                     success: true,
-                    data: null
+                    data: null,
+                    dataSource: 'proxy',
+                    hasHistoricalData: true
                 };
             }
             return {
@@ -38,15 +67,52 @@ class GetConsoleMessageHandler {
                     args: latestMessage.args,
                     timestamp: latestMessage.timestamp,
                     stackTrace: latestMessage.stackTrace
-                }
+                },
+                dataSource: 'proxy',
+                hasHistoricalData: true
             };
         }
         catch (error) {
+            console.warn('⚠️  Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
+            console.warn('⚠️  Note: Direct connection only captures NEW console messages, not historical data.');
+            return null;
+        }
+    }
+    async executeDirectCDP(client, params) {
+        if (!this.consoleMonitor) {
+            this.consoleMonitor = new ConsoleMonitor_1.ConsoleMonitor(client);
+        }
+        if (params.startMonitoring || !this.consoleMonitor.isActive()) {
+            await this.consoleMonitor.startMonitoring();
+        }
+        const filter = {};
+        if (params.type) {
+            filter.types = [params.type];
+        }
+        if (params.textPattern) {
+            filter.textPattern = params.textPattern;
+        }
+        const latestMessage = this.consoleMonitor.getLatestMessage(filter);
+        if (!latestMessage) {
             return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
+                success: true,
+                data: null,
+                dataSource: 'direct',
+                hasHistoricalData: false
             };
         }
+        return {
+            success: true,
+            data: {
+                type: latestMessage.type,
+                text: latestMessage.text,
+                args: latestMessage.args,
+                timestamp: latestMessage.timestamp,
+                stackTrace: latestMessage.stackTrace
+            },
+            dataSource: 'direct',
+            hasHistoricalData: false
+        };
     }
     validateArgs(args) {
         if (!args || typeof args !== 'object') {
@@ -85,7 +151,11 @@ Examples:
   get_console_message
   get_console_message --type error
   get_console_message --textPattern "API"
-  get_console_message --startMonitoring`;
+  get_console_message --startMonitoring
+
+Note: This command now uses the proxy server when available, providing access to
+historical console messages from connection establishment. When proxy is unavailable,
+falls back to direct CDP connection (captures only new messages).`;
     }
 }
 exports.GetConsoleMessageHandler = GetConsoleMessageHandler;

package/dist/handlers/GetNetworkRequestHandler.js

@@ -2,43 +2,101 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetNetworkRequestHandler = void 0;
 const NetworkMonitor_1 = require("../monitors/NetworkMonitor");
+const ProxyClient_1 = require("../client/ProxyClient");
 class GetNetworkRequestHandler {
     constructor() {
         this.name = 'get_network_request';
         this.networkMonitor = null;
+        this.proxyClient = null;
     }
     async execute(client, args) {
         try {
             const params = args;
-            if (!this.networkMonitor) {
-                this.networkMonitor = new NetworkMonitor_1.NetworkMonitor(client);
+            const proxyResult = await this.tryProxyExecution(params);
+            if (proxyResult) {
+                return proxyResult;
             }
-            if (!this.networkMonitor.isActive()) {
-                await this.networkMonitor.startMonitoring();
+            return await this.executeDirectCDP(client, params);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    async tryProxyExecution(params) {
+        try {
+            if (!this.proxyClient) {
+                this.proxyClient = new ProxyClient_1.ProxyClient();
+            }
+            const isProxyAvailable = await this.proxyClient.isProxyAvailable();
+            if (!isProxyAvailable) {
+                console.warn('⚠️  Proxy server unavailable. Falling back to direct CDP connection.');
+                console.warn('⚠️  Note: Direct connection only captures NEW network requests, not historical data.');
+                return null;
+            }
+            if (!this.proxyClient.getConnectionId()) {
+                const host = params.host || 'localhost';
+                const port = params.port || 9222;
+                await this.proxyClient.connect(host, port, params.targetId);
             }
             const filter = params.filter ? {
                 methods: params.filter.methods,
                 urlPattern: params.filter.urlPattern,
                 statusCodes: params.filter.statusCodes,
-            } : undefined;
-            const latestRequest = this.networkMonitor.getLatestRequest(filter);
+                maxRequests: 1,
+            } : { maxRequests: 1 };
+            const requests = await this.proxyClient.getNetworkRequests(filter);
+            const latestRequest = requests.length > 0 ? requests[requests.length - 1] : null;
             if (!latestRequest) {
                 return {
                     success: true,
-                    data: null
+                    data: null,
+                    dataSource: 'proxy',
+                    hasHistoricalData: true
                 };
             }
             return {
                 success: true,
-                data: latestRequest
+                data: latestRequest,
+                dataSource: 'proxy',
+                hasHistoricalData: true
             };
         }
         catch (error) {
+            console.warn('⚠️  Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
+            console.warn('⚠️  Note: Direct connection only captures NEW network requests, not historical data.');
+            return null;
+        }
+    }
+    async executeDirectCDP(client, params) {
+        if (!this.networkMonitor) {
+            this.networkMonitor = new NetworkMonitor_1.NetworkMonitor(client);
+        }
+        if (!this.networkMonitor.isActive()) {
+            await this.networkMonitor.startMonitoring();
+        }
+        const filter = params.filter ? {
+            methods: params.filter.methods,
+            urlPattern: params.filter.urlPattern,
+            statusCodes: params.filter.statusCodes,
+        } : undefined;
+        const latestRequest = this.networkMonitor.getLatestRequest(filter);
+        if (!latestRequest) {
             return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
+                success: true,
+                data: null,
+                dataSource: 'direct',
+                hasHistoricalData: false
             };
         }
+        return {
+            success: true,
+            data: latestRequest,
+            dataSource: 'direct',
+            hasHistoricalData: false
+        };
     }
     getNetworkMonitor() {
         return this.networkMonitor;

package/dist/handlers/ListConsoleMessagesHandler.js

@@ -2,19 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListConsoleMessagesHandler = void 0;
 const ConsoleMonitor_1 = require("../monitors/ConsoleMonitor");
+const ProxyClient_1 = require("../client/ProxyClient");
 class ListConsoleMessagesHandler {
     constructor() {
         this.name = 'list_console_messages';
         this.consoleMonitor = null;
+        this.proxyClient = null;
     }
     async execute(client, args) {
         try {
             const params = args;
-            if (!this.consoleMonitor) {
-                this.consoleMonitor = new ConsoleMonitor_1.ConsoleMonitor(client);
+            const proxyResult = await this.tryProxyExecution(params);
+            if (proxyResult) {
+                return proxyResult;
             }
-            if (params.startMonitoring || !this.consoleMonitor.isActive()) {
-                await this.consoleMonitor.startMonitoring();
+            return await this.executeDirectCDP(client, params);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    async tryProxyExecution(params) {
+        try {
+            if (!this.proxyClient) {
+                this.proxyClient = new ProxyClient_1.ProxyClient();
+            }
+            const isProxyAvailable = await this.proxyClient.isProxyAvailable();
+            if (!isProxyAvailable) {
+                console.warn('⚠️  Proxy server unavailable. Falling back to direct CDP connection.');
+                console.warn('⚠️  Note: Direct connection only captures NEW console messages, not historical data.');
+                return null;
+            }
+            if (!this.proxyClient.getConnectionId()) {
+                const host = params.host || 'localhost';
+                const port = params.port || 9222;
+                await this.proxyClient.connect(host, port, params.targetId);
             }
             const filter = {};
             if (params.types && params.types.length > 0) {
@@ -32,7 +57,7 @@ class ListConsoleMessagesHandler {
             if (params.endTime) {
                 filter.endTime = params.endTime;
             }
-            const messages = this.consoleMonitor.getMessages(filter);
+            const messages = await this.proxyClient.getConsoleMessages(filter);
             return {
                 success: true,
                 data: {
@@ -44,16 +69,58 @@ class ListConsoleMessagesHandler {
                         stackTrace: msg.stackTrace
                     })),
                     totalCount: messages.length,
-                    isMonitoring: this.consoleMonitor.isActive()
-                }
+                    isMonitoring: true
+                },
+                dataSource: 'proxy',
+                hasHistoricalData: true
             };
         }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
+            console.warn('⚠️  Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
+            console.warn('⚠️  Note: Direct connection only captures NEW console messages, not historical data.');
+            return null;
+        }
+    }
+    async executeDirectCDP(client, params) {
+        if (!this.consoleMonitor) {
+            this.consoleMonitor = new ConsoleMonitor_1.ConsoleMonitor(client);
+        }
+        if (params.startMonitoring || !this.consoleMonitor.isActive()) {
+            await this.consoleMonitor.startMonitoring();
+        }
+        const filter = {};
+        if (params.types && params.types.length > 0) {
+            filter.types = params.types;
+        }
+        if (params.textPattern) {
+            filter.textPattern = params.textPattern;
+        }
+        if (params.maxMessages && params.maxMessages > 0) {
+            filter.maxMessages = params.maxMessages;
+        }
+        if (params.startTime) {
+            filter.startTime = params.startTime;
+        }
+        if (params.endTime) {
+            filter.endTime = params.endTime;
         }
+        const messages = this.consoleMonitor.getMessages(filter);
+        return {
+            success: true,
+            data: {
+                messages: messages.map(msg => ({
+                    type: msg.type,
+                    text: msg.text,
+                    args: msg.args,
+                    timestamp: msg.timestamp,
+                    stackTrace: msg.stackTrace
+                })),
+                totalCount: messages.length,
+                isMonitoring: this.consoleMonitor.isActive()
+            },
+            dataSource: 'direct',
+            hasHistoricalData: false
+        };
     }
     validateArgs(args) {
         if (!args || typeof args !== 'object') {
@@ -108,7 +175,11 @@ Examples:
   list_console_messages
   list_console_messages --types error,warn
   list_console_messages --textPattern "API" --maxMessages 10
-  list_console_messages --startTime 1640995200000`;
+  list_console_messages --startTime 1640995200000
+
+Note: This command now uses the proxy server when available, providing access to
+historical console messages from connection establishment. When proxy is unavailable,
+falls back to direct CDP connection (captures only new messages).`;
     }
 }
 exports.ListConsoleMessagesHandler = ListConsoleMessagesHandler;

package/dist/handlers/ListNetworkRequestsHandler.js

@@ -2,19 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListNetworkRequestsHandler = void 0;
 const NetworkMonitor_1 = require("../monitors/NetworkMonitor");
+const ProxyClient_1 = require("../client/ProxyClient");
 class ListNetworkRequestsHandler {
     constructor() {
         this.name = 'list_network_requests';
         this.networkMonitor = null;
+        this.proxyClient = null;
     }
     async execute(client, args) {
         try {
             const params = args;
-            if (!this.networkMonitor) {
-                this.networkMonitor = new NetworkMonitor_1.NetworkMonitor(client);
+            const proxyResult = await this.tryProxyExecution(params);
+            if (proxyResult) {
+                return proxyResult;
             }
-            if (!this.networkMonitor.isActive()) {
-                await this.networkMonitor.startMonitoring();
+            return await this.executeDirectCDP(client, params);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    async tryProxyExecution(params) {
+        try {
+            if (!this.proxyClient) {
+                this.proxyClient = new ProxyClient_1.ProxyClient();
+            }
+            const isProxyAvailable = await this.proxyClient.isProxyAvailable();
+            if (!isProxyAvailable) {
+                const proxyStarted = await this.proxyClient.ensureProxyRunning();
+                if (!proxyStarted) {
+                    console.warn('⚠️  Proxy server unavailable. Falling back to direct CDP connection.');
+                    console.warn('⚠️  Note: Direct connection only captures NEW network requests, not historical data.');
+                    return null;
+                }
+            }
+            if (!this.proxyClient.getConnectionId()) {
+                const host = params.host || 'localhost';
+                const port = params.port || 9222;
+                await this.proxyClient.connect(host, port, params.targetId);
             }
             const filter = params.filter ? {
                 methods: params.filter.methods,
@@ -24,22 +52,50 @@ class ListNetworkRequestsHandler {
                 startTime: params.filter.startTime,
                 endTime: params.filter.endTime,
             } : undefined;
-            const requests = this.networkMonitor.getRequests(filter);
+            const requests = await this.proxyClient.getNetworkRequests(filter);
             return {
                 success: true,
                 data: {
                     requests,
                     count: requests.length,
-                    isMonitoring: this.networkMonitor.isActive()
-                }
+                    isMonitoring: true
+                },
+                dataSource: 'proxy',
+                hasHistoricalData: true
             };
         }
         catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
+            console.warn('⚠️  Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
+            console.warn('⚠️  Note: Direct connection only captures NEW network requests, not historical data.');
+            return null;
+        }
+    }
+    async executeDirectCDP(client, params) {
+        if (!this.networkMonitor) {
+            this.networkMonitor = new NetworkMonitor_1.NetworkMonitor(client);
+        }
+        if (!this.networkMonitor.isActive()) {
+            await this.networkMonitor.startMonitoring();
         }
+        const filter = params.filter ? {
+            methods: params.filter.methods,
+            urlPattern: params.filter.urlPattern,
+            statusCodes: params.filter.statusCodes,
+            maxRequests: params.filter.maxRequests,
+            startTime: params.filter.startTime,
+            endTime: params.filter.endTime,
+        } : undefined;
+        const requests = this.networkMonitor.getRequests(filter);
+        return {
+            success: true,
+            data: {
+                requests,
+                count: requests.length,
+                isMonitoring: this.networkMonitor.isActive()
+            },
+            dataSource: 'direct',
+            hasHistoricalData: false
+        };
     }
     getNetworkMonitor() {
         return this.networkMonitor;

package/dist/monitors/ConsoleMonitor.js

@@ -13,10 +13,19 @@ class ConsoleMonitor {
             return;
         }
         await this.client.send('Runtime.enable');
+        try {
+            await this.client.send('Log.enable');
+        }
+        catch (error) {
+            console.warn('Log domain not available:', error);
+        }
         this.messageHandler = (params) => {
             this.handleConsoleMessage(params);
         };
         this.client.on('Runtime.consoleAPICalled', this.messageHandler);
+        this.client.on('Log.entryAdded', (params) => {
+            this.handleLogEntry(params);
+        });
         this.isMonitoring = true;
     }
     async stopMonitoring() {
@@ -82,6 +91,31 @@ class ConsoleMonitor {
             console.error('Error handling console message:', error);
         }
     }
+    handleLogEntry(params) {
+        try {
+            const logParams = params;
+            const entry = logParams.entry;
+            const message = {
+                type: this.mapLogLevel(entry.level),
+                text: entry.text,
+                args: [entry.text],
+                timestamp: entry.timestamp,
+                stackTrace: entry.url && entry.lineNumber ? [{
+                        functionName: '<unknown>',
+                        url: entry.url,
+                        lineNumber: entry.lineNumber,
+                        columnNumber: 0
+                    }] : undefined
+            };
+            this.messages.push(message);
+            if (this.messages.length > 1000) {
+                this.messages = this.messages.slice(-1000);
+            }
+        }
+        catch (error) {
+            console.error('Error handling log entry:', error);
+        }
+    }
     mapConsoleType(cdpType) {
         switch (cdpType) {
             case 'log':
@@ -98,6 +132,19 @@ class ConsoleMonitor {
                 return 'log';
         }
     }
+    mapLogLevel(logLevel) {
+        switch (logLevel.toLowerCase()) {
+            case 'verbose':
+            case 'info':
+                return 'info';
+            case 'warning':
+                return 'warn';
+            case 'error':
+                return 'error';
+            default:
+                return 'log';
+        }
+    }
     formatConsoleArgs(args) {
         return args.map(arg => {
             if (arg.value !== undefined) {