chrome-cdp-cli 1.0.1 → 1.1.0

package/README.md

@@ -2,17 +2,46 @@
 
 A powerful command-line tool for controlling Chrome browser instances via the Chrome DevTools Protocol (CDP). This tool provides programmatic access to browser automation, debugging, and inspection capabilities without requiring a graphical interface.
 
+## Implementation Status
+
+### ✅ Fully Implemented Features
+
+- 🔗 **Connection Management**: Connect to local or remote Chrome instances with auto-discovery
+- ⚡ **JavaScript Execution**: Execute JavaScript code in browser context with full async support and file execution
+- 📸 **Visual Capture**: Take screenshots and capture complete DOM snapshots with layout information
+- 📊 **Console Monitoring**: Real-time console message capture with filtering and storage
+- 🌐 **Network Monitoring**: Real-time network request/response monitoring with comprehensive filtering
+- 🔧 **CLI Interface**: Full command-line interface with argument parsing and routing
+- 📦 **Build System**: Complete TypeScript build pipeline with testing framework
+
+### 🚧 Eval Workaround Available
+
+These features are not directly implemented but can be achieved using the `eval` command:
+
+- 📄 **Page Navigation**: `eval "window.location.href = 'https://example.com'"`
+- 🖱️ **Element Interaction**: `eval "document.querySelector('#btn').click()"`
+- 📝 **Form Filling**: `eval "document.querySelector('#input').value = 'text'"`
+- 📄 **HTML Content**: `eval "document.documentElement.outerHTML"`
+- 🚀 **Performance Data**: `eval "performance.now()"` or `eval "performance.getEntriesByType('navigation')"`
+- 📱 **User Agent**: `eval "navigator.userAgent"`
+- 🌐 **Network Requests**: `eval "fetch('/api').then(r => r.json())"`
+
+### ⏳ Not Yet Implemented
+
+- 📄 **Direct Page Management**: Native commands for creating, closing, listing, and selecting tabs
+- 🖱️ **Direct Element Interaction**: Native click, hover, drag, and form filling commands
+- 🚀 **Performance Analysis**: Native performance profiling and metrics collection
+- 📱 **Device Emulation**: Native device and network condition simulation
+- 📊 **Output Formatting**: Advanced JSON/text formatting with quiet/verbose modes
+
 ## Features
 
 - 🔗 **Connection Management**: Connect to local or remote Chrome instances
-- 📄 **Page Management**: Navigate, create, close, and manage browser tabs
 - ⚡ **JavaScript Execution**: Execute JavaScript code in browser context with full async support
 - 📸 **Visual Capture**: Take screenshots and capture HTML content
-- 🖱️ **Element Interaction**: Click, hover, fill forms, and interact with page elements
 - 📊 **Monitoring**: Monitor console messages and network requests in real-time
-- 🚀 **Performance Analysis**: Profile page performance and analyze metrics
-- 📱 **Device Emulation**: Simulate different devices and network conditions
 - 🔧 **Flexible Output**: Support for JSON and human-readable text output formats
+- 🚧 **Eval Workarounds**: Many advanced features available through JavaScript execution
 
 ## Installation
 
@@ -77,17 +106,26 @@ chrome-cdp-cli eval "document.title"
 # Or use with npx (no installation needed)
 npx chrome-cdp-cli eval "document.title"
 
-# Navigate to a website
-chrome-cdp-cli navigate_page "https://example.com"
+# Navigate to a website (via eval)
+chrome-cdp-cli eval "window.location.href = 'https://example.com'"
 
 # Take a screenshot
 chrome-cdp-cli screenshot --filename screenshot.png
 
-# Click an element
-chrome-cdp-cli click "#submit-button"
+# Capture DOM snapshot
+chrome-cdp-cli snapshot --filename dom-snapshot.json
+
+# Click an element (via eval)
+chrome-cdp-cli eval "document.querySelector('#submit-button').click()"
 
