chrome-devtools-mcp 0.21.0 → 0.23.0

package/build/src/daemon/daemon.js

@@ -11,19 +11,20 @@ import process from 'node:process';
 import { logger } from '../logger.js';
 import { Client, PipeTransport, StdioClientTransport, } from '../third_party/index.js';
 import { VERSION } from '../version.js';
-import { DAEMON_CLIENT_NAME, getDaemonPid, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
-const pid = getDaemonPid();
-if (isDaemonRunning(pid)) {
+import { DAEMON_CLIENT_NAME, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
+const sessionId = process.env.CHROME_DEVTOOLS_MCP_SESSION_ID || '';
+logger(`Daemon sessionId: ${sessionId}`);
+if (isDaemonRunning(sessionId)) {
     logger('Another daemon process is running.');
     process.exit(1);
 }
-const pidFilePath = getPidFilePath();
+const pidFilePath = getPidFilePath(sessionId);
 fs.mkdirSync(path.dirname(pidFilePath), {
     recursive: true,
 });
 fs.writeFileSync(pidFilePath, process.pid.toString());
 logger(`Writing ${process.pid.toString()} to ${pidFilePath}`);
-const socketPath = getSocketPath();
+const socketPath = getSocketPath(sessionId);
 const startDate = new Date();
 const mcpServerArgs = process.argv.slice(2);
 let mcpClient = null;
@@ -32,10 +33,6 @@ let server = null;
 async function setupMCPClient() {
     console.log('Setting up MCP client connection...');
     // Create stdio transport for chrome-devtools-mcp
-    // Workaround for https://github.com/modelcontextprotocol/typescript-sdk/blob/v1.x/src/client/stdio.ts#L128
-    // which causes the console window to show on Windows.
-    // @ts-expect-error no types for type.
-    process.type = 'mcp-client';
     mcpTransport = new StdioClientTransport({
         command: process.execPath,
         args: [INDEX_SCRIPT_PATH, ...mcpServerArgs],

package/build/src/daemon/utils.js

@@ -13,46 +13,50 @@ export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'bin', 'ch
 const APP_NAME = 'chrome-devtools-mcp';
 export const DAEMON_CLIENT_NAME = 'chrome-devtools-cli-daemon';
 // Using these paths due to strict limits on the POSIX socket path length.
-export function getSocketPath() {
+export function getSocketPath(sessionId) {
     const uid = os.userInfo().uid;
+    const suffix = sessionId ? `-${sessionId}` : '';
+    const appName = APP_NAME + suffix;
     if (IS_WINDOWS) {
         // Windows uses Named Pipes, not file paths.
         // This format is required for server.listen()
-        return path.join('\\\\.\\pipe', APP_NAME, 'server.sock');
+        return path.join('\\\\.\\pipe', appName, 'server.sock');
     }
     // 1. Try XDG_RUNTIME_DIR (Linux standard, sometimes macOS)
     if (process.env.XDG_RUNTIME_DIR) {
-        return path.join(process.env.XDG_RUNTIME_DIR, APP_NAME, 'server.sock');
+        return path.join(process.env.XDG_RUNTIME_DIR, appName, 'server.sock');
     }
     // 2. macOS/Unix Fallback: Use /tmp/
     // We use /tmp/ because it is much shorter than ~/Library/Application Support/
     // and keeps us well under the 104-character limit.
-    return path.join('/tmp', `${APP_NAME}-${uid}.sock`);
+    return path.join('/tmp', `${appName}-${uid}.sock`);
 }
-export function getRuntimeHome() {
+export function getRuntimeHome(sessionId) {
     const platform = os.platform();
     const uid = os.userInfo().uid;
+    const suffix = sessionId ? `-${sessionId}` : '';
+    const appName = APP_NAME + suffix;
     // 1. Check for the modern Unix standard
     if (process.env.XDG_RUNTIME_DIR) {
-        return path.join(process.env.XDG_RUNTIME_DIR, APP_NAME);
+        return path.join(process.env.XDG_RUNTIME_DIR, appName);
     }
     // 2. Fallback for macOS and older Linux
     if (platform === 'darwin' || platform === 'linux') {
         // /tmp is cleared on boot, making it perfect for PIDs
-        return path.join('/tmp', `${APP_NAME}-${uid}`);
+        return path.join('/tmp', `${appName}-${uid}`);
     }
     // 3. Windows Fallback
-    return path.join(os.tmpdir(), APP_NAME);
+    return path.join(os.tmpdir(), appName);
 }
 export const IS_WINDOWS = os.platform() === 'win32';
-export function getPidFilePath() {
-    const runtimeDir = getRuntimeHome();
+export function getPidFilePath(sessionId) {
+    const runtimeDir = getRuntimeHome(sessionId);
     return path.join(runtimeDir, 'daemon.pid');
 }
-export function getDaemonPid() {
+export function getDaemonPid(sessionId) {
     try {
-        const pidFile = getPidFilePath();
-        logger(`Daemon pid file ${pidFile}`);
+        const pidFile = getPidFilePath(sessionId);
+        logger(`Daemon pid file ${pidFile} sessionId=${sessionId}`);
         if (!fs.existsSync(pidFile)) {
             return null;
         }
@@ -68,7 +72,8 @@ export function getDaemonPid() {
         return null;
     }
 }
-export function isDaemonRunning(pid = getDaemonPid()) {
+export function isDaemonRunning(sessionId) {
+    const pid = getDaemonPid(sessionId);
     if (pid) {
         try {
             process.kill(pid, 0); // Throws if process doesn't exist

package/build/src/formatters/HeapSnapshotFormatter.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { stableIdSymbol } from '../utils/id.js';
+export class HeapSnapshotFormatter {
+    #aggregates;
+    constructor(aggregates) {
+        this.#aggregates = aggregates;
+    }
+    #getSortedAggregates() {
+        return Object.values(this.#aggregates).sort((a, b) => b.self - a.self);
+    }
+    toString() {
+        const sorted = this.#getSortedAggregates();
+        const lines = [];
+        lines.push('uid,className,count,selfSize,maxRetainedSize');
+        for (const info of sorted) {
+            const uid = info[stableIdSymbol] ?? '';
+            lines.push(`${uid},"${info.name}",${info.count},${info.self},${info.maxRet}`);
+        }
+        return lines.join('\n');
+    }
+    toJSON() {
+        const sorted = this.#getSortedAggregates();
+        return sorted.map(info => ({
+            uid: info[stableIdSymbol],
+            className: info.name,
+            count: info.count,
+            selfSize: info.self,
+            retainedSize: info.maxRet,
+        }));
+    }
+    static sort(aggregates) {
+        return Object.entries(aggregates).sort((a, b) => b[1].self - a[1].self);
+    }
+}

package/build/src/formatters/NetworkFormatter.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  * */
 import { isUtf8 } from 'node:buffer';
+import { DevTools, } from '../third_party/index.js';
 const BODY_CONTEXT_SIZE_LIMIT = 10000;
 export class NetworkFormatter {
     #request;
@@ -40,8 +41,8 @@ export class NetworkFormatter {
                     throw new Error('saveFile is not provided');
                 }
                 if (data) {
-                    await this.#options.saveFile(Buffer.from(data), this.#options.requestFilePath);
-                    this.#requestBodyFilePath = this.#options.requestFilePath;
+                    const result = await this.#options.saveFile(Buffer.from(data), this.#options.requestFilePath, '.network-request');
+                    this.#requestBodyFilePath = result.filename;
                 }
                 else {
                     this.#requestBody = requestBodyNotAvailableMessage;
@@ -66,8 +67,8 @@ export class NetworkFormatter {
                     if (!this.#options.saveFile) {
                         throw new Error('saveFile is not provided');
                     }
-                    await this.#options.saveFile(buffer, this.#options.responseFilePath);
-                    this.#responseBodyFilePath = this.#options.responseFilePath;
+                    const result = await this.#options.saveFile(buffer, this.#options.responseFilePath, '.network-response');
+                    this.#responseBodyFilePath = result.filename;
                 }
                 catch {
                     // Flatten error handling for buffer() failure and save failure
@@ -96,6 +97,16 @@ export class NetworkFormatter {
             selectedInDevToolsUI: this.#options.selectedInDevToolsUI,
         };
     }
+    #redactNetworkHeaders(headers) {
+        const headersList = Object.entries(headers).map(item => {
+            return { name: item[0], value: item[1] };
+        });
+        const redacted = DevTools.NetworkRequestFormatter.sanitizeHeaders(headersList);
+        return redacted.reduce((acc, item) => {
+            acc[item.name] = item.value;
+            return acc;
+        }, {});
+    }
     toJSONDetailed() {
         const redirectChain = this.#request.redirectChain();
         const formattedRedirectChain = redirectChain.reverse().map(request => {
@@ -105,15 +116,21 @@ export class NetworkFormatter {
             const formatter = new NetworkFormatter(request, {
                 requestId: id,
                 saveFile: this.#options.saveFile,
+                redactNetworkHeaders: this.#options.redactNetworkHeaders,
             });
             return formatter.toJSON();
         });
+        const responseHeaders = this.#request.response()?.headers();
         return {
             ...this.toJSON(),
-            requestHeaders: this.#request.headers(),
+            requestHeaders: this.#options.redactNetworkHeaders
+                ? this.#redactNetworkHeaders(this.#request.headers())
+                : this.#request.headers(),
             requestBody: this.#requestBody,
             requestBodyFilePath: this.#requestBodyFilePath,
-            responseHeaders: this.#request.response()?.headers(),
+            responseHeaders: this.#options.redactNetworkHeaders && responseHeaders
+                ? this.#redactNetworkHeaders(responseHeaders)
+                : this.#request.response()?.headers(),
             responseBody: this.#responseBody,
             responseBodyFilePath: this.#responseBodyFilePath,
             failure: this.#request.failure()?.errorText,
@@ -210,7 +227,7 @@ function converNetworkRequestDetailedToStringDetailed(data) {
         response.push(`### Redirect chain`);
         let indent = 0;
         for (const request of redirectChain.reverse()) {
-            response.push(`${'  '.repeat(indent)}${convertNetworkRequestConciseToString(request)})}`);
+            response.push(`${'  '.repeat(indent)}${convertNetworkRequestConciseToString(request)}`);
             indent++;
         }
     }

package/build/src/index.js

@@ -101,7 +101,7 @@ export async function createMcpServer(serverArgs, options) {
             return;
         }
         if (tool.annotations.category === ToolCategory.EXTENSIONS &&
-            !serverArgs.categoryExtensions) {
+            serverArgs.categoryExtensions === false) {
             return;
         }
         if (tool.annotations.category === ToolCategory.IN_PAGE &&
@@ -112,6 +112,10 @@ export async function createMcpServer(serverArgs, options) {
             !serverArgs.experimentalVision) {
             return;
         }
+        if (tool.annotations.conditions?.includes('experimentalMemory') &&
+            !serverArgs.experimentalMemory) {
+            return;
+        }
         if (tool.annotations.conditions?.includes('experimentalInteropTools') &&
             !serverArgs.experimentalInteropTools) {
             return;
@@ -120,6 +124,10 @@ export async function createMcpServer(serverArgs, options) {
             !serverArgs.experimentalScreencast) {
             return;
         }
+        if (tool.annotations.conditions?.includes('experimentalWebmcp') &&
+            !serverArgs.experimentalWebmcp) {
+            return;
+        }
         const schema = 'pageScoped' in tool &&
             tool.pageScoped &&
             serverArgs.experimentalPageIdRouting &&
@@ -142,6 +150,7 @@ export async function createMcpServer(serverArgs, options) {
                 const response = serverArgs.slim
                     ? new SlimMcpResponse(serverArgs)
                     : new McpResponse(serverArgs);
+                response.setRedactNetworkHeaders(serverArgs.redactNetworkHeaders);
                 if ('pageScoped' in tool && tool.pageScoped) {
                     const page = serverArgs.experimentalPageIdRouting &&
                         params.pageId &&
@@ -190,6 +199,8 @@ export async function createMcpServer(serverArgs, options) {
             finally {
                 void clearcutLogger?.logToolInvocation({
                     toolName: tool.name,
+                    params,
+                    schema,
                     success,
                     latencyMs: bucketizeLatency(Date.now() - startTime),
                 });

package/build/src/telemetry/ClearcutLogger.js

@@ -10,7 +10,7 @@ import { FilePersistence } from './persistence.js';
 import { McpClient, WatchdogMessageType, OsType, } from './types.js';
 import { WatchdogClient } from './WatchdogClient.js';
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
-const PARAM_BLOCKLIST = new Set(['uid']);
+export const PARAM_BLOCKLIST = new Set(['uid', 'reqid', 'msgid']);
 const SUPPORTED_ZOD_TYPES = [
     'ZodString',
     'ZodNumber',
@@ -21,7 +21,7 @@ const SUPPORTED_ZOD_TYPES = [
 function isZodType(type) {
     return SUPPORTED_ZOD_TYPES.includes(type);
 }
-function getZodType(zodType) {
+export function getZodType(zodType) {
     const def = zodType._def;
     const typeName = def.typeName;
     if (typeName === 'ZodOptional' ||
@@ -37,15 +37,31 @@ function getZodType(zodType) {
     }
     throw new Error(`Unsupported zod type for tool parameter: ${typeName}`);
 }
-function transformName(zodType, name) {
+export function transformArgName(zodType, name) {
+    const snakeCaseName = name.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
     if (zodType === 'ZodString') {
-        return `${name}_length`;
+        return `${snakeCaseName}_length`;
     }
     else if (zodType === 'ZodArray') {
-        return `${name}_count`;
+        return `${snakeCaseName}_count`;
     }
     else {
-        return name;
+        return snakeCaseName;
+    }
+}
+export function transformArgType(zodType) {
+    if (zodType === 'ZodString' || zodType === 'ZodArray') {
+        return 'number';
+    }
+    switch (zodType) {
+        case 'ZodNumber':
+            return 'number';
+        case 'ZodBoolean':
+            return 'boolean';
+        case 'ZodEnum':
+            return 'enum';
+        default:
+            throw new Error(`Unsupported zod type for tool parameter: ${zodType}`);
     }
 }
 function transformValue(zodType, value) {
@@ -91,7 +107,7 @@ export function sanitizeParams(params, schema) {
         if (!hasEquivalentType(zodType, value)) {
             throw new Error(`parameter ${name} has type ${zodType} but value ${value} is not of equivalent type`);
         }
-        const transformedName = transformName(zodType, name);
+        const transformedName = transformArgName(zodType, name);
         const transformedValue = transformValue(zodType, value);
         transformed[transformedName] = transformedValue;
     }
@@ -153,15 +169,21 @@ export class ClearcutLogger {
         }
     }
     async logToolInvocation(args) {
+        const tool_invocation = {
+            tool_name: args.toolName,
+            success: args.success,
+            latency_ms: args.latencyMs,
+        };
+        if (Object.keys(args.params).length > 0) {
+            tool_invocation.tool_params = {
+                [`${args.toolName}_params`]: sanitizeParams(args.params, args.schema),
+            };
+        }
         this.#watchdog.send({
             type: WatchdogMessageType.LOG_EVENT,
             payload: {
                 mcp_client: this.#mcpClient,
-                tool_invocation: {
-                    tool_name: args.toolName,
-                    success: args.success,
-                    latency_ms: args.latencyMs,
-                },
+                tool_invocation: tool_invocation,
             },
         });
     }

package/build/src/telemetry/flagUtils.js

@@ -4,6 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { toSnakeCase } from '../utils/string.js';
+/**
+ * For enums, log the value as uppercase.
+ * We're going to have an enum for such flags with choices represented
+ * as an `enum` where the keys of the enum will map to the uppercase `choice`.
+ */
+function formatEnumChoice(snakeCaseName, choice) {
+    return `${snakeCaseName}_${choice}`.toUpperCase();
+}
 /**
  * Computes telemetry flag usage from parsed arguments and CLI options.
  *
@@ -14,6 +22,8 @@ import { toSnakeCase } from '../utils/string.js';
  *    - The provided value differs from the default value.
  * - Boolean flags are logged with their literal value.
  * - String flags with defined `choices` (Enums) are logged as their uppercase value.
+ *
+ * IMPORTANT: keep getPossibleFlagMetrics() in sync with this function.
  */
 export function computeFlagUsage(args, options) {
     const usage = {};
@@ -35,11 +45,43 @@ export function computeFlagUsage(args, options) {
             typeof value === 'string' &&
             'choices' in config &&
             config.choices) {
-            // For enums, log the value as uppercase
-            // We're going to have an enum for such flags with choices represented
-            // as an `enum` where the keys of the enum will map to the uppercase `choice`.
-            usage[snakeCaseName] = `${snakeCaseName}_${value}`.toUpperCase();
+            usage[snakeCaseName] = formatEnumChoice(snakeCaseName, value);
         }
     }
     return usage;
 }
+/**
+ * Computes the list of possible flag metrics based on the CLI options.
+ *
+ * IMPORTANT: keep this function in sync with computeFlagUsage().
+ */
+export function getPossibleFlagMetrics(options) {
+    const metrics = [];
+    for (const [flagName, config] of Object.entries(options)) {
+        const snakeCaseName = toSnakeCase(flagName);
+        // _present is always a possible metric
+        metrics.push({
+            name: `${snakeCaseName}_present`,
+            flagType: 'boolean',
+        });
+        if (config.type === 'boolean') {
+            metrics.push({
+                name: snakeCaseName,
+                flagType: 'boolean',
+            });
+        }
+        else if (config.type === 'string' &&
+            'choices' in config &&
+            config.choices) {
+            metrics.push({
+                name: snakeCaseName,
+                flagType: 'enum',
+                choices: [
+                    `${snakeCaseName.toUpperCase()}_UNSPECIFIED`,
+                    ...config.choices.map(choice => formatEnumChoice(snakeCaseName, choice)),
+                ],
+            });
+        }
+    }
+    return metrics;
+}

package/build/src/telemetry/toolMetricsUtils.js

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { transformArgName, transformArgType, getZodType, PARAM_BLOCKLIST, } from './ClearcutLogger.js';
+/**
+ * Validates that all values in an enum are of the homogeneous primitive type.
+ * Returns the primitive type string. Throws an error if heterogeneous.
+ */
+export function validateEnumHomogeneity(values) {
+    const firstType = typeof values[0];
+    for (const val of values) {
+        if (typeof val !== firstType) {
+            throw new Error('Heterogeneous enum types found');
+        }
+    }
+    return firstType;
+}
+export function applyToExistingMetrics(existing, update) {
+    const updated = applyToExisting(existing, update);
+    const existingByName = new Map(existing.map(tool => [tool.name, tool]));
+    const updatedByName = new Map(update.map(tool => [tool.name, tool]));
+    return updated.map(tool => {
+        const existingTool = existingByName.get(tool.name);
+        const updatedTool = updatedByName.get(tool.name);
+        // If the tool still exists in the update, we will update the args.
+        if (existingTool && updatedTool) {
+            const updatedArgs = applyToExisting(existingTool.args, updatedTool.args);
+            return { ...tool, args: updatedArgs };
+        }
+        return tool;
+    });
+}
+function applyToExisting(existing, update) {
+    const existingNames = new Set(existing.map(item => item.name));
+    const updatedNames = new Set(update.map(item => item.name));
+    const result = [];
+    // Keep the original ordering.
+    for (const entry of existing) {
+        const toAdd = { ...entry };
+        if (!updatedNames.has(entry.name)) {
+            toAdd.isDeprecated = true;
+        }
+        result.push(toAdd);
+    }
+    // New entries must be added to the very back of the list.
+    for (const entry of update) {
+        if (!existingNames.has(entry.name)) {
+            result.push({ ...entry });
+        }
+    }
+    return result;
+}
+/**
+ * Generates tool metrics from tool definitions.
+ */
+export function generateToolMetrics(tools) {
+    return tools.map(tool => {
+        const args = [];
+        for (const [name, schema] of Object.entries(tool.schema)) {
+            if (PARAM_BLOCKLIST.has(name)) {
+                continue;
+            }
+            const zodType = getZodType(schema);
+            const transformedName = transformArgName(zodType, name);
+            let argType = transformArgType(zodType);
+            if (argType === 'enum') {
+                let values;
+                if (schema._def.values?.length > 0) {
+                    values = schema._def.values;
+                }
+                else {
+                    values = schema._def.innerType._def.values;
+                }
+                argType = validateEnumHomogeneity(values);
+            }
+            args.push({
+                name: transformedName,
+                argType,
+            });
+        }
+        return {
+            name: tool.name,
+            args,
+        };
+    });
+}

package/build/src/telemetry/watchdog/ClearcutSender.js

@@ -42,13 +42,14 @@ export class ClearcutSender {
             this.#sessionId = crypto.randomUUID();
             this.#sessionCreated = Date.now();
         }
-        logger('Enqueing telemetry event', JSON.stringify(event, null, 2));
-        this.#addToBuffer({
+        const eventToSend = {
             ...event,
             session_id: this.#sessionId,
             app_version: this.#appVersion,
             os_type: this.#osType,
-        });
+        };
+        logger('Enqueing telemetry event', JSON.stringify(eventToSend, null, 2));
+        this.#addToBuffer(eventToSend);
         if (!this.#timerStarted) {
             this.#timerStarted = true;
             this.#scheduleFlush(this.#flushIntervalMs);