chrome-cdp-cli 1.0.0 → 1.0.1

package/README.md

@@ -72,28 +72,28 @@ chrome --remote-debugging-port=9222 --no-first-run --no-default-browser-check
 
 ```bash
 # Connect and execute JavaScript
-chrome-cli eval "document.title"
+chrome-cdp-cli eval "document.title"
 
 # Or use with npx (no installation needed)
 npx chrome-cdp-cli eval "document.title"
 
 # Navigate to a website
-chrome-cli navigate_page "https://example.com"
+chrome-cdp-cli navigate_page "https://example.com"
 
 # Take a screenshot
-chrome-cli take_screenshot --output screenshot.png
+chrome-cdp-cli screenshot --filename screenshot.png
 
 # Click an element
-chrome-cli click "#submit-button"
+chrome-cdp-cli click "#submit-button"
 
 # Fill a form field
-chrome-cli fill "#email" "user@example.com"
+chrome-cdp-cli fill "#email" "user@example.com"
 
 # Get help for all commands
-chrome-cli --help
+chrome-cdp-cli --help
 
 # Get help for a specific command
-chrome-cli eval --help
+chrome-cdp-cli eval --help
 ```
 
 ## Command Reference
@@ -117,13 +117,13 @@ All commands support these connection options:
 #### JavaScript Execution
 ```bash
 # Execute JavaScript expression
-chrome-cli eval "console.log('Hello World')"
+chrome-cdp-cli eval "console.log('Hello World')"
 
 # Execute from file
-chrome-cli eval --file script.js
+chrome-cdp-cli eval --file script.js
 
 # Execute with timeout
-chrome-cli eval "await new Promise(r => setTimeout(r, 5000))" --timeout 10000
+chrome-cdp-cli eval "await new Promise(r => setTimeout(r, 5000))" --timeout 10000
 
 # Using npx (no installation required)
 npx chrome-cdp-cli eval "document.title"
@@ -133,56 +133,59 @@ npx chrome-cdp-cli eval --file script.js
 #### Page Management
 ```bash
 # Navigate to URL
-chrome-cli navigate_page "https://example.com"
+chrome-cdp-cli navigate_page "https://example.com"
 
 # Create new tab
-chrome-cli new_page
+chrome-cdp-cli new_page
 
 # List all pages
-chrome-cli list_pages
+chrome-cdp-cli list_pages
 
 # Close current page
-chrome-cli close_page
+chrome-cdp-cli close_page
 
 # Switch to specific page
-chrome-cli select_page --id "page-id"
+chrome-cdp-cli select_page --id "page-id"
 ```
 
 #### Element Interaction
 ```bash
 # Click element
-chrome-cli click "#button"
+chrome-cdp-cli click "#button"
 
 # Fill input field
-chrome-cli fill "#email" "user@example.com"
+chrome-cdp-cli fill "#email" "user@example.com"
 
 # Hover over element
-chrome-cli hover ".menu-item"
+chrome-cdp-cli hover ".menu-item"
 
 # Wait for element
-chrome-cli wait_for "#loading" --timeout 5000
+chrome-cdp-cli wait_for "#loading" --timeout 5000
 ```
 
 #### Visual Capture
 ```bash
 # Take screenshot
-chrome-cli take_screenshot --output screenshot.png
+chrome-cdp-cli screenshot --filename screenshot.png
 
-# Full page screenshot
-chrome-cli take_snapshot --output fullpage.png
+# Full page screenshot  
+chrome-cdp-cli screenshot --full-page --filename fullpage.png
+
+# DOM snapshot
+chrome-cdp-cli snapshot --filename dom-snapshot.json
 
 # Custom dimensions
-chrome-cli take_screenshot --width 1920 --height 1080 --output custom.png
+chrome-cdp-cli screenshot --width 1920 --height 1080 --filename custom.png
 
 # Get HTML content
-chrome-cli get_html --output page.html
+chrome-cdp-cli get_html --output page.html
 ```
 
 ## Configuration
 
 ### Configuration File
 
-Create a `.chrome-cli.json` file in your project root or home directory:
+Create a `.chrome-cdp-cli.json` file in your project root or home directory:
 
 ```json
 {
@@ -347,7 +350,7 @@ console.log(result);
 Enable verbose logging for troubleshooting:
 
 ```bash
-chrome-cli --verbose eval "console.log('debug')"
+chrome-cdp-cli --verbose eval "console.log('debug')"
 ```
 
 ### Packaging

package/dist/cli/CLIApplication.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIApplication = void 0;
 const CLIInterface_1 = require("./CLIInterface");
 const ConnectionManager_1 = require("../connection/ConnectionManager");
-const EvaluateScriptHandler_1 = require("../handlers/EvaluateScriptHandler");
+const handlers_1 = require("../handlers");
 const logger_1 = require("../utils/logger");
 const CommandRouter_1 = require("./CommandRouter");
 class CLIApplication {
@@ -14,7 +14,9 @@ class CLIApplication {
         this.setupHandlers();
     }
     setupHandlers() {
-        this.cli.registerHandler(new EvaluateScriptHandler_1.EvaluateScriptHandler());
+        this.cli.registerHandler(new handlers_1.EvaluateScriptHandler());
+        this.cli.registerHandler(new handlers_1.TakeScreenshotHandler());
+        this.cli.registerHandler(new handlers_1.TakeSnapshotHandler());
     }
     async run(argv) {
         try {

package/dist/cli/CLIInterface.js

@@ -48,7 +48,7 @@ class CLIInterface {
     }
     setupProgram() {
         this.program
-            .name('chrome-cli')
+            .name('chrome-cdp-cli')
             .description('Command-line tool for controlling Chrome browser via DevTools Protocol')
             .version('1.0.0')
             .allowUnknownOption(true)
@@ -139,9 +139,9 @@ class CLIInterface {
         }
         else {
             const defaultPaths = [
-                '.chrome-cli.json',
-                path.join(process.env.HOME || '', '.chrome-cli.json'),
-                '/etc/chrome-cli.json'
+                '.chrome-cdp-cli.json',
+                path.join(process.env.HOME || '', '.chrome-cdp-cli.json'),
+                '/etc/chrome-cdp-cli.json'
             ];
             for (const defaultPath of defaultPaths) {
                 try {
@@ -239,12 +239,45 @@ class CLIInterface {
                 commandArgs.text = args[1];
                 break;
             case 'screenshot':
+                if (options.filename)
+                    commandArgs.filename = options.filename;
                 if (options.output || options.o)
-                    commandArgs.output = options.output || options.o;
+                    commandArgs.filename = options.output || options.o;
                 if (options.width || options.w)
                     commandArgs.width = parseInt(options.width || options.w, 10);
                 if (options.height || options.h)
                     commandArgs.height = parseInt(options.height || options.h, 10);
+                if (options.format)
+                    commandArgs.format = options.format;
+                if (options.quality)
+                    commandArgs.quality = parseInt(options.quality, 10);
+                if (options['full-page'])
+                    commandArgs.fullPage = true;
+                if (options['clip-x'] || options['clip-y'] || options['clip-width'] || options['clip-height'] || options['clip-scale']) {
+                    commandArgs.clip = {
+                        x: options['clip-x'] ? parseInt(options['clip-x'], 10) : 0,
+                        y: options['clip-y'] ? parseInt(options['clip-y'], 10) : 0,
+                        width: options['clip-width'] ? parseInt(options['clip-width'], 10) : 0,
+                        height: options['clip-height'] ? parseInt(options['clip-height'], 10) : 0,
+                        scale: options['clip-scale'] ? parseFloat(options['clip-scale']) : 1
+                    };
+                }
+                break;
+            case 'snapshot':
+                if (options.filename)
+                    commandArgs.filename = options.filename;
+                if (options.output || options.o)
+                    commandArgs.filename = options.output || options.o;
+                if (options.format)
+                    commandArgs.format = options.format;
+                if (options['include-styles'] !== undefined)
+                    commandArgs.includeStyles = options['include-styles'] !== 'false';
+                if (options['include-attributes'] !== undefined)
+                    commandArgs.includeAttributes = options['include-attributes'] !== 'false';
+                if (options['include-paint-order'])
+                    commandArgs.includePaintOrder = true;
+                if (options['include-text-index'])
+                    commandArgs.includeTextIndex = true;
                 break;
             case 'console_messages':
                 if (options.filter)

package/dist/cli/CommandRouter.js

@@ -186,7 +186,7 @@ class CommandRouter {
         return `
 Chrome DevTools CLI - Command-line tool for controlling Chrome browser
 
-Usage: chrome-cli [options] <command> [command-options]
+Usage: chrome-cdp-cli [options] <command> [command-options]
 
 Global Options:
   -h, --host <host>        Chrome host address (default: localhost)
@@ -201,12 +201,14 @@ Available Commands:
 ${commands.map(cmd => `  ${cmd.padEnd(20)} - ${this.getCommandDescription(cmd)}`).join('\n')}
 
 Examples:
-  chrome-cli eval "document.title"
-  chrome-cli eval --file script.js
-  chrome-cli help <command>
+  chrome-cdp-cli eval "document.title"
+  chrome-cdp-cli eval --file script.js
+  chrome-cdp-cli screenshot --filename page.png
+  chrome-cdp-cli snapshot --format html --filename dom.html
+  chrome-cdp-cli help <command>
 
 For more information about a specific command, use:
-  chrome-cli help <command>
+  chrome-cdp-cli help <command>
 `;
     }
     getCommandDescription(commandName) {
@@ -223,8 +225,8 @@ For more information about a specific command, use:
             'click': 'Click element',
             'fill': 'Fill form field',
             'hover': 'Hover over element',
-            'screenshot': 'Take screenshot',
-            'get-html': 'Get page HTML content',
+            'screenshot': 'Capture page screenshot',
+            'snapshot': 'Capture DOM snapshot with structure and styles',
             'console-messages': 'Get console messages',
             'network-requests': 'Get network requests',
             'help': 'Show help information'

package/dist/handlers/TakeScreenshotHandler.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TakeScreenshotHandler = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class TakeScreenshotHandler {
+    constructor() {
+        this.name = 'screenshot';
+    }
+    async execute(client, args) {
+        const screenshotArgs = args;
+        try {
+            await client.send('Page.enable');
+            const params = this.buildScreenshotParams(screenshotArgs);
+            const response = await client.send('Page.captureScreenshot', params);
+            if (!response || !response.data) {
+                return {
+                    success: false,
+                    error: 'Failed to capture screenshot: empty response'
+                };
+            }
+            if (screenshotArgs.filename) {
+                await this.saveScreenshot(response.data, screenshotArgs.filename);
+                return {
+                    success: true,
+                    data: {
+                        message: `Screenshot saved to ${screenshotArgs.filename}`,
+                        filename: screenshotArgs.filename,
+                        format: screenshotArgs.format || 'png'
+                    }
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    base64: response.data,
+                    format: screenshotArgs.format || 'png'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    buildScreenshotParams(args) {
+        const params = {};
+        params.format = args.format || 'png';
+        if (args.format === 'jpeg' && args.quality !== undefined) {
+            if (args.quality < 0 || args.quality > 100) {
+                throw new Error('JPEG quality must be between 0 and 100');
+            }
+            params.quality = args.quality;
+        }
+        if (args.clip) {
+            params.clip = {
+                x: args.clip.x,
+                y: args.clip.y,
+                width: args.clip.width,
+                height: args.clip.height,
+                scale: args.clip.scale || 1
+            };
+        }
+        if (args.width || args.height) {
+        }
+        if (args.fullPage) {
+            params.captureBeyondViewport = true;
+        }
+        return params;
+    }
+    async saveScreenshot(base64Data, filename) {
+        try {
+            const dir = (0, path_1.dirname)(filename);
+            await fs_1.promises.mkdir(dir, { recursive: true });
+            const buffer = Buffer.from(base64Data, 'base64');
+            await fs_1.promises.writeFile(filename, buffer);
+        }
+        catch (error) {
+            throw new Error(`Failed to save screenshot to "${filename}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    validateArgs(args) {
+        if (typeof args !== 'object' || args === null) {
+            return false;
+        }
+        const screenshotArgs = args;
+        if (screenshotArgs.filename !== undefined && typeof screenshotArgs.filename !== 'string') {
+            return false;
+        }
+        if (screenshotArgs.width !== undefined && (typeof screenshotArgs.width !== 'number' || screenshotArgs.width <= 0)) {
+            return false;
+        }
+        if (screenshotArgs.height !== undefined && (typeof screenshotArgs.height !== 'number' || screenshotArgs.height <= 0)) {
+            return false;
+        }
+        if (screenshotArgs.format !== undefined && !['png', 'jpeg'].includes(screenshotArgs.format)) {
+            return false;
+        }
+        if (screenshotArgs.quality !== undefined) {
+            if (typeof screenshotArgs.quality !== 'number' || screenshotArgs.quality < 0 || screenshotArgs.quality > 100) {
+                return false;
+            }
+        }
+        if (screenshotArgs.fullPage !== undefined && typeof screenshotArgs.fullPage !== 'boolean') {
+            return false;
+        }
+        if (screenshotArgs.clip !== undefined) {
+            const clip = screenshotArgs.clip;
+            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') {
+                return false;
+            }
+            if (clip.width <= 0 || clip.height <= 0) {
+                return false;
+            }
+            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
+
+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
+
+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
+
+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
+
+  # Return base64 data (no file)
+  screenshot --format png
+`;
+    }
+}
+exports.TakeScreenshotHandler = TakeScreenshotHandler;

package/dist/handlers/TakeSnapshotHandler.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TakeSnapshotHandler = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class TakeSnapshotHandler {
+    constructor() {
+        this.name = 'snapshot';
+    }
+    async execute(client, args) {
+        const snapshotArgs = args;
+        try {
+            await client.send('DOMSnapshot.enable');
+            await client.send('DOM.enable');
+            await client.send('CSS.enable');
+            const params = this.buildSnapshotParams(snapshotArgs);
+            const response = await client.send('DOMSnapshot.captureSnapshot', params);
+            if (!response || !response.documents || response.documents.length === 0) {
+                return {
+                    success: false,
+                    error: 'Failed to capture DOM snapshot: empty response'
+                };
+            }
+            const processedSnapshot = this.processSnapshot(response, snapshotArgs);
+            if (snapshotArgs.filename) {
+                await this.saveSnapshot(processedSnapshot, snapshotArgs.filename, snapshotArgs.format);
+                return {
+                    success: true,
+                    data: {
+                        message: `DOM snapshot saved to ${snapshotArgs.filename}`,
+                        filename: snapshotArgs.filename,
+                        format: snapshotArgs.format || 'json',
+                        documentsCount: response.documents.length,
+                        nodesCount: response.documents[0]?.nodes?.nodeName?.length || 0
+                    }
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    snapshot: processedSnapshot,
+                    format: snapshotArgs.format || 'json',
+                    documentsCount: response.documents.length,
+                    nodesCount: response.documents[0]?.nodes?.nodeName?.length || 0
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    buildSnapshotParams(args) {
+        const params = {};
+        params.computedStyles = args.includeStyles !== false;
+        params.includeDOMRects = args.includeAttributes !== false;
+        if (args.includePaintOrder) {
+            params.includePaintOrder = true;
+        }
+        if (args.includeTextIndex) {
+            params.includeTextIndex = true;
+        }
+        params.computedStyleWhitelist = [];
+        return params;
+    }
+    processSnapshot(response, args) {
+        if (args.format === 'html') {
+            return this.convertToHTML(response);
+        }
+        return {
+            metadata: {
+                captureTime: new Date().toISOString(),
+                documentsCount: response.documents.length,
+                stringsCount: response.strings.length
+            },
+            documents: response.documents.map(doc => ({
+                url: doc.documentURL,
+                title: doc.title,
+                baseURL: doc.baseURL,
+                language: doc.contentLanguage,
+                encoding: doc.encodingName,
+                frameId: doc.frameId,
+                domTree: this.buildDOMTree(doc, response.strings),
+                layout: this.processLayoutInfo(doc.layout, response.strings),
+                textBoxes: doc.textBoxes
+            })),
+            strings: response.strings
+        };
+    }
+    buildDOMTree(doc, strings) {
+        const nodes = doc.nodes;
+        if (!nodes.nodeName || !nodes.nodeType) {
+            return [];
+        }
+        const nodeCount = nodes.nodeName.length;
+        const tree = [];
+        const nodeMap = new Map();
+        for (let i = 0; i < nodeCount; i++) {
+            const node = {
+                index: i,
+                nodeType: nodes.nodeType[i],
+                nodeName: nodes.nodeName[i],
+                nodeValue: nodes.nodeValue?.[i],
+                backendNodeId: nodes.backendNodeId?.[i],
+                children: []
+            };
+            if (nodes.attributes?.[i]) {
+                const attrs = nodes.attributes[i];
+                node.attributes = {};
+                for (let j = 0; j < attrs.length; j += 2) {
+                    const name = strings[parseInt(attrs[j])];
+                    const value = strings[parseInt(attrs[j + 1])];
+                    node.attributes[name] = value;
+                }
+            }
+            if (nodes.textValue?.index.includes(i)) {
+                const textIndex = nodes.textValue.index.indexOf(i);
+                const stringIndex = nodes.textValue.value[textIndex];
+                if (typeof stringIndex === 'number') {
+                    node.textValue = strings[stringIndex];
+                }
+            }
+            if (nodes.inputValue?.index.includes(i)) {
+                const inputIndex = nodes.inputValue.index.indexOf(i);
+                const stringIndex = nodes.inputValue.value[inputIndex];
+                if (typeof stringIndex === 'number') {
+                    node.inputValue = strings[stringIndex];
+                }
+            }
+            if (nodes.inputChecked?.index.includes(i)) {
+                node.inputChecked = true;
+            }
+            if (nodes.optionSelected?.index.includes(i)) {
+                node.optionSelected = true;
+            }
+            if (nodes.isClickable?.index.includes(i)) {
+                node.isClickable = true;
+            }
+            nodeMap.set(i, node);
+        }
+        for (let i = 0; i < nodeCount; i++) {
+            const parentIndex = nodes.parentIndex?.[i];
+            const node = nodeMap.get(i);
+            if (parentIndex !== undefined && parentIndex >= 0) {
+                const parent = nodeMap.get(parentIndex);
+                if (parent) {
+                    parent.children.push(node);
+                }
+            }
+            else {
+                tree.push(node);
+            }
+        }
+        return tree;
+    }
+    processLayoutInfo(layout, strings) {
+        return {
+            nodeCount: layout.nodeIndex.length,
+            styles: layout.styles.map(styleArray => styleArray.map(styleIndex => strings[parseInt(styleIndex)])),
+            bounds: layout.bounds,
+            text: layout.text,
+            paintOrders: layout.paintOrders,
+            offsetRects: layout.offsetRects,
+            scrollRects: layout.scrollRects,
+            clientRects: layout.clientRects,
+            blendedBackgroundColors: layout.blendedBackgroundColors,
+            textColorOpacities: layout.textColorOpacities
+        };
+    }
+    convertToHTML(response) {
+        const doc = response.documents[0];
+        if (!doc)
+            return '';
+        const tree = this.buildDOMTree(doc, response.strings);
+        return this.renderNodeAsHTML(tree[0], 0);
+    }
+    renderNodeAsHTML(node, depth) {
+        if (!node)
+            return '';
+        const indent = '  '.repeat(depth);
+        if (node.nodeType === 3) {
+            const text = node.nodeValue || node.textValue || '';
+            return text.trim() ? `${indent}${text.trim()}\n` : '';
+        }
+        if (node.nodeType === 8) {
+            return `${indent}<!-- ${node.nodeValue || ''} -->\n`;
+        }
+        if (node.nodeType === 1) {
+            const tagName = node.nodeName.toLowerCase();
+            let html = `${indent}<${tagName}`;
+            if (node.attributes) {
+                for (const [name, value] of Object.entries(node.attributes)) {
+                    html += ` ${name}="${value}"`;
+                }
+            }
+            const selfClosing = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+            if (selfClosing.includes(tagName)) {
+                html += ' />\n';
+                return html;
+            }
+            html += '>';
+            if (node.children && node.children.length > 0) {
+                html += '\n';
+                for (const child of node.children) {
+                    html += this.renderNodeAsHTML(child, depth + 1);
+                }
+                html += `${indent}</${tagName}>\n`;
+            }
+            else {
+                html += `</${tagName}>\n`;
+            }
+            return html;
+        }
+        return '';
+    }
+    async saveSnapshot(snapshotData, filename, format) {
+        try {
+            const dir = (0, path_1.dirname)(filename);
+            await fs_1.promises.mkdir(dir, { recursive: true });
+            let content;
+            if (format === 'html') {
+                content = snapshotData;
+            }
+            else {
+                content = JSON.stringify(snapshotData, null, 2);
+            }
+            await fs_1.promises.writeFile(filename, content, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save DOM snapshot to "${filename}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    validateArgs(args) {
+        if (typeof args !== 'object' || args === null) {
+            return false;
+        }
+        const snapshotArgs = args;
+        if (snapshotArgs.filename !== undefined && typeof snapshotArgs.filename !== 'string') {
+            return false;
+        }
+        if (snapshotArgs.format !== undefined && !['json', 'html'].includes(snapshotArgs.format)) {
+            return false;
+        }
+        if (snapshotArgs.includeStyles !== undefined && typeof snapshotArgs.includeStyles !== 'boolean') {
+            return false;
+        }
+        if (snapshotArgs.includeAttributes !== undefined && typeof snapshotArgs.includeAttributes !== 'boolean') {
+            return false;
+        }
+        if (snapshotArgs.includePaintOrder !== undefined && typeof snapshotArgs.includePaintOrder !== 'boolean') {
+            return false;
+        }
+        if (snapshotArgs.includeTextIndex !== undefined && typeof snapshotArgs.includeTextIndex !== 'boolean') {
+            return false;
+        }
+        return true;
+    }
+    getHelp() {
+        return `
+snapshot - Capture a DOM snapshot including DOM tree structure, computed styles, and layout information
+
+Usage:
+  snapshot
+  snapshot --filename dom-snapshot.json
+  snapshot --format html --filename page-structure.html
+  snapshot --include-paint-order --filename detailed-snapshot.json
+
+Arguments:
+  --filename <path>           Output filename (if not provided, returns data directly)
+  --format <json|html>        Output format (default: json)
+  --include-styles            Include computed styles (default: true)
+  --include-attributes        Include DOM attributes (default: true)
+  --include-paint-order       Include paint order information (default: false)
+  --include-text-index        Include text node indices (default: false)
+
+Output Formats:
+  json: Structured JSON with DOM tree, layout info, and computed styles
+  html: Reconstructed HTML representation of the DOM
+
+Examples:
+  # Basic DOM snapshot as JSON
+  snapshot --filename dom-snapshot.json
+
+  # HTML representation
+  snapshot --format html --filename page-structure.html
+
+  # Detailed snapshot with paint order
+  snapshot --include-paint-order --filename detailed-snapshot.json
+
+  # Return data directly (no file)
+  snapshot --format json
+
+Note:
+  DOM snapshots capture the complete DOM tree structure including:
+  - Element hierarchy and attributes
+  - Computed CSS styles for each element
+  - Layout information (bounds, positioning)
+  - Text content and form values
+  - Visibility and clickability information
+  - Paint order and rendering details (optional)
+`;
+    }
+}
+exports.TakeSnapshotHandler = TakeSnapshotHandler;

package/dist/handlers/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./EvaluateScriptHandler"), exports);
+__exportStar(require("./TakeScreenshotHandler"), exports);
+__exportStar(require("./TakeSnapshotHandler"), exports);

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "chrome-cdp-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Command-line tool for controlling Chrome browser instances via the Chrome DevTools Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "chrome-cli": "dist/index.js",
-    "chrome-devtools-cli": "dist/index.js"
+    "chrome-cdp-cli": "dist/index.js"
   },
   "files": [
     "dist/**/*",