chrome-devtools-mcp 0.19.0 → 0.20.1

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

@@ -0,0 +1,7 @@
+# Selective Permissions Intervention
+
+The Selective Permissions Intervention blocks calls to privacy-sensitive APIs when they are called from ad scripts in order to align the permission grant with the user's intent. The particular API that was blocked, the call-stack that triggered the intervention, and why the script that called the API is considered ad-related is shown below.
+
+Note that Chrome considers any script with a URL that matches a rule in the [filterlist](ChromeFilterlistRepository) as ad script, and the matching rule is shown in the Ad Ancestry section. In addition, any script loaded while an ad script is in the JavaScript stack will also be considered an ad script by Chrome and is also shown in Ad Ancestry.
+
+If you believe this intervention  was in error (e.g., this call would occur even when loading the page with an ad blocker enabled), then please [file a bug](SelectivePermissionsInterventionIssue).

package/build/src/version.js

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

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "chrome-devtools-mcp",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "MCP server for Chrome DevTools",
   "type": "module",
-  "bin": "./build/src/index.js",
-  "main": "./build/src/server.js",
+  "bin": {
+    "chrome-devtools-mcp": "./build/src/bin/chrome-devtools-mcp.js",
+    "chrome-devtools": "./build/src/bin/chrome-devtools.js"
+  },
+  "main": "./build/src/index.js",
   "scripts": {
     "cli:generate": "node --experimental-strip-types scripts/generate-cli.ts",
     "clean": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\"",
@@ -56,7 +59,7 @@
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.43.0",
     "@typescript-eslint/parser": "^8.43.0",
-    "chrome-devtools-frontend": "1.0.1592362",
+    "chrome-devtools-frontend": "1.0.1596260",
     "core-js": "3.48.0",
     "debug": "4.4.3",
     "eslint": "^9.35.0",
@@ -65,7 +68,7 @@
     "globals": "^17.0.0",
     "lighthouse": "13.0.3",
     "prettier": "^3.6.2",
-    "puppeteer": "24.38.0",
+    "puppeteer": "24.39.1",
     "rollup": "4.59.0",
     "rollup-plugin-cleanup": "^3.2.1",
     "rollup-plugin-license": "^3.6.0",

package/build/src/server.js

@@ -1,209 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-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, } from './third_party/index.js';
-import { ToolCategory } from './tools/categories.js';
-import { pageIdSchema } from './tools/ToolDefinition.js';
-import { createTools } from './tools/tools.js';
-import { VERSION } from './version.js';
-export async function createMcpServer(serverArgs, options) {
-    let clearcutLogger;
-    if (serverArgs.usageStatistics) {
-        clearcutLogger = new ClearcutLogger({
-            logFile: serverArgs.logFile,
-            appVersion: VERSION,
-            clearcutEndpoint: serverArgs.clearcutEndpoint,
-            clearcutForceFlushIntervalMs: serverArgs.clearcutForceFlushIntervalMs,
-            clearcutIncludePidHeader: serverArgs.clearcutIncludePidHeader,
-        });
-    }
-    const server = new McpServer({
-        name: 'chrome_devtools',
-        title: 'Chrome DevTools MCP server',
-        version: VERSION,
-    }, { capabilities: { logging: {} } });
-    server.server.setRequestHandler(SetLevelRequestSchema, () => {
-        return {};
-    });
-    let context;
-    async function getContext() {
-        const chromeArgs = (serverArgs.chromeArg ?? []).map(String);
-        const ignoreDefaultChromeArgs = (serverArgs.ignoreDefaultChromeArg ?? []).map(String);
-        if (serverArgs.proxyServer) {
-            chromeArgs.push(`--proxy-server=${serverArgs.proxyServer}`);
-        }
-        const devtools = serverArgs.experimentalDevtools ?? false;
-        const browser = serverArgs.browserUrl || serverArgs.wsEndpoint || serverArgs.autoConnect
-            ? await ensureBrowserConnected({
-                browserURL: serverArgs.browserUrl,
-                wsEndpoint: serverArgs.wsEndpoint,
-                wsHeaders: serverArgs.wsHeaders,
-                // Important: only pass channel, if autoConnect is true.
-                channel: serverArgs.autoConnect
-                    ? serverArgs.channel
-                    : undefined,
-                userDataDir: serverArgs.userDataDir,
-                devtools,
-            })
-            : await ensureBrowserLaunched({
-                headless: serverArgs.headless,
-                executablePath: serverArgs.executablePath,
-                channel: serverArgs.channel,
-                isolated: serverArgs.isolated ?? false,
-                userDataDir: serverArgs.userDataDir,
-                logFile: options.logFile,
-                viewport: serverArgs.viewport,
-                chromeArgs,
-                ignoreDefaultChromeArgs,
-                acceptInsecureCerts: serverArgs.acceptInsecureCerts,
-                devtools,
-                enableExtensions: serverArgs.categoryExtensions,
-                viaCli: serverArgs.viaCli,
-            });
-        if (context?.browser !== browser) {
-            context = await McpContext.from(browser, logger, {
-                experimentalDevToolsDebugging: devtools,
-                experimentalIncludeAllPages: serverArgs.experimentalIncludeAllPages,
-                performanceCrux: serverArgs.performanceCrux,
-            });
-        }
-        return context;
-    }
-    const toolMutex = new Mutex();
-    function registerTool(tool) {
-        if (tool.annotations.category === ToolCategory.EMULATION &&
-            serverArgs.categoryEmulation === false) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.PERFORMANCE &&
-            serverArgs.categoryPerformance === false) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.NETWORK &&
-            serverArgs.categoryNetwork === false) {
-            return;
-        }
-        if (tool.annotations.category === ToolCategory.EXTENSIONS &&
-            serverArgs.categoryExtensions === false) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('computerVision') &&
-            !serverArgs.experimentalVision) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('experimentalInteropTools') &&
-            !serverArgs.experimentalInteropTools) {
-            return;
-        }
-        if (tool.annotations.conditions?.includes('screencast') &&
-            !serverArgs.experimentalScreencast) {
-            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,
-            annotations: tool.annotations,
-        }, async (params) => {
-            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);
-                if ('pageScoped' in tool && tool.pageScoped) {
-                    const page = serverArgs.experimentalPageIdRouting &&
-                        params.pageId &&
-                        !serverArgs.slim
-                        ? context.getPageById(params.pageId)
-                        : context.getSelectedMcpPage();
-                    response.setPage(page);
-                    await tool.handler({
-                        params,
-                        page,
-                    }, response, context);
-                }
-                else {
-                    await tool.handler(
-                    // @ts-expect-error types do not match.
-                    {
-                        params,
-                    }, response, context);
-                }
-                const { content, structuredContent } = await response.handle(tool.name, context);
-                const result = {
-                    content,
-                };
-                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,
-                    success,
-                    latencyMs: bucketizeLatency(Date.now() - startTime),
-                });
-                guard.dispose();
-            }
-        });
-    }
-    const tools = createTools(serverArgs);
-    for (const tool of tools) {
-        registerTool(tool);
-    }
-    await loadIssueDescriptions();
-    return { server, clearcutLogger };
-}
-export const logDisclaimers = (args) => {
-    console.error(`chrome-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect,
-debug, and modify any data in the browser or DevTools.
-Avoid sharing sensitive or personal information that you do not want to share with MCP clients.`);
-    if (!args.slim && args.performanceCrux) {
-        console.error(`Performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data. To disable, run with --no-performance-crux.`);
-    }
-    if (!args.slim && args.usageStatistics) {
-        console.error(`
-Google collects usage statistics to improve Chrome DevTools MCP. To opt-out, run with --no-usage-statistics.
-For more details, visit: https://github.com/ChromeDevTools/chrome-devtools-mcp#usage-statistics`);
-    }
-};