chrome-devtools-mcp 0.20.3 → 0.22.0

package/build/src/tools/script.js

@@ -9,7 +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. Returns the response as JSON,
+        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,
@@ -32,18 +32,22 @@ Example with arguments: \`(el) => {
                 .describe('The uid of an element on the page from the page content snapshot'))
                 .optional()
                 .describe(`An optional list of arguments to pass to the function.`),
+            dialogAction: zod
+                .string()
+                .optional()
+                .describe('Handle dialogs while execution. "accept", "dismiss", or string for response of window.prompt. Defaults to accept.'),
             ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
             ...(cliArgs?.categoryExtensions
                 ? {
                     serviceWorkerId: zod
                         .string()
                         .optional()
-                        .describe(`An optional service worker id to evaluate the script in.`),
+                        .describe(`The optional service worker id to evaluate the script in. If provided, 'pageId' should be omitted. Note: 'args' (element UIDs) cannot be used when evaluating in a service worker.`),
                 }
                 : {}),
         },
         handler: async (request, response, context) => {
-            const { serviceWorkerId, args: uidArgs, function: fnString, pageId, } = request.params;
+            const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, } = request.params;
             if (cliArgs?.categoryExtensions && serviceWorkerId) {
                 if (uidArgs && uidArgs.length > 0) {
                     throw new Error('args (element uids) cannot be used when evaluating in a service worker.');
@@ -52,7 +56,9 @@ Example with arguments: \`(el) => {
                     throw new Error('specify either a pageId or a serviceWorkerId.');
                 }
                 const worker = await getWebWorker(context, serviceWorkerId);
-                await performEvaluation(worker, fnString, [], response, context);
+                await context.getSelectedMcpPage().waitForEventsAfterAction(async () => {
+                    await performEvaluation(worker, fnString, [], response);
+                }, { handleDialog: dialogAction ?? 'accept' });
                 return;
             }
             const mcpPage = cliArgs?.experimentalPageIdRouting
@@ -68,7 +74,9 @@ Example with arguments: \`(el) => {
                     args.push(handle);
                 }
                 const evaluatable = await getPageOrFrame(page, frames);
-                await performEvaluation(evaluatable, fnString, args, response, context);
+                await mcpPage.waitForEventsAfterAction(async () => {
+                    await performEvaluation(evaluatable, fnString, args, response);
+                }, { handleDialog: dialogAction ?? 'accept' });
             }
             finally {
                 void Promise.allSettled(args.map(arg => arg.dispose()));
@@ -76,19 +84,17 @@ Example with arguments: \`(el) => {
         },
     };
 });
-const performEvaluation = async (evaluatable, fnString, args, response, context) => {
+const performEvaluation = async (evaluatable, fnString, args, response) => {
     const fn = await evaluatable.evaluateHandle(`(${fnString})`);
     try {
-        await context.waitForEventsAfterAction(async () => {
-            const result = await evaluatable.evaluate(async (fn, ...args) => {
-                // @ts-expect-error no types for function fn
-                return JSON.stringify(await fn(...args));
-            }, fn, ...args);
-            response.appendResponseLine('Script ran on page and returned:');
-            response.appendResponseLine('```json');
-            response.appendResponseLine(`${result}`);
-            response.appendResponseLine('```');
-        });
+        const result = await evaluatable.evaluate(async (fn, ...args) => {
+            // @ts-expect-error no types for function fn
+            return JSON.stringify(await fn(...args));
+        }, fn, ...args);
+        response.appendResponseLine('Script ran on page and returned:');
+        response.appendResponseLine('```json');
+        response.appendResponseLine(`${result}`);
+        response.appendResponseLine('```');
     }
     finally {
         void fn.dispose();

package/build/src/tools/tools.js

@@ -6,6 +6,7 @@
 import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
 import * as extensionTools from './extensions.js';
+import * as inPageTools from './inPage.js';
 import * as inputTools from './input.js';
 import * as lighthouseTools from './lighthouse.js';
 import * as memoryTools from './memory.js';
@@ -17,6 +18,7 @@ import * as screenshotTools from './screenshot.js';
 import * as scriptTools from './script.js';
 import * as slimTools from './slim/tools.js';
 import * as snapshotTools from './snapshot.js';
+import * as webmcpTools from './webmcp.js';
 export const createTools = (args) => {
     const rawTools = args.slim
         ? Object.values(slimTools)
@@ -24,6 +26,7 @@ export const createTools = (args) => {
             ...Object.values(consoleTools),
             ...Object.values(emulationTools),
             ...Object.values(extensionTools),
+            ...Object.values(inPageTools),
             ...Object.values(inputTools),
             ...Object.values(lighthouseTools),
             ...Object.values(memoryTools),
@@ -34,6 +37,7 @@ export const createTools = (args) => {
             ...Object.values(screenshotTools),
             ...Object.values(scriptTools),
             ...Object.values(snapshotTools),
+            ...Object.values(webmcpTools),
         ];
     const tools = [];
     for (const tool of rawTools) {

package/build/src/tools/webmcp.js

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+export const listWebMcpTools = definePageTool({
+    name: 'list_webmcp_tools',
+    description: `Lists all WebMCP tools the page exposes.`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: true,
+        conditions: ['experimentalWebmcp'],
+    },
+    schema: {},
+    handler: async (_request, response, _context) => {
+        response.setListWebMcpTools();
+    },
+});
+export const executeWebMcpTool = definePageTool({
+    name: 'execute_webmcp_tool',
+    description: `Executes a WebMCP tool exposed by the page.`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+        conditions: ['experimentalWebmcp'],
+    },
+    schema: {
+        toolName: zod.string().describe('The name of the WebMCP tool to execute'),
+        input: zod
+            .string()
+            .optional()
+            .describe('The JSON-stringified parameters to pass to the WebMCP tool'),
+    },
+    handler: async (request, response) => {
+        const toolName = request.params.toolName;
+        let input = {};
+        if (request.params.input) {
+            try {
+                const parsed = JSON.parse(request.params.input);
+                if (typeof parsed === 'object' && parsed !== null) {
+                    input = parsed;
+                }
+                else {
+                    throw new Error('Parsed input is not an object');
+                }
+            }
+            catch (e) {
+                const errorMessage = e instanceof Error ? e.message : String(e);
+                throw new Error(`Failed to parse input as JSON: ${errorMessage}`);
+            }
+        }
+        const tools = request.page.pptrPage.webmcp.tools();
+        const tool = tools.find(t => t.name === toolName);
+        if (!tool) {
+            throw new Error(`Tool ${toolName} not found`);
+        }
+        const { status, output, errorText } = await tool.execute(input);
+        response.appendResponseLine(JSON.stringify({ status, output, errorText }, null, 2));
+    },
+});

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

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import child_process from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { semver } from '../third_party/index.js';
+import { VERSION } from '../version.js';
+/**
+ * Notifies the user if an update is available.
+ * @param message The message to display in the update notification.
+ */
+let isChecking = false;
+/** @internal Reset flag for tests only. */
+export function resetUpdateCheckFlagForTesting() {
+    isChecking = false;
+}
+export async function checkForUpdates(message) {
+    if (isChecking || process.env['CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS']) {
+        return;
+    }
+    isChecking = true;
+    const cachePath = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'latest.json');
+    let cachedVersion;
+    let stats;
+    try {
+        stats = await fs.stat(cachePath);
+        const data = await fs.readFile(cachePath, 'utf8');
+        cachedVersion = JSON.parse(data).version;
+    }
+    catch {
+        // Ignore errors reading cache.
+    }
+    if (cachedVersion && semver.lt(VERSION, cachedVersion)) {
+        console.warn(`\nUpdate available: ${VERSION} -> ${cachedVersion}\n${message}\n`);
+    }
+    const now = Date.now();
+    if (stats && now - stats.mtimeMs < 24 * 60 * 60 * 1000) {
+        return;
+    }
+    // Update mtime immediately to prevent multiple subprocesses.
+    try {
+        const parentDir = path.dirname(cachePath);
+        await fs.mkdir(parentDir, { recursive: true });
+        const nowTime = new Date();
+        if (stats) {
+            await fs.utimes(cachePath, nowTime, nowTime);
+        }
+        else {
+            await fs.writeFile(cachePath, JSON.stringify({ version: VERSION }));
+        }
+    }
+    catch {
+        // Ignore errors.
+    }
+    // In a separate process, check the latest available version number
+    // and update the local snapshot accordingly.
+    const scriptPath = path.join(import.meta.dirname, '..', 'bin', 'check-latest-version.js');
+    try {
+        const child = child_process.spawn(process.execPath, [scriptPath, cachePath], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+    catch {
+        // Fail silently in case of any errors.
+    }
+}

package/build/src/utils/files.js

@@ -17,3 +17,7 @@ export async function saveTemporaryFile(data, filename) {
         throw new Error('Could not save a file', { cause: err });
     }
 }
+export function ensureExtension(filepath, extension) {
+    const ext = path.extname(filepath);
+    return filepath.slice(0, filepath.length - ext.length) + extension;
+}

package/build/src/utils/id.js

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function createIdGenerator() {
+    let i = 1;
+    return () => {
+        if (i === Number.MAX_SAFE_INTEGER) {
+            i = 0;
+        }
+        return i++;
+    };
+}
+export const stableIdSymbol = Symbol('stableIdSymbol');

package/build/src/version.js

@@ -5,5 +5,5 @@
  */
 // If moved update release-please config
 // x-release-please-start-version
-export const VERSION = '0.20.3';
+export const VERSION = '0.22.0';
 // x-release-please-end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp",
-  "version": "0.20.3",
+  "version": "0.22.0",
   "description": "MCP server for Chrome DevTools",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "typecheck": "tsc --noEmit",
     "format": "eslint --cache --fix . && prettier --write --cache .",
     "check-format": "eslint --cache . && prettier --check --cache .;",
-    "gen": "npm run build && npm run docs:generate && npm run cli:generate && npm run format",
+    "gen": "npm run build && npm run docs:generate && npm run cli:generate && npm run update-tool-call-metrics && npm run update-flag-usage-metrics && npm run format",
     "docs:generate": "node --experimental-strip-types scripts/generate-docs.ts",
     "start": "npm run build && node build/src/index.js",
     "start-debug": "DEBUG=mcp:* DEBUG_COLORS=false npm run build && node build/src/index.js",
@@ -27,6 +27,8 @@
     "prepare": "node --experimental-strip-types scripts/prepare.ts",
     "verify-server-json-version": "node --experimental-strip-types scripts/verify-server-json-version.ts",
     "update-lighthouse": "node --experimental-strip-types scripts/update-lighthouse.ts",
+    "update-tool-call-metrics": "node --experimental-strip-types scripts/update_tool_call_metrics.ts",
+    "update-flag-usage-metrics": "node --experimental-strip-types scripts/update_flag_usage_metrics.ts",
     "verify-npm-package": "node scripts/verify-npm-package.mjs",
     "eval": "npm run build && node --experimental-strip-types scripts/eval_gemini.ts",
     "count-tokens": "node --experimental-strip-types scripts/count_tokens.ts"
@@ -47,7 +49,7 @@
   "devDependencies": {
     "@eslint/js": "^9.35.0",
     "@google/genai": "^1.37.0",
-    "@modelcontextprotocol/sdk": "1.27.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
@@ -55,26 +57,28 @@
     "@types/debug": "^4.1.12",
     "@types/filesystem": "^0.0.36",
     "@types/node": "^25.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.1599001",
-    "core-js": "3.48.0",
+    "chrome-devtools-frontend": "1.0.1613625",
+    "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.0.3",
+    "lighthouse": "13.1.0",
     "prettier": "^3.6.2",
-    "puppeteer": "24.39.1",
-    "rollup": "4.59.0",
+    "puppeteer": "24.42.0",
+    "rollup": "4.60.2",
     "rollup-plugin-cleanup": "^3.2.1",
     "rollup-plugin-license": "^3.6.0",
+    "semver": "^7.7.4",
     "sinon": "^21.0.0",
     "tiktoken": "^1.0.22",
-    "typescript": "^5.9.2",
+    "typescript": "^6.0.2",
     "typescript-eslint": "^8.43.0",
     "yargs": "18.0.0"
   },

package/build/src/third_party/issue-descriptions/sharedDictionaryUseErrorNoCorpCrossOriginNoCorsRequest.md

@@ -1,3 +0,0 @@
-# Dictionary compression cannot be used for cross-origin no-cors requests without a Cross-Origin-Resource-Policy response header
-
-To use dictionary compression for a cross-origin no-cors request, the response must have a `Cross-Origin-Resource-Policy: cross-origin` header. Without it, the response can not be decoded and will fail.

package/build/src/third_party/issue-descriptions/sharedDictionaryWriteErrorNoCorpCossOriginNoCorsRequest.md

@@ -1,3 +0,0 @@
-# A cross-origin no-cors response cannot be stored as a shared dictionary for future requests without a Cross-Origin-Resource-Policy response header
-
-To store a response from a cross-origin no-cors request as a shared dictionary for future requests, the response must have a `Cross-Origin-Resource-Policy: cross-origin` header. Without it, the response will not be stored as a dictionary.

package/build/src/utils/ExtensionRegistry.js

@@ -1,35 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export class ExtensionRegistry {
-    #extensions = new Map();
-    async registerExtension(id, extensionPath) {
-        const manifestPath = path.join(extensionPath, 'manifest.json');
-        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
-        const manifest = JSON.parse(manifestContent);
-        const name = manifest.name ?? 'Unknown';
-        const version = manifest.version ?? 'Unknown';
-        const extension = {
-            id,
-            name,
-            version,
-            isEnabled: true,
-            path: extensionPath,
-        };
-        this.#extensions.set(extension.id, extension);
-        return extension;
-    }
-    remove(id) {
-        this.#extensions.delete(id);
-    }
-    list() {
-        return Array.from(this.#extensions.values());
-    }
-    getById(id) {
-        return this.#extensions.get(id);
-    }
-}