-# Fill a form field
-chrome-cdp-cli fill "#email" "user@example.com"
+# Fill a form field (via eval)
+chrome-cdp-cli eval "document.querySelector('#email').value = 'user@example.com'"
+
+# Monitor console messages
+chrome-cdp-cli get_console_message
+
+# Monitor network requests
+chrome-cdp-cli get_network_request
 
 # Get help for all commands
 chrome-cdp-cli --help
@@ -112,7 +150,23 @@ All commands support these connection options:
 - `--quiet`: Suppress non-essential output
 - `--verbose`: Enable detailed logging
 
-### Core Commands
+## Command Reference
+
+### Connection Options
+
+All commands support these connection options:
+
+- `--host <host>`: Chrome host (default: localhost)
+- `--port <port>`: DevTools port (default: 9222)
+- `--timeout <ms>`: Command timeout in milliseconds (default: 30000)
+
+### Output Options
+
+- `--format <format>`: Output format - 'json' or 'text' (default: text)
+- `--quiet`: Suppress non-essential output
+- `--verbose`: Enable detailed logging
+
+### ✅ Implemented Commands
 
 #### JavaScript Execution
 ```bash
@@ -130,57 +184,299 @@ npx chrome-cdp-cli eval "document.title"
 npx chrome-cdp-cli eval --file script.js
 ```
 
+#### Visual Capture
+```bash
+# Take screenshot
+chrome-cdp-cli screenshot --filename screenshot.png
+
+# Full page screenshot  
+chrome-cdp-cli screenshot --full-page --filename fullpage.png
+
+# DOM snapshot with complete layout information
+chrome-cdp-cli snapshot --filename dom-snapshot.json
+
+# Custom dimensions
+chrome-cdp-cli screenshot --width 1920 --height 1080 --filename custom.png
+```
+
+#### Console Monitoring
+```bash
+# Get latest console message
+chrome-cdp-cli get_console_message
+
+# List all console messages
+chrome-cdp-cli list_console_messages
+
+# Filter console messages
+chrome-cdp-cli list_console_messages --filter '{"types":["error","warn"]}'
+```
+
+#### Network Monitoring
+```bash
+# Get latest network request
+chrome-cdp-cli get_network_request
+
+# List all network requests
+chrome-cdp-cli list_network_requests
+
+# Filter network requests
+chrome-cdp-cli list_network_requests --filter '{"methods":["POST"],"statusCodes":[200,201]}'
+```
+
+### 🚧 Available via Eval Workarounds
+
 #### Page Management
 ```bash
 # Navigate to URL
-chrome-cdp-cli navigate_page "https://example.com"
+chrome-cdp-cli eval "window.location.href = 'https://example.com'"
 
-# Create new tab
-chrome-cdp-cli new_page
+# Get current URL
+chrome-cdp-cli eval "window.location.href"
 
-# List all pages
-chrome-cdp-cli list_pages
+# Reload page
+chrome-cdp-cli eval "window.location.reload()"
 
-# Close current page
-chrome-cdp-cli close_page
+# Go back
+chrome-cdp-cli eval "window.history.back()"
 
-# Switch to specific page
-chrome-cdp-cli select_page --id "page-id"
+# Go forward
+chrome-cdp-cli eval "window.history.forward()"
 ```
 
 #### Element Interaction
 ```bash
 # Click element
-chrome-cdp-cli click "#button"
+chrome-cdp-cli eval "document.querySelector('#button').click()"
 
 # Fill input field
-chrome-cdp-cli fill "#email" "user@example.com"
+chrome-cdp-cli eval "document.querySelector('#email').value = 'user@example.com'"
+
+# Hover over element (trigger mouseover event)
+chrome-cdp-cli eval "document.querySelector('.menu-item').dispatchEvent(new MouseEvent('mouseover'))"
 
-# Hover over element
-chrome-cdp-cli hover ".menu-item"
+# Check if element exists
+chrome-cdp-cli eval "!!document.querySelector('#element')"
 
-# Wait for element
-chrome-cdp-cli wait_for "#loading" --timeout 5000
+# Get element text
+chrome-cdp-cli eval "document.querySelector('#element').textContent"
+
+# Get element attributes
+chrome-cdp-cli eval "document.querySelector('#element').getAttribute('class')"
 ```
 
-#### Visual Capture
+#### Form Handling
 ```bash
-# Take screenshot
-chrome-cdp-cli screenshot --filename screenshot.png
+# Fill multiple form fields
+chrome-cdp-cli eval "
+document.querySelector('#name').value = 'John Doe';
+document.querySelector('#email').value = 'john@example.com';
+document.querySelector('#phone').value = '123-456-7890';
+"
 
-# Full page screenshot  
-chrome-cdp-cli screenshot --full-page --filename fullpage.png
+# Submit form
+chrome-cdp-cli eval "document.querySelector('#myform').submit()"
 
-# DOM snapshot
-chrome-cdp-cli snapshot --filename dom-snapshot.json
+# Select dropdown option
+chrome-cdp-cli eval "document.querySelector('#dropdown').value = 'option1'"
 
-# Custom dimensions
-chrome-cdp-cli screenshot --width 1920 --height 1080 --filename custom.png
+# Check checkbox
+chrome-cdp-cli eval "document.querySelector('#checkbox').checked = true"
+```
+
+#### Content Extraction
+```bash
+# Get page HTML
+chrome-cdp-cli eval "document.documentElement.outerHTML"
+
+# Get page title
+chrome-cdp-cli eval "document.title"
+
+# Get all links
+chrome-cdp-cli eval "Array.from(document.querySelectorAll('a')).map(a => a.href)"
+
+# Get all images
+chrome-cdp-cli eval "Array.from(document.querySelectorAll('img')).map(img => img.src)"
+
+# Extract table data
+chrome-cdp-cli eval "Array.from(document.querySelectorAll('table tr')).map(row => Array.from(row.cells).map(cell => cell.textContent))"
+```
+
+#### Performance Monitoring
+```bash
+# Get performance timing
+chrome-cdp-cli eval "performance.timing"
+
+# Get navigation entries
+chrome-cdp-cli eval "performance.getEntriesByType('navigation')"
+
+# Get resource entries
+chrome-cdp-cli eval "performance.getEntriesByType('resource')"
+
+# Get current timestamp
+chrome-cdp-cli eval "performance.now()"
+
+# Measure performance
+chrome-cdp-cli eval "
+performance.mark('start');
+// ... some operation ...
+performance.mark('end');
+performance.measure('operation', 'start', 'end');
+performance.getEntriesByName('operation')[0].duration;
+"
+```
+
+#### Network Operations
+```bash
+# Make HTTP request
+chrome-cdp-cli eval "fetch('/api/data').then(r => r.json())"
+
+# POST data
+chrome-cdp-cli eval "
+fetch('/api/users', {
+  method: 'POST',
+  headers: {'Content-Type': 'application/json'},
+  body: JSON.stringify({name: 'John', email: 'john@example.com'})
+}).then(r => r.json())
+"
+
+# Check network connectivity
+chrome-cdp-cli eval "navigator.onLine"
+```
 
-# Get HTML content
-chrome-cdp-cli get_html --output page.html
+#### Browser Information
+```bash
+# Get user agent
+chrome-cdp-cli eval "navigator.userAgent"
+
+# Get viewport size
+chrome-cdp-cli eval "{width: window.innerWidth, height: window.innerHeight}"
+
+# Get screen resolution
+chrome-cdp-cli eval "{width: screen.width, height: screen.height}"
+
+# Get browser language
+chrome-cdp-cli eval "navigator.language"
+
+# Get cookies
+chrome-cdp-cli eval "document.cookie"
+```
+
+### ⏳ Not Yet Implemented
+
+These features require dedicated handlers and are not yet available:
+
+- Native page management commands (new_page, close_page, list_pages, select_page)
+- Native element interaction commands (click, hover, fill, drag)
+- Native performance profiling commands
+- Native device emulation commands
+- Advanced output formatting options
+
+## The Power of Eval
+
+The `eval` command is the most powerful feature of this CLI tool. It allows you to execute any JavaScript code in the browser context, making it possible to achieve almost any browser automation task. Here are some advanced examples:
+
+### Advanced Automation Examples
+
+```bash
+# Wait for element to appear
+chrome-cdp-cli eval "
+new Promise(resolve => {
+  const check = () => {
+    const element = document.querySelector('#dynamic-content');
+    if (element) resolve(element.textContent);
+    else setTimeout(check, 100);
+  };
+  check();
+})
+"
+
+# Scroll to element
+chrome-cdp-cli eval "
+document.querySelector('#target').scrollIntoView({behavior: 'smooth'});
+"
+
+# Take element screenshot (get element bounds for screenshot)
+chrome-cdp-cli eval "
+const element = document.querySelector('#target');
+const rect = element.getBoundingClientRect();
+({x: rect.x, y: rect.y, width: rect.width, height: rect.height})
+"
+
+# Simulate complex user interactions
+chrome-cdp-cli eval "
+const element = document.querySelector('#button');
+element.dispatchEvent(new MouseEvent('mousedown'));
+setTimeout(() => element.dispatchEvent(new MouseEvent('mouseup')), 100);
+"
+
+# Extract structured data
+chrome-cdp-cli eval "
+Array.from(document.querySelectorAll('.product')).map(product => ({
+  name: product.querySelector('.name').textContent,
+  price: product.querySelector('.price').textContent,
+  image: product.querySelector('img').src
+}))
+"
+
+# Monitor page changes
+chrome-cdp-cli eval "
+new Promise(resolve => {
+  const observer = new MutationObserver(mutations => {
+    resolve(mutations.length + ' changes detected');
+    observer.disconnect();
+  });
+  observer.observe(document.body, {childList: true, subtree: true});
+  setTimeout(() => {
+    observer.disconnect();
+    resolve('No changes in 5 seconds');
+  }, 5000);
+})
+"
 ```
 
+## Current Limitations & Roadmap
+
+### Current Limitations
+
+- **No native page management**: Creating, closing, and switching between tabs requires manual implementation
+- **No native element interaction**: Clicking, hovering, and form filling must be done via eval
+- **No performance profiling**: Advanced performance analysis requires manual JavaScript
+- **No device emulation**: Mobile/tablet simulation not yet implemented
+- **Basic output formatting**: Advanced JSON/text formatting options not available
+
+### Upcoming Features
+
+1. **Native Page Management Commands**
+   - `new_page`, `close_page`, `list_pages`, `select_page`
+   - Direct CDP Target domain integration
+
+2. **Native Element Interaction**
+   - `click`, `hover`, `fill`, `drag` commands
+   - CSS selector-based element targeting
+
+3. **Performance Analysis**
+   - `performance_start_trace`, `performance_stop_trace`
+   - Built-in performance metrics and analysis
+
+4. **Device Emulation**
+   - `emulate` command for device simulation
+   - Network condition simulation
+
+5. **Advanced Output Formatting**
+   - Enhanced JSON/text formatting
+   - Quiet and verbose modes
+   - Custom output templates
+
+### Why Use Eval Workarounds?
+
+The eval approach offers several advantages:
+
+- **Immediate availability**: No waiting for feature implementation
+- **Maximum flexibility**: Any JavaScript operation is possible
+- **Learning opportunity**: Better understanding of browser APIs
+- **Custom solutions**: Tailor automation to specific needs
+- **Future-proof**: Works with any web technology
+
 ## Configuration
 
 ### Configuration File

package/dist/cli/CLIApplication.js

@@ -17,6 +17,8 @@ class CLIApplication {
         this.cli.registerHandler(new handlers_1.EvaluateScriptHandler());
         this.cli.registerHandler(new handlers_1.TakeScreenshotHandler());
         this.cli.registerHandler(new handlers_1.TakeSnapshotHandler());
+        this.cli.registerHandler(new handlers_1.GetConsoleMessageHandler());
+        this.cli.registerHandler(new handlers_1.ListConsoleMessagesHandler());
     }
     async run(argv) {
         try {

package/dist/handlers/GetConsoleMessageHandler.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetConsoleMessageHandler = void 0;
+const ConsoleMonitor_1 = require("../monitors/ConsoleMonitor");
+class GetConsoleMessageHandler {
+    constructor() {
+        this.name = 'get_console_message';
+        this.consoleMonitor = null;
+    }
+    async execute(client, args) {
+        try {
+            const params = args;
+            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: true,
+                    data: null
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    type: latestMessage.type,
+                    text: latestMessage.text,
+                    args: latestMessage.args,
+                    timestamp: latestMessage.timestamp,
+                    stackTrace: latestMessage.stackTrace
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    validateArgs(args) {
+        if (!args || typeof args !== 'object') {
+            return true;
+        }
+        const params = args;
+        if (params.type !== undefined) {
+            if (typeof params.type !== 'string') {
+                return false;
+            }
+            const validTypes = ['log', 'info', 'warn', 'error', 'debug'];
+            if (!validTypes.includes(params.type)) {
+                return false;
+            }
+        }
+        if (params.textPattern !== undefined && typeof params.textPattern !== 'string') {
+            return false;
+        }
+        if (params.startMonitoring !== undefined && typeof params.startMonitoring !== 'boolean') {
+            return false;
+        }
+        return true;
+    }
+    getHelp() {
+        return `get_console_message - Get the latest console message
+    
+Usage:
+  get_console_message [options]
+  
+Options:
+  --type <type>           Filter by message type (log, info, warn, error, debug)
+  --textPattern <pattern> Filter by text pattern (regex)
+  --startMonitoring       Start monitoring if not already active
+  
+Examples:
+  get_console_message
+  get_console_message --type error
+  get_console_message --textPattern "API"
+  get_console_message --startMonitoring`;
+    }
+}
+exports.GetConsoleMessageHandler = GetConsoleMessageHandler;

package/dist/handlers/GetNetworkRequestHandler.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetNetworkRequestHandler = void 0;
+const NetworkMonitor_1 = require("../monitors/NetworkMonitor");
+class GetNetworkRequestHandler {
+    constructor() {
+        this.name = 'get_network_request';
+        this.networkMonitor = null;
+    }
+    async execute(client, args) {
+        try {
+            const params = args;
+            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: true,
+                    data: null
+                };
+            }
+            return {
+                success: true,
+                data: latestRequest
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    getNetworkMonitor() {
+        return this.networkMonitor;
+    }
+    setNetworkMonitor(monitor) {
+        this.networkMonitor = monitor;
+    }
+}
+exports.GetNetworkRequestHandler = GetNetworkRequestHandler;

package/dist/handlers/ListConsoleMessagesHandler.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListConsoleMessagesHandler = void 0;
+const ConsoleMonitor_1 = require("../monitors/ConsoleMonitor");
+class ListConsoleMessagesHandler {
+    constructor() {
+        this.name = 'list_console_messages';
+        this.consoleMonitor = null;
+    }
+    async execute(client, args) {
+        try {
+            const params = args;
+            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()
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    validateArgs(args) {
+        if (!args || typeof args !== 'object') {
+            return true;
+        }
+        const params = args;
+        if (params.types !== undefined) {
+            if (!Array.isArray(params.types)) {
+                return false;
+            }
+            const validTypes = ['log', 'info', 'warn', 'error', 'debug'];
+            for (const type of params.types) {
+                if (typeof type !== 'string' || !validTypes.includes(type)) {
+                    return false;
+                }
+            }
+        }
+        if (params.textPattern !== undefined && typeof params.textPattern !== 'string') {
+            return false;
+        }
+        if (params.maxMessages !== undefined) {
+            if (typeof params.maxMessages !== 'number' || params.maxMessages <= 0) {
+                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;
+        }
+        return true;
+    }
+    getHelp() {
+        return `list_console_messages - List all captured console messages
+    
+Usage:
+  list_console_messages [options]
+  
+Options:
+  --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
+  
+Examples:
+  list_console_messages
+  list_console_messages --types error,warn
+  list_console_messages --textPattern "API" --maxMessages 10
+  list_console_messages --startTime 1640995200000`;
+    }
+}
+exports.ListConsoleMessagesHandler = ListConsoleMessagesHandler;

package/dist/handlers/ListNetworkRequestsHandler.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListNetworkRequestsHandler = void 0;
+const NetworkMonitor_1 = require("../monitors/NetworkMonitor");
+class ListNetworkRequestsHandler {
+    constructor() {
+        this.name = 'list_network_requests';
+        this.networkMonitor = null;
+    }
+    async execute(client, args) {
+        try {
+            const params = args;
+            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()
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    getNetworkMonitor() {
+        return this.networkMonitor;
+    }
+    setNetworkMonitor(monitor) {
+        this.networkMonitor = monitor;
+    }
+}
+exports.ListNetworkRequestsHandler = ListNetworkRequestsHandler;

package/dist/handlers/index.js

@@ -17,3 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./EvaluateScriptHandler"), exports);
 __exportStar(require("./TakeScreenshotHandler"), exports);
 __exportStar(require("./TakeSnapshotHandler"), exports);
+__exportStar(require("./GetConsoleMessageHandler"), exports);
+__exportStar(require("./ListConsoleMessagesHandler"), exports);
+__exportStar(require("./GetNetworkRequestHandler"), exports);
+__exportStar(require("./ListNetworkRequestsHandler"), exports);

package/dist/monitors/ConsoleMonitor.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleMonitor = void 0;
+class ConsoleMonitor {
+    constructor(client) {
+        this.messages = [];
+        this.isMonitoring = false;
+        this.messageHandler = null;
+        this.client = client;
+    }
+    async startMonitoring() {
+        if (this.isMonitoring) {
+            return;
+        }
+        await this.client.send('Runtime.enable');
+        this.messageHandler = (params) => {
+            this.handleConsoleMessage(params);
+        };
+        this.client.on('Runtime.consoleAPICalled', this.messageHandler);
+        this.isMonitoring = true;
+    }
+    async stopMonitoring() {
+        if (!this.isMonitoring || !this.messageHandler) {
+            return;
+        }
+        this.client.off('Runtime.consoleAPICalled', this.messageHandler);
+        this.messageHandler = null;
+        this.isMonitoring = false;
+    }
+    getMessages(filter) {
+        let filteredMessages = [...this.messages];
+        if (filter) {
+            if (filter.types && filter.types.length > 0) {
+                filteredMessages = filteredMessages.filter(msg => filter.types.includes(msg.type));
+            }
+            if (filter.textPattern) {
+                const pattern = new RegExp(filter.textPattern, 'i');
+                filteredMessages = filteredMessages.filter(msg => pattern.test(msg.text));
+            }
+            if (filter.startTime) {
+                filteredMessages = filteredMessages.filter(msg => msg.timestamp >= filter.startTime);
+            }
+            if (filter.endTime) {
+                filteredMessages = filteredMessages.filter(msg => msg.timestamp <= filter.endTime);
+            }
+            if (filter.maxMessages && filter.maxMessages > 0) {
+                filteredMessages = filteredMessages.slice(-filter.maxMessages);
+            }
+        }
+        return filteredMessages;
+    }
+    getLatestMessage(filter) {
+        const messages = this.getMessages(filter);
+        return messages.length > 0 ? messages[messages.length - 1] : null;
+    }
+    clearMessages() {
+        this.messages = [];
+    }
+    getMessageCount(filter) {
+        return this.getMessages(filter).length;
+    }
+    isActive() {
+        return this.isMonitoring;
+    }
+    handleConsoleMessage(params) {
+        try {
+            const consoleParams = params;
+            const message = {
+                type: this.mapConsoleType(consoleParams.type),
+                text: this.formatConsoleArgs(consoleParams.args),
+                args: consoleParams.args.map(arg => arg.value || arg.description || ''),
+                timestamp: consoleParams.timestamp,
+                stackTrace: consoleParams.stackTrace ?
+                    this.convertStackTrace(consoleParams.stackTrace.callFrames) : undefined
+            };
+            this.messages.push(message);
+            if (this.messages.length > 1000) {
+                this.messages = this.messages.slice(-1000);
+            }
+        }
+        catch (error) {
+            console.error('Error handling console message:', error);
+        }
+    }
+    mapConsoleType(cdpType) {
+        switch (cdpType) {
+            case 'log':
+                return 'log';
+            case 'info':
+                return 'info';
+            case 'warning':
+                return 'warn';
+            case 'error':
+                return 'error';
+            case 'debug':
+                return 'debug';
+            default:
+                return 'log';
+        }
+    }
+    formatConsoleArgs(args) {
+        return args.map(arg => {
+            if (arg.value !== undefined) {
+                if (typeof arg.value === 'string') {
+                    return arg.value;
+                }
+                return JSON.stringify(arg.value);
+            }
+            return arg.description || '';
+        }).join(' ');
+    }
+    convertStackTrace(callFrames) {
+        return callFrames.map(frame => ({
+            functionName: frame.functionName || '<anonymous>',
+            url: frame.url,
+            lineNumber: frame.lineNumber,
+            columnNumber: frame.columnNumber
+        }));
+    }
+}
+exports.ConsoleMonitor = ConsoleMonitor;

package/dist/monitors/NetworkMonitor.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkMonitor = void 0;
+class NetworkMonitor {
+    constructor(client) {
+        this.requests = new Map();
+        this.completedRequests = [];
+        this.isMonitoring = false;
+        this.requestWillBeSentHandler = null;
+        this.responseReceivedHandler = null;
+        this.loadingFinishedHandler = null;
+        this.loadingFailedHandler = null;
+        this.client = client;
+    }
+    async startMonitoring() {
+        if (this.isMonitoring) {
+            return;
+        }
+        await this.client.send('Network.enable');
+        this.requestWillBeSentHandler = (params) => {
+            this.handleRequestWillBeSent(params);
+        };
+        this.responseReceivedHandler = (params) => {
+            this.handleResponseReceived(params);
+        };
+        this.loadingFinishedHandler = (params) => {
+            this.handleLoadingFinished(params);
+        };
+        this.loadingFailedHandler = (params) => {
+            this.handleLoadingFailed(params);
+        };
+        this.client.on('Network.requestWillBeSent', this.requestWillBeSentHandler);
+        this.client.on('Network.responseReceived', this.responseReceivedHandler);
+        this.client.on('Network.loadingFinished', this.loadingFinishedHandler);
+        this.client.on('Network.loadingFailed', this.loadingFailedHandler);
+        this.isMonitoring = true;
+    }
+    async stopMonitoring() {
+        if (!this.isMonitoring) {
+            return;
+        }
+        if (this.requestWillBeSentHandler) {
+            this.client.off('Network.requestWillBeSent', this.requestWillBeSentHandler);
+            this.requestWillBeSentHandler = null;
+        }
+        if (this.responseReceivedHandler) {
+            this.client.off('Network.responseReceived', this.responseReceivedHandler);
+            this.responseReceivedHandler = null;
+        }
+        if (this.loadingFinishedHandler) {
+            this.client.off('Network.loadingFinished', this.loadingFinishedHandler);
+            this.loadingFinishedHandler = null;
+        }
+        if (this.loadingFailedHandler) {
+            this.client.off('Network.loadingFailed', this.loadingFailedHandler);
+            this.loadingFailedHandler = null;
+        }
+        this.isMonitoring = false;
+    }
+    getRequests(filter) {
+        let filteredRequests = [...this.completedRequests];
+        if (filter) {
+            if (filter.methods && filter.methods.length > 0) {
+                filteredRequests = filteredRequests.filter(req => filter.methods.includes(req.method.toUpperCase()));
+            }
+            if (filter.urlPattern) {
+                const pattern = new RegExp(filter.urlPattern, 'i');
+                filteredRequests = filteredRequests.filter(req => pattern.test(req.url));
+            }
+            if (filter.statusCodes && filter.statusCodes.length > 0) {
+                filteredRequests = filteredRequests.filter(req => req.status && filter.statusCodes.includes(req.status));
+            }
+            if (filter.startTime) {
+                filteredRequests = filteredRequests.filter(req => req.timestamp >= filter.startTime);
+            }
+            if (filter.endTime) {
+                filteredRequests = filteredRequests.filter(req => req.timestamp <= filter.endTime);
+            }
+            if (filter.maxRequests && filter.maxRequests > 0) {
+                filteredRequests = filteredRequests.slice(-filter.maxRequests);
+            }
+        }
+        return filteredRequests;
+    }
+    getLatestRequest(filter) {
+        const requests = this.getRequests(filter);
+        return requests.length > 0 ? requests[requests.length - 1] : null;
+    }
+    clearRequests() {
+        this.requests.clear();
+        this.completedRequests = [];
+    }
+    getRequestCount(filter) {
+        return this.getRequests(filter).length;
+    }
+    isActive() {
+        return this.isMonitoring;
+    }
+    handleRequestWillBeSent(params) {
+        try {
+            const requestParams = params;
+            const networkRequest = {
+                requestId: requestParams.requestId,
+                url: requestParams.request.url,
+                method: requestParams.request.method,
+                headers: requestParams.request.headers,
+                timestamp: requestParams.wallTime * 1000,
+            };
+            this.requests.set(requestParams.requestId, networkRequest);
+        }
+        catch (error) {
+            console.error('Error handling requestWillBeSent:', error);
+        }
+    }
+    handleResponseReceived(params) {
+        try {
+            const responseParams = params;
+            const request = this.requests.get(responseParams.requestId);
+            if (request) {
+                request.status = responseParams.response.status;
+                request.responseHeaders = responseParams.response.headers;
+            }
+        }
+        catch (error) {
+            console.error('Error handling responseReceived:', error);
+        }
+    }
+    handleLoadingFinished(params) {
+        try {
+            const loadingParams = params;
+            const request = this.requests.get(loadingParams.requestId);
+            if (request) {
+                this.completedRequests.push(request);
+                this.requests.delete(loadingParams.requestId);
+                if (this.completedRequests.length > 1000) {
+                    this.completedRequests = this.completedRequests.slice(-1000);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error handling loadingFinished:', error);
+        }
+    }
+    handleLoadingFailed(params) {
+        try {
+            const failedParams = params;
+            const request = this.requests.get(failedParams.requestId);
+            if (request) {
+                request.status = 0;
+                this.completedRequests.push(request);
+                this.requests.delete(failedParams.requestId);
+                if (this.completedRequests.length > 1000) {
+                    this.completedRequests = this.completedRequests.slice(-1000);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error handling loadingFailed:', error);
+        }
+    }
+}
+exports.NetworkMonitor = NetworkMonitor;

package/dist/monitors/index.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chrome-cdp-cli",
-  "version": "1.0.1",
-  "description": "Command-line tool for controlling Chrome browser instances via the Chrome DevTools Protocol",
+  "version": "1.1.0",
+  "description": "Command-line tool for controlling Chrome browser instances via the Chrome DevTools Protocol. Core features: JavaScript execution, screenshot capture, DOM snapshots, console/network monitoring. Additional features available via eval workarounds.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -51,12 +51,12 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nickxiao42/chrome-devtools-cli.git"
+    "url": "git+https://github.com/nicoster/chrome-devtools-cli.git"
   },
   "bugs": {
-    "url": "https://github.com/nickxiao42/chrome-devtools-cli/issues"
+    "url": "https://github.com/nicoster/chrome-devtools-cli/issues"
   },
-  "homepage": "https://github.com/nickxiao42/chrome-devtools-cli#readme",
+  "homepage": "https://github.com/nicoster/chrome-devtools-cli#readme",
   "dependencies": {
     "commander": "^11.1.0",
     "node-fetch": "^2.7.0",