chrome-devtools-mcp 0.25.0 → 0.26.0

package/README.md

@@ -161,7 +161,7 @@ To install Chrome DevTools MCP with skills, add the marketplace registry in Clau
 Then, install the plugin:
 
 ```sh
-/plugin install chrome-devtools-mcp
+/plugin install chrome-devtools-mcp@chrome-devtools-plugins
 ```
 
 Restart Claude Code to have the MCP server and skills load (check with `/skills`).

package/build/src/ToolHandler.js

@@ -0,0 +1,188 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from './logger.js';
+import { McpResponse } from './McpResponse.js';
+import { SlimMcpResponse } from './SlimMcpResponse.js';
+import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
+import { bucketizeLatency } from './telemetry/metricUtils.js';
+import { labels, OFF_BY_DEFAULT_CATEGORIES } from './tools/categories.js';
+import { pageIdSchema } from './tools/ToolDefinition.js';
+export function buildFlag(category) {
+    return `category${category.charAt(0).toUpperCase() + category.slice(1)}`;
+}
+function buildDisabledMessage(toolName, flag, categoryLabel) {
+    const reason = categoryLabel
+        ? `is in category ${categoryLabel} which`
+        : `requires experimental feature ${flag} and`;
+    return `Tool ${toolName} ${reason} is currently disabled. Enable it by running chrome-devtools start ${flag}=true. For more information check the README.`;
+}
+function getCategoryStatus(category, serverArgs) {
+    const categoryFlag = buildFlag(category);
+    const flagValue = serverArgs[categoryFlag];
+    const isDisabled = OFF_BY_DEFAULT_CATEGORIES.includes(category)
+        ? !flagValue
+        : flagValue === false;
+    if (isDisabled) {
+        return {
+            categoryFlag,
+            disabled: true,
+        };
+    }
+    return {
+        disabled: false,
+    };
+}
+function getConditionStatus(condition, serverArgs) {
+    if (condition && !serverArgs[condition]) {
+        return { conditionFlag: condition, disabled: true };
+    }
+    return { disabled: false };
+}
+function getToolStatusInfo(tool, serverArgs) {
+    const category = tool.annotations.category;
+    const categoryCheck = getCategoryStatus(category, serverArgs);
+    if (category && categoryCheck.disabled) {
+        if (!categoryCheck.categoryFlag) {
+            throw new Error('when the category is disabled there should always be a flag set');
+        }
+        return {
+            disabled: true,
+            reason: buildDisabledMessage(tool.name, `--${categoryCheck.categoryFlag}`, labels[category]),
+        };
+    }
+    for (const condition of tool.annotations.conditions || []) {
+        const conditionCheck = getConditionStatus(condition, serverArgs);
+        if (conditionCheck.disabled) {
+            if (!conditionCheck.conditionFlag) {
+                throw new Error('when the condition is disabled there should always be a flag set');
+            }
+            return {
+                disabled: true,
+                reason: buildDisabledMessage(tool.name, `--${conditionCheck.conditionFlag}`),
+            };
+        }
+    }
+    return { disabled: false };
+}
+function isPageScopedTool(tool) {
+    return 'pageScoped' in tool && tool.pageScoped === true;
+}
+export class ToolHandler {
+    tool;
+    serverArgs;
+    getContext;
+    toolMutex;
+    inputSchema;
+    shouldRegister;
+    disabledReason;
+    constructor(tool, serverArgs, getContext, toolMutex) {
+        this.tool = tool;
+        this.serverArgs = serverArgs;
+        this.getContext = getContext;
+        this.toolMutex = toolMutex;
+        const { disabled, reason } = getToolStatusInfo(tool, serverArgs);
+        this.disabledReason = reason;
+        this.shouldRegister = !(disabled && !serverArgs.viaCli);
+        this.inputSchema =
+            'pageScoped' in tool &&
+                tool.pageScoped &&
+                serverArgs.experimentalPageIdRouting &&
+                !serverArgs.slim
+                ? { ...tool.schema, ...pageIdSchema }
+                : tool.schema;
+    }
+    async handle(params) {
+        if (this.disabledReason) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: this.disabledReason,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const guard = await this.toolMutex.acquire();
+        const startTime = Date.now();
+        let success = false;
+        try {
+            logger(`${this.tool.name} request: ${JSON.stringify(params, null, '  ')}`);
+            const context = await this.getContext();
+            logger(`${this.tool.name} context: resolved`);
+            await context.detectOpenDevToolsWindows();
+            const response = this.serverArgs.slim
+                ? new SlimMcpResponse(this.serverArgs)
+                : new McpResponse(this.serverArgs);
+            response.setRedactNetworkHeaders(this.serverArgs.redactNetworkHeaders);
+            try {
+                if (isPageScopedTool(this.tool)) {
+                    const pageId = typeof params.pageId === 'number' ? params.pageId : undefined;
+                    const page = this.serverArgs.experimentalPageIdRouting &&
+                        pageId !== undefined &&
+                        !this.serverArgs.slim
+                        ? context.getPageById(pageId)
+                        : context.getSelectedMcpPage();
+                    response.setPage(page);
+                    if (this.tool.blockedByDialog) {
+                        page.throwIfDialogOpen();
+                    }
+                    await this.tool.handler({
+                        params,
+                        page,
+                    }, response, context);
+                }
+                else {
+                    await this.tool.handler({
+                        params,
+                    }, response, context);
+                }
+            }
+            catch (err) {
+                response.setError(err);
+            }
+            const { content, structuredContent } = await response.handle(this.tool.name, context);
+            const result = {
+                content,
+            };
+            if (response.error) {
+                result.isError = true;
+            }
+            success = true;
+            if (this.serverArgs.experimentalStructuredContent) {
+                result.structuredContent = structuredContent;
+            }
+            return result;
+        }
+        catch (err) {
+            logger(`${this.tool.name} error:`, err, err?.stack);
+            let errorText = err && 'message' in err ? err.message : String(err);
+            if ('cause' in err && err.cause) {
+                errorText += `\nCause: ${err.cause.message}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        finally {
+            void ClearcutLogger.get()?.logToolInvocation({
+                toolName: this.tool.name,
+                params,
+                schema: this.inputSchema,
+                success,
+                latencyMs: bucketizeLatency(Date.now() - startTime),
+            });
+            guard.dispose();
+        }
+    }
+}
+//# sourceMappingURL=ToolHandler.js.map

package/build/src/bin/chrome-devtools-cli-options.js

@@ -211,7 +211,7 @@ export const commands = {
             value: {
                 name: 'value',
                 type: 'string',
-                description: 'The value to fill in',
+                description: 'The value to fill in. "true" or "false" for checkboxes and toggles, "true" for radio buttons.',
                 required: true,
             },
             includeSnapshot: {

package/build/src/bin/chrome-devtools-mcp-main.js

@@ -7,6 +7,7 @@ import '../polyfill.js';
 import process from 'node:process';
 import { createMcpServer, logDisclaimers } from '../index.js';
 import { logger, saveLogsToFile } from '../logger.js';
+import { ClearcutLogger } from '../telemetry/ClearcutLogger.js';
 import { computeFlagUsage } from '../telemetry/flagUtils.js';
 import { StdioServerTransport } from '../third_party/index.js';
 import { checkForUpdates } from '../utils/check-for-updates.js';
@@ -21,13 +22,13 @@ if (process.env['CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT'] !== 'true') {
     });
 }
 logger(`Starting Chrome DevTools MCP Server v${VERSION}`);
-const { server, clearcutLogger } = await createMcpServer(args, {
+const { server } = await createMcpServer(args, {
     logFile,
 });
 const transport = new StdioServerTransport();
 await server.connect(transport);
 logger('Chrome DevTools MCP Server connected');
 logDisclaimers(args);
-void clearcutLogger?.logDailyActiveIfNeeded();
-void clearcutLogger?.logServerStart(computeFlagUsage(args, cliOptions));
+void ClearcutLogger.get()?.logDailyActiveIfNeeded();
+void ClearcutLogger.get()?.logServerStart(computeFlagUsage(args, cliOptions));
 //# sourceMappingURL=chrome-devtools-mcp-main.js.map

package/build/src/bin/chrome-devtools.js

@@ -24,8 +24,6 @@ const defaultArgs = ['--viaCli', '--experimentalStructuredContent'];
 const startCliOptions = {
     ...cliOptions,
 };
-// Not supported in CLI on purpose.
-delete startCliOptions.autoConnect;
 // Missing CLI serialization.
 delete startCliOptions.viewport;
 // Change the defaults for the CLI.

package/build/src/index.js

@@ -7,77 +7,16 @@ import { ensureBrowserConnected, ensureBrowserLaunched } from './browser.js';
 import { loadIssueDescriptions } from './issue-descriptions.js';
 import { logger } from './logger.js';
 import { McpContext } from './McpContext.js';
-import { McpResponse } from './McpResponse.js';
 import { Mutex } from './Mutex.js';
-import { SlimMcpResponse } from './SlimMcpResponse.js';
 import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
-import { bucketizeLatency } from './telemetry/metricUtils.js';
 import { McpServer, SetLevelRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, } from './third_party/index.js';
-import { labels, OFF_BY_DEFAULT_CATEGORIES } from './tools/categories.js';
-import { pageIdSchema } from './tools/ToolDefinition.js';
+import { ToolHandler } from './ToolHandler.js';
 import { createTools } from './tools/tools.js';
 import { VERSION } from './version.js';
-export function buildFlag(category) {
-    return `category${category.charAt(0).toUpperCase() + category.slice(1)}`;
-}
-function buildDisabledMessage(toolName, flag, categoryLabel) {
-    const reason = categoryLabel
-        ? `is in category ${categoryLabel} which`
-        : `requires experimental feature ${flag} and`;
-    return `Tool ${toolName} ${reason} is currently disabled. Enable it by running chrome-devtools start ${flag}=true. For more information check the README.`;
-}
-function getCategoryStatus(category, serverArgs) {
-    const categoryFlag = buildFlag(category);
-    const flagValue = serverArgs[categoryFlag];
-    const isDisabled = OFF_BY_DEFAULT_CATEGORIES.includes(category)
-        ? !flagValue
-        : flagValue === false;
-    if (isDisabled) {
-        return {
-            categoryFlag,
-            disabled: true,
-        };
-    }
-    return {
-        disabled: false,
-    };
-}
-function getConditionStatus(condition, serverArgs) {
-    if (condition && !serverArgs[condition]) {
-        return { conditionFlag: condition, disabled: true };
-    }
-    return { disabled: false };
-}
-function getToolStatusInfo(tool, serverArgs) {
-    const category = tool.annotations.category;
-    const categoryCheck = getCategoryStatus(category, serverArgs);
-    if (category && categoryCheck.disabled) {
-        if (!categoryCheck.categoryFlag) {
-            throw new Error('when the category is disabled there should always be a flag set');
-        }
-        return {
-            disabled: true,
-            reason: buildDisabledMessage(tool.name, `--${categoryCheck.categoryFlag}`, labels[category]),
-        };
-    }
-    for (const condition of tool.annotations.conditions || []) {
-        const conditionCheck = getConditionStatus(condition, serverArgs);
-        if (conditionCheck.disabled) {
-            if (!conditionCheck.conditionFlag) {
-                throw new Error('when the condition is disabled there should always be a flag set');
-            }
-            return {
-                disabled: true,
-                reason: buildDisabledMessage(tool.name, `--${conditionCheck.conditionFlag}`),
-            };
-        }
-    }
-    return { disabled: false };
-}
+export { buildFlag } from './ToolHandler.js';
 export async function createMcpServer(serverArgs, options) {
-    let clearcutLogger;
     if (serverArgs.usageStatistics) {
-        clearcutLogger = new ClearcutLogger({
+        ClearcutLogger.initialize({
             logFile: serverArgs.logFile,
             appVersion: VERSION,
             clearcutEndpoint: serverArgs.clearcutEndpoint,
@@ -108,7 +47,7 @@ export async function createMcpServer(serverArgs, options) {
     server.server.oninitialized = () => {
         const clientName = server.server.getClientVersion()?.name;
         if (clientName) {
-            clearcutLogger?.setClientName(clientName);
+            ClearcutLogger.get()?.setClientName(clientName);
         }
         if (server.server.getClientCapabilities()?.roots) {
             void updateRoots();
@@ -164,110 +103,16 @@ export async function createMcpServer(serverArgs, options) {
     }
     const toolMutex = new Mutex();
     function registerTool(tool) {
-        const { disabled, reason: disabledReason } = getToolStatusInfo(tool, serverArgs);
-        if (disabled && !serverArgs.viaCli) {
+        const toolHandler = new ToolHandler(tool, serverArgs, getContext, toolMutex);
+        if (!toolHandler.shouldRegister) {
             return;
         }
-        const schema = 'pageScoped' in tool &&
-            tool.pageScoped &&
-            serverArgs.experimentalPageIdRouting &&
-            !serverArgs.slim
-            ? { ...tool.schema, ...pageIdSchema }
-            : tool.schema;
         server.registerTool(tool.name, {
             description: tool.description,
-            inputSchema: schema,
+            inputSchema: toolHandler.inputSchema,
             annotations: tool.annotations,
         }, async (params) => {
-            if (disabledReason) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: disabledReason,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const guard = await toolMutex.acquire();
-            const startTime = Date.now();
-            let success = false;
-            try {
-                logger(`${tool.name} request: ${JSON.stringify(params, null, '  ')}`);
-                const context = await getContext();
-                logger(`${tool.name} context: resolved`);
-                await context.detectOpenDevToolsWindows();
-                const response = serverArgs.slim
-                    ? new SlimMcpResponse(serverArgs)
-                    : new McpResponse(serverArgs);
-                response.setRedactNetworkHeaders(serverArgs.redactNetworkHeaders);
-                try {
-                    const page = serverArgs.experimentalPageIdRouting &&
-                        params.pageId &&
-                        !serverArgs.slim
-                        ? context.getPageById(params.pageId)
-                        : context.getSelectedMcpPage();
-                    response.setPage(page);
-                    if (tool.blockedByDialog) {
-                        page.throwIfDialogOpen();
-                    }
-                    if ('pageScoped' in tool && tool.pageScoped) {
-                        await tool.handler({
-                            params,
-                            page,
-                        }, response, context);
-                    }
-                    else {
-                        await tool.handler(
-                        // @ts-expect-error types do not match.
-                        {
-                            params,
-                        }, response, context);
-                    }
-                }
-                catch (err) {
-                    response.setError(err);
-                }
-                const { content, structuredContent } = await response.handle(tool.name, context);
-                const result = {
-                    content,
-                };
-                if (response.error) {
-                    result.isError = true;
-                }
-                success = true;
-                if (serverArgs.experimentalStructuredContent) {
-                    result.structuredContent = structuredContent;
-                }
-                return result;
-            }
-            catch (err) {
-                logger(`${tool.name} error:`, err, err?.stack);
-                let errorText = err && 'message' in err ? err.message : String(err);
-                if ('cause' in err && err.cause) {
-                    errorText += `\nCause: ${err.cause.message}`;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: errorText,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            finally {
-                void clearcutLogger?.logToolInvocation({
-                    toolName: tool.name,
-                    params,
-                    schema,
-                    success,
-                    latencyMs: bucketizeLatency(Date.now() - startTime),
-                });
-                guard.dispose();
-            }
+            return await toolHandler.handle(params);
         });
     }
     const tools = createTools(serverArgs);
@@ -275,7 +120,7 @@ export async function createMcpServer(serverArgs, options) {
         registerTool(tool);
     }
     await loadIssueDescriptions();
-    return { server, clearcutLogger };
+    return { server };
 }
 export const logDisclaimers = (args) => {
     console.error(`chrome-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect,

package/build/src/telemetry/ClearcutLogger.js

@@ -136,10 +136,25 @@ function detectOsType() {
             return OsType.OS_TYPE_UNSPECIFIED;
     }
 }
+// Not const to allow resetting the instance for testing purposes.
+let _clearcut_logger_instance;
 export class ClearcutLogger {
     #persistence;
     #watchdog;
     #mcpClient;
+    static initialize(options) {
+        if (_clearcut_logger_instance) {
+            throw new Error('ClearcutLogger is already initialized');
+        }
+        _clearcut_logger_instance = new ClearcutLogger(options);
+        return _clearcut_logger_instance;
+    }
+    static get() {
+        return _clearcut_logger_instance;
+    }
+    static resetForTesting() {
+        _clearcut_logger_instance = undefined;
+    }
     constructor(options) {
         this.#persistence = options.persistence ?? new FilePersistence();
         this.#watchdog =
@@ -237,6 +252,18 @@ export class ClearcutLogger {
             logger('Error in logDailyActiveIfNeeded:', err);
         }
     }
+    async logServerError(args) {
+        this.#watchdog.send({
+            type: WatchdogMessageType.LOG_EVENT,
+            payload: {
+                mcp_client: this.#mcpClient,
+                server_error: {
+                    tool_name: args.toolName ?? '',
+                    error_code: args.errorCode,
+                },
+            },
+        });
+    }
     #shouldLogDailyActive(state) {
         if (!state.lastActive) {
             return true;

package/build/src/telemetry/errors.js

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * IMPORTANT:
+ *   1. this module must only contain ErrorCode.
+ *   2. do not refactor ErrorCode to elsewhere.
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["ERROR_CODE_UNSPECIFIED"] = 0] = "ERROR_CODE_UNSPECIFIED";
+})(ErrorCode || (ErrorCode = {}));
+//# sourceMappingURL=errors.js.map

package/build/src/telemetry/types.js

@@ -11,14 +11,6 @@ export var OsType;
     OsType[OsType["OS_TYPE_MACOS"] = 2] = "OS_TYPE_MACOS";
     OsType[OsType["OS_TYPE_LINUX"] = 3] = "OS_TYPE_LINUX";
 })(OsType || (OsType = {}));
-export var ChromeChannel;
-(function (ChromeChannel) {
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_UNSPECIFIED"] = 0] = "CHROME_CHANNEL_UNSPECIFIED";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_CANARY"] = 1] = "CHROME_CHANNEL_CANARY";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_DEV"] = 2] = "CHROME_CHANNEL_DEV";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_BETA"] = 3] = "CHROME_CHANNEL_BETA";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_STABLE"] = 4] = "CHROME_CHANNEL_STABLE";
-})(ChromeChannel || (ChromeChannel = {}));
 export var McpClient;
 (function (McpClient) {
     McpClient[McpClient["MCP_CLIENT_UNSPECIFIED"] = 0] = "MCP_CLIENT_UNSPECIFIED";

package/build/src/third_party/THIRD_PARTY_NOTICES

@@ -324,7 +324,7 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 
 Name: semver
 URL: git+https://github.com/npm/node-semver.git
-Version: 7.7.4
+Version: 7.8.0
 License: ISC
 
 The ISC License
@@ -617,15 +617,13 @@ SOFTWARE.
 
 Name: fast-uri
 URL: https://github.com/fastify/fast-uri
-Version: 3.1.0
+Version: 3.1.2
 License: BSD-3-Clause
 
 Copyright (c) 2011-2021, Gary Court until https://github.com/garycourt/uri-js/commit/a1acf730b4bba3f1097c9f52e7d9d3aba8cdcaae
-Copyright (c) 2021-present The Fastify team
+Copyright (c) 2021-present The Fastify team <https://github.com/fastify/fastify#team>
 All rights reserved.
 
-The Fastify team members are listed at https://github.com/fastify/fastify#team.
-
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
     * Redistributions of source code must retain the above copyright
@@ -1145,7 +1143,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 Name: ip-address
 URL: git://github.com/beaugunderson/ip-address.git
-Version: 10.1.0
+Version: 10.2.0
 License: MIT
 
 Copyright (C) 2011 by Beau Gunderson
@@ -1264,7 +1262,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 Name: basic-ftp
 URL: https://github.com/patrickjuchli/basic-ftp.git
-Version: 5.3.0
+Version: 5.3.1
 License: MIT
 
 Copyright (c) 2019 Patrick Juchli
@@ -3988,7 +3986,7 @@ SOFTWARE.
 
 Name: puppeteer-core
 URL: https://github.com/puppeteer/puppeteer/tree/main/packages/puppeteer-core
-Version: 24.42.0
+Version: 24.43.0
 License: Apache-2.0
 
 -------------------- DEPENDENCY DIVIDER --------------------
@@ -4054,7 +4052,7 @@ SOFTWARE.
 
 Name: tldts-core
 URL: https://github.com/remusao/tldts#readme
-Version: 7.0.29
+Version: 7.0.30
 License: MIT
 
 Copyright (c) 2017 Thomas Parisot, 2018 Rémi Berson
@@ -4076,7 +4074,7 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTH
 
 Name: tldts-icann
 URL: https://github.com/remusao/tldts#readme
-Version: 7.0.29
+Version: 7.0.30
 License: MIT
 
 Copyright (c) 2017 Thomas Parisot, 2018 Rémi Berson
@@ -4118,7 +4116,7 @@ PERFORMANCE OF THIS SOFTWARE.
 
 Name: web-features
 URL: git+https://github.com/web-platform-dx/web-features.git
-Version: 3.25.0
+Version: 3.26.0
 License: Apache-2.0
 
                                  Apache License

package/build/src/third_party/bundled-packages.json

@@ -1,9 +1,9 @@
 {
   "@modelcontextprotocol/sdk": "1.29.0",
-  "chrome-devtools-frontend": "1.0.1625079",
+  "chrome-devtools-frontend": "1.0.1626840",
   "core-js": "3.49.0",
   "debug": "4.4.3",
-  "lighthouse": "13.2.0",
+  "lighthouse": "13.3.0",
   "semver": "^7.7.4",
   "urlpattern-polyfill": "^10.1.0",
   "yargs": "18.0.0",