chrome-devtools-mcp 0.20.3 → 0.22.0

package/build/src/McpResponse.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ConsoleFormatter } from './formatters/ConsoleFormatter.js';
+import { HeapSnapshotFormatter } from './formatters/HeapSnapshotFormatter.js';
 import { IssueFormatter } from './formatters/IssueFormatter.js';
 import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
@@ -12,6 +13,99 @@ import { DevTools } from './third_party/index.js';
 import { handleDialog } from './tools/pages.js';
 import { getInsightOutput, getTraceSummary } from './trace-processing/parse.js';
 import { paginate } from './utils/pagination.js';
+export function replaceHtmlElementsWithUids(schema) {
+    if (typeof schema === 'boolean') {
+        return;
+    }
+    let isHtmlElement = false;
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'x-mcp-type' && value === 'HTMLElement') {
+            isHtmlElement = true;
+            break;
+        }
+    }
+    if (isHtmlElement) {
+        schema.properties = { uid: { type: 'string' } };
+        schema.required = ['uid'];
+    }
+    if (schema.properties) {
+        for (const key of Object.keys(schema.properties)) {
+            replaceHtmlElementsWithUids(schema.properties[key]);
+        }
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            for (const item of schema.items) {
+                replaceHtmlElementsWithUids(item);
+            }
+        }
+        else {
+            replaceHtmlElementsWithUids(schema.items);
+        }
+    }
+    if (schema.anyOf) {
+        for (const s of schema.anyOf) {
+            replaceHtmlElementsWithUids(s);
+        }
+    }
+    if (schema.allOf) {
+        for (const s of schema.allOf) {
+            replaceHtmlElementsWithUids(s);
+        }
+    }
+    if (schema.oneOf) {
+        for (const s of schema.oneOf) {
+            replaceHtmlElementsWithUids(s);
+        }
+    }
+}
+async function getToolGroup(page) {
+    // Check if there is a `devtoolstooldiscovery` event listener
+    const windowHandle = await page.pptrPage.evaluateHandle(() => window);
+    // @ts-expect-error internal API
+    const client = page.pptrPage._client();
+    const { listeners } = await client.send('DOMDebugger.getEventListeners', {
+        objectId: windowHandle.remoteObject().objectId,
+    });
+    if (listeners.find(l => l.type === 'devtoolstooldiscovery') === undefined) {
+        return;
+    }
+    const toolGroup = await page.pptrPage.evaluate(() => {
+        return new Promise(resolve => {
+            const event = new CustomEvent('devtoolstooldiscovery');
+            // @ts-expect-error Adding custom property
+            event.respondWith = (toolGroup) => {
+                if (!window.__dtmcp) {
+                    window.__dtmcp = {};
+                }
+                window.__dtmcp.toolGroup = toolGroup;
+                // When receiving a toolGroup for the first time, expose a simple execution helper
+                if (!window.__dtmcp.executeTool) {
+                    window.__dtmcp.executeTool = async (toolName, args) => {
+                        if (!window.__dtmcp?.toolGroup) {
+                            throw new Error('No tools found on the page');
+                        }
+                        const tool = window.__dtmcp.toolGroup.tools.find(t => t.name === toolName);
+                        if (!tool) {
+                            throw new Error(`Tool ${toolName} not found`);
+                        }
+                        return await tool.execute(args);
+                    };
+                }
+                resolve(toolGroup);
+            };
+            window.dispatchEvent(event);
+            // If the page does not synchronously call `event.respondWith`, return instead of timing out
+            setTimeout(() => {
+                resolve(undefined);
+            }, 0);
+        });
+    });
+    for (const tool of toolGroup?.tools ?? []) {
+        replaceHtmlElementsWithUids(tool.inputSchema);
+    }
+    return toolGroup;
+}
 export class McpResponse {
     #includePages = false;
     #includeExtensionServiceWorkers = false;
@@ -25,19 +119,26 @@ export class McpResponse {
     #attachedLighthouseResult;
     #textResponseLines = [];
     #images = [];
+    #heapSnapshotOptions;
     #networkRequestsOptions;
     #consoleDataOptions;
     #listExtensions;
+    #listInPageTools;
+    #listWebMcpTools;
     #devToolsData;
     #tabId;
     #args;
     #page;
+    #redactNetworkHeaders = true;
     constructor(args) {
         this.#args = args;
     }
     setPage(page) {
         this.#page = page;
     }
+    setRedactNetworkHeaders(value) {
+        this.#redactNetworkHeaders = value;
+    }
     attachDevToolsData(data) {
         this.#devToolsData = data;
     }
@@ -59,6 +160,14 @@ export class McpResponse {
     setListExtensions() {
         this.#listExtensions = true;
     }
+    setListInPageTools() {
+        if (this.#args.categoryInPageTools) {
+            this.#listInPageTools = true;
+        }
+    }
+    setListWebMcpTools() {
+        this.#listWebMcpTools = true;
+    }
     setIncludeNetworkRequests(value, options) {
         if (!value) {
             this.#networkRequestsOptions = undefined;
@@ -94,8 +203,8 @@ export class McpResponse {
             includePreservedMessages: options?.includePreservedMessages,
         };
     }
-    attachNetworkRequest(reqid, options) {
-        this.#attachedNetworkRequestId = reqid;
+    attachNetworkRequest(reqId, options) {
+        this.#attachedNetworkRequestId = reqId;
         this.#attachedNetworkRequestOptions = options;
     }
     attachConsoleMessage(msgid) {
@@ -147,6 +256,22 @@ export class McpResponse {
     appendResponseLine(value) {
         this.#textResponseLines.push(value);
     }
+    setHeapSnapshotAggregates(aggregates, options) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            aggregates,
+            pagination: options,
+        };
+    }
+    setHeapSnapshotStats(stats, staticData) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            stats,
+            staticData,
+        };
+    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -159,6 +284,9 @@ export class McpResponse {
     get snapshotParams() {
         return this.#snapshotParams;
     }
+    get listWebMcpTools() {
+        return this.#listWebMcpTools;
+    }
     async handle(toolName, context) {
         if (this.#includePages) {
             await context.createPagesSnapshot();
@@ -176,8 +304,8 @@ export class McpResponse {
             if (textSnapshot) {
                 const formatter = new SnapshotFormatter(textSnapshot);
                 if (this.#snapshotParams.filePath) {
-                    await context.saveFile(new TextEncoder().encode(formatter.toString()), this.#snapshotParams.filePath);
-                    snapshot = this.#snapshotParams.filePath;
+                    const result = await context.saveFile(new TextEncoder().encode(formatter.toString()), this.#snapshotParams.filePath, '.txt');
+                    snapshot = result.filename;
                 }
                 else {
                     snapshot = formatter;
@@ -196,7 +324,8 @@ export class McpResponse {
                 fetchData: true,
                 requestFilePath: this.#attachedNetworkRequestOptions?.requestFilePath,
                 responseFilePath: this.#attachedNetworkRequestOptions?.responseFilePath,
-                saveFile: (data, filename) => context.saveFile(data, filename),
+                saveFile: (data, filename, extension) => context.saveFile(data, filename, extension),
+                redactNetworkHeaders: this.#redactNetworkHeaders,
             });
             detailedNetworkRequest = formatter;
         }
@@ -223,14 +352,25 @@ export class McpResponse {
                     elementIdResolver: context.resolveCdpElementId.bind(context, this.#page),
                 });
                 if (!formatter.isValid()) {
-                    throw new Error("Can't provide detals for the msgid " + consoleMessageStableId);
+                    throw new Error("Can't provide details for the msgid " + consoleMessageStableId);
                 }
                 detailedConsoleMessage = formatter;
             }
         }
         let extensions;
         if (this.#listExtensions) {
-            extensions = context.listExtensions();
+            extensions = await context.listExtensions();
+        }
+        let inPageTools;
+        if (this.#listInPageTools) {
+            const page = this.#page ?? context.getSelectedMcpPage();
+            inPageTools = await getToolGroup(page);
+            page.inPageTools = inPageTools;
+        }
+        let webmcpTools;
+        if (this.#listWebMcpTools && this.#args.experimentalWebmcp) {
+            const page = this.#page ?? context.getSelectedMcpPage();
+            webmcpTools = page.getWebMcpTools();
         }
         let consoleMessages;
         if (this.#consoleDataOptions?.include) {
@@ -294,7 +434,8 @@ export class McpResponse {
                     selectedInDevToolsUI: context.getNetworkRequestStableId(request) ===
                         this.#networkRequestsOptions?.networkRequestIdInDevToolsUI,
                     fetchData: false,
-                    saveFile: (data, filename) => context.saveFile(data, filename),
+                    saveFile: (data, filename, extension) => context.saveFile(data, filename, extension),
+                    redactNetworkHeaders: this.#redactNetworkHeaders,
                 })));
             }
         }
@@ -308,6 +449,8 @@ export class McpResponse {
             traceSummary: this.#attachedTraceSummary,
             extensions,
             lighthouseResult: this.#attachedLighthouseResult,
+            inPageTools,
+            webmcpTools,
         });
     }
     format(toolName, context, data) {
@@ -473,6 +616,32 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 structuredContent.snapshot = data.snapshot.toJSON();
             }
         }
+        if (this.#heapSnapshotOptions?.include) {
+            response.push('## Heap Snapshot Data');
+            const stats = this.#heapSnapshotOptions.stats;
+            const staticData = this.#heapSnapshotOptions.staticData;
+            if (stats) {
+                response.push(`Statistics: ${JSON.stringify(stats, null, 2)}`);
+                structuredContent.heapSnapshot = structuredContent.heapSnapshot || {};
+                structuredContent.heapSnapshot.stats = stats;
+            }
+            if (staticData) {
+                response.push(`Static Data: ${JSON.stringify(staticData, null, 2)}`);
+                structuredContent.heapSnapshot = structuredContent.heapSnapshot || {};
+                structuredContent.heapSnapshot.staticData = staticData;
+            }
+            const aggregates = this.#heapSnapshotOptions.aggregates;
+            if (aggregates) {
+                const sortedEntries = HeapSnapshotFormatter.sort(aggregates);
+                const paginationData = this.#dataWithPagination(sortedEntries, this.#heapSnapshotOptions.pagination);
+                structuredContent.pagination = paginationData.pagination;
+                response.push(...paginationData.info);
+                const paginatedRecord = Object.fromEntries(paginationData.items);
+                const formatter = new HeapSnapshotFormatter(paginatedRecord);
+                response.push(formatter.toString());
+                structuredContent.heapSnapshotData = formatter.toJSON();
+            }
+        }
         if (data.detailedNetworkRequest) {
             response.push(data.detailedNetworkRequest.toStringDetailed());
             structuredContent.networkRequest =
@@ -484,20 +653,59 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 data.detailedConsoleMessage.toJSONDetailed();
         }
         if (data.extensions) {
-            structuredContent.extensions = data.extensions;
+            const extensionArray = Array.from(data.extensions.values());
+            structuredContent.extensions = extensionArray;
             response.push('## Extensions');
-            if (data.extensions.length === 0) {
+            if (extensionArray.length === 0) {
                 response.push('No extensions installed.');
             }
             else {
-                const extensionsMessage = data.extensions
+                const extensionsMessage = extensionArray
                     .map(extension => {
-                    return `id=${extension.id} "${extension.name}" v${extension.version} ${extension.isEnabled ? 'Enabled' : 'Disabled'}`;
+                    return `id=${extension.id} "${extension.name}" v${extension.version} ${extension.enabled ? 'Enabled' : 'Disabled'}`;
                 })
                     .join('\n');
                 response.push(extensionsMessage);
             }
         }
+        if (this.#listInPageTools) {
+            structuredContent.inPageTools = data.inPageTools ?? undefined;
+            response.push('## In-page tools');
+            if (!data.inPageTools || !data.inPageTools.tools) {
+                response.push('No in-page tools available.');
+            }
+            else {
+                const toolGroup = data.inPageTools;
+                response.push(`${toolGroup.name}: ${toolGroup.description}`);
+                response.push('Available tools:');
+                const toolDefinitionsMessage = toolGroup.tools
+                    .map(tool => {
+                    return `name="${tool.name}", description="${tool.description}", inputSchema=${JSON.stringify(tool.inputSchema)}`;
+                })
+                    .join('\n');
+                response.push(toolDefinitionsMessage);
+            }
+        }
+        if (this.#listWebMcpTools && data.webmcpTools) {
+            structuredContent.webmcpTools = data.webmcpTools.map(({ name, description, inputSchema, annotations }) => ({
+                name,
+                description,
+                inputSchema,
+                annotations,
+            }));
+            response.push('## WebMCP tools');
+            if (data.webmcpTools.length === 0) {
+                response.push('No WebMCP tools available.');
+            }
+            else {
+                const webmcpToolsMessage = data.webmcpTools
+                    .map(tool => {
+                    return `name="${tool.name}", description="${tool.description}", inputSchema=${JSON.stringify(tool.inputSchema)}, annotations=${JSON.stringify(tool.annotations)}`;
+                })
+                    .join('\n');
+                response.push(webmcpToolsMessage);
+            }
+        }
         if (this.#networkRequestsOptions?.include && data.networkRequests) {
             const requests = data.networkRequests;
             response.push('## Network requests');

package/build/src/PageCollector.js

@@ -6,6 +6,7 @@
 import { FakeIssuesManager } from './DevtoolsUtils.js';
 import { logger } from './logger.js';
 import { DevTools } from './third_party/index.js';
+import { createIdGenerator, stableIdSymbol, } from './utils/id.js';
 export class UncaughtError {
     details;
     targetId;
@@ -14,16 +15,6 @@ export class UncaughtError {
         this.targetId = targetId;
     }
 }
-function createIdGenerator() {
-    let i = 1;
-    return () => {
-        if (i === Number.MAX_SAFE_INTEGER) {
-            i = 0;
-        }
-        return i++;
-    };
-}
-export const stableIdSymbol = Symbol('stableIdSymbol');
 export class PageCollector {
     #browser;
     #listenersInitializer;
@@ -198,42 +189,33 @@ class PageEventSubscriber {
     #resetIssueAggregator() {
         this.#issueManager = new FakeIssuesManager();
         if (this.#issueAggregator) {
-            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
+            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
         }
         this.#issueAggregator = new DevTools.IssueAggregator(this.#issueManager);
-        this.#issueAggregator.addEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
+        this.#issueAggregator.addEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
     }
     async subscribe() {
         this.#resetIssueAggregator();
         this.#page.on('framenavigated', this.#onFrameNavigated);
-        this.#session.on('Audits.issueAdded', this.#onIssueAdded);
+        this.#page.on('issue', this.#onIssueAdded);
         this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
-        try {
-            await this.#session.send('Audits.enable');
-        }
-        catch (error) {
-            logger('Error subscribing to issues', error);
-        }
     }
     unsubscribe() {
         this.#seenKeys.clear();
         this.#seenIssues.clear();
         this.#page.off('framenavigated', this.#onFrameNavigated);
-        this.#session.off('Audits.issueAdded', this.#onIssueAdded);
+        this.#page.off('issue', this.#onIssueAdded);
         this.#session.off('Runtime.exceptionThrown', this.#onExceptionThrown);
         if (this.#issueAggregator) {
-            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
+            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* DevTools.IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedIssue);
         }
-        void this.#session.send('Audits.disable').catch(() => {
-            // might fail.
-        });
     }
-    #onAggregatedissue = (event) => {
+    #onAggregatedIssue = (event) => {
         if (this.#seenIssues.has(event.data)) {
             return;
         }
         this.#seenIssues.add(event.data);
-        this.#page.emit('issue', event.data);
+        this.#page.emit('devtoolsAggregatedIssue', event.data);
     };
     #onExceptionThrown = (event) => {
         this.#page.emit('uncaughtError', new UncaughtError(event.exceptionDetails, this.#targetId));
@@ -248,9 +230,13 @@ class PageEventSubscriber {
         this.#seenIssues.clear();
         this.#resetIssueAggregator();
     };
-    #onIssueAdded = (data) => {
+    #onIssueAdded = (inspectorIssue) => {
         try {
-            const inspectorIssue = data.issue;
+            // DevTools currently defines this protocol issue code but has no
+            // IssuesManager handler for it, so calling into the mapper only warns.
+            if (String(inspectorIssue.code) === 'PerformanceIssue') {
+                return;
+            }
             const issue = DevTools.createIssuesFromProtocolIssue(null, 
             // @ts-expect-error Protocol types diverge.
             inspectorIssue)[0];

package/build/src/WaitForHelper.js

@@ -104,6 +104,23 @@ export class WaitForHelper {
         });
     }
     async waitForEventsAfterAction(action, options) {
+        if (options?.handleDialog) {
+            const dialogHandler = (dialog) => {
+                if (options.handleDialog === 'dismiss') {
+                    void dialog.dismiss();
+                }
+                else if (options.handleDialog === 'accept') {
+                    void dialog.accept();
+                }
+                else {
+                    void dialog.accept(options.handleDialog);
+                }
+            };
+            this.#page.on('dialog', dialogHandler);
+            this.#abortController.signal.addEventListener('abort', () => {
+                this.#page.off('dialog', dialogHandler);
+            });
+        }
         const navigationFinished = this.waitForNavigationStarted()
             .then(navigationStated => {
             if (navigationStated) {
@@ -137,3 +154,17 @@ export class WaitForHelper {
         }
     }
 }
+export function getNetworkMultiplierFromString(condition) {
+    const puppeteerCondition = condition;
+    switch (puppeteerCondition) {
+        case 'Fast 4G':
+            return 1;
+        case 'Slow 4G':
+            return 2.5;
+        case 'Fast 3G':
+            return 5;
+        case 'Slow 3G':
+            return 10;
+    }
+    return 1;
+}

package/build/src/bin/check-latest-version.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+const cachePath = process.argv[2];
+if (cachePath) {
+    try {
+        const response = await fetch('https://registry.npmjs.org/chrome-devtools-mcp/latest');
+        const data = response.ok ? await response.json() : null;
+        if (data &&
+            typeof data === 'object' &&
+            'version' in data &&
+            typeof data.version === 'string') {
+            await fs.mkdir(path.dirname(cachePath), { recursive: true });
+            await fs.writeFile(cachePath, JSON.stringify({ version: data.version }));
+        }
+    }
+    catch {
+        // Ignore errors.
+    }
+}

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

@@ -7,8 +7,8 @@ import { yargs, hideBin } from '../third_party/index.js';
 export const cliOptions = {
     autoConnect: {
         type: 'boolean',
-        description: 'If specified, automatically connects to a browser (Chrome 144+) running locally from the user data directory identified by the channel param (default channel is stable). Requires the remoted debugging server to be started in the Chrome instance via chrome://inspect/#remote-debugging.',
-        conflicts: ['isolated', 'executablePath', 'categoryExtensions'],
+        description: 'If specified, automatically connects to a browser (Chrome 144+) running locally from the user data directory identified by the channel param (default channel is stable). Requires the remote debugging server to be started in the Chrome instance via chrome://inspect/#remote-debugging.',
+        conflicts: ['isolated', 'executablePath'],
         default: false,
         coerce: (value) => {
             if (!value) {
@@ -21,7 +21,7 @@ export const cliOptions = {
         type: 'string',
         description: 'Connect to a running, debuggable Chrome instance (e.g. `http://127.0.0.1:9222`). For more details see: https://github.com/ChromeDevTools/chrome-devtools-mcp#connecting-to-a-running-chrome-instance.',
         alias: 'u',
-        conflicts: ['wsEndpoint', 'categoryExtensions'],
+        conflicts: ['wsEndpoint'],
         coerce: (url) => {
             if (!url) {
                 return;
@@ -39,7 +39,7 @@ export const cliOptions = {
         type: 'string',
         description: 'WebSocket endpoint to connect to a running Chrome instance (e.g., ws://127.0.0.1:9222/devtools/browser/<id>). Alternative to --browserUrl.',
         alias: 'w',
-        conflicts: ['browserUrl', 'categoryExtensions'],
+        conflicts: ['browserUrl'],
         coerce: (url) => {
             if (!url) {
                 return;
@@ -102,7 +102,7 @@ export const cliOptions = {
     channel: {
         type: 'string',
         description: 'Specify a different Chrome channel that should be used. The default is the stable channel version.',
-        choices: ['stable', 'canary', 'beta', 'dev'],
+        choices: ['canary', 'dev', 'beta', 'stable'],
         conflicts: ['browserUrl', 'wsEndpoint', 'executablePath'],
     },
     logFile: {
@@ -146,7 +146,12 @@ export const cliOptions = {
     },
     experimentalVision: {
         type: 'boolean',
-        describe: 'Whether to enable vision tools',
+        describe: 'Whether to enable coordinate-based tools such as click_at(x,y). Usually requires a computer-use model able to produce accurate coordinates by looking at screenshots.',
+        hidden: false,
+    },
+    experimentalMemory: {
+        type: 'boolean',
+        describe: 'Whether to enable experimental memory tools.',
         hidden: true,
     },
     experimentalStructuredContent: {
@@ -168,6 +173,10 @@ export const cliOptions = {
         type: 'boolean',
         describe: 'Exposes experimental screencast tools (requires ffmpeg). Install ffmpeg https://www.ffmpeg.org/download.html and ensure it is available in the MCP server PATH.',
     },
+    experimentalWebmcp: {
+        type: 'boolean',
+        describe: 'Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`',
+    },
     chromeArg: {
         type: 'array',
         describe: 'Additional arguments for Chrome. Only applies when Chrome is launched by chrome-devtools-mcp.',
@@ -192,10 +201,15 @@ export const cliOptions = {
         describe: 'Set to false to exclude tools related to network.',
     },
     categoryExtensions: {
+        type: 'boolean',
+        hidden: false,
+        default: false,
+        describe: 'Set to true to include tools related to extensions. Note: This feature is currently only supported with a pipe connection. autoConnect, browserUrl, and wsEndpoint are not supported with this feature until 149 will be released.',
+    },
+    categoryInPageTools: {
         type: 'boolean',
         hidden: true,
-        conflicts: ['browserUrl', 'autoConnect', 'wsEndpoint'],
-        describe: 'Set to true to include tools related to extensions. Note: This feature is only supported with a pipe connection. autoConnect is not supported.',
+        describe: 'Set to true to enable tools exposed by the inspected page itself',
     },
     performanceCrux: {
         type: 'boolean',
@@ -205,7 +219,7 @@ export const cliOptions = {
     usageStatistics: {
         type: 'boolean',
         default: true,
-        describe: 'Set to false to opt-out of usage statistics collection. Google collects usage data to improve the tool, handled under the Google Privacy Policy (https://policies.google.com/privacy). This is independent from Chrome browser metrics. Disabled if CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS or CI env variables are set.',
+        describe: 'Set to false to opt-out of usage statistics collection. Google collects usage data to improve the tool, handled under the Google Privacy Policy (https://policies.google.com/privacy). This is independent from Chrome browser metrics. Disabled if `CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS` or `CI` env variables are set.',
     },
     clearcutEndpoint: {
         type: 'string',
@@ -231,6 +245,11 @@ export const cliOptions = {
         describe: 'Set by Chrome DevTools CLI if the MCP server is started via the CLI client (this arg exists for usage stats)',
         hidden: true,
     },
+    redactNetworkHeaders: {
+        type: 'boolean',
+        describe: 'If true, redacts some of the network headers considered senstive before returning to the client.',
+        default: false,
+    },
 };
 export function parseArguments(version, argv = process.argv) {
     const yargsInstance = yargs(hideBin(argv))

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

@@ -9,8 +9,10 @@ import { createMcpServer, logDisclaimers } from '../index.js';
 import { logger, saveLogsToFile } from '../logger.js';
 import { computeFlagUsage } from '../telemetry/flagUtils.js';
 import { StdioServerTransport } from '../third_party/index.js';
+import { checkForUpdates } from '../utils/check-for-updates.js';
 import { VERSION } from '../version.js';
 import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-options.js';
+await checkForUpdates('Run `npm install chrome-devtools-mcp@latest` to update.');
 export const args = parseArguments(VERSION);
 const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 if (process.env['CI'] ||

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

@@ -4,6 +4,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+process.title = 'chrome-devtools-mcp';
 import { version } from 'node:process';
 const [major, minor] = version.substring(1).split('.').map(Number);
 if (major === 20 && minor < 19) {