chrome-cdp-cli 2.0.4 → 2.1.0

package/dist/handlers/InstallCursorCommandHandler.js

@@ -58,8 +58,8 @@ To install Cursor commands:
 4. Use --force to install anyway
 
 Examples:
-  chrome-cdp-cli install-cursor-command --target-directory /path/to/.cursor/commands
-  chrome-cdp-cli install-cursor-command --force`
+  cdp install-cursor-command --target-directory /path/to/.cursor/commands
+  cdp install-cursor-command --force`
                     };
                 }
             }
@@ -133,60 +133,60 @@ Examples:
 
 ### JavaScript Execution
 - **eval** - Execute JavaScript code and return results
-  \`chrome-cdp-cli eval "document.title"\`
-  \`chrome-cdp-cli eval "fetch('/api/data').then(r => r.json())"\`
+  \`cdp eval "document.title"\`
+  \`cdp eval "fetch('/api/data').then(r => r.json())"\`
 
 ### Screenshots and Snapshots
 - **screenshot** - Capture page screenshot
-  \`chrome-cdp-cli screenshot --filename page.png\`
-  \`chrome-cdp-cli screenshot --filename fullpage.png --full-page\`
+  \`cdp screenshot --filename page.png\`
+  \`cdp screenshot --filename fullpage.png --full-page\`
 
 - **snapshot** - Capture complete DOM snapshot
-  \`chrome-cdp-cli snapshot\`
-  \`chrome-cdp-cli snapshot --filename dom-snapshot.txt\`
+  \`cdp snapshot\`
+  \`cdp snapshot --filename dom-snapshot.txt\`
 
 ### Element Interaction
 - **click** - Click page elements
-  \`chrome-cdp-cli click "#submit-button"\`
-  \`chrome-cdp-cli click ".menu-item" --timeout 10000\`
+  \`cdp click "#submit-button"\`
+  \`cdp click ".menu-item" --timeout 10000\`
 
 - **hover** - Mouse hover over elements
-  \`chrome-cdp-cli hover "#dropdown-trigger"\`
+  \`cdp hover "#dropdown-trigger"\`
 
 - **fill** - Fill form fields
-  \`chrome-cdp-cli fill "#username" "john@example.com"\`
-  \`chrome-cdp-cli fill "input[name='password']" "secret123"\`
+  \`cdp fill "#username" "john@example.com"\`
+  \`cdp fill "input[name='password']" "secret123"\`
 
 - **fill_form** - Batch fill forms
-  \`chrome-cdp-cli fill_form '{"#username": "john", "#password": "secret"}'\`
+  \`cdp fill_form '{"#username": "john", "#password": "secret"}'\`
 
 ### Advanced Interactions
 - **drag** - Drag and drop operations
-  \`chrome-cdp-cli drag "#draggable" "#dropzone"\`
+  \`cdp drag "#draggable" "#dropzone"\`
 
 - **press_key** - Simulate keyboard input
-  \`chrome-cdp-cli press_key "Enter"\`
-  \`chrome-cdp-cli press_key "a" --modifiers Ctrl --selector "#input"\`
+  \`cdp press_key "Enter"\`
+  \`cdp press_key "a" --modifiers Ctrl --selector "#input"\`
 
 - **upload_file** - File upload
-  \`chrome-cdp-cli upload_file "input[type='file']" "./document.pdf"\`
+  \`cdp upload_file "input[type='file']" "./document.pdf"\`
 
 - **wait_for** - Wait for elements to appear or meet conditions
-  \`chrome-cdp-cli wait_for "#loading" --condition hidden\`
-  \`chrome-cdp-cli wait_for "#submit-btn" --condition enabled\`
+  \`cdp wait_for "#loading" --condition hidden\`
+  \`cdp wait_for "#submit-btn" --condition enabled\`
 
 - **handle_dialog** - Handle browser dialogs
-  \`chrome-cdp-cli handle_dialog accept\`
-  \`chrome-cdp-cli handle_dialog accept --text "user input"\`
+  \`cdp handle_dialog accept\`
+  \`cdp handle_dialog accept --text "user input"\`
 
 ### Monitoring
 - **console** - List console messages or get latest
-  \`chrome-cdp-cli console --latest\`
-  \`chrome-cdp-cli console --types error\`
+  \`cdp console --latest\`
+  \`cdp console --types error\`
 
 - **network** - List network requests or get latest
-  \`chrome-cdp-cli network --latest\`
-  \`chrome-cdp-cli network --filter '{"methods":["POST"]}'\`
+  \`cdp network --latest\`
+  \`cdp network --filter '{"methods":["POST"]}'\`
 
 ## Common Options
 
@@ -198,54 +198,54 @@ Examples:
 
 ### Form Testing
 \`\`\`bash
-chrome-cdp-cli wait_for "#login-form" --condition visible
-chrome-cdp-cli fill "#email" "test@example.com"
-chrome-cdp-cli fill "#password" "password123"
-chrome-cdp-cli click "#submit-button"
-chrome-cdp-cli wait_for "#success-message" --condition visible
-chrome-cdp-cli screenshot --filename login-success.png
-chrome-cdp-cli console --types error
+cdp wait_for "#login-form" --condition visible
+cdp fill "#email" "test@example.com"
+cdp fill "#password" "password123"
+cdp click "#submit-button"
+cdp wait_for "#success-message" --condition visible
+cdp screenshot --filename login-success.png
+cdp console --types error
 \`\`\`
 
 ### File Upload
 \`\`\`bash
-chrome-cdp-cli click "#upload-trigger"
-chrome-cdp-cli upload_file "input[type='file']" "./test-document.pdf"
-chrome-cdp-cli wait_for ".upload-success" --condition visible
-chrome-cdp-cli eval "document.querySelector('.file-name').textContent"
+cdp click "#upload-trigger"
+cdp upload_file "input[type='file']" "./test-document.pdf"
+cdp wait_for ".upload-success" --condition visible
+cdp eval "document.querySelector('.file-name').textContent"
 \`\`\`
 
 ### Drag and Drop
 \`\`\`bash
-chrome-cdp-cli wait_for "#draggable-item" --condition visible
-chrome-cdp-cli wait_for "#drop-zone" --condition visible
-chrome-cdp-cli drag "#draggable-item" "#drop-zone"
-chrome-cdp-cli eval "document.querySelector('#drop-zone').children.length"
+cdp wait_for "#draggable-item" --condition visible
+cdp wait_for "#drop-zone" --condition visible
+cdp drag "#draggable-item" "#drop-zone"
+cdp eval "document.querySelector('#drop-zone').children.length"
 \`\`\`
 
 ### Keyboard Input
 \`\`\`bash
-chrome-cdp-cli click "#search-input"
-chrome-cdp-cli press_key "t"
-chrome-cdp-cli press_key "e"
-chrome-cdp-cli press_key "s"
-chrome-cdp-cli press_key "t"
-chrome-cdp-cli press_key "a" --modifiers Ctrl
-chrome-cdp-cli press_key "Enter"
-chrome-cdp-cli handle_dialog accept
+cdp click "#search-input"
+cdp press_key "t"
+cdp press_key "e"
+cdp press_key "s"
+cdp press_key "t"
+cdp press_key "a" --modifiers Ctrl
+cdp press_key "Enter"
+cdp handle_dialog accept
 \`\`\``,
                 examples: [
-                    'chrome-cdp-cli eval "document.title"',
-                    'chrome-cdp-cli screenshot --filename page.png',
-                    'chrome-cdp-cli click "#submit-button"',
-                    'chrome-cdp-cli fill "#username" "test@example.com"',
-                    'chrome-cdp-cli drag "#item" "#target"',
-                    'chrome-cdp-cli press_key "Enter"',
-                    'chrome-cdp-cli upload_file "input[type=file]" "./doc.pdf"',
-                    'chrome-cdp-cli wait_for "#loading" --condition hidden',
-                    'chrome-cdp-cli handle_dialog accept',
-                    'chrome-cdp-cli console --latest',
-                    'chrome-cdp-cli network'
+                    'cdp eval "document.title"',
+                    'cdp screenshot --filename page.png',
+                    'cdp click "#submit-button"',
+                    'cdp fill "#username" "test@example.com"',
+                    'cdp drag "#item" "#target"',
+                    'cdp press_key "Enter"',
+                    'cdp upload_file "input[type=file]" "./doc.pdf"',
+                    'cdp wait_for "#loading" --condition hidden',
+                    'cdp handle_dialog accept',
+                    'cdp console --latest',
+                    'cdp network'
                 ]
             }
         ];

package/dist/handlers/ListConsoleMessagesHandler.js

@@ -2,118 +2,29 @@
 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 = 'console';
+        this.name = "log";
+        this.aliases = ["console"];
         this.consoleMonitor = null;
-        this.proxyClient = null;
     }
     async execute(client, args) {
         try {
             const params = args;
-            const proxyResult = await this.tryProxyExecution(params);
-            if (proxyResult) {
-                return proxyResult;
-            }
-            return await this.executeDirectCDP(client, params);
+            return await this.executeFollowMode(client, params);
         }
         catch (error) {
             return {
                 success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
+                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) {
-                filter.types = params.types;
-            }
-            if (params.textPattern) {
-                filter.textPattern = params.textPattern;
-            }
-            if (params.latest) {
-                filter.maxMessages = 1;
-            }
-            else 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 = await this.proxyClient.getConsoleMessages(filter);
-            if (params.latest) {
-                const latestMessage = messages.length > 0 ? messages[messages.length - 1] : null;
-                if (!latestMessage) {
-                    return {
-                        success: true,
-                        data: null,
-                        dataSource: 'proxy',
-                        hasHistoricalData: true
-                    };
-                }
-                return {
-                    success: true,
-                    data: {
-                        type: latestMessage.type,
-                        text: latestMessage.text,
-                        args: latestMessage.args,
-                        timestamp: latestMessage.timestamp,
-                        stackTrace: latestMessage.stackTrace
-                    },
-                    dataSource: 'proxy',
-                    hasHistoricalData: true
-                };
-            }
-            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: true
-                },
-                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) {
+    async executeFollowMode(client, params) {
         if (!this.consoleMonitor) {
             this.consoleMonitor = new ConsoleMonitor_1.ConsoleMonitor(client);
         }
-        if (params.startMonitoring || !this.consoleMonitor.isActive()) {
-            await this.consoleMonitor.startMonitoring();
-        }
+        await this.consoleMonitor.startMonitoring();
         const filter = {};
         if (params.types && params.types.length > 0) {
             filter.types = params.types;
@@ -121,120 +32,157 @@ class ListConsoleMessagesHandler {
         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;
-        }
-        if (params.latest) {
-            const latestMessage = this.consoleMonitor.getLatestMessage(filter);
-            if (!latestMessage) {
-                return {
-                    success: true,
-                    data: null,
-                    dataSource: 'direct',
-                    hasHistoricalData: false
-                };
+        const outputFormat = params.format || "text";
+        const messageCallback = (message) => {
+            if (!this.shouldOutputMessage(message, filter)) {
+                return;
             }
-            return {
-                success: true,
-                data: {
-                    type: latestMessage.type,
-                    text: latestMessage.text,
-                    args: latestMessage.args,
-                    timestamp: latestMessage.timestamp,
-                    stackTrace: latestMessage.stackTrace
-                },
-                dataSource: 'direct',
-                hasHistoricalData: false
-            };
+            this.outputMessage(message, outputFormat);
+        };
+        this.consoleMonitor.onMessage(messageCallback);
+        let isShuttingDown = false;
+        const cleanup = async () => {
+            if (isShuttingDown)
+                return;
+            isShuttingDown = true;
+            this.consoleMonitor?.offMessage(messageCallback);
+            await this.consoleMonitor?.stopMonitoring();
+        };
+        const signalHandler = async () => {
+            process.stderr.write("\n");
+            await cleanup();
+            process.exit(0);
+        };
+        process.removeAllListeners("SIGINT");
+        process.removeAllListeners("SIGTERM");
+        process.on("SIGINT", signalHandler);
+        process.on("SIGTERM", signalHandler);
+        if (outputFormat === "text") {
+            console.log("Following console messages (press Ctrl+C to stop)...\n");
         }
-        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()
+                message: "Following console messages in real-time. Press Ctrl+C to stop.",
+                isLongRunning: true,
             },
-            dataSource: 'direct',
-            hasHistoricalData: false
+            isLongRunning: true,
         };
     }
+    shouldOutputMessage(message, filter) {
+        if (filter.types && filter.types.length > 0) {
+            if (!filter.types.includes(message.type)) {
+                return false;
+            }
+        }
+        if (filter.textPattern) {
+            const pattern = new RegExp(filter.textPattern, "i");
+            if (!pattern.test(message.text)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    outputMessage(message, format) {
+        switch (format) {
+            case "json":
+                console.log(JSON.stringify({
+                    type: message.type,
+                    text: message.text,
+                    timestamp: message.timestamp,
+                    args: message.args,
+                    stackTrace: message.stackTrace,
+                }));
+                break;
+            case "pretty": {
+                const timestamp = new Date(message.timestamp).toISOString();
+                const typeColor = this.getTypeColor(message.type);
+                const typeLabel = message.type.toUpperCase().padEnd(5);
+                console.log(`[${timestamp}] ${typeColor}${typeLabel}\x1b[0m ${message.text}`);
+                if (message.stackTrace && message.stackTrace.length > 0) {
+                    const frame = message.stackTrace[0];
+                    console.log(`  at ${frame.functionName} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})`);
+                }
+                break;
+            }
+            case "text":
+            default: {
+                const time = new Date(message.timestamp).toISOString();
+                const type = message.type.toUpperCase().padEnd(5);
+                console.log(`[${time}] ${type} ${message.text}`);
+                break;
+            }
+        }
+    }
+    getTypeColor(type) {
+        switch (type) {
+            case "error":
+                return "\x1b[31m";
+            case "warn":
+                return "\x1b[33m";
+            case "info":
+                return "\x1b[36m";
+            case "debug":
+                return "\x1b[90m";
+            default:
+                return "\x1b[0m";
+        }
+    }
     validateArgs(args) {
-        if (!args || typeof args !== 'object') {
+        if (!args || typeof args !== "object") {
             return true;
         }
         const params = args;
         if (params.types !== undefined) {
-            if (!Array.isArray(params.types)) {
+            if (!Array.isArray(params.types))
                 return false;
-            }
-            const validTypes = ['log', 'info', 'warn', 'error', 'debug'];
+            const validTypes = ["log", "info", "warn", "error", "debug"];
             for (const type of params.types) {
-                if (typeof type !== 'string' || !validTypes.includes(type)) {
+                if (typeof type !== "string" || !validTypes.includes(type))
                     return false;
-                }
             }
         }
-        if (params.textPattern !== undefined && typeof params.textPattern !== 'string') {
+        if (params.textPattern !== undefined &&
+            typeof params.textPattern !== "string") {
             return false;
         }
-        if (params.maxMessages !== undefined) {
-            if (typeof params.maxMessages !== 'number' || params.maxMessages <= 0) {
+        if (params.format !== undefined) {
+            const validFormats = ["text", "json", "pretty"];
+            if (typeof params.format !== "string" ||
+                !validFormats.includes(params.format)) {
                 return false;
             }
         }
-        if (params.startTime !== undefined && typeof params.startTime !== 'number') {
-            return false;
-        }
-        if (params.endTime !== undefined && typeof params.endTime !== 'number') {
-            return false;
-        }
-        if (params.startMonitoring !== undefined && typeof params.startMonitoring !== 'boolean') {
-            return false;
-        }
-        if (params.latest !== undefined && typeof params.latest !== 'boolean') {
-            return false;
-        }
         return true;
     }
     getHelp() {
-        return `console - List console messages
-    
+        return `log - Follow console messages in real-time
+
 Usage:
-  console [options]
-  
+  cdp log [options]
+
 Options:
-  --latest                Get only the latest console message
   --types <types>         Filter by message types (comma-separated: log,info,warn,error,debug)
-  --textPattern <pattern> Filter by text pattern (regex)
-  --maxMessages <count>   Maximum number of messages to return
-  --startTime <timestamp> Filter messages after this timestamp
-  --endTime <timestamp>   Filter messages before this timestamp
-  --startMonitoring       Start monitoring if not already active
-  
+  --textPattern <pattern> Filter by text pattern (regex, case-insensitive)
+  --format <format>       Output format: text, json, or pretty (default: text)
+  -f, --follow            Alias flag (follow mode is always active)
+
 Examples:
-  console
-  console --latest
-  console --types error,warn
-  console --latest --type error
-  console --textPattern "API" --maxMessages 10
-  console --startTime 1640995200000
+  cdp log                                    # Follow all console messages
+  cdp log --types error,warn                 # Follow only errors and warnings
+  cdp log --textPattern "API"                # Follow messages matching /API/i
+  cdp log --format json                      # Output as JSON (one object per line)
+  cdp log --format pretty                    # Colorized output
+  cdp log --types error --textPattern "404"  # Combined filters
+
+Note:
+  This command runs continuously and streams console messages in real-time.
+  Press Ctrl+C to stop. The command connects directly to Chrome via CDP —
+  no background process is required. Only messages arriving after the command
+  starts will be shown.
 
-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).`;
+Aliases:
+  cdp console   (deprecated, use cdp log)`;
     }
 }
 exports.ListConsoleMessagesHandler = ListConsoleMessagesHandler;