chrome-devtools-mcp 0.21.0 → 0.23.0

package/build/src/TextSnapshot.js

@@ -0,0 +1,230 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from './logger.js';
+export class TextSnapshot {
+    static nextSnapshotId = 1;
+    static resetCounter() {
+        TextSnapshot.nextSnapshotId = 1;
+    }
+    root;
+    idToNode;
+    snapshotId;
+    selectedElementUid;
+    hasSelectedElement;
+    verbose;
+    constructor(data) {
+        this.root = data.root;
+        this.idToNode = data.idToNode;
+        this.snapshotId = data.snapshotId;
+        this.selectedElementUid = data.selectedElementUid;
+        this.hasSelectedElement = data.hasSelectedElement;
+        this.verbose = data.verbose;
+    }
+    static async create(page, options = {}) {
+        const verbose = options.verbose ?? false;
+        const rootNode = await page.pptrPage.accessibility.snapshot({
+            includeIframes: true,
+            interestingOnly: !verbose,
+        });
+        if (!rootNode) {
+            throw new Error('Failed to create accessibility snapshot');
+        }
+        const { uniqueBackendNodeIdToMcpId } = page;
+        const snapshotId = TextSnapshot.nextSnapshotId++;
+        // Iterate through the whole accessibility node tree and assign node ids that
+        // will be used for the tree serialization and mapping ids back to nodes.
+        let idCounter = 0;
+        const idToNode = new Map();
+        const seenUniqueIds = new Set();
+        const seenBackendNodeIds = new Set();
+        const assignIds = (node) => {
+            let id = '';
+            // @ts-expect-error untyped backendNodeId.
+            const backendNodeId = node.backendNodeId;
+            // @ts-expect-error untyped loaderId.
+            const uniqueBackendId = `${node.loaderId}_${backendNodeId}`;
+            const existingMcpId = uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
+            if (existingMcpId !== undefined) {
+                // Re-use MCP exposed ID if the uniqueId is the same.
+                id = existingMcpId;
+            }
+            else {
+                // Only generate a new ID if we have not seen the node before.
+                id = `${snapshotId}_${idCounter++}`;
+                uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
+            }
+            seenUniqueIds.add(uniqueBackendId);
+            seenBackendNodeIds.add(backendNodeId);
+            const nodeWithId = {
+                ...node,
+                id,
+                children: node.children
+                    ? node.children.map(child => assignIds(child))
+                    : [],
+            };
+            // The AXNode for an option doesn't contain its `value`.
+            // Therefore, set text content of the option as value.
+            if (node.role === 'option') {
+                const optionText = node.name;
+                if (optionText) {
+                    nodeWithId.value = optionText.toString();
+                }
+            }
+            idToNode.set(nodeWithId.id, nodeWithId);
+            return nodeWithId;
+        };
+        const rootNodeWithId = assignIds(rootNode);
+        await TextSnapshot.insertExtraNodes(page, idToNode, seenUniqueIds, snapshotId, idCounter, rootNodeWithId, seenBackendNodeIds, options.extraHandles ?? []);
+        const snapshot = new TextSnapshot({
+            root: rootNodeWithId,
+            snapshotId: String(snapshotId),
+            idToNode,
+            hasSelectedElement: false,
+            verbose,
+        });
+        const data = options.devtoolsData ?? (await page.getDevToolsData());
+        if (data?.cdpBackendNodeId) {
+            snapshot.hasSelectedElement = true;
+            snapshot.selectedElementUid = page.resolveCdpElementId(data.cdpBackendNodeId);
+        }
+        // Clean up unique IDs that we did not see anymore.
+        for (const key of uniqueBackendNodeIdToMcpId.keys()) {
+            if (!seenUniqueIds.has(key)) {
+                uniqueBackendNodeIdToMcpId.delete(key);
+            }
+        }
+        return snapshot;
+    }
+    // ExtraHandles represent DOM nodes which might not be part of the accessibility tree, e.g. DOM nodes
+    // returned by in-page tools. We insert them into the tree by finding the closest ancestor in the
+    // tree and inserting the node as a child. The ancestor's child nodes are re-parented if necessary.
+    static async insertExtraNodes(page, idToNode, seenUniqueIds, snapshotId, idCounter, rootNodeWithId, seenBackendNodeIds, extraHandles) {
+        const { uniqueBackendNodeIdToMcpId } = page;
+        const createExtraNode = async (handle) => {
+            const backendNodeId = await handle.backendNodeId();
+            if (!backendNodeId || seenBackendNodeIds.has(backendNodeId)) {
+                return null;
+            }
+            const uniqueBackendId = `custom_${backendNodeId}`;
+            if (seenUniqueIds.has(uniqueBackendId)) {
+                return null;
+            }
+            seenBackendNodeIds.add(backendNodeId);
+            let id = '';
+            const mcpId = uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
+            if (mcpId !== undefined) {
+                id = mcpId;
+            }
+            else {
+                id = `${snapshotId}_${idCounter++}`;
+                uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
+            }
+            seenUniqueIds.add(uniqueBackendId);
+            const tagHandle = await handle.getProperty('localName');
+            const tagValue = await tagHandle.jsonValue();
+            const extraNode = {
+                role: tagValue,
+                id,
+                backendNodeId,
+                children: [],
+                elementHandle: async () => handle,
+            };
+            return extraNode;
+        };
+        const findAncestorNode = async (handle) => {
+            let ancestorHandle = await handle.evaluateHandle(el => el.parentElement);
+            while (ancestorHandle) {
+                const ancestorElement = ancestorHandle.asElement();
+                if (!ancestorElement) {
+                    await ancestorHandle.dispose();
+                    return null;
+                }
+                const ancestorBackendId = await ancestorElement.backendNodeId();
+                if (ancestorBackendId) {
+                    const ancestorNode = idToNode
+                        .values()
+                        .find(node => node.backendNodeId === ancestorBackendId);
+                    if (ancestorNode) {
+                        await ancestorHandle.dispose();
+                        return ancestorNode;
+                    }
+                }
+                const nextHandle = await ancestorElement.evaluateHandle(el => el.parentElement);
+                await ancestorHandle.dispose();
+                ancestorHandle = nextHandle;
+            }
+            return null;
+        };
+        const findDescendantNodes = async (backendNodeId) => {
+            const descendantIds = new Set();
+            try {
+                // @ts-expect-error internal API
+                const client = page.pptrPage._client();
+                if (client) {
+                    const { node } = await client.send('DOM.describeNode', {
+                        backendNodeId,
+                        depth: -1,
+                        pierce: true,
+                    });
+                    const collect = (node) => {
+                        if (node.backendNodeId && node.backendNodeId !== backendNodeId) {
+                            descendantIds.add(node.backendNodeId);
+                        }
+                        if (node.children) {
+                            for (const child of node.children) {
+                                collect(child);
+                            }
+                        }
+                    };
+                    collect(node);
+                }
+            }
+            catch (e) {
+                logger(`Failed to collect descendants for backend node ${backendNodeId}`, e);
+            }
+            return descendantIds;
+        };
+        const moveChildNodes = (attachTarget, extraNode, descendantIds) => {
+            let firstMovedIndex = -1;
+            if (descendantIds.size > 0 && attachTarget.children) {
+                const remainingChildren = [];
+                for (const child of attachTarget.children) {
+                    if (child.backendNodeId && descendantIds.has(child.backendNodeId)) {
+                        if (firstMovedIndex === -1) {
+                            firstMovedIndex = remainingChildren.length;
+                        }
+                        extraNode.children.push(child);
+                    }
+                    else {
+                        remainingChildren.push(child);
+                    }
+                }
+                attachTarget.children = remainingChildren;
+            }
+            return firstMovedIndex !== -1
+                ? firstMovedIndex
+                : attachTarget.children
+                    ? attachTarget.children.length
+                    : 0;
+        };
+        if (extraHandles.length) {
+            page.extraHandles = extraHandles;
+        }
+        for (const handle of page.extraHandles) {
+            const extraNode = await createExtraNode(handle);
+            if (!extraNode) {
+                continue;
+            }
+            idToNode.set(extraNode.id, extraNode);
+            const attachTarget = (await findAncestorNode(handle)) || rootNodeWithId;
+            if (extraNode.backendNodeId !== undefined) {
+                const descendantIds = await findDescendantNodes(extraNode.backendNodeId);
+                const index = moveChildNodes(attachTarget, extraNode, descendantIds);
+                attachTarget.children.splice(index, 0, extraNode);
+            }
+        }
+    }
+}

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: {
@@ -159,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',
@@ -168,6 +178,15 @@ 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`',
+    },
     chromeArg: {
         type: 'array',
         describe: 'Additional arguments for Chrome. Only applies when Chrome is launched by chrome-devtools-mcp.',
@@ -193,9 +212,9 @@ export const cliOptions = {
     },
     categoryExtensions: {
         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.',
+        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',
@@ -210,7 +229,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',
@@ -236,6 +255,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.js

@@ -10,12 +10,14 @@ import { startDaemon, stopDaemon, sendCommand, handleResponse, } from '../daemon
 import { isDaemonRunning, serializeArgs } from '../daemon/utils.js';
 import { logDisclaimers } from '../index.js';
 import { hideBin, yargs } from '../third_party/index.js';
+import { checkForUpdates } from '../utils/check-for-updates.js';
 import { VERSION } from '../version.js';
 import { commands } from './chrome-devtools-cli-options.js';
 import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-options.js';
-async function start(args) {
+await checkForUpdates('Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.');
+async function start(args, sessionId) {
     const combinedArgs = [...args, ...defaultArgs];
-    await startDaemon(combinedArgs);
+    await startDaemon(combinedArgs, sessionId);
     logDisclaimers(parseArguments(VERSION, combinedArgs));
 }
 const defaultArgs = ['--viaCli', '--experimentalStructuredContent'];
@@ -30,6 +32,7 @@ delete startCliOptions.viewport;
 // 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;
@@ -53,6 +56,12 @@ const y = yargs(hideBin(process.argv))
     .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()
@@ -62,8 +71,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) {
@@ -73,15 +82,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}`);
@@ -97,11 +106,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)) {
@@ -156,9 +166,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)) {
@@ -170,7 +181,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']));
             }

package/build/src/bin/cliDefinitions.js

@@ -84,7 +84,7 @@ export const commands = {
             geolocation: {
                 name: 'geolocation',
                 type: 'string',
-                description: 'Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit clear the geolocation override.',
+                description: 'Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
                 required: false,
             },
             userAgent: {
@@ -124,10 +124,16 @@ export const commands = {
                 description: 'An optional list of arguments to pass to the function.',
                 required: false,
             },
+            dialogAction: {
+                name: 'dialogAction',
+                type: 'string',
+                description: 'Handle dialogs while execution. "accept", "dismiss", or string for response of window.prompt. Defaults to accept.',
+                required: false,
+            },
         },
     },
     fill: {
-        description: 'Type text into a input, text area or select an option from a <select> element.',
+        description: 'Type text into an input, text area or select an option from a <select> element.',
         category: 'Input automation',
         args: {
             uid: {
@@ -175,13 +181,13 @@ export const commands = {
             requestFilePath: {
                 name: 'requestFilePath',
                 type: 'string',
-                description: 'The absolute or relative path to save the request body to. If omitted, the body is returned inline.',
+                description: 'The absolute or relative path to a .network-request file to save the request body to. If omitted, the body is returned inline.',
                 required: false,
             },
             responseFilePath: {
                 name: 'responseFilePath',
                 type: 'string',
-                description: 'The absolute or relative path to save the response body to. If omitted, the body is returned inline.',
+                description: 'The absolute or relative path to a .network-response file to save the response body to. If omitted, the body is returned inline.',
                 required: false,
             },
         },
@@ -258,7 +264,7 @@ export const commands = {
             pageSize: {
                 name: 'pageSize',
                 type: 'integer',
-                description: 'Maximum number of messages to return. When omitted, returns all requests.',
+                description: 'Maximum number of messages to return. When omitted, returns all messages.',
                 required: false,
             },
             pageIdx: {
@@ -314,7 +320,7 @@ export const commands = {
         },
     },
     list_pages: {
-        description: 'Get a list of pages  open in the browser.',
+        description: 'Get a list of pages open in the browser.',
         category: 'Navigation automation',
         args: {},
     },
@@ -504,7 +510,7 @@ export const commands = {
     },
     take_memory_snapshot: {
         description: 'Capture a heap snapshot of the currently selected page. Use to analyze the memory distribution of JavaScript objects and debug memory leaks.',
-        category: 'Performance',
+        category: 'Memory',
         args: {
             filePath: {
                 name: 'filePath',
@@ -535,7 +541,7 @@ export const commands = {
             uid: {
                 name: 'uid',
                 type: 'string',
-                description: 'The uid of an element on the page from the page content snapshot. If omitted takes a pages screenshot.',
+                description: 'The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.',
                 required: false,
             },
             fullPage: {

package/build/src/daemon/client.js

@@ -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) {
@@ -135,7 +135,7 @@ export async function handleResponse(response, format) {
                 case 'image/jpeg':
                     extension = '.jpeg';
                     break;
-                case 'webp':
+                case 'image/webp':
                     extension = '.webp';
                     break;
             }