chrome-cdp-cli 1.6.0 → 1.7.1

package/dist/cli/CLIApplication.js

@@ -37,19 +37,26 @@ class CLIApplication {
     }
     async run(argv) {
         try {
+            console.log('[DEBUG] CLIApplication.run called with argv:', argv);
             const command = this.cli.parseArgs(argv);
+            console.log('[DEBUG] Parsed command:', command);
             if (command.config.verbose) {
                 this.proxyManager.setLogging(true);
             }
+            console.log('[DEBUG] Ensuring proxy is ready...');
             await this.ensureProxyReady();
             if (this.needsConnection(command.name)) {
+                console.log('[DEBUG] Command needs connection, ensuring connection...');
                 await this.ensureConnection(command);
             }
+            console.log('[DEBUG] Executing command via CLI interface...');
             const result = await this.cli.execute(command);
+            console.log('[DEBUG] Command execution result:', result);
             this.outputResult(result, command);
             return result.exitCode || (result.success ? CommandRouter_1.ExitCode.SUCCESS : CommandRouter_1.ExitCode.GENERAL_ERROR);
         }
         catch (error) {
+            console.log('[DEBUG] Error in CLIApplication.run:', error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.error(`Error: ${errorMessage}`);
             return CommandRouter_1.ExitCode.GENERAL_ERROR;

package/dist/cli/CommandRouter.js

@@ -169,14 +169,18 @@ class CommandRouter {
     }
     async executeWithTimeout(handler, command) {
         const timeout = command.config.timeout;
+        console.log(`[DEBUG] CommandRouter.executeWithTimeout called for command: ${command.name}, timeout: ${timeout}ms`);
         const timeoutPromise = new Promise((_, reject) => {
             setTimeout(() => {
+                console.log(`[DEBUG] Command timeout reached for: ${command.name} after ${timeout}ms`);
                 reject(new Error(`Command timeout after ${timeout}ms`));
             }, timeout);
         });
+        console.log(`[DEBUG] Starting handler execution for: ${command.name}`);
         const executionPromise = handler.execute(this.client, command.args);
         try {
             const result = await Promise.race([executionPromise, timeoutPromise]);
+            console.log(`[DEBUG] Command completed successfully for: ${command.name}`);
             if (!result || typeof result !== 'object') {
                 return {
                     success: false,
@@ -190,6 +194,7 @@ class CommandRouter {
             return result;
         }
         catch (error) {
+            console.log(`[DEBUG] Command execution error for: ${command.name}:`, error);
             if (error instanceof Error && error.message.includes('timeout')) {
                 return {
                     success: false,

package/dist/client/ProxyClient.js

@@ -172,25 +172,32 @@ class ProxyClient {
         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 ws = new ws_1.WebSocket(`${wsUrl}/ws/${this.connectionId}`);
+            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}`);
         }
     }
@@ -222,6 +229,23 @@ class ProxyClient {
     }
     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;

package/dist/handlers/EvaluateScriptHandler.js

@@ -8,12 +8,13 @@ const ProxyClient_1 = require("../client/ProxyClient");
 const fs_1 = require("fs");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 class EvaluateScriptHandler {
-    constructor(useProxy = true) {
+    constructor(useProxy = false) {
         this.name = 'eval';
         this.proxyClient = new ProxyClient_1.ProxyClient();
         this.useProxy = useProxy;
     }
     async execute(client, args) {
+        console.log('[DEBUG] EvaluateScriptHandler.execute called with args:', args);
         const scriptArgs = args;
         if (!scriptArgs.expression && !scriptArgs.file) {
             return {
@@ -27,12 +28,18 @@ class EvaluateScriptHandler {
                 error: 'Cannot specify both "expression" and "file" arguments'
             };
         }
+        console.log('[DEBUG] Arguments validated, useProxy:', this.useProxy);
         try {
             if (this.useProxy) {
+                console.log('[DEBUG] Checking proxy availability...');
                 const proxyAvailable = await this.proxyClient.isProxyAvailable();
+                console.log('[DEBUG] Proxy available:', proxyAvailable);
                 if (proxyAvailable) {
                     console.log('[INFO] Using proxy connection for script evaluation');
-                    return await this.executeWithProxy(scriptArgs);
+                    console.log('[DEBUG] About to call executeWithProxy...');
+                    const result = await this.executeWithProxy(scriptArgs);
+                    console.log('[DEBUG] executeWithProxy returned:', result);
+                    return result;
                 }
                 else {
                     console.warn('[WARN] Proxy not available, falling back to direct CDP connection');
@@ -42,10 +49,12 @@ class EvaluateScriptHandler {
         catch (error) {
             console.warn('[WARN] Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
         }
+        console.log('[DEBUG] Falling back to direct CDP');
         return await this.executeWithDirectCDP(client, scriptArgs);
     }
     async executeWithProxy(scriptArgs) {
         try {
+            console.log('[DEBUG] Starting executeWithProxy');
             let expression;
             if (scriptArgs.file) {
                 expression = await this.readScriptFile(scriptArgs.file);
@@ -53,83 +62,38 @@ class EvaluateScriptHandler {
             else {
                 expression = scriptArgs.expression;
             }
-            const response = await (0, node_fetch_1.default)('http://localhost:9223/api/connections');
-            if (!response.ok) {
-                throw new Error('Failed to get proxy connections');
-            }
-            const result = await response.json();
-            if (!result.success || !result.data.connections || result.data.connections.length === 0) {
-                throw new Error('No active proxy connections found');
-            }
-            const connection = result.data.connections.find((conn) => conn.isHealthy);
-            if (!connection) {
-                throw new Error('No healthy proxy connections found');
-            }
-            console.log(`[INFO] Using existing proxy connection: ${connection.id}`);
-            this.proxyClient.connectionId = connection.id;
-            const ws = await this.proxyClient.createWebSocketProxy();
+            console.log('[DEBUG] Expression to execute:', expression.substring(0, 100));
+            console.log('[DEBUG] Creating new proxy connection...');
+            const connectionId = await this.proxyClient.connect('localhost', 9222);
+            console.log(`[DEBUG] Created new proxy connection: ${connectionId}`);
             try {
-                const result = await this.executeScriptThroughProxy(ws, expression, scriptArgs);
+                const result = await this.executeScriptThroughHTTP(connectionId, expression, scriptArgs);
                 return {
                     success: true,
                     data: result
                 };
             }
             finally {
-                ws.close();
+                await this.proxyClient.disconnect();
             }
         }
         catch (error) {
+            console.log('[DEBUG] Error in executeWithProxy:', error);
             return {
                 success: false,
                 error: error instanceof Error ? error.message : String(error)
             };
         }
     }
-    async executeScriptThroughProxy(ws, expression, args) {
-        return new Promise((resolve, reject) => {
-            const commandId = Date.now();
-            const timeout = args.timeout || 30000;
-            const awaitPromise = args.awaitPromise ?? true;
-            const returnByValue = args.returnByValue ?? true;
-            const timeoutHandle = setTimeout(() => {
-                reject(new Error(`Script execution timeout after ${timeout}ms`));
-            }, timeout);
-            ws.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data.toString());
-                    if (response.id === commandId) {
-                        clearTimeout(timeoutHandle);
-                        if (response.error) {
-                            reject(new Error(`CDP Error: ${response.error.message}`));
-                            return;
-                        }
-                        const result = response.result;
-                        if (result.exceptionDetails) {
-                            const error = new Error(result.result?.description || 'Script execution failed');
-                            error.exceptionDetails = result.exceptionDetails;
-                            reject(error);
-                            return;
-                        }
-                        let value = result.result?.value;
-                        if (result.result?.type === 'undefined') {
-                            value = undefined;
-                        }
-                        else if (result.result?.unserializableValue) {
-                            value = result.result.unserializableValue;
-                        }
-                        resolve(value);
-                    }
-                }
-                catch (error) {
-                    clearTimeout(timeoutHandle);
-                    reject(new Error(`Failed to parse CDP response: ${error instanceof Error ? error.message : error}`));
-                }
-            });
-            ws.on('error', (error) => {
-                clearTimeout(timeoutHandle);
-                reject(new Error(`WebSocket error: ${error.message}`));
-            });
+    async executeScriptThroughHTTP(connectionId, expression, args) {
+        const timeout = args.timeout || 30000;
+        const awaitPromise = args.awaitPromise ?? true;
+        const returnByValue = args.returnByValue ?? true;
+        console.log(`[DEBUG] Starting HTTP script execution, timeout: ${timeout}ms`);
+        console.log(`[DEBUG] Expression: ${expression.substring(0, 100)}${expression.length > 100 ? '...' : ''}`);
+        try {
+            const proxyUrl = this.proxyClient.getConfig().proxyUrl;
+            const commandId = Date.now() + Math.floor(Math.random() * 10000);
             const command = {
                 id: commandId,
                 method: 'Runtime.evaluate',
@@ -141,8 +105,61 @@ class EvaluateScriptHandler {
                     generatePreview: false
                 }
             };
-            ws.send(JSON.stringify(command));
-        });
+            console.log(`[DEBUG] Sending HTTP command to ${proxyUrl}/api/execute/${connectionId}`);
+            const controller = new AbortController();
+            const timeoutHandle = setTimeout(() => controller.abort(), timeout);
+            try {
+                const response = await (0, node_fetch_1.default)(`${proxyUrl}/api/execute/${connectionId}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-client-id': `eval_handler_${Date.now()}`
+                    },
+                    body: JSON.stringify({
+                        command,
+                        timeout
+                    }),
+                    signal: controller.signal
+                });
+                clearTimeout(timeoutHandle);
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(`HTTP ${response.status}: ${errorData.error || response.statusText}`);
+                }
+                const result = await response.json();
+                console.log(`[DEBUG] HTTP command response:`, result);
+                if (!result.success) {
+                    throw new Error(`Command execution failed: ${result.error || 'Unknown error'}`);
+                }
+                const commandResult = result.data.result;
+                if (result.data.error) {
+                    throw new Error(`CDP Error: ${result.data.error.message}`);
+                }
+                if (commandResult.exceptionDetails) {
+                    console.log(`[DEBUG] Exception details:`, commandResult.exceptionDetails);
+                    const error = new Error(commandResult.result?.description || 'Script execution failed');
+                    error.exceptionDetails = commandResult.exceptionDetails;
+                    throw error;
+                }
+                let value = commandResult.result?.value;
+                if (commandResult.result?.type === 'undefined') {
+                    value = undefined;
+                }
+                else if (commandResult.result?.unserializableValue) {
+                    value = commandResult.result.unserializableValue;
+                }
+                console.log(`[DEBUG] Successful HTTP result:`, value);
+                return value;
+            }
+            catch (error) {
+                clearTimeout(timeoutHandle);
+                throw error;
+            }
+        }
+        catch (error) {
+            console.log(`[DEBUG] Error in HTTP script execution:`, error);
+            throw error;
+        }
     }
     async executeWithDirectCDP(client, scriptArgs) {
         try {

package/dist/handlers/InstallCursorCommandHandler.js

@@ -126,148 +126,148 @@ Examples:
         return [
             {
                 name: 'cdp-cli',
-                description: 'Chrome DevTools Protocol CLI 工具',
-                instructions: `通过 Chrome DevTools Protocol 控制 Chrome 浏览器，支持完整的自动化操作。
+                description: 'Chrome DevTools Protocol CLI Tool',
+                instructions: `Control Chrome browser through Chrome DevTools Protocol, supporting complete automation operations.
 
-## 完整命令列表
+## Complete Command List
 
-### 1. JavaScript 执行
-- **eval** - 执行 JavaScript 代码并返回结果，支持异步代码和 Promise
+### 1. JavaScript Execution
+- **eval** - Execute JavaScript code and return results, supports async code and Promises
   \`chrome-cdp-cli eval "document.title"\`
   \`chrome-cdp-cli eval "fetch('/api/data').then(r => r.json())"\`
 
-### 2. 页面截图和快照
-- **screenshot** - 捕获页面截图并保存到文件
+### 2. Page Screenshots and Snapshots
+- **screenshot** - Capture page screenshot and save to file
   \`chrome-cdp-cli screenshot --filename page.png\`
   \`chrome-cdp-cli screenshot --filename fullpage.png --full-page\`
 
-- **snapshot** - 捕获完整 DOM 快照（包含结构、样式、布局）
+- **snapshot** - Capture complete DOM snapshot (including structure, styles, layout)
   \`chrome-cdp-cli snapshot --filename dom-snapshot.json\`
 
-### 3. 元素交互
-- **click** - 点击页面元素
+### 3. Element Interaction
+- **click** - Click page elements
   \`chrome-cdp-cli click "#submit-button"\`
   \`chrome-cdp-cli click ".menu-item" --timeout 10000\`
 
-- **hover** - 鼠标悬停在元素上
+- **hover** - Mouse hover over elements
   \`chrome-cdp-cli hover "#dropdown-trigger"\`
 
-- **fill** - 填充表单字段
+- **fill** - Fill form fields
   \`chrome-cdp-cli fill "#username" "john@example.com"\`
   \`chrome-cdp-cli fill "input[name='password']" "secret123"\`
 
-- **fill_form** - 批量填充表单
+- **fill_form** - Batch fill forms
   \`chrome-cdp-cli fill_form '{"#username": "john", "#password": "secret"}'\`
 
-### 4. 高级交互
-- **drag** - 拖拽操作
+### 4. Advanced Interactions
+- **drag** - Drag and drop operations
   \`chrome-cdp-cli drag "#draggable" "#dropzone"\`
 
-- **press_key** - 模拟键盘输入
+- **press_key** - Simulate keyboard input
   \`chrome-cdp-cli press_key "Enter"\`
   \`chrome-cdp-cli press_key "a" --modifiers Ctrl --selector "#input"\`
 
-- **upload_file** - 文件上传
+- **upload_file** - File upload
   \`chrome-cdp-cli upload_file "input[type='file']" "./document.pdf"\`
 
-- **wait_for** - 等待元素出现或满足条件
+- **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\`
 
-- **handle_dialog** - 处理浏览器对话框
+- **handle_dialog** - Handle browser dialogs
   \`chrome-cdp-cli handle_dialog accept\`
   \`chrome-cdp-cli handle_dialog accept --text "user input"\`
 
-### 5. 监控功能
-- **get_console_message** - 获取最新控制台消息
+### 5. Monitoring Features
+- **get_console_message** - Get latest console message
   \`chrome-cdp-cli get_console_message\`
 
-- **list_console_messages** - 列出所有控制台消息
+- **list_console_messages** - List all console messages
   \`chrome-cdp-cli list_console_messages --type error\`
 
-- **get_network_request** - 获取最新网络请求
+- **get_network_request** - Get latest network request
   \`chrome-cdp-cli get_network_request\`
 
-- **list_network_requests** - 列出所有网络请求
+- **list_network_requests** - List all network requests
   \`chrome-cdp-cli list_network_requests --method POST\`
 
-### 6. IDE 集成
-- **install_cursor_command** - 安装 Cursor 命令
+### 6. IDE Integration
+- **install_cursor_command** - Install Cursor commands
   \`chrome-cdp-cli install_cursor_command\`
 
-- **install_claude_skill** - 安装 Claude 技能
+- **install_claude_skill** - Install Claude skills
   \`chrome-cdp-cli install_claude_skill --skill-type personal\`
 
-## 常用工作流程
+## Common Workflows
 
-### 完整的表单测试流程
+### Complete Form Testing Workflow
 \`\`\`bash
-# 1. 等待页面加载
+# 1. Wait for page to load
 chrome-cdp-cli wait_for "#login-form" --condition visible
 
-# 2. 填写表单
+# 2. Fill form
 chrome-cdp-cli fill "#email" "test@example.com"
 chrome-cdp-cli fill "#password" "password123"
 
-# 3. 提交表单
+# 3. Submit form
 chrome-cdp-cli click "#submit-button"
 
-# 4. 等待结果并截图
+# 4. Wait for result and take screenshot
 chrome-cdp-cli wait_for "#success-message" --condition visible
 chrome-cdp-cli screenshot --filename login-success.png
 
-# 5. 检查控制台错误
+# 5. Check console errors
 chrome-cdp-cli list_console_messages --type error
 \`\`\`
 
-### 文件上传测试
+### File Upload Testing
 \`\`\`bash
-# 1. 点击上传按钮
+# 1. Click upload button
 chrome-cdp-cli click "#upload-trigger"
 
-# 2. 上传文件
+# 2. Upload file
 chrome-cdp-cli upload_file "input[type='file']" "./test-document.pdf"
 
-# 3. 等待上传完成
+# 3. Wait for upload completion
 chrome-cdp-cli wait_for ".upload-success" --condition visible
 
-# 4. 验证结果
+# 4. Verify result
 chrome-cdp-cli eval "document.querySelector('.file-name').textContent"
 \`\`\`
 
-### 拖拽交互测试
+### Drag and Drop Interaction Testing
 \`\`\`bash
-# 1. 等待元素可用
+# 1. Wait for elements to be available
 chrome-cdp-cli wait_for "#draggable-item" --condition visible
 chrome-cdp-cli wait_for "#drop-zone" --condition visible
 
-# 2. 执行拖拽
+# 2. Perform drag and drop
 chrome-cdp-cli drag "#draggable-item" "#drop-zone"
 
-# 3. 验证拖拽结果
+# 3. Verify drag result
 chrome-cdp-cli eval "document.querySelector('#drop-zone').children.length"
 \`\`\`
 
-### 键盘导航测试
+### Keyboard Navigation Testing
 \`\`\`bash
-# 1. 聚焦到输入框
+# 1. Focus on input field
 chrome-cdp-cli click "#search-input"
 
-# 2. 输入文本
+# 2. Type text
 chrome-cdp-cli press_key "t"
 chrome-cdp-cli press_key "e"
 chrome-cdp-cli press_key "s"
 chrome-cdp-cli press_key "t"
 
-# 3. 使用快捷键
-chrome-cdp-cli press_key "a" --modifiers Ctrl  # 全选
-chrome-cdp-cli press_key "Enter"  # 提交
+# 3. Use keyboard shortcuts
+chrome-cdp-cli press_key "a" --modifiers Ctrl  # Select all
+chrome-cdp-cli press_key "Enter"  # Submit
 
-# 4. 处理可能的确认对话框
+# 4. Handle possible confirmation dialog
 chrome-cdp-cli handle_dialog accept
 \`\`\`
 
-命令会自动连接到运行在 localhost:9222 的 Chrome 实例。`,
+Commands automatically connect to Chrome instance running on localhost:9222.`,
                 examples: [
                     'chrome-cdp-cli eval "document.title"',
                     'chrome-cdp-cli screenshot --filename page.png',
@@ -290,74 +290,74 @@ chrome-cdp-cli handle_dialog accept
 
 ${command.instructions}
 
-## 使用示例
+## Usage Examples
 
 ${examples}
 
-## 前置条件
+## Prerequisites
 
-确保 Chrome 浏览器已启动并开启了远程调试：
+Ensure Chrome browser is started with remote debugging enabled:
 
 \`\`\`bash
 chrome --remote-debugging-port=9222
 \`\`\`
 
-或者在 macOS 上：
+Or on macOS:
 
 \`\`\`bash
 /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --remote-debugging-port=9222
 \`\`\`
 
-## 全局选项
+## Global Options
 
-所有命令都支持以下全局选项：
+All commands support the following global options:
 
-- \`--host <hostname>\`: Chrome DevTools 主机地址 (默认: localhost)
-- \`--port <number>\`: Chrome DevTools 端口 (默认: 9222)
-- \`--format <json|text>\`: 输出格式 (默认: json)
-- \`--verbose\`: 启用详细日志
-- \`--quiet\`: 静默模式
-- \`--timeout <ms>\`: 命令超时时间
+- \`--host <hostname>\`: Chrome DevTools host address (default: localhost)
+- \`--port <number>\`: Chrome DevTools port (default: 9222)
+- \`--format <json|text>\`: Output format (default: json)
+- \`--verbose\`: Enable verbose logging
+- \`--quiet\`: Silent mode
+- \`--timeout <ms>\`: Command timeout
 
-## 常用工作流程
+## Common Workflows
 
-### 网页自动化测试
+### Web Automation Testing
 \`\`\`bash
-# 1. 导航到页面并截图
+# 1. Navigate to page and take screenshot
 chrome-cdp-cli eval "window.location.href = 'https://example.com'"
 chrome-cdp-cli screenshot --filename before.png
 
-# 2. 填写表单
+# 2. Fill form
 chrome-cdp-cli eval "document.querySelector('#email').value = 'test@example.com'"
 chrome-cdp-cli eval "document.querySelector('#password').value = 'password123'"
 
-# 3. 提交并检查结果
+# 3. Submit and check results
 chrome-cdp-cli eval "document.querySelector('#submit').click()"
 chrome-cdp-cli screenshot --filename after.png
 chrome-cdp-cli list_console_messages --type error
 \`\`\`
 
-### API 调用监控
+### API Call Monitoring
 \`\`\`bash
-# 1. 开始监控网络请求
+# 1. Start monitoring network requests
 chrome-cdp-cli eval "fetch('/api/users').then(r => r.json())"
 
-# 2. 查看网络请求
+# 2. View network requests
 chrome-cdp-cli list_network_requests --method POST
 
-# 3. 获取最新请求详情
+# 3. Get latest request details
 chrome-cdp-cli get_network_request
 \`\`\`
 
-### 页面分析
+### Page Analysis
 \`\`\`bash
-# 1. 获取页面基本信息
+# 1. Get basic page information
 chrome-cdp-cli eval "({title: document.title, url: location.href, links: document.querySelectorAll('a').length})"
 
-# 2. 捕获完整页面结构
+# 2. Capture complete page structure
 chrome-cdp-cli snapshot --filename page-analysis.json
 
-# 3. 检查控制台错误
+# 3. Check console errors
 chrome-cdp-cli list_console_messages --type error
 \`\`\`
 `;

package/dist/proxy/server/CDPProxyServer.js

@@ -157,6 +157,7 @@ class CDPProxyServer {
             this.performanceMonitor.stop();
             await this.eventMonitor.stopAllMonitoring();
             this.wsProxy.stop();
+            this.apiServer.cleanup();
             if (this.wsServer) {
                 this.wsServer.close();
             }

package/dist/proxy/server/CommandExecutionService.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandExecutionService = void 0;
+const logger_1 = require("../../utils/logger");
+class CommandExecutionService {
+    constructor(connectionPool) {
+        this.pendingCommands = new Map();
+        this.commandMetrics = {
+            totalCommands: 0,
+            successfulCommands: 0,
+            failedCommands: 0,
+            averageExecutionTime: 0,
+            timeoutCount: 0
+        };
+        this.messageHandlers = new Map();
+        this.activeCLIClient = null;
+        this.connectionPool = connectionPool;
+        this.logger = (0, logger_1.createLogger)({ component: 'CommandExecutionService' });
+    }
+    async executeCommand(request, clientId) {
+        const startTime = Date.now();
+        const commandId = this.generateCommandId();
+        const timeout = request.timeout || 30000;
+        try {
+            if (this.activeCLIClient && clientId && this.activeCLIClient !== clientId) {
+                throw new Error('Another CLI client is already connected. Only one CLI client can use the proxy at a time.');
+            }
+            if (clientId && !this.activeCLIClient) {
+                this.activeCLIClient = clientId;
+                this.logger.info(`CLI client ${clientId} is now the active client`);
+            }
+            const connection = this.connectionPool.getConnectionInfo(request.connectionId);
+            if (!connection) {
+                throw new Error(`Connection ${request.connectionId} not found`);
+            }
+            if (!connection.isHealthy) {
+                throw new Error(`Connection ${request.connectionId} is not healthy`);
+            }
+            this.logger.debug(`Executing CDP command: ${request.command.method}`, {
+                connectionId: request.connectionId,
+                commandId,
+                method: request.command.method,
+                timeout,
+                clientId: clientId || 'unknown'
+            });
+            const cdpMessage = {
+                id: typeof request.command.id === 'number' ? request.command.id : this.generateCDPMessageId(),
+                method: request.command.method,
+                params: request.command.params
+            };
+            const result = await this.sendCDPCommand(request.connectionId, cdpMessage, timeout);
+            const executionTime = Date.now() - startTime;
+            this.updateMetrics(true, executionTime);
+            this.logger.debug(`CDP command executed successfully: ${request.command.method}`, {
+                connectionId: request.connectionId,
+                commandId,
+                executionTime,
+                clientId: clientId || 'unknown'
+            });
+            return {
+                success: true,
+                result,
+                executionTime
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            this.updateMetrics(false, executionTime);
+            this.logger.error(`CDP command execution failed: ${request.command.method}`, {
+                connectionId: request.connectionId,
+                commandId,
+                executionTime,
+                clientId: clientId || 'unknown',
+                error: error instanceof Error ? error.message : String(error)
+            });
+            let errorCode = 500;
+            let errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (errorMessage.includes('Another CLI client')) {
+                errorCode = 409;
+            }
+            else if (errorMessage.includes('timeout')) {
+                errorCode = 408;
+                this.commandMetrics.timeoutCount++;
+            }
+            else if (errorMessage.includes('not found')) {
+                errorCode = 404;
+            }
+            else if (errorMessage.includes('not healthy')) {
+                errorCode = 503;
+            }
+            return {
+                success: false,
+                error: {
+                    code: errorCode,
+                    message: errorMessage
+                },
+                executionTime
+            };
+        }
+    }
+    async sendCDPCommand(connectionId, command, timeout) {
+        const connection = this.connectionPool.getConnectionInfo(connectionId);
+        if (!connection) {
+            throw new Error(`Connection ${connectionId} not found`);
+        }
+        return new Promise((resolve, reject) => {
+            const commandKey = `${connectionId}:${command.id}`;
+            const pendingCommand = {
+                id: commandKey,
+                connectionId,
+                command,
+                timestamp: Date.now(),
+                timeout,
+                resolve,
+                reject
+            };
+            this.pendingCommands.set(commandKey, pendingCommand);
+            this.setupMessageHandler(connectionId);
+            const timeoutHandle = setTimeout(() => {
+                if (this.pendingCommands.has(commandKey)) {
+                    this.pendingCommands.delete(commandKey);
+                    reject(new Error(`Command timeout after ${timeout}ms: ${command.method}`));
+                }
+            }, timeout);
+            pendingCommand.resolve = (value) => {
+                clearTimeout(timeoutHandle);
+                resolve(value);
+            };
+            pendingCommand.reject = (error) => {
+                clearTimeout(timeoutHandle);
+                reject(error);
+            };
+            try {
+                const messageStr = JSON.stringify(command);
+                connection.connection.send(messageStr);
+                this.logger.debug(`Sent CDP command to Chrome: ${command.method}`, {
+                    connectionId,
+                    commandId: command.id,
+                    messageLength: messageStr.length
+                });
+            }
+            catch (error) {
+                clearTimeout(timeoutHandle);
+                this.pendingCommands.delete(commandKey);
+                reject(new Error(`Failed to send command: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+    }
+    setupMessageHandler(connectionId) {
+        if (this.messageHandlers.has(connectionId)) {
+            return;
+        }
+        const connection = this.connectionPool.getConnectionInfo(connectionId);
+        if (!connection) {
+            return;
+        }
+        const messageHandler = (data) => {
+            try {
+                const message = data.toString();
+                let cdpResponse;
+                try {
+                    cdpResponse = JSON.parse(message);
+                }
+                catch (parseError) {
+                    this.logger.warn(`Invalid JSON from CDP connection ${connectionId}: ${message.substring(0, 100)}`);
+                    return;
+                }
+                if (typeof cdpResponse.id === 'undefined') {
+                    return;
+                }
+                const commandKey = `${connectionId}:${cdpResponse.id}`;
+                const pendingCommand = this.pendingCommands.get(commandKey);
+                if (pendingCommand) {
+                    this.pendingCommands.delete(commandKey);
+                    this.logger.debug(`Received CDP response for command: ${pendingCommand.command.method}`, {
+                        connectionId,
+                        commandId: cdpResponse.id,
+                        hasResult: !!cdpResponse.result,
+                        hasError: !!cdpResponse.error
+                    });
+                    if (cdpResponse.error) {
+                        pendingCommand.reject(new Error(`CDP Error: ${cdpResponse.error.message} (Code: ${cdpResponse.error.code})`));
+                    }
+                    else {
+                        pendingCommand.resolve(cdpResponse.result);
+                    }
+                }
+                else {
+                    this.logger.debug(`Received CDP response for unknown command ID: ${cdpResponse.id}`, {
+                        connectionId
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error handling CDP message for connection ${connectionId}:`, error);
+            }
+        };
+        connection.connection.on('message', messageHandler);
+        this.messageHandlers.set(connectionId, messageHandler);
+        this.logger.debug(`Set up message handler for connection: ${connectionId}`);
+        connection.connection.on('close', () => {
+            this.cleanupMessageHandler(connectionId);
+        });
+    }
+    cleanupMessageHandler(connectionId) {
+        const handler = this.messageHandlers.get(connectionId);
+        if (handler) {
+            const connection = this.connectionPool.getConnectionInfo(connectionId);
+            if (connection) {
+                connection.connection.off('message', handler);
+            }
+            this.messageHandlers.delete(connectionId);
+            this.logger.debug(`Cleaned up message handler for connection: ${connectionId}`);
+        }
+        const commandsToCleanup = [];
+        for (const [, pendingCommand] of this.pendingCommands.entries()) {
+            if (pendingCommand.connectionId === connectionId) {
+                commandsToCleanup.push(pendingCommand.id);
+                pendingCommand.reject(new Error('Connection closed'));
+            }
+        }
+        for (const commandKey of commandsToCleanup) {
+            this.pendingCommands.delete(commandKey);
+        }
+        if (commandsToCleanup.length > 0) {
+            this.logger.debug(`Cleaned up ${commandsToCleanup.length} pending commands for connection: ${connectionId}`);
+        }
+    }
+    getMetrics() {
+        return { ...this.commandMetrics };
+    }
+    getPendingCommandsCount() {
+        return this.pendingCommands.size;
+    }
+    getPendingCommandsForConnection(connectionId) {
+        let count = 0;
+        for (const pendingCommand of this.pendingCommands.values()) {
+            if (pendingCommand.connectionId === connectionId) {
+                count++;
+            }
+        }
+        return count;
+    }
+    setActiveCLIClient(clientId) {
+        if (this.activeCLIClient && this.activeCLIClient !== clientId) {
+            this.logger.warn(`Replacing active CLI client ${this.activeCLIClient} with ${clientId}`);
+        }
+        this.activeCLIClient = clientId;
+        this.logger.info(`CLI client ${clientId} is now the active client`);
+    }
+    releaseActiveCLIClient(clientId) {
+        if (clientId && this.activeCLIClient !== clientId) {
+            this.logger.warn(`Attempted to release CLI client ${clientId}, but active client is ${this.activeCLIClient}`);
+            return;
+        }
+        const previousClient = this.activeCLIClient;
+        this.activeCLIClient = null;
+        if (previousClient) {
+            this.logger.info(`Released active CLI client: ${previousClient}`);
+        }
+    }
+    getActiveCLIClient() {
+        return this.activeCLIClient;
+    }
+    hasActiveCLIClient() {
+        return this.activeCLIClient !== null;
+    }
+    cleanup() {
+        for (const [, pendingCommand] of this.pendingCommands.entries()) {
+            pendingCommand.reject(new Error('Service shutting down'));
+        }
+        this.pendingCommands.clear();
+        for (const connectionId of this.messageHandlers.keys()) {
+            this.cleanupMessageHandler(connectionId);
+        }
+        this.activeCLIClient = null;
+        this.logger.info('CommandExecutionService cleanup completed');
+    }
+    generateCommandId() {
+        return `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateCDPMessageId() {
+        return Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 10000);
+    }
+    updateMetrics(success, executionTime) {
+        this.commandMetrics.totalCommands++;
+        if (success) {
+            this.commandMetrics.successfulCommands++;
+        }
+        else {
+            this.commandMetrics.failedCommands++;
+        }
+        const totalTime = this.commandMetrics.averageExecutionTime * (this.commandMetrics.totalCommands - 1) + executionTime;
+        this.commandMetrics.averageExecutionTime = totalTime / this.commandMetrics.totalCommands;
+    }
+}
+exports.CommandExecutionService = CommandExecutionService;

package/dist/proxy/server/ConnectionPool.js

@@ -172,29 +172,36 @@ class ConnectionPool {
                 connection.isHealthy = false;
                 return false;
             }
-            const messageId = Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 1000);
+            const messageId = Math.floor(Date.now() % 1000000) + Math.floor(Math.random() * 10000);
             const testMessage = {
                 id: messageId,
                 method: 'Runtime.evaluate',
                 params: { expression: '1+1' }
             };
+            console.log(`[DEBUG] Health check starting for connection ${connectionId} with message ID: ${messageId}`);
             const healthCheckPromise = new Promise((resolve) => {
                 const timeout = setTimeout(() => {
+                    console.log(`[DEBUG] Health check timeout for connection ${connectionId}, message ID: ${messageId}`);
                     resolve(false);
                 }, 5000);
                 const messageHandler = (data) => {
                     try {
                         const response = JSON.parse(data.toString());
+                        console.log(`[DEBUG] Health check received message for connection ${connectionId}, response ID: ${response.id}, expected: ${messageId}`);
                         if (response.id === testMessage.id) {
                             clearTimeout(timeout);
                             connection.connection.off('message', messageHandler);
-                            resolve(response.result && !response.error);
+                            const isHealthy = response.result && !response.error;
+                            console.log(`[DEBUG] Health check result for connection ${connectionId}: ${isHealthy}`);
+                            resolve(isHealthy);
                         }
                     }
                     catch (error) {
+                        console.log(`[DEBUG] Health check message parsing error for connection ${connectionId}:`, error);
                     }
                 };
                 connection.connection.on('message', messageHandler);
+                console.log(`[DEBUG] Sending health check command for connection ${connectionId}:`, testMessage);
                 connection.connection.send(JSON.stringify(testMessage));
             });
             const isHealthy = await healthCheckPromise;

package/dist/proxy/server/ProxyAPIServer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyAPIServer = void 0;
 const SecurityManager_1 = require("./SecurityManager");
+const CommandExecutionService_1 = require("./CommandExecutionService");
 const logger_1 = require("../../utils/logger");
 class ProxyAPIServer {
     constructor(connectionPool, messageStore, healthMonitor, performanceMonitor, securityManager) {
@@ -10,6 +11,7 @@ class ProxyAPIServer {
         this.healthMonitor = healthMonitor;
         this.performanceMonitor = performanceMonitor;
         this.securityManager = securityManager || new SecurityManager_1.SecurityManager();
+        this.commandExecutionService = new CommandExecutionService_1.CommandExecutionService(connectionPool);
         this.logger = new logger_1.Logger();
     }
     setupRoutes(app) {
@@ -20,6 +22,9 @@ class ProxyAPIServer {
         app.get('/api/console/:connectionId', this.validateConnectionId.bind(this), this.handleGetConsoleMessages.bind(this));
         app.get('/api/network/:connectionId', this.validateConnectionId.bind(this), this.handleGetNetworkRequests.bind(this));
         app.get('/api/health/:connectionId', this.validateConnectionId.bind(this), this.handleHealthCheck.bind(this));
+        app.post('/api/execute/:connectionId', this.securityManager.getStrictRateLimiter(), this.validateConnectionId.bind(this), this.validateCommandExecutionRequest.bind(this), this.handleCommandExecution.bind(this));
+        app.post('/api/client/release', this.handleReleaseCLIClient.bind(this));
+        app.get('/api/client/status', this.handleGetCLIClientStatus.bind(this));
         app.get('/api/health', this.handleServerHealth.bind(this));
         app.get('/api/health/detailed', this.handleDetailedHealthCheck.bind(this));
         app.get('/api/health/statistics', this.handleHealthStatistics.bind(this));
@@ -33,6 +38,13 @@ class ProxyAPIServer {
         app.get('/api/status', this.handleServerStatus.bind(this));
         this.logger.info('API routes configured with enhanced security measures');
     }
+    cleanup() {
+        this.commandExecutionService.cleanup();
+        this.logger.info('ProxyAPIServer cleanup completed');
+    }
+    getCommandExecutionService() {
+        return this.commandExecutionService;
+    }
     async handleConnect(req, res) {
         try {
             const { host, port, targetId } = req.body;
@@ -245,6 +257,78 @@ class ProxyAPIServer {
             });
         }
     }
+    async handleCommandExecution(req, res) {
+        try {
+            const { connectionId } = req.params;
+            const { command, timeout } = req.body;
+            const clientId = req.headers['x-client-id'] || `client_${req.ip}_${Date.now()}`;
+            const connection = this.connectionPool.getConnectionInfo(connectionId);
+            if (!connection) {
+                res.status(404).json({
+                    success: false,
+                    error: 'Connection not found',
+                    timestamp: Date.now()
+                });
+                return;
+            }
+            if (!connection.isHealthy) {
+                res.status(503).json({
+                    success: false,
+                    error: 'Connection is not healthy',
+                    timestamp: Date.now()
+                });
+                return;
+            }
+            this.logger.debug(`Executing CDP command: ${command.method}`, {
+                connectionId,
+                method: command.method,
+                hasParams: !!command.params,
+                timeout: timeout || 30000,
+                clientId
+            });
+            const executionRequest = {
+                connectionId,
+                command,
+                timeout
+            };
+            const result = await this.commandExecutionService.executeCommand(executionRequest, clientId);
+            const statusCode = result.success ? 200 : (result.error?.code || 500);
+            res.status(statusCode).json({
+                success: result.success,
+                data: result,
+                timestamp: Date.now()
+            });
+            this.logger.debug(`CDP command execution completed: ${command.method}`, {
+                connectionId,
+                success: result.success,
+                executionTime: result.executionTime,
+                statusCode,
+                clientId
+            });
+        }
+        catch (error) {
+            this.logger.error('Command execution API error:', error);
+            let statusCode = 500;
+            let errorMessage = error instanceof Error ? error.message : 'Command execution failed';
+            if (errorMessage.includes('Another CLI client')) {
+                statusCode = 409;
+            }
+            else if (errorMessage.includes('timeout')) {
+                statusCode = 408;
+            }
+            else if (errorMessage.includes('not found')) {
+                statusCode = 404;
+            }
+            else if (errorMessage.includes('not healthy')) {
+                statusCode = 503;
+            }
+            res.status(statusCode).json({
+                success: false,
+                error: errorMessage,
+                timestamp: Date.now()
+            });
+        }
+    }
     async handleListConnections(_req, res) {
         try {
             const connections = this.connectionPool.getAllConnections();
@@ -665,6 +749,85 @@ class ProxyAPIServer {
         }
         next();
     }
+    validateCommandExecutionRequest(req, res, next) {
+        const { command, timeout } = req.body;
+        if (!command || typeof command !== 'object') {
+            this.logger.logSecurityEvent('invalid_command_request', 'Missing or invalid command object', {
+                command,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command is required and must be an object',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (!command.method || typeof command.method !== 'string' || command.method.trim() === '') {
+            this.logger.logSecurityEvent('invalid_command_request', 'Missing or invalid command method', {
+                method: command.method,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command method is required and must be a non-empty string',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        const methodRegex = /^[A-Za-z][A-Za-z0-9]*\.[A-Za-z][A-Za-z0-9]*$/;
+        if (!methodRegex.test(command.method)) {
+            this.logger.logSecurityEvent('invalid_command_method', 'Command method has invalid format', {
+                method: command.method,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command method must be in format "Domain.method" (e.g., "Runtime.evaluate")',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (command.id !== undefined && (typeof command.id !== 'number' && typeof command.id !== 'string')) {
+            this.logger.logSecurityEvent('invalid_command_request', 'Invalid command ID type', {
+                commandId: command.id,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command ID must be a number or string if provided',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (timeout !== undefined) {
+            if (typeof timeout !== 'number' || timeout <= 0 || timeout > 300000) {
+                this.logger.logSecurityEvent('invalid_command_request', 'Invalid timeout value', {
+                    timeout,
+                    ip: req.ip
+                });
+                res.status(400).json({
+                    success: false,
+                    error: 'Timeout must be a positive number between 1 and 300000 (5 minutes)',
+                    timestamp: Date.now()
+                });
+                return;
+            }
+        }
+        if (command.params !== undefined && (command.params === null || (typeof command.params !== 'object' && !Array.isArray(command.params)))) {
+            this.logger.logSecurityEvent('invalid_command_request', 'Invalid command params', {
+                paramsType: typeof command.params,
+                ip: req.ip
+            });
+            res.status(400).json({
+                success: false,
+                error: 'Command params must be an object or array if provided',
+                timestamp: Date.now()
+            });
+            return;
+        }
+        next();
+    }
     parseConsoleMessageFilter(query) {
         try {
             const filter = {};
@@ -905,5 +1068,53 @@ class ProxyAPIServer {
             return `${minutes} minute${minutes > 1 ? 's' : ''}`;
         }
     }
+    async handleReleaseCLIClient(req, res) {
+        try {
+            const clientId = req.headers['x-client-id'] || `client_${req.ip}_${Date.now()}`;
+            this.commandExecutionService.releaseActiveCLIClient(clientId);
+            this.logger.info(`CLI client released: ${clientId}`);
+            res.json({
+                success: true,
+                data: {
+                    message: 'CLI client released successfully',
+                    clientId
+                },
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            this.logger.error('Release CLI client API error:', error);
+            res.status(500).json({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to release CLI client',
+                timestamp: Date.now()
+            });
+        }
+    }
+    async handleGetCLIClientStatus(_req, res) {
+        try {
+            const activeCLIClient = this.commandExecutionService.getActiveCLIClient();
+            const hasActiveClient = this.commandExecutionService.hasActiveCLIClient();
+            const pendingCommandsCount = this.commandExecutionService.getPendingCommandsCount();
+            res.json({
+                success: true,
+                data: {
+                    hasActiveClient,
+                    activeCLIClient,
+                    pendingCommandsCount,
+                    singleClientMode: true
+                },
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            this.logger.error('Get CLI client status API error:', error);
+            res.status(500).json({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get CLI client status',
+                timestamp: Date.now()
+            });
+        }
+    }
 }
 exports.ProxyAPIServer = ProxyAPIServer;

package/dist/proxy/server/WSProxy.js

@@ -236,9 +236,11 @@ class WSProxy {
                 if (cdpConnection.connection.readyState === WebSocket.OPEN) {
                     cdpConnection.connection.send(message);
                     proxyConnection.messageCount++;
+                    console.log(`[DEBUG] Forwarded CDP command from client ${proxyConnection.id}: ${cdpCommand.method} (id: ${cdpCommand.id})`);
                     this.logger.debug(`Forwarded CDP command from client ${proxyConnection.id}: ${cdpCommand.method} (id: ${cdpCommand.id})`);
                 }
                 else {
+                    console.log(`[DEBUG] CDP connection ${connectionId} is not open, readyState: ${cdpConnection.connection.readyState}`);
                     this.logger.warn(`CDP connection ${connectionId} is not open, cannot forward command`);
                     clientWs.send(JSON.stringify({
                         error: { code: -32001, message: 'CDP connection unavailable' },
@@ -266,20 +268,30 @@ class WSProxy {
                     return;
                 }
                 if (this.isCDPResponse(cdpMessage)) {
+                    console.log(`[DEBUG] Received CDP response for client ${proxyConnection.id}: id ${cdpMessage.id}`);
                     if (clientWs.readyState === WebSocket.OPEN) {
                         clientWs.send(message);
                         proxyConnection.messageCount++;
+                        console.log(`[DEBUG] Forwarded CDP response to client ${proxyConnection.id}: id ${cdpMessage.id}`);
                         this.logger.debug(`Forwarded CDP response to client ${proxyConnection.id}: id ${cdpMessage.id}`);
                     }
+                    else {
+                        console.log(`[DEBUG] Client WebSocket is not open for ${proxyConnection.id}, readyState: ${clientWs.readyState}`);
+                    }
                 }
                 else if (this.isCDPEvent(cdpMessage)) {
+                    console.log(`[DEBUG] Received CDP event: ${cdpMessage.method}`);
                     this.forwardEventToSubscribedClients(connectionId, cdpMessage, message);
                 }
+                else {
+                    console.log(`[DEBUG] Received unknown CDP message type:`, cdpMessage);
+                }
             }
             catch (error) {
                 this.logger.error(`Error forwarding message to client ${proxyConnection.id}:`, error);
             }
         };
+        console.log(`[DEBUG] Adding message handler to CDP connection ${connectionId} for proxy ${proxyConnection.id}`);
         cdpConnection.connection.on('message', cdpMessageHandler);
         clientWs.on('close', () => {
             cdpConnection.connection.off('message', cdpMessageHandler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-cdp-cli",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "LLM-first browser automation CLI via Chrome DevTools Protocol. Eval-first design optimized for AI assistants - LLMs write JavaScript scripts for rapid validation. Features: JavaScript execution, element interaction, screenshots, DOM snapshots, console/network monitoring. Built-in IDE integration for Cursor and Claude.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",