chrome-cdp-cli 2.1.3 → 2.1.5

package/README.md

@@ -81,6 +81,9 @@ cdp log -f
 # Follow network requests in real time
 cdp network -f
 
+# List available Chrome pages
+cdp list
+
 # Element interactions
 cdp click "#submit-button"
 cdp fill "#email" "user@example.com"
@@ -126,6 +129,7 @@ Use arrow keys to navigate, Enter to select, `q`/ESC/Ctrl+C to cancel (exits cle
 To skip the prompt, pass `-i` before or after the command:
 
 ```bash
+cdp list
 cdp -i 1 eval "document.title"
 cdp eval "document.title" -i 1    # also works
 ```

package/dist/cli/CLIApplication.js

@@ -84,6 +84,12 @@ class CLIApplication {
             this.configureDebugMode(command.config.debug);
             this.logger.debug("CLIApplication.run called with argv:", argv);
             this.logger.debug("Parsed command:", command);
+            if (command.name === "list") {
+                const result = await this.executeListCommand(command);
+                this.outputResult(result, command);
+                return (result.exitCode ||
+                    (result.success ? CommandRouter_1.ExitCode.SUCCESS : CommandRouter_1.ExitCode.GENERAL_ERROR));
+            }
             if (this.needsConnection(command.name)) {
                 this.logger.debug("Command needs connection, ensuring connection...");
                 try {
@@ -131,11 +137,65 @@ class CLIApplication {
             "help",
             "connect",
             "disconnect",
+            "list",
             "install_cursor_command",
             "install_claude_skill",
         ];
         return !noConnectionCommands.includes(commandName);
     }
+    async executeListCommand(command) {
+        try {
+            const targets = await this.connectionManager.discoverTargets(command.config.host, command.config.port);
+            const selectableTargets = targets
+                .filter((target) => target.type === "page")
+                .filter((target) => !this.isDevToolsWindow(target));
+            if (command.config.outputFormat === "json") {
+                return {
+                    success: true,
+                    data: {
+                        count: selectableTargets.length,
+                        targets: selectableTargets.map((target, index) => ({
+                            index: index + 1,
+                            id: target.id,
+                            title: target.title || "(Untitled)",
+                            url: target.url,
+                            type: target.type,
+                        })),
+                    },
+                };
+            }
+            if (selectableTargets.length === 0) {
+                return {
+                    success: true,
+                    data: `No selectable Chrome pages found at ${command.config.host}:${command.config.port}.\n` +
+                        "Open a regular tab in Chrome and try again.",
+                };
+            }
+            const lines = [
+                `Found ${selectableTargets.length} selectable Chrome page(s):`,
+                "",
+                ...selectableTargets.flatMap((target, index) => [
+                    `[${index + 1}] ${target.title || "(Untitled)"}`,
+                    `    ${target.url}`,
+                ]),
+                "",
+                "Use `cdp -i <number> <command>` to target one of these pages.",
+            ];
+            return {
+                success: true,
+                data: lines.join("\n"),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error
+                    ? error.message
+                    : String(error),
+                exitCode: CommandRouter_1.ExitCode.CONNECTION_ERROR,
+            };
+        }
+    }
     isDevToolsWindow(target) {
         const url = target.url.toLowerCase();
         const title = target.title.toLowerCase();

package/dist/cli/CommandSchemaRegistry.js

@@ -55,6 +55,28 @@ class CommandSchemaRegistry {
             options: [],
             arguments: [],
         });
+        this.registerCommand({
+            name: "list",
+            aliases: ["ls"],
+            description: "List available Chrome pages you can target",
+            usage: "cdp [global-options] list",
+            examples: [
+                {
+                    command: "cdp list",
+                    description: "List selectable Chrome pages",
+                },
+                {
+                    command: "cdp --format json list",
+                    description: "List selectable Chrome pages as JSON",
+                },
+                {
+                    command: "cdp --host localhost --port 9223 list",
+                    description: "List pages from a specific Chrome instance",
+                },
+            ],
+            options: [],
+            arguments: [],
+        });
         this.registerCommand({
             name: "eval",
             aliases: ["js", "execute"],
@@ -568,7 +590,7 @@ class CommandSchemaRegistry {
             name: "log",
             aliases: ["console"],
             description: "Follow console messages in real-time",
-            usage: "cdp log [options]",
+            usage: "cdp log [PATTERN] [options]",
             examples: [
                 { command: "cdp log", description: "Follow all console messages" },
                 {
@@ -576,8 +598,20 @@ class CommandSchemaRegistry {
                     description: "Follow only errors and warnings",
                 },
                 {
-                    command: 'cdp log --textPattern "API"',
-                    description: "Follow messages matching /API/i",
+                    command: "cdp log '\\[AI'",
+                    description: "Follow messages matching regex /\\[AI/i",
+                },
+                {
+                    command: "cdp log -e error -e warn",
+                    description: "Follow messages matching 'error' OR 'warn'",
+                },
+                {
+                    command: "cdp log -F '[AI'",
+                    description: "Follow messages containing literal string '[AI'",
+                },
+                {
+                    command: "cdp log -v 'debug'",
+                    description: "Follow messages NOT matching 'debug'",
                 },
                 {
                     command: "cdp log --format json",
@@ -592,9 +626,28 @@ class CommandSchemaRegistry {
                     type: "string",
                 },
                 {
-                    name: "textPattern",
-                    description: "Filter by text pattern (regex, case-insensitive)",
+                    name: "expression",
+                    short: "e",
+                    description: "Pattern to match (regex by default). May be specified multiple times (OR logic).",
                     type: "string",
+                    multiple: true,
+                },
+                {
+                    name: "fixed-strings",
+                    short: "F",
+                    description: "Treat pattern(s) as literal strings, not regexps",
+                    type: "boolean",
+                },
+                {
+                    name: "invert-match",
+                    short: "v",
+                    description: "Output messages that do NOT match the pattern",
+                    type: "boolean",
+                },
+                {
+                    name: "case-sensitive",
+                    description: "Match is case-sensitive (default: case-insensitive)",
+                    type: "boolean",
                 },
                 {
                     name: "follow",
@@ -609,7 +662,14 @@ class CommandSchemaRegistry {
                     choices: ["text", "json", "pretty"],
                 },
             ],
-            arguments: [],
+            arguments: [
+                {
+                    name: "pattern",
+                    description: "Pattern to match (regex by default, case-insensitive)",
+                    type: "string",
+                    required: false,
+                },
+            ],
         });
         this.registerCommand({
             name: "network",

package/dist/cli/HelpSystem.js

@@ -163,7 +163,7 @@ class HelpSystem {
                 orderedCategories.push([cat, categorizedCommands.get(cat)]);
             }
         }
-        for (const [cat, cmds] of categorizedCommands) {
+        for (const [cat, cmds] of Array.from(categorizedCommands.entries())) {
             if (!categoryOrder.includes(cat)) {
                 orderedCategories.push([cat, cmds]);
             }
@@ -310,11 +310,11 @@ class HelpSystem {
                 }
             }
         }
-        return [...new Set(similar)].slice(0, 5);
+        return Array.from(new Set(similar)).slice(0, 5);
     }
     findContextualSuggestions(error, commandName) {
         const suggestions = [];
-        for (const [errorPattern, helpers] of this.contextualHelpers) {
+        for (const [errorPattern, helpers] of Array.from(this.contextualHelpers.entries())) {
             if (error.toLowerCase().includes(errorPattern.toLowerCase())) {
                 suggestions.push(...helpers);
             }
@@ -351,7 +351,7 @@ class HelpSystem {
             else if (command.name.includes("install")) {
                 category = "Installation & Setup";
             }
-            else if (["help", "version"].includes(command.name)) {
+            else if (["help", "version", "list"].includes(command.name)) {
                 category = "Help & Information";
             }
             if (!categories.has(category)) {
@@ -359,7 +359,7 @@ class HelpSystem {
             }
             categories.get(category).push(command);
         }
-        for (const [, categoryCommands] of categories) {
+        for (const [, categoryCommands] of Array.from(categories.entries())) {
             categoryCommands.sort((a, b) => a.name.localeCompare(b.name));
         }
         return categories;

package/dist/client/CDPClient.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CDPClient = void 0;
-const ws_1 = __importDefault(require("ws"));
+const WebSocket = require("ws");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 class CDPClient {
     constructor() {
@@ -26,7 +26,7 @@ class CDPClient {
                 targetId = pageTarget.id;
             }
             const wsUrl = await this.getWebSocketUrl(host, port, targetId);
-            this.ws = new ws_1.default(wsUrl);
+            this.ws = new WebSocket(wsUrl);
             return new Promise((resolve, reject) => {
                 if (!this.ws) {
                     reject(new Error('WebSocket not initialized'));

package/dist/handlers/ListConsoleMessagesHandler.js

@@ -20,21 +20,44 @@ class ListConsoleMessagesHandler {
             };
         }
     }
+    buildMatcher(params) {
+        const rawExpressions = params.expression
+            ? Array.isArray(params.expression)
+                ? params.expression
+                : [params.expression]
+            : [];
+        const patterns = [
+            ...(params.pattern ? [params.pattern] : []),
+            ...rawExpressions,
+        ];
+        if (patterns.length === 0)
+            return () => true;
+        const fixedStrings = params.fixedStrings ?? params["fixed-strings"] ?? false;
+        const caseSensitive = params.caseSensitive ?? params["case-sensitive"] ?? false;
+        const invertMatch = params.invertMatch ?? params["invert-match"] ?? false;
+        const flags = caseSensitive ? "" : "i";
+        const tests = patterns.map((p) => {
+            if (fixedStrings) {
+                return caseSensitive
+                    ? (text) => text.includes(p)
+                    : (text) => text.toLowerCase().includes(p.toLowerCase());
+            }
+            const re = new RegExp(p, flags);
+            return (text) => re.test(text);
+        });
+        const anyMatch = (text) => tests.some((t) => t(text));
+        return invertMatch ? (text) => !anyMatch(text) : anyMatch;
+    }
     async executeFollowMode(client, params) {
         if (!this.consoleMonitor) {
             this.consoleMonitor = new ConsoleMonitor_1.ConsoleMonitor(client);
         }
         await this.consoleMonitor.startMonitoring();
-        const filter = {};
-        if (params.types && params.types.length > 0) {
-            filter.types = params.types;
-        }
-        if (params.textPattern) {
-            filter.textPattern = params.textPattern;
-        }
+        const typeFilter = params.types && params.types.length > 0 ? params.types : null;
+        const matchText = this.buildMatcher(params);
         const outputFormat = params.format || "text";
         const messageCallback = (message) => {
-            if (!this.shouldOutputMessage(message, filter)) {
+            if (!this.shouldOutputMessage(message, typeFilter, matchText)) {
                 return;
             }
             this.outputMessage(message, outputFormat);
@@ -69,19 +92,11 @@ class ListConsoleMessagesHandler {
             isLongRunning: true,
         };
     }
-    shouldOutputMessage(message, filter) {
-        if (filter.types && filter.types.length > 0) {
-            if (!filter.types.includes(message.type)) {
-                return false;
-            }
-        }
-        if (filter.textPattern) {
-            const pattern = new RegExp(filter.textPattern, "i");
-            if (!pattern.test(message.text)) {
-                return false;
-            }
+    shouldOutputMessage(message, typeFilter, matchText) {
+        if (typeFilter && !typeFilter.includes(message.type)) {
+            return false;
         }
-        return true;
+        return matchText(message.text);
     }
     outputMessage(message, format) {
         switch (format) {
@@ -142,10 +157,16 @@ class ListConsoleMessagesHandler {
                     return false;
             }
         }
-        if (params.textPattern !== undefined &&
-            typeof params.textPattern !== "string") {
+        if (params.pattern !== undefined && typeof params.pattern !== "string") {
             return false;
         }
+        if (params.expression !== undefined) {
+            const exprs = Array.isArray(params.expression)
+                ? params.expression
+                : [params.expression];
+            if (!exprs.every((e) => typeof e === "string"))
+                return false;
+        }
         if (params.format !== undefined) {
             const validFormats = ["text", "json", "pretty"];
             if (typeof params.format !== "string" ||
@@ -159,21 +180,30 @@ class ListConsoleMessagesHandler {
         return `log - Follow console messages in real-time
 
 Usage:
-  cdp log [options]
+  cdp log [PATTERN] [options]
+
+Arguments:
+  PATTERN                 Pattern to match (regex, case-insensitive by default)
 
 Options:
-  --types <types>         Filter by message types (comma-separated: log,info,warn,error,debug)
-  --textPattern <pattern> Filter by text pattern (regex, case-insensitive)
-  --format <format>       Output format: text, json, or pretty (default: text)
+  -e, --expression <pat>  Pattern to match; may be used multiple times (OR logic)
+  -F, --fixed-strings     Treat pattern(s) as literal strings, not regexps
+  -v, --invert-match      Output messages that do NOT match the pattern
+      --case-sensitive    Case-sensitive matching (default: case-insensitive)
+      --types <types>     Filter by message types (log,info,warn,error,debug)
+      --format <format>   Output format: text, json, or pretty (default: text)
   -f, --follow            Alias flag (follow mode is always active)
 
 Examples:
-  cdp log                                    # Follow all console messages
-  cdp log --types error,warn                 # Follow only errors and warnings
-  cdp log --textPattern "API"                # Follow messages matching /API/i
-  cdp log --format json                      # Output as JSON (one object per line)
-  cdp log --format pretty                    # Colorized output
-  cdp log --types error --textPattern "404"  # Combined filters
+  cdp log                          # Follow all console messages
+  cdp log '\\[AI'                  # Messages matching regex /\\[AI/i
+  cdp log -e error -e warn         # Messages containing 'error' OR 'warn'
+  cdp log -F '[AI'                 # Messages containing literal '[AI'
+  cdp log -v debug                 # Messages NOT containing 'debug'
+  cdp log '404' --case-sensitive   # Case-sensitive match
+  cdp log --types error,warn       # Filter by type
+  cdp log --format json            # Output as JSON (one object per line)
+  cdp log --format pretty          # Colorized output
 
 Note:
   This command runs continuously and streams console messages in real-time.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-cdp-cli",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "Browser automation CLI via Chrome DevTools Protocol. Designed for developers and AI assistants - combines dedicated commands for common tasks with flexible JavaScript execution for complex scenarios. Features: 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",