chrome-devtools-mcp 1.3.0 → 1.5.0

package/build/src/tools/memory.js

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { zod } from '../third_party/index.js';
-import { ensureExtension } from '../utils/files.js';
 import { ToolCategory } from './categories.js';
 import { definePageTool, defineTool } from './ToolDefinition.js';
 export const takeHeapSnapshot = definePageTool({
@@ -21,12 +20,13 @@ export const takeHeapSnapshot = definePageTool({
     },
     blockedByDialog: true,
     verifyFilesSchema: ['filePath'],
-    handler: async (request, response) => {
+    handler: async (request, response, context) => {
         const page = request.page;
+        const snapshotPath = await context.ensureExtension(request.params.filePath, '.heapsnapshot');
         await page.pptrPage.captureHeapSnapshot({
-            path: ensureExtension(request.params.filePath, '.heapsnapshot'),
+            path: snapshotPath,
         });
-        response.appendResponseLine(`Heap snapshot saved to ${request.params.filePath}`);
+        response.appendResponseLine(`Heap snapshot saved to ${snapshotPath}`);
     },
 });
 export const getHeapSnapshotSummary = defineTool({
@@ -224,4 +224,60 @@ export const getHeapSnapshotDominators = defineTool({
         response.setHeapSnapshotDominators(dominators);
     },
 });
+export const compareHeapSnapshots = defineTool({
+    name: 'compare_heapsnapshots',
+    description: 'Loads two memory heapsnapshots and returns the comparison. If classIndex is provided, returns detailed diff for that class, otherwise returns summary diff.',
+    annotations: {
+        category: ToolCategory.MEMORY,
+        readOnlyHint: true,
+        conditions: ['memoryDebugging'],
+    },
+    verifyFilesSchema: ['baseFilePath', 'currentFilePath'],
+    schema: {
+        baseFilePath: zod
+            .string()
+            .describe('A path to the base .heapsnapshot file (earlier snapshot).'),
+        currentFilePath: zod
+            .string()
+            .describe('A path to the current .heapsnapshot file (later snapshot).'),
+        classIndex: zod
+            .number()
+            .optional()
+            .describe('Optional 0-based index of the class in the summary list to filter results, showing individual objects.'),
+    },
+    blockedByDialog: false,
+    handler: async (request, response, context) => {
+        if (request.params.classIndex !== undefined) {
+            const classDiffResult = await context.getHeapSnapshotDetailedClassDiff(request.params.baseFilePath, request.params.currentFilePath, request.params.classIndex);
+            response.setHeapSnapshotDetailedClassDiff(classDiffResult);
+        }
+        else {
+            const diff = await context.getHeapSnapshotClassDiffs(request.params.baseFilePath, request.params.currentFilePath);
+            response.setHeapSnapshotClassDiffs(diff);
+        }
+    },
+});
+export const getHeapSnapshotDuplicateStrings = defineTool({
+    name: 'get_heapsnapshot_duplicate_strings',
+    description: 'Loads a memory heapsnapshot and returns duplicate strings grouped by their value.',
+    annotations: {
+        category: ToolCategory.MEMORY,
+        readOnlyHint: true,
+        conditions: ['memoryDebugging'],
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: ['filePath'],
+    schema: {
+        filePath: zod.string().describe('A path to a .heapsnapshot file to read.'),
+        pageIdx: zod.number().optional().describe('The page index for pagination.'),
+        pageSize: zod.number().optional().describe('The page size for pagination.'),
+    },
+    handler: async (request, response, context) => {
+        const duplicateStrings = await context.getHeapSnapshotDuplicateStrings(request.params.filePath);
+        response.setHeapSnapshotDuplicateStrings(duplicateStrings, {
+            pageIdx: request.params.pageIdx,
+            pageSize: request.params.pageSize,
+        });
+    },
+});
 //# sourceMappingURL=memory.js.map

package/build/src/tools/screencast.js

@@ -7,7 +7,6 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { zod } from '../third_party/index.js';
-import { ensureExtension } from '../utils/files.js';
 import { ToolCategory } from './categories.js';
 import { definePageTool } from './ToolDefinition.js';
 async function generateTempFilePath() {
@@ -53,7 +52,7 @@ export const startScreencast = definePageTool(args => ({
         const enforcedExtension = matchedExtension ?? '.mp4';
         const format = (matchedExtension?.substring(1) ??
             'mp4');
-        const resolvedPath = ensureExtension(path.resolve(filePath), enforcedExtension);
+        const resolvedPath = await context.ensureExtension(filePath, enforcedExtension);
         const page = request.page;
         let recorder;
         try {

package/build/src/tools/script.js

@@ -9,8 +9,7 @@ import { defineTool, pageIdSchema } from './ToolDefinition.js';
 export const evaluateScript = defineTool(cliArgs => {
     return {
         name: 'evaluate_script',
-        description: `Evaluate a JavaScript function inside the currently selected page${cliArgs?.categoryExtensions ? ' or service worker' : ''}. Returns the response as JSON,
-so returned values have to be JSON-serializable.`,
+        description: `Evaluate a JavaScript function inside the currently selected page${cliArgs?.categoryExtensions ? ' or service worker' : ''}. Returns the response as JSON, so returned values have to be JSON-serializable.`,
         annotations: {
             category: ToolCategory.DEBUGGING,
             readOnlyHint: false,
@@ -18,14 +17,8 @@ so returned values have to be JSON-serializable.`,
         schema: {
             ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
             function: zod.string().describe(`A JavaScript function declaration to be executed by the tool in the currently selected page.
-Example without arguments: \`() => {
-  return document.title
-}\` or \`async () => {
-  return await fetch("example.com")
-}\`.
-Example with arguments: \`(el) => {
-  return el.innerText;
-}\`
+Example without arguments: \`() => document.title\` or \`async () => await fetch("example.com")\`.
+Example with arguments: \`(el) => el.innerText\`
 `),
             args: zod
                 .array(zod

package/build/src/tools/thirdPartyDeveloper.js

@@ -9,12 +9,12 @@ import { definePageTool } from './ToolDefinition.js';
 export const listThirdPartyDeveloperTools = definePageTool({
     name: 'list_3p_developer_tools',
     description: `Lists all third-party developer tools the page exposes for providing runtime information.
-  Third-party developer tools can be called via the 'execute_3p_developer_tool()' MCP tool.
-  Alternatively, third-party developer tools can be executed by calling 'evaluate_script' and adding the
-  following command to the script:
-  'window.__dtmcp.executeTool(toolName, params)'
-  This might be helpful when the third-party developer tools return non-serializable values or when composing
-  third-party developer tools with additional functionality.`,
+Third-party developer tools can be called via the 'execute_3p_developer_tool()' MCP tool.
+Alternatively, third-party developer tools can be executed by calling 'evaluate_script' and adding the
+following command to the script:
+\`window.__dtmcp.executeTool(toolName, params)\`
+This might be helpful when the third-party developer tools return non-serializable values or when composing
+third-party developer tools with additional functionality.`,
     annotations: {
         category: ToolCategory.THIRD_PARTY,
         readOnlyHint: true,

package/build/src/utils/check-for-updates.js

@@ -64,6 +64,7 @@ export async function checkForUpdates(message) {
         const child = child_process.spawn(process.execPath, [scriptPath, cachePath], {
             detached: true,
             stdio: 'ignore',
+            windowsHide: true,
         });
         child.unref();
     }

package/build/src/utils/files.js

@@ -11,10 +11,6 @@ export async function getTempFilePath(filename) {
     const filepath = path.join(dir, filename);
     return filepath;
 }
-export function ensureExtension(filepath, extension) {
-    const ext = path.extname(filepath);
-    return filepath.slice(0, filepath.length - ext.length) + extension;
-}
 export async function resolveCanonicalPath(filePath) {
     const absolutePath = path.resolve(filePath);
     try {

package/build/src/version.js

@@ -5,6 +5,6 @@
  */
 // If moved update release-please config
 // x-release-please-start-version
-export const VERSION = '1.3.0';
+export const VERSION = '1.5.0';
 // x-release-please-end
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "MCP server for Chrome DevTools",
   "type": "module",
   "bin": {
@@ -35,6 +35,7 @@
   "files": [
     "build/src",
     "LICENSE",
+    "skills",
     "!*.tsbuildinfo",
     "!*.js.map"
   ],
@@ -57,23 +58,23 @@
     "@toon-format/toon": "^2.2.0",
     "@types/debug": "^4.1.12",
     "@types/filesystem": "^0.0.36",
-    "@types/node": "^25.0.0",
+    "@types/node": "^26.0.0",
     "@types/semver": "^7.7.1",
     "@types/sinon": "^21.0.0",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.43.0",
     "@typescript-eslint/parser": "^8.43.0",
-    "chrome-devtools-frontend": "1.0.1646286",
+    "chrome-devtools-frontend": "1.0.1652307",
     "core-js": "3.49.0",
     "debug": "4.4.3",
     "eslint": "^9.35.0",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
     "globals": "^17.0.0",
-    "lighthouse": "13.3.0",
+    "lighthouse": "13.4.0",
     "prettier": "^3.6.2",
-    "puppeteer": "25.1.0",
-    "rollup": "4.61.1",
+    "puppeteer": "25.2.1",
+    "rollup": "4.62.2",
     "rollup-plugin-cleanup": "^3.2.1",
     "rollup-plugin-license": "^3.6.0",
     "semver": "^7.7.4",
@@ -83,6 +84,14 @@
     "urlpattern-polyfill": "^10.1.0",
     "yargs": "18.0.0"
   },
+  "peerDependencies": {
+    "@toon-format/toon": "^2.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@toon-format/toon": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=23"
   },

package/skills/a11y-debugging/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: a11y-debugging
+description: Uses Chrome DevTools MCP for accessibility (a11y) debugging and auditing based on web.dev guidelines. Use when testing semantic HTML, ARIA labels, focus states, keyboard navigation, tap targets, and color contrast.
+---
+
+## Core Concepts
+
+**Accessibility Tree vs DOM**: Visually hiding an element (e.g., `CSS opacity: 0`) behaves differently for screen readers than `display: none` or `aria-hidden="true"`. The `take_snapshot` tool returns the accessibility tree of the page, which represents what assistive technologies "see", making it the most reliable source of truth for semantic structure.
+
+**Reading web.dev documentation**: If you need to research specific accessibility guidelines (like `https://web.dev/articles/accessible-tap-targets`), you can append `.md.txt` to the URL (e.g., `https://web.dev/articles/accessible-tap-targets.md.txt`) to fetch the clean, raw markdown version. This is much easier to read!
+
+## Workflow Patterns
+
+### 1. Automated Audit (Lighthouse)
+
+Start by running a Lighthouse accessibility audit to get a comprehensive baseline. This tool provides a high-level score and lists specific failing elements with remediation advice.
+
+1.  Run the audit:
+    - Set `mode` to `"navigation"` to refresh the page and capture load issues.
+    - Set `outputDirPath` (e.g., `/tmp/lh-report`) to save the full JSON report.
+2.  **Analyze the Summary**:
+    - Check `scores` (0-1 scale). A score < 1 indicates violations.
+    - Review `audits.failed` count.
+3.  **Review the Report (CRITICAL)**:
+    - **Parsing**: Do not read the entire file line-by-line. Use a CLI tool like `jq` or a Node.js one-liner to filter for failures:
+      ```bash
+      # Extract failing audits with their details
+      node -e "const r=require('./report.json'); Object.values(r.audits).filter(a=>a.score!==null && a.score<1).forEach(a=>console.log(JSON.stringify({id:a.id, title:a.title, items:a.details?.items})))"
+      ```
+    - This efficiently extracts the `selector` and `snippet` of failing elements without loading the full report into context.
+
+### 2. Browser Issues & Audits
+
+Chrome automatically checks for common accessibility problems. Use `list_console_messages` to check for these native audits:
+
+- `types`: `["issue"]`
+- `includePreservedMessages`: `true` (to catch issues that occurred during page load)
+
+This often reveals missing labels, invalid ARIA attributes, and other critical errors without manual investigation.
+
+### 3. Semantics & Structure
+
+The accessibility tree exposes the heading hierarchy and semantic landmarks.
+
+1.  Navigate to the page.
+2.  Use `take_snapshot` to capture the accessibility tree.
+3.  **Check Heading Levels**: Ensure heading levels (`h1`, `h2`, `h3`, etc.) are logical and do not skip levels. The snapshot will include heading roles.
+4.  **Content Reordering**: Verify that the DOM order (which drives the accessibility tree) matches the visual reading order. Use `take_screenshot` to inspect the visual layout and compare it against the snapshot structure to catch CSS floats or absolute positioning that jumbles the logical flow.
+
+### 4. Labels, Forms & Text Alternatives
+
+1.  Locate buttons, inputs, and images in the `take_snapshot` output.
+2.  Ensure interactive elements have an accessible name (e.g., a button should not just say `""` if it only contains an icon).
+3.  **Orphaned Inputs**: Verify that all form inputs have associated labels. Use `evaluate_script` with the **"Find Orphaned Form Inputs" snippet** found in [references/a11y-snippets.md](references/a11y-snippets.md).
+4.  Check images for `alt` text.
+
+### 5. Focus & Keyboard Navigation
+
+Testing "keyboard traps" and proper focus management without visual feedback relies on tracking the focused element.
+
+1.  Use the `press_key` tool with `"Tab"` or `"Shift+Tab"` to move focus.
+2.  Use `take_snapshot` to capture the updated accessibility tree.
+3.  Locate the element marked as focused in the snapshot to verify focus moved to the expected interactive element.
+4.  If a modal opens, focus must move into the modal and "trap" within it until closed.
+
+### 6. Tap Targets and Visuals
+
+According to web.dev, tap targets should be at least 48x48 pixels with sufficient spacing. Since the accessibility tree doesn't show sizes, use `evaluate_script` with the **"Measure Tap Target Size" snippet** found in [references/a11y-snippets.md](references/a11y-snippets.md).
+
+_Pass the element's `uid` from the snapshot as an argument to `evaluate_script`._
+
+### 7. Color Contrast
+
+To verify color contrast ratios, start by checking for native accessibility issues:
+
+1.  Call `list_console_messages` with `types: ["issue"]`.
+2.  Look for "Low Contrast" issues in the output.
+
+If native audits do not report issues (which may happen in some headless environments) or if you need to check a specific element manually, use `evaluate_script` with the **"Check Color Contrast" snippet** found in [references/a11y-snippets.md](references/a11y-snippets.md).
+
+### 8. Global Page Checks
+
+Verify document-level accessibility settings often missed in component testing using the **"Global Page Checks" snippet** found in [references/a11y-snippets.md](references/a11y-snippets.md).
+
+## Troubleshooting
+
+If standard a11y queries fail or the `evaluate_script` snippets return unexpected results:
+
+- **Visual Inspection**: If automated scripts cannot determine contrast (e.g., text over gradient images or complex backgrounds), use `take_screenshot` to capture the element. While models cannot measure exact contrast ratios from images, they can visually assess legibility and identify obvious issues.

package/skills/a11y-debugging/references/a11y-snippets.md

@@ -0,0 +1,92 @@
+# Accessibility Debugging Snippets
+
+Use these JavaScript snippets with the `evaluate_script` tool.
+
+## 1. Find Orphaned Form Inputs
+
+Finds form inputs that lack an associated label (no `label[for]`, `aria-label`, `aria-labelledby`, or wrapping `<label>`).
+
+```js
+() =>
+  Array.from(document.querySelectorAll('input, select, textarea'))
+    .filter(i => {
+      const hasId = i.id && document.querySelector(`label[for="${i.id}"]`);
+      const hasAria =
+        i.getAttribute('aria-label') || i.getAttribute('aria-labelledby');
+      return !hasId && !hasAria && !i.closest('label');
+    })
+    .map(i => ({
+      tag: i.tagName,
+      id: i.id,
+      name: i.name,
+      placeholder: i.placeholder,
+    }));
+```
+
+## 2. Measure Tap Target Size
+
+Returns the bounding box dimensions of an element. Pass the element's `uid` from the snapshot as an argument to `evaluate_script`.
+
+```js
+el => {
+  const rect = el.getBoundingClientRect();
+  return {width: rect.width, height: rect.height};
+};
+```
+
+## 3. Check Color Contrast
+
+Approximates the contrast ratio between an element's text color and background color. Pass the element's `uid` to test against WCAG AA (4.5:1 for normal text, 3:1 for large text).
+
+**Note**: This uses a simplified algorithm and may not account for transparency, gradients, or background images. For production-grade auditing, consider injecting `axe-core`.
+
+```js
+el => {
+  function getRGB(colorStr) {
+    const match = colorStr.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+    return match
+      ? [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])]
+      : [255, 255, 255];
+  }
+  function luminance(r, g, b) {
+    const a = [r, g, b].map(function (v) {
+      v /= 255;
+      return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    });
+    return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+  }
+
+  const style = window.getComputedStyle(el);
+  const fg = getRGB(style.color);
+  let bg = getRGB(style.backgroundColor);
+
+  const l1 = luminance(fg[0], fg[1], fg[2]);
+  const l2 = luminance(bg[0], bg[1], bg[2]);
+  const ratio = (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+
+  return {
+    color: style.color,
+    bg: style.backgroundColor,
+    contrastRatio: ratio.toFixed(2),
+  };
+};
+```
+
+## 4. Global Page Checks
+
+Checks document-level accessibility settings often missed in component testing.
+
+```js
+() => ({
+  lang:
+    document.documentElement.lang ||
+    'MISSING - Screen readers need this for pronunciation',
+  title: document.title || 'MISSING - Required for context',
+  viewport:
+    document.querySelector('meta[name="viewport"]')?.content ||
+    'MISSING - Check for user-scalable=no (bad practice)',
+  reducedMotion: window.matchMedia('(prefers-reduced-motion: reduce)').matches
+    ? 'Enabled'
+    : 'Disabled',
+});
+```

package/skills/chrome-devtools/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: chrome-devtools
+description: Uses Chrome DevTools via MCP for efficient debugging, troubleshooting and browser automation. Use when debugging web pages, automating browser interactions, analyzing performance, or inspecting network requests. This skill does not apply to `--slim` mode (MCP configuration).
+---
+
+## Core Concepts
+
+**Browser lifecycle**: Browser starts automatically on first tool call using a persistent Chrome profile. Configure via CLI args in the MCP server configuration: `npx chrome-devtools-mcp@latest --help`.
+Addional tooling can be enabled by providing the following flags:
+
+- For extension tooling, use the `--categoryExtensions` flag.
+- For memory tooling, use the `--memoryDebugging` flag.
+
+**Page selection**: Tools operate on the currently selected page. Use `list_pages` to see available pages, then `select_page` to switch context.
+**Element interaction**: Use `take_snapshot` to get page structure with element `uid`s. Each element has a unique `uid` for interaction. If an element isn't found, take a fresh snapshot - the element may have been removed or the page changed.
+
+## Workflow Patterns
+
+### Before interacting with a page
+
+1. Navigate: `navigate_page` or `new_page`
+2. Wait: `wait_for` to ensure content is loaded if you know what you look for.
+3. Snapshot: `take_snapshot` to understand page structure
+4. Interact: Use element `uid`s from snapshot for `click`, `fill`, etc.
+
+### Efficient data retrieval
+
+- Use `filePath` parameter for large outputs (screenshots, snapshots, traces)
+- Use pagination (`pageIdx`, `pageSize`) and filtering (`types`) to minimize data
+- Set `includeSnapshot: false` on input actions unless you need updated page state
+
+### Tool selection
+
+- **Automation/interaction**: `take_snapshot` (text-based, faster, better for automation)
+- **Visual inspection**: `take_screenshot` (when user needs to see visual state)
+- **Additional details**: `evaluate_script` for data not in accessibility tree
+
+### Parallel execution
+
+You can send multiple tool calls in parallel, but maintain correct order: navigate → wait → snapshot → interact.
+
+### Testing an extension
+
+> **Before proceeding**: Extension tools (`install_extension`, `list_extensions`, etc.) are only available when the MCP server is started with the `--categoryExtensions` flag. If these tools are not in your tool list, stop and ask the user to update their MCP server configuration:
+>
+> ```json
+> {
+>   "mcpServers": {
+>     "chrome-devtools": {
+>       "command": "npx",
+>       "args": ["chrome-devtools-mcp@latest", "--categoryExtensions"]
+>     }
+>   }
+> }
+> ```
+>
+> After updating, the user must restart the MCP server (or their AI client) for the change to take effect.
+
+1. **Install**: Use `install_extension` with the path to the unpacked extension.
+2. **Identify**: Get the extension ID from the response or by calling `list_extensions`.
+3. **Trigger Action**: Use `trigger_extension_action` to open the popup or side panel if applicable.
+4. **Verify Service Worker**: Use `evaluate_script` with `serviceWorkerId` to check extension state or trigger background actions.
+5. **Verify Page Behavior**: Navigate to a page where the extension operates and use `take_snapshot` to check if content scripts injected elements or modified the page correctly.
+
+## Troubleshooting
+
+If `chrome-devtools-mcp` is insufficient, guide users to use Chrome DevTools UI:
+
+- https://developer.chrome.com/docs/devtools
+- https://developer.chrome.com/docs/devtools/ai-assistance
+
+If there are errors launching `chrome-devtools-mcp` or Chrome, refer to https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/troubleshooting.md.

package/skills/chrome-devtools-cli/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: chrome-devtools-cli
+description: Use this skill to write shell scripts or run shell commands to automate tasks in the browser or otherwise use Chrome DevTools via CLI.
+---
+
+The `chrome-devtools-mcp` CLI lets you interact with the browser from your terminal.
+
+## Setup
+
+_Note: If this is your very first time using the CLI, see [references/installation.md](references/installation.md) for setup. Installation is a one-time prerequisite and is **not** part of the regular AI workflow._
+
+## AI Workflow
+
+1. **Execute**: Run tools directly (e.g., `chrome-devtools list_pages`). The background server starts implicitly; **do not** run `start`/`status`/`stop` before each use.
+2. **Inspect**: Use `take_snapshot` to get an element `<uid>`.
+3. **Act**: Use `click`, `fill`, etc. State persists across commands.
+
+Snapshot example:
+
+```
+uid=1_0 RootWebArea "Example Domain" url="https://example.com/"
+  uid=1_1 heading "Example Domain" level="1"
+```
+
+## Command Usage
+
+```sh
+chrome-devtools <tool> [arguments] [flags]
+```
+
+Use `--help` on any command. Output defaults to Markdown, use `--output-format=json` for JSON.
+
+## Input Automation (<uid> from snapshot)
+
+```bash
+chrome-devtools take_snapshot --help # Help message for commands, works for any command.
+chrome-devtools take_snapshot # Take a text snapshot of the page to get UIDs for elements
+chrome-devtools click "id" # Clicks on the provided element
+chrome-devtools click "id" --dblClick true --includeSnapshot true # Double clicks and returns a snapshot
+chrome-devtools drag "src" "dst" # Drag an element onto another element
+chrome-devtools drag "src" "dst" --includeSnapshot true # Drag an element and return a snapshot
+chrome-devtools fill "id" "text" # Type text into an input or select an option
+chrome-devtools fill "id" "text" --includeSnapshot true # Fill an element and return a snapshot
+chrome-devtools handle_dialog accept # Handle a browser dialog
+chrome-devtools handle_dialog dismiss --promptText "hi" # Dismiss a dialog with prompt text
+chrome-devtools hover "id" # Hover over the provided element
+chrome-devtools hover "id" --includeSnapshot true # Hover over an element and return a snapshot
+chrome-devtools press_key "Enter" # Press a key or key combination
+chrome-devtools press_key "Control+A" --includeSnapshot true # Press a key and return a snapshot
+chrome-devtools type_text "hello" # Type text using keyboard into a focused input
+chrome-devtools type_text "hello" --submitKey "Enter" # Type text and press a submit key
+chrome-devtools upload_file "id" "file.txt" # Upload a file through a provided element
+chrome-devtools upload_file "id" "file.txt" --includeSnapshot true # Upload a file and return a snapshot
+```
+
+## Navigation
+
+```bash
+chrome-devtools close_page 1 # Closes the page by its index
+chrome-devtools list_pages # Get a list of pages open in the browser
+chrome-devtools navigate_page --url "https://example.com" # Navigates the currently selected page to a URL
+chrome-devtools navigate_page --type "reload" --ignoreCache true # Reload page ignoring cache
+chrome-devtools navigate_page --url "https://example.com" --timeout 5000 # Navigate with a timeout
+chrome-devtools navigate_page --handleBeforeUnload "accept" # Handle before unload dialog
+chrome-devtools navigate_page --type "back" --initScript "foo()" # Navigate back and run an init script
+chrome-devtools new_page "https://example.com" # Creates a new page
+chrome-devtools new_page "https://example.com" --background true --timeout 5000 # Create new page in background
+chrome-devtools new_page "https://example.com" --isolatedContext "ctx" # Create new page with isolated context
+chrome-devtools select_page 1 # Select a page as a context for future tool calls
+chrome-devtools select_page 1 --bringToFront true # Select a page and bring it to front
+```
+
+## Emulation
+
+```bash
+chrome-devtools emulate --networkConditions "Offline" # Emulate network conditions
+chrome-devtools emulate --cpuThrottlingRate 4 --geolocation "0x0" # Emulate CPU throttling and geolocation
+chrome-devtools emulate --colorScheme "dark" --viewport "1920x1080" # Emulate color scheme and viewport
+chrome-devtools emulate --userAgent "Mozilla/5.0..." # Emulate user agent
+chrome-devtools resize_page 1920 1080 # Resizes the selected page's window
+```
+
+## Performance
+
+```bash
+chrome-devtools performance_analyze_insight "1" "LCPBreakdown" # Get more details on a specific Performance Insight
+chrome-devtools performance_start_trace true false # Starts a performance trace recording
+chrome-devtools performance_start_trace true true --filePath t.gz # Start trace and save to a file
+chrome-devtools performance_stop_trace # Stops the active performance trace
+chrome-devtools performance_stop_trace --filePath "t.json" # Stop trace and save to a file
+chrome-devtools take_memory_snapshot "./snap.heapsnapshot" # Capture a memory heapsnapshot
+```
+
+## Network
+
+```bash
+chrome-devtools get_network_request # Get the currently selected network request
+chrome-devtools get_network_request --reqid 1 --requestFilePath req.md # Get request by id and save to file
+chrome-devtools get_network_request --responseFilePath res.md # Save response body to file
+chrome-devtools list_network_requests # List all network requests
+chrome-devtools list_network_requests --pageSize 50 --pageIdx 0 # List network requests with pagination
+chrome-devtools list_network_requests --resourceTypes Fetch # Filter requests by resource type
+chrome-devtools list_network_requests --includePreservedRequests true # Include preserved requests
+```
+
+## Debugging & Inspection
+
+```bash
+chrome-devtools evaluate_script "() => document.title" # Evaluate a JavaScript function on the page
+chrome-devtools evaluate_script "(a) => a.innerText" --args 1_4 # Evaluate JS with UID arguments
+chrome-devtools get_console_message 1 # Gets a console message by its ID
+chrome-devtools lighthouse_audit --mode "navigation" # Run Lighthouse audit for navigation
+chrome-devtools lighthouse_audit --mode "snapshot" --device "mobile" # Run Lighthouse audit for a snapshot on mobile
+chrome-devtools lighthouse_audit --outputDirPath ./out # Run Lighthouse audit and save reports
+chrome-devtools list_console_messages # List all console messages
+chrome-devtools list_console_messages --pageSize 20 --pageIdx 1 # List console messages with pagination
+chrome-devtools list_console_messages --types error --types info # Filter console messages by type
+chrome-devtools list_console_messages --includePreservedMessages true # Include preserved messages
+chrome-devtools take_screenshot # Take a screenshot of the page viewport
+chrome-devtools take_screenshot --fullPage true --format "jpeg" --quality 80 # Take a full page screenshot as JPEG with quality
+chrome-devtools take_screenshot --uid "id" --filePath "s.png" # Take a screenshot of an element
+chrome-devtools take_snapshot # Take a text snapshot of the page from the a11y tree
+chrome-devtools take_snapshot --verbose true --filePath "s.txt" # Take a verbose snapshot and save to file
+```
+
+## Extensions
+
+```bash
+chrome-devtools list_extensions # Lists all the Chrome extensions installed in the browser
+chrome-devtools install_extension "/path/to/extension" # Installs a Chrome extension from the given path
+chrome-devtools uninstall_extension "extension_id" # Uninstalls a Chrome extension by its ID
+chrome-devtools reload_extension "extension_id" # Reloads an unpacked Chrome extension by its ID
+chrome-devtools trigger_extension_action "extension_id" # Triggers the default action of an extension by its ID
+```
+
+## Experimental Features
+
+Experimental tools are disabled by default. Enable them with the corresponding flag during `start`.
+
+```bash
+chrome-devtools click_at 100 200 # Clicks at the provided coordinates (requires --experimentalVision=true)
+chrome-devtools screencast_start # Starts a screencast recording (requires --experimentalScreencast=true and ffmpeg)
+chrome-devtools screencast_stop # Stops the active screencast
+chrome-devtools list_webmcp_tools # List all WebMCP tools (requires --categoryExperimentalWebmcp=true)
+```
+
+## Service Management
+
+```bash
+chrome-devtools start   # Start or restart chrome-devtools-mcp
+chrome-devtools status  # Checks if chrome-devtools-mcp is running
+chrome-devtools stop    # Stop chrome-devtools-mcp if any
+```

package/skills/chrome-devtools-cli/references/installation.md

@@ -0,0 +1,14 @@
+# Installation
+
+Install the package globally to make the `chrome-devtools` command available. You only need to do this the first time you use it.
+
+```sh
+npm i chrome-devtools-mcp@latest -g
+chrome-devtools status # check if install worked.
+```
+
+## Troubleshooting
+
+- **Command not found:** If `chrome-devtools` is not recognized, ensure your global npm `bin` directory is in your system's `PATH`. Restart your terminal or source your shell configuration file (e.g., `.bashrc`, `.zshrc`).
+- **Permission errors:** If you encounter `EACCES` or permission errors during installation, avoid using `sudo`. Instead, use a node version manager like `nvm`, or configure npm to use a different global directory.
+- **Old version running:** Run `chrome-devtools stop && npm uninstall -g chrome-devtools-mcp` before reinstalling, or ensure the latest version is being picked up by your path.