chrome-devtools-mcp 0.22.0 → 0.24.0

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

@@ -164,6 +164,11 @@ export const cliOptions = {
         describe: 'Whether to include all kinds of pages such as webviews or background pages as pages.',
         hidden: true,
     },
+    experimentalNavigationAllowlist: {
+        type: 'boolean',
+        describe: 'Whether to enable navigation allowlist tool parameter.',
+        hidden: true,
+    },
     experimentalInteropTools: {
         type: 'boolean',
         describe: 'Whether to enable interoperability tools',
@@ -173,6 +178,11 @@ 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.',
     },
+    experimentalFfmpegPath: {
+        type: 'string',
+        describe: 'Path to ffmpeg executable for screencast recording.',
+        implies: 'experimentalScreencast',
+    },
     experimentalWebmcp: {
         type: 'boolean',
         describe: 'Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`',
@@ -206,9 +216,10 @@ export const cliOptions = {
         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: {
+    categoryExperimentalInPage: {
         type: 'boolean',
         hidden: true,
+        default: false,
         describe: 'Set to true to enable tools exposed by the inspected page itself',
     },
     performanceCrux: {
@@ -334,3 +345,4 @@ export function parseArguments(version, argv = process.argv) {
         .version(version)
         .parseSync();
 }
+//# sourceMappingURL=chrome-devtools-mcp-cli-options.js.map

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

@@ -35,3 +35,4 @@ logger('Chrome DevTools MCP Server connected');
 logDisclaimers(args);
 void clearcutLogger?.logDailyActiveIfNeeded();
 void clearcutLogger?.logServerStart(computeFlagUsage(args, cliOptions));
+//# sourceMappingURL=chrome-devtools-mcp-main.js.map

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

@@ -20,3 +20,4 @@ if (major < 20) {
     process.exit(1);
 }
 await import('./chrome-devtools-mcp-main.js');
+//# sourceMappingURL=chrome-devtools-mcp.js.map

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

@@ -15,9 +15,9 @@ import { VERSION } from '../version.js';
 import { commands } from './chrome-devtools-cli-options.js';
 import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-options.js';
 await checkForUpdates('Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.');
-async function start(args) {
+async function start(args, sessionId) {
     const combinedArgs = [...args, ...defaultArgs];
-    await startDaemon(combinedArgs);
+    await startDaemon(combinedArgs, sessionId);
     logDisclaimers(parseArguments(VERSION, combinedArgs));
 }
 const defaultArgs = ['--viaCli', '--experimentalStructuredContent'];
@@ -28,20 +28,10 @@ const startCliOptions = {
 delete startCliOptions.autoConnect;
 // Missing CLI serialization.
 delete startCliOptions.viewport;
-// CLI is generated based on the default tool definitions. To enable conditional
-// tools, they need to be enabled during CLI generation.
-delete startCliOptions.experimentalPageIdRouting;
-delete startCliOptions.experimentalVision;
-delete startCliOptions.experimentalWebmcp;
-delete startCliOptions.experimentalInteropTools;
-delete startCliOptions.experimentalScreencast;
-delete startCliOptions.categoryEmulation;
-delete startCliOptions.categoryPerformance;
-delete startCliOptions.categoryNetwork;
-delete startCliOptions.categoryExtensions;
-// Always on in CLI.
+// Change the defaults for the CLI.
 delete startCliOptions.experimentalStructuredContent;
-// Change the defaults.
+delete startCliOptions.experimentalInteropTools;
+delete startCliOptions.experimentalPageIdRouting;
 if (!('default' in cliOptions.headless)) {
     throw new Error('headless cli option unexpectedly does not have a default');
 }
@@ -51,11 +41,18 @@ if ('default' in cliOptions.isolated) {
 startCliOptions.headless.default = true;
 startCliOptions.isolated.description =
     'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed. Defaults to true unless userDataDir is provided.';
+startCliOptions.categoryExtensions.default = true;
 const y = yargs(hideBin(process.argv))
     .scriptName('chrome-devtools')
     .showHelpOnFail(true)
     .usage('chrome-devtools <command> [...args] --flags')
     .usage(`Run 'chrome-devtools <command> --help' for help on the specific command.`)
+    .option('sessionId', {
+    type: 'string',
+    description: 'Session ID for daemon scoping',
+    default: '',
+    hidden: true,
+})
     .demandCommand()
     .version(VERSION)
     .strict()
@@ -65,8 +62,8 @@ y.command('start', 'Start or restart chrome-devtools-mcp', y => y
     .options(startCliOptions)
     .example('$0 start --browserUrl http://localhost:9222', 'Start the server connecting to an existing browser')
     .strict(), async (argv) => {
-    if (isDaemonRunning()) {
-        await stopDaemon();
+    if (isDaemonRunning(argv.sessionId)) {
+        await stopDaemon(argv.sessionId);
     }
     // Defaults but we do not want to affect the yargs conflict resolution.
     if (argv.isolated === undefined && argv.userDataDir === undefined) {
@@ -76,15 +73,15 @@ y.command('start', 'Start or restart chrome-devtools-mcp', y => y
         argv.headless = true;
     }
     const args = serializeArgs(cliOptions, argv);
-    await start(args);
+    await start(args, argv.sessionId);
     process.exit(0);
 }).strict(); // Re-enable strict validation for other commands; this is applied to the yargs instance itself
-y.command('status', 'Checks if chrome-devtools-mcp is running', async () => {
-    if (isDaemonRunning()) {
+y.command('status', 'Checks if chrome-devtools-mcp is running', y => y, async (argv) => {
+    if (isDaemonRunning(argv.sessionId)) {
         console.log('chrome-devtools-mcp daemon is running.');
         const response = await sendCommand({
             method: 'status',
-        });
+        }, argv.sessionId);
         if (response.success) {
             const data = JSON.parse(response.result);
             console.log(`pid=${data.pid} socket=${data.socketPath} start-date=${data.startDate} version=${data.version}`);
@@ -100,11 +97,12 @@ y.command('status', 'Checks if chrome-devtools-mcp is running', async () => {
     }
     process.exit(0);
 });
-y.command('stop', 'Stop chrome-devtools-mcp if any', async () => {
-    if (!isDaemonRunning()) {
+y.command('stop', 'Stop chrome-devtools-mcp if any', y => y, async (argv) => {
+    const sessionId = argv.sessionId;
+    if (!isDaemonRunning(sessionId)) {
         process.exit(0);
     }
-    await stopDaemon();
+    await stopDaemon(sessionId);
     process.exit(0);
 });
 for (const [commandName, commandDef] of Object.entries(commands)) {
@@ -159,9 +157,10 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
             }
         }
     }, async (argv) => {
+        const sessionId = argv.sessionId;
         try {
-            if (!isDaemonRunning()) {
-                await start([]);
+            if (!isDaemonRunning(sessionId)) {
+                await start([], sessionId);
             }
             const commandArgs = {};
             for (const argName of Object.keys(args)) {
@@ -173,7 +172,7 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
                 method: 'invoke_tool',
                 tool: commandName,
                 args: commandArgs,
-            });
+            }, sessionId);
             if (response.success) {
                 console.log(await handleResponse(JSON.parse(response.result), argv['output-format']));
             }
@@ -189,3 +188,4 @@ for (const [commandName, commandDef] of Object.entries(commands)) {
     });
 }
 await y.parse();
+//# sourceMappingURL=chrome-devtools.js.map

package/build/src/browser.js

@@ -201,3 +201,4 @@ export async function ensureBrowserLaunched(options) {
     browser = await launch(options);
     return browser;
 }
+//# sourceMappingURL=browser.js.map

package/build/src/daemon/client.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import net from 'node:net';
 import { logger } from '../logger.js';
 import { PipeTransport } from '../third_party/index.js';
-import { saveTemporaryFile } from '../utils/files.js';
+import { getTempFilePath } from '../utils/files.js';
 import { DAEMON_SCRIPT_PATH, getSocketPath, getPidFilePath, isDaemonRunning, } from './utils.js';
 const FILE_TIMEOUT = 10_000;
 /**
@@ -48,12 +48,12 @@ function waitForFile(filePath, removed = false) {
         });
     });
 }
-export async function startDaemon(mcpArgs = []) {
-    if (isDaemonRunning()) {
+export async function startDaemon(mcpArgs = [], sessionId) {
+    if (isDaemonRunning(sessionId)) {
         logger('Daemon is already running');
         return;
     }
-    const pidFilePath = getPidFilePath();
+    const pidFilePath = getPidFilePath(sessionId);
     if (fs.existsSync(pidFilePath)) {
         fs.unlinkSync(pidFilePath);
     }
@@ -61,7 +61,7 @@ export async function startDaemon(mcpArgs = []) {
     const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
         detached: true,
         stdio: 'ignore',
-        env: process.env,
+        env: { ...process.env, CHROME_DEVTOOLS_MCP_SESSION_ID: sessionId },
         cwd: process.cwd(),
         windowsHide: true,
     });
@@ -72,8 +72,8 @@ const SEND_COMMAND_TIMEOUT = 60_000; // ms
 /**
  * `sendCommand` opens a socket connection sends a single command and disconnects.
  */
-export async function sendCommand(command) {
-    const socketPath = getSocketPath();
+export async function sendCommand(command, sessionId) {
+    const socketPath = getSocketPath(sessionId);
     const socket = net.createConnection({
         path: socketPath,
     });
@@ -102,13 +102,13 @@ export async function sendCommand(command) {
         transport.send(JSON.stringify(command));
     });
 }
-export async function stopDaemon() {
-    if (!isDaemonRunning()) {
+export async function stopDaemon(sessionId) {
+    if (!isDaemonRunning(sessionId)) {
         logger('Daemon is not running');
         return;
     }
-    const pidFilePath = getPidFilePath();
-    await sendCommand({ method: 'stop' });
+    const pidFilePath = getPidFilePath(sessionId);
+    await sendCommand({ method: 'stop' }, sessionId);
     await waitForFile(pidFilePath, /*removed=*/ true);
 }
 export async function handleResponse(response, format) {
@@ -141,7 +141,8 @@ export async function handleResponse(response, format) {
             }
             const data = Buffer.from(imageData, 'base64');
             const name = crypto.randomUUID();
-            const { filepath } = await saveTemporaryFile(data, `${name}${extension}`);
+            const filepath = await getTempFilePath(`${name}${extension}`);
+            fs.writeFileSync(filepath, data);
             chunks.push(`Saved to ${filepath}.`);
         }
         else {
@@ -150,3 +151,4 @@ export async function handleResponse(response, format) {
     }
     return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
 }
+//# sourceMappingURL=client.js.map

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;
@@ -200,3 +201,4 @@ const started = startSocketServer().catch(error => {
     logger('Failed to start daemon server:', error);
     process.exit(1);
 });
+//# sourceMappingURL=daemon.js.map

package/build/src/daemon/types.js

@@ -4,3 +4,4 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 export {};
+//# sourceMappingURL=types.js.map

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
@@ -107,3 +112,4 @@ export function serializeArgs(options, argv) {
     }
     return args;
 }
+//# sourceMappingURL=utils.js.map

package/build/src/formatters/ConsoleFormatter.js

@@ -131,6 +131,36 @@ export class ConsoleFormatter {
             id: this.#id,
         };
     }
+    /**
+     * Groups consecutive messages with the same type, text, and argument count.
+     * Similar to Chrome DevTools' console grouping behavior.
+     */
+    static groupConsecutive(messages) {
+        const grouped = [];
+        for (const msg of messages) {
+            const prev = grouped[grouped.length - 1];
+            if (prev &&
+                prev.message instanceof ConsoleFormatter &&
+                msg instanceof ConsoleFormatter &&
+                prev.message.#type === msg.#type &&
+                prev.message.#text === msg.#text &&
+                prev.message.#argCount === msg.#argCount) {
+                prev.count++;
+            }
+            else {
+                grouped.push({ message: msg, count: 1 });
+            }
+        }
+        return grouped.map(({ message, count }) => count > 1 && message instanceof ConsoleFormatter
+            ? new GroupedConsoleFormatter({
+                id: message.#id,
+                type: message.#type,
+                text: message.#text,
+                argCount: message.#argCount,
+                isIgnored: message.isIgnored,
+            }, count)
+            : message);
+    }
     toJSONDetailed() {
         return {
             id: this.#id,
@@ -144,8 +174,24 @@ export class ConsoleFormatter {
         };
     }
 }
+export class GroupedConsoleFormatter extends ConsoleFormatter {
+    #count;
+    constructor(params, count) {
+        super(params);
+        this.#count = count;
+    }
+    toString() {
+        return convertConsoleMessageConciseToString(this.toJSON());
+    }
+    toJSON() {
+        const json = super.toJSON();
+        json.count = this.#count;
+        return json;
+    }
+}
 function convertConsoleMessageConciseToString(msg) {
-    return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)`;
+    const countSuffix = msg.count && msg.count > 1 ? ` [${msg.count} times]` : '';
+    return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)${countSuffix}`;
 }
 function convertConsoleMessageConciseDetailedToString(msg) {
     const result = [
@@ -239,3 +285,4 @@ function formatCause(cause, formatter) {
         ...formatStackTraceInner(cause.stackTrace, cause.cause, formatter),
     ];
 }
+//# sourceMappingURL=ConsoleFormatter.js.map

package/build/src/formatters/HeapSnapshotFormatter.js

@@ -4,13 +4,28 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { stableIdSymbol } from '../utils/id.js';
+export function isNodeLike(item) {
+    return (typeof item === 'object' && item !== null && 'id' in item && 'name' in item);
+}
 export class HeapSnapshotFormatter {
     #aggregates;
     constructor(aggregates) {
         this.#aggregates = aggregates;
     }
+    static formatNodes(items) {
+        const lines = [];
+        if (items.length > 0 && isNodeLike(items[0])) {
+            lines.push('id,name,type,distance,selfSize,retainedSize');
+        }
+        for (const item of items) {
+            if (isNodeLike(item)) {
+                lines.push(`${item.id},"${item.name}",${item.type},${item.distance},${item.selfSize},${item.retainedSize}`);
+            }
+        }
+        return lines.join('\n');
+    }
     #getSortedAggregates() {
-        return Object.values(this.#aggregates).sort((a, b) => b.self - a.self);
+        return Object.values(this.#aggregates).sort((a, b) => b.maxRet - a.maxRet);
     }
     toString() {
         const sorted = this.#getSortedAggregates();
@@ -33,6 +48,7 @@ export class HeapSnapshotFormatter {
         }));
     }
     static sort(aggregates) {
-        return Object.entries(aggregates).sort((a, b) => b[1].self - a[1].self);
+        return Object.entries(aggregates).sort((a, b) => b[1].maxRet - a[1].maxRet);
     }
 }
+//# sourceMappingURL=HeapSnapshotFormatter.js.map

package/build/src/formatters/IssueFormatter.js

@@ -190,3 +190,4 @@ function convertIssueDetailedToString(issue) {
     result.push(`Message: issue> ${bodyParts.join('\n')}`);
     return result.join('\n');
 }
+//# sourceMappingURL=IssueFormatter.js.map

package/build/src/formatters/NetworkFormatter.js

@@ -233,3 +233,4 @@ function converNetworkRequestDetailedToStringDetailed(data) {
     }
     return response.join('\n');
 }
+//# sourceMappingURL=NetworkFormatter.js.map

package/build/src/formatters/SnapshotFormatter.js

@@ -12,7 +12,7 @@ export class SnapshotFormatter {
         const chunks = [];
         const root = this.#snapshot.root;
         // Top-level content of the snapshot.
-        if (this.#snapshot.verbose &&
+        if (!this.#snapshot.verbose &&
             this.#snapshot.hasSelectedElement &&
             !this.#snapshot.selectedElementUid) {
             chunks.push(`Note: there is a selected element in the DevTools Elements panel but it is not included into the current a11y tree snapshot.
@@ -132,3 +132,4 @@ const excludedAttributes = new Set([
     'backendNodeId',
     'loaderId',
 ]);
+//# sourceMappingURL=SnapshotFormatter.js.map