chrome-cdp-cli 2.0.5 → 2.1.0

package/dist/handlers/ListNetworkRequestsHandler.js

@@ -2,140 +2,160 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListNetworkRequestsHandler = void 0;
 const NetworkMonitor_1 = require("../monitors/NetworkMonitor");
-const ProxyClient_1 = require("../client/ProxyClient");
 class ListNetworkRequestsHandler {
     constructor() {
-        this.name = 'network';
+        this.name = "network";
         this.networkMonitor = null;
-        this.proxyClient = null;
     }
     async execute(client, args) {
         try {
             const params = args;
-            const proxyResult = await this.tryProxyExecution(params);
-            if (proxyResult) {
-                return proxyResult;
-            }
-            return await this.executeDirectCDP(client, params);
+            return await this.executeFollowMode(client, params);
         }
         catch (error) {
             return {
                 success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
+                error: error instanceof Error ? error.message : "Unknown error occurred",
             };
         }
     }
-    async tryProxyExecution(params) {
-        try {
-            if (!this.proxyClient) {
-                this.proxyClient = new ProxyClient_1.ProxyClient();
-            }
-            const isProxyAvailable = await this.proxyClient.isProxyAvailable();
-            if (!isProxyAvailable) {
-                const proxyStarted = await this.proxyClient.ensureProxyRunning();
-                if (!proxyStarted) {
-                    console.warn('⚠️  Proxy server unavailable. Falling back to direct CDP connection.');
-                    console.warn('⚠️  Note: Direct connection only captures NEW network requests, not historical data.');
-                    return null;
-                }
-            }
-            if (!this.proxyClient.getConnectionId()) {
-                const host = params.host || 'localhost';
-                const port = params.port || 9222;
-                await this.proxyClient.connect(host, port, params.targetId);
-            }
-            const filter = params.filter ? {
-                methods: params.filter.methods,
-                urlPattern: params.filter.urlPattern,
-                statusCodes: params.filter.statusCodes,
-                maxRequests: params.latest ? 1 : params.filter.maxRequests,
-                startTime: params.filter.startTime,
-                endTime: params.filter.endTime,
-            } : params.latest ? { maxRequests: 1 } : undefined;
-            const requests = await this.proxyClient.getNetworkRequests(filter);
-            if (params.latest) {
-                const latestRequest = requests.length > 0 ? requests[requests.length - 1] : null;
-                if (!latestRequest) {
-                    return {
-                        success: true,
-                        data: null,
-                        dataSource: 'proxy',
-                        hasHistoricalData: true
-                    };
-                }
-                return {
-                    success: true,
-                    data: latestRequest,
-                    dataSource: 'proxy',
-                    hasHistoricalData: true
-                };
-            }
-            return {
-                success: true,
-                data: {
-                    requests,
-                    count: requests.length,
-                    isMonitoring: true
-                },
-                dataSource: 'proxy',
-                hasHistoricalData: true
-            };
-        }
-        catch (error) {
-            console.warn('⚠️  Proxy execution failed, falling back to direct CDP:', error instanceof Error ? error.message : error);
-            console.warn('⚠️  Note: Direct connection only captures NEW network requests, not historical data.');
-            return null;
-        }
-    }
-    async executeDirectCDP(client, params) {
+    async executeFollowMode(client, params) {
         if (!this.networkMonitor) {
             this.networkMonitor = new NetworkMonitor_1.NetworkMonitor(client);
         }
-        if (!this.networkMonitor.isActive()) {
-            await this.networkMonitor.startMonitoring();
-        }
-        const filter = params.filter ? {
-            methods: params.filter.methods,
-            urlPattern: params.filter.urlPattern,
-            statusCodes: params.filter.statusCodes,
-            maxRequests: params.filter.maxRequests,
-            startTime: params.filter.startTime,
-            endTime: params.filter.endTime,
-        } : undefined;
-        if (params.latest) {
-            const latestRequest = this.networkMonitor.getLatestRequest(filter);
-            if (!latestRequest) {
-                return {
-                    success: true,
-                    data: null,
-                    dataSource: 'direct',
-                    hasHistoricalData: false
-                };
+        await this.networkMonitor.startMonitoring();
+        const methods = this.parseList(params.methods);
+        const statusCodes = this.parseList(params.statusCodes)
+            .map(Number)
+            .filter((n) => !isNaN(n));
+        const urlPattern = params.urlPattern;
+        const outputFormat = params.format || "text";
+        const requestCallback = (request) => {
+            if (!this.shouldOutputRequest(request, methods, urlPattern, statusCodes)) {
+                return;
             }
-            return {
-                success: true,
-                data: latestRequest,
-                dataSource: 'direct',
-                hasHistoricalData: false
-            };
+            this.outputRequest(request, outputFormat);
+        };
+        this.networkMonitor.onRequest(requestCallback);
+        let isShuttingDown = false;
+        const cleanup = async () => {
+            if (isShuttingDown)
+                return;
+            isShuttingDown = true;
+            this.networkMonitor?.offRequest(requestCallback);
+            await this.networkMonitor?.stopMonitoring();
+        };
+        const signalHandler = async () => {
+            process.stderr.write("\n");
+            await cleanup();
+            process.exit(0);
+        };
+        process.removeAllListeners("SIGINT");
+        process.removeAllListeners("SIGTERM");
+        process.on("SIGINT", signalHandler);
+        process.on("SIGTERM", signalHandler);
+        if (outputFormat === "text") {
+            console.log("Following network requests (press Ctrl+C to stop)...\n");
         }
-        const requests = this.networkMonitor.getRequests(filter);
         return {
             success: true,
             data: {
-                requests,
-                count: requests.length,
-                isMonitoring: this.networkMonitor.isActive()
+                message: "Following network requests in real-time. Press Ctrl+C to stop.",
+                isLongRunning: true,
             },
-            dataSource: 'direct',
-            hasHistoricalData: false
+            isLongRunning: true,
         };
     }
-    getNetworkMonitor() {
-        return this.networkMonitor;
+    parseList(value) {
+        if (!value)
+            return [];
+        if (Array.isArray(value))
+            return value;
+        return value
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    shouldOutputRequest(request, methods, urlPattern, statusCodes) {
+        if (methods.length > 0 &&
+            !methods
+                .map((m) => m.toUpperCase())
+                .includes(request.method.toUpperCase())) {
+            return false;
+        }
+        if (urlPattern) {
+            const pattern = new RegExp(urlPattern, "i");
+            if (!pattern.test(request.url))
+                return false;
+        }
+        if (statusCodes.length > 0 &&
+            request.status !== undefined &&
+            !statusCodes.includes(request.status)) {
+            return false;
+        }
+        return true;
+    }
+    outputRequest(request, format) {
+        const status = request.status ?? "???";
+        const method = request.method.toUpperCase().padEnd(7);
+        const time = new Date(request.timestamp).toISOString();
+        switch (format) {
+            case "json":
+                console.log(JSON.stringify({
+                    method: request.method,
+                    url: request.url,
+                    status: request.status,
+                    timestamp: request.timestamp,
+                }));
+                break;
+            case "pretty": {
+                const statusColor = this.getStatusColor(request.status);
+                console.log(`[${time}] ${method} ${statusColor}${status}\x1b[0m ${request.url}`);
+                break;
+            }
+            case "text":
+            default:
+                console.log(`[${time}] ${method} ${status} ${request.url}`);
+                break;
+        }
+    }
+    getStatusColor(status) {
+        if (status === undefined || status === 0)
+            return "\x1b[31m";
+        if (status >= 500)
+            return "\x1b[31m";
+        if (status >= 400)
+            return "\x1b[33m";
+        if (status >= 300)
+            return "\x1b[36m";
+        return "\x1b[32m";
     }
-    setNetworkMonitor(monitor) {
-        this.networkMonitor = monitor;
+    getHelp() {
+        return `network - Follow network requests in real-time
+
+Usage:
+  cdp network [options]
+
+Options:
+  --methods <methods>         Filter by HTTP methods (comma-separated: GET,POST,PUT,DELETE,...)
+  --urlPattern <pattern>      Filter by URL pattern (regex, case-insensitive)
+  --statusCodes <codes>       Filter by HTTP status codes (comma-separated: 200,404,500)
+  --format <format>           Output format: text, json, or pretty (default: text)
+  -f, --follow                Alias flag (follow mode is always active)
+
+Examples:
+  cdp network                                    # Follow all network requests
+  cdp network --methods POST,PUT                 # Follow only POST and PUT requests
+  cdp network --urlPattern "/api/"               # Follow requests matching /\\/api\\//i
+  cdp network --statusCodes 404,500              # Follow requests with error status
+  cdp network --format json                      # Output as JSON (one object per line)
+  cdp network --format pretty                    # Colorized output
+  cdp network --methods GET --urlPattern "/api"  # Combined filters
+
+Note:
+  This command runs continuously and streams network requests in real-time.
+  Each entry is printed when the request fully completes (or fails).
+  Press Ctrl+C to stop. No background process is required.`;
     }
 }
 exports.ListNetworkRequestsHandler = ListNetworkRequestsHandler;

package/dist/handlers/RestartProxyHandler.js

@@ -61,8 +61,8 @@ class RestartProxyHandler {
 restart - Restart the proxy server process
 
 Usage:
-  chrome-cdp-cli restart
-  chrome-cdp-cli restart --force
+  cdp restart
+  cdp restart --force
 
 Description:
   Restarts the proxy server process. This will:
@@ -82,10 +82,10 @@ Options:
 
 Examples:
   # Restart the proxy server
-  chrome-cdp-cli restart
+  cdp restart
 
   # Force restart even if proxy is healthy
-  chrome-cdp-cli restart --force
+  cdp restart --force
 
 Note:
   - Restarting the proxy will clear all stored console messages and network requests

package/dist/handlers/TakeScreenshotHandler.js

@@ -5,18 +5,27 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 class TakeScreenshotHandler {
     constructor() {
-        this.name = 'screenshot';
+        this.name = "screenshot";
     }
     async execute(client, args) {
         const screenshotArgs = args;
         try {
-            await client.send('Page.enable');
+            if (!screenshotArgs.filename && process.stdout.isTTY) {
+                process.stderr.write("Error: Binary output to terminal detected.\n" +
+                    "Use --filename <path> to save to a file, or redirect: cdp screenshot > page.png\n");
+                return {
+                    success: false,
+                    error: "Binary output to terminal detected. Use --filename or redirect output.",
+                    exitCode: 1,
+                };
+            }
+            await client.send("Page.enable");
             const params = this.buildScreenshotParams(screenshotArgs);
-            const response = await client.send('Page.captureScreenshot', params);
+            const response = (await client.send("Page.captureScreenshot", params));
             if (!response || !response.data) {
                 return {
                     success: false,
-                    error: 'Failed to capture screenshot: empty response'
+                    error: "Failed to capture screenshot: empty response",
                 };
             }
             if (screenshotArgs.filename) {
@@ -26,31 +35,30 @@ class TakeScreenshotHandler {
                     data: {
                         message: `Screenshot saved to ${screenshotArgs.filename}`,
                         filename: screenshotArgs.filename,
-                        format: screenshotArgs.format || 'png'
-                    }
+                        imageFormat: screenshotArgs.imageFormat || "png",
+                    },
                 };
             }
+            process.stdout.write(Buffer.from(response.data, "base64"));
             return {
                 success: true,
-                data: {
-                    base64: response.data,
-                    format: screenshotArgs.format || 'png'
-                }
+                data: null,
+                _rawOutput: true,
             };
         }
         catch (error) {
             return {
                 success: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             };
         }
     }
     buildScreenshotParams(args) {
         const params = {};
-        params.format = args.format || 'png';
-        if (args.format === 'jpeg' && args.quality !== undefined) {
+        params.format = args.imageFormat || "png";
+        if (args.imageFormat === "jpeg" && args.quality !== undefined) {
             if (args.quality < 0 || args.quality > 100) {
-                throw new Error('JPEG quality must be between 0 and 100');
+                throw new Error("JPEG quality must be between 0 and 100");
             }
             params.quality = args.quality;
         }
@@ -60,7 +68,7 @@ class TakeScreenshotHandler {
                 y: args.clip.y,
                 width: args.clip.width,
                 height: args.clip.height,
-                scale: args.clip.scale || 1
+                scale: args.clip.scale || 1,
             };
         }
         if (args.width || args.height) {
@@ -74,7 +82,7 @@ class TakeScreenshotHandler {
         try {
             const dir = (0, path_1.dirname)(filename);
             await fs_1.promises.mkdir(dir, { recursive: true });
-            const buffer = Buffer.from(base64Data, 'base64');
+            const buffer = Buffer.from(base64Data, "base64");
             await fs_1.promises.writeFile(filename, buffer);
         }
         catch (error) {
@@ -82,88 +90,91 @@ class TakeScreenshotHandler {
         }
     }
     validateArgs(args) {
-        if (typeof args !== 'object' || args === null) {
+        if (typeof args !== "object" || args === null) {
             return false;
         }
         const screenshotArgs = args;
-        if (screenshotArgs.filename !== undefined && typeof screenshotArgs.filename !== 'string') {
+        if (screenshotArgs.filename !== undefined &&
+            typeof screenshotArgs.filename !== "string") {
             return false;
         }
-        if (screenshotArgs.width !== undefined && (typeof screenshotArgs.width !== 'number' || screenshotArgs.width <= 0)) {
+        if (screenshotArgs.width !== undefined &&
+            (typeof screenshotArgs.width !== "number" || screenshotArgs.width <= 0)) {
             return false;
         }
-        if (screenshotArgs.height !== undefined && (typeof screenshotArgs.height !== 'number' || screenshotArgs.height <= 0)) {
+        if (screenshotArgs.height !== undefined &&
+            (typeof screenshotArgs.height !== "number" || screenshotArgs.height <= 0)) {
             return false;
         }
-        if (screenshotArgs.format !== undefined && !['png', 'jpeg'].includes(screenshotArgs.format)) {
+        if (screenshotArgs.imageFormat !== undefined &&
+            !["png", "jpeg"].includes(screenshotArgs.imageFormat)) {
             return false;
         }
         if (screenshotArgs.quality !== undefined) {
-            if (typeof screenshotArgs.quality !== 'number' || screenshotArgs.quality < 0 || screenshotArgs.quality > 100) {
+            if (typeof screenshotArgs.quality !== "number" ||
+                screenshotArgs.quality < 0 ||
+                screenshotArgs.quality > 100) {
                 return false;
             }
         }
-        if (screenshotArgs.fullPage !== undefined && typeof screenshotArgs.fullPage !== 'boolean') {
+        if (screenshotArgs.fullPage !== undefined &&
+            typeof screenshotArgs.fullPage !== "boolean") {
             return false;
         }
         if (screenshotArgs.clip !== undefined) {
             const clip = screenshotArgs.clip;
-            if (typeof clip !== 'object' || clip === null) {
+            if (typeof clip !== "object" || clip === null) {
                 return false;
             }
-            if (typeof clip.x !== 'number' || typeof clip.y !== 'number' ||
-                typeof clip.width !== 'number' || typeof clip.height !== 'number') {
+            if (typeof clip.x !== "number" ||
+                typeof clip.y !== "number" ||
+                typeof clip.width !== "number" ||
+                typeof clip.height !== "number") {
                 return false;
             }
             if (clip.width <= 0 || clip.height <= 0) {
                 return false;
             }
-            if (clip.scale !== undefined && (typeof clip.scale !== 'number' || clip.scale <= 0)) {
+            if (clip.scale !== undefined &&
+                (typeof clip.scale !== "number" || clip.scale <= 0)) {
                 return false;
             }
         }
         return true;
     }
     getHelp() {
-        return `
-screenshot - Capture a screenshot of the current page
+        return `screenshot - Capture a screenshot of the current page
 
 Usage:
-  screenshot
-  screenshot --filename screenshot.png
-  screenshot --width 1920 --height 1080 --filename full-hd.png
-  screenshot --format jpeg --quality 80 --filename compressed.jpg
-  screenshot --full-page --filename full-page.png
+  cdp screenshot                                   # Output PNG binary to stdout
+  cdp screenshot --filename page.png               # Save to file
+  cdp screenshot > page.png                        # Pipe binary to file
 
 Arguments:
-  --filename <path>       Output filename (if not provided, returns base64 data)
-  --width <pixels>        Screenshot width (requires viewport adjustment)
-  --height <pixels>       Screenshot height (requires viewport adjustment)
-  --format <png|jpeg>     Image format (default: png)
-  --quality <1-100>       JPEG quality (only for jpeg format)
-  --full-page             Capture full page beyond viewport (default: false)
-  --clip-x <pixels>       Clip rectangle X coordinate
-  --clip-y <pixels>       Clip rectangle Y coordinate
-  --clip-width <pixels>   Clip rectangle width
-  --clip-height <pixels>  Clip rectangle height
-  --clip-scale <number>   Clip rectangle scale factor
+  --filename <path>            Output filename (if omitted, binary is written to stdout)
+  --width <pixels>             Screenshot width
+  --height <pixels>            Screenshot height
+  --image-format <png|jpeg>    Image encoding format (default: png)
+  --quality <1-100>            JPEG quality (only for jpeg format)
+  --full-page                  Capture full page beyond viewport (default: false)
+  --clip-x <pixels>            Clip rectangle X coordinate
+  --clip-y <pixels>            Clip rectangle Y coordinate
+  --clip-width <pixels>        Clip rectangle width
+  --clip-height <pixels>       Clip rectangle height
+  --clip-scale <number>        Clip rectangle scale factor
 
 Examples:
-  # Basic screenshot
-  screenshot --filename page.png
-
-  # High quality JPEG
-  screenshot --format jpeg --quality 95 --filename page.jpg
-
-  # Full page screenshot
-  screenshot --full-page --filename full-page.png
-
-  # Clipped screenshot
-  screenshot --clip-x 100 --clip-y 100 --clip-width 800 --clip-height 600 --filename clipped.png
+  cdp screenshot --filename page.png
+  cdp screenshot > page.png
+  cdp screenshot --image-format jpeg --quality 90 --filename page.jpg
+  cdp screenshot --full-page --filename full-page.png
+  cdp screenshot --clip-x 100 --clip-y 100 --clip-width 800 --clip-height 600 --filename clipped.png
 
-  # Return base64 data (no file)
-  screenshot --format png
-`;
+Note:
+  When no --filename is given, raw binary image data is written to stdout.
+  Redirecting to a file (> page.png) or piping is the intended usage.
+  Running without redirection in a terminal will show a warning and exit.
+  The global --format flag has no effect on screenshot output.`;
     }
 }
 exports.TakeScreenshotHandler = TakeScreenshotHandler;