chrome-devtools-mcp 0.22.0 → 0.23.0

package/README.md

@@ -591,6 +591,10 @@ The Chrome DevTools MCP server supports the following configuration option:
   Exposes experimental screencast tools (requires ffmpeg). Install ffmpeg https://www.ffmpeg.org/download.html and ensure it is available in the MCP server PATH.
   - **Type:** boolean
 
+- **`--experimentalFfmpegPath`/ `--experimental-ffmpeg-path`**
+  Path to ffmpeg executable for screencast recording.
+  - **Type:** string
+
 - **`--experimentalWebmcp`/ `--experimental-webmcp`**
   Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`
   - **Type:** boolean

package/build/src/McpContext.js

@@ -37,7 +37,6 @@ export class McpContext {
     #extensionPages = new WeakMap();
     #extensionServiceWorkerMap = new WeakMap();
     #nextExtensionServiceWorkerId = 1;
-    #nextSnapshotId = 1;
     #traceResults = [];
     #locatorClass;
     #options;
@@ -105,29 +104,6 @@ export class McpContext {
         }
         return this.#networkCollector.getIdForResource(request);
     }
-    resolveCdpElementId(page, cdpBackendNodeId) {
-        if (!cdpBackendNodeId) {
-            this.logger('no cdpBackendNodeId');
-            return;
-        }
-        const snapshot = page.textSnapshot;
-        if (!snapshot) {
-            this.logger('no text snapshot');
-            return;
-        }
-        // TODO: index by backendNodeId instead.
-        const queue = [snapshot.root];
-        while (queue.length) {
-            const current = queue.pop();
-            if (current.backendNodeId === cdpBackendNodeId) {
-                return current.id;
-            }
-            for (const child of current.children) {
-                queue.push(child);
-            }
-        }
-        return;
-    }
     getNetworkRequests(page, includePreservedRequests) {
         return this.#networkCollector.getData(page.pptrPage, includePreservedRequests);
     }
@@ -486,107 +462,6 @@ export class McpContext {
     getIsolatedContextName(page) {
         return this.#mcpPages.get(page)?.isolatedContextName;
     }
-    getDevToolsPage(page) {
-        return this.#mcpPages.get(page)?.devToolsPage;
-    }
-    async getDevToolsData(page) {
-        try {
-            this.logger('Getting DevTools UI data');
-            const devtoolsPage = this.getDevToolsPage(page.pptrPage);
-            if (!devtoolsPage) {
-                this.logger('No DevTools page detected');
-                return {};
-            }
-            const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
-                // @ts-expect-error no types
-                const UI = await import('/bundled/ui/legacy/legacy.js');
-                // @ts-expect-error no types
-                const SDK = await import('/bundled/core/sdk/sdk.js');
-                const request = UI.Context.Context.instance().flavor(SDK.NetworkRequest.NetworkRequest);
-                const node = UI.Context.Context.instance().flavor(SDK.DOMModel.DOMNode);
-                return {
-                    cdpRequestId: request?.requestId(),
-                    cdpBackendNodeId: node?.backendNodeId(),
-                };
-            });
-            return { cdpBackendNodeId, cdpRequestId };
-        }
-        catch (err) {
-            this.logger('error getting devtools data', err);
-        }
-        return {};
-    }
-    /**
-     * Creates a text snapshot of a page.
-     */
-    async createTextSnapshot(page, verbose = false, devtoolsData = undefined) {
-        const rootNode = await page.pptrPage.accessibility.snapshot({
-            includeIframes: true,
-            interestingOnly: !verbose,
-        });
-        if (!rootNode) {
-            return;
-        }
-        const { uniqueBackendNodeIdToMcpId } = page;
-        const snapshotId = this.#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 assignIds = (node) => {
-            let id = '';
-            // @ts-expect-error untyped loaderId & backendNodeId.
-            const uniqueBackendId = `${node.loaderId}_${node.backendNodeId}`;
-            if (uniqueBackendNodeIdToMcpId.has(uniqueBackendId)) {
-                // Re-use MCP exposed ID if the uniqueId is the same.
-                id = uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
-            }
-            else {
-                // Only generate a new ID if we have not seen the node before.
-                id = `${snapshotId}_${idCounter++}`;
-                uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
-            }
-            seenUniqueIds.add(uniqueBackendId);
-            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);
-        const snapshot = {
-            root: rootNodeWithId,
-            snapshotId: String(snapshotId),
-            idToNode,
-            hasSelectedElement: false,
-            verbose,
-        };
-        page.textSnapshot = snapshot;
-        const data = devtoolsData ?? (await this.getDevToolsData(page));
-        if (data?.cdpBackendNodeId) {
-            snapshot.hasSelectedElement = true;
-            snapshot.selectedElementUid = this.resolveCdpElementId(page, 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);
-            }
-        }
-    }
     async saveTemporaryFile(data, filename) {
         return await saveTemporaryFile(data, filename);
     }

package/build/src/McpPage.js

@@ -3,6 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { logger } from './logger.js';
+import { TextSnapshot } from './TextSnapshot.js';
 import { takeSnapshot } from './tools/snapshot.js';
 import { getNetworkMultiplierFromString, WaitForHelper, } from './WaitForHelper.js';
 /**
@@ -19,6 +21,7 @@ export class McpPage {
     // Snapshot
     textSnapshot = null;
     uniqueBackendNodeIdToMcpId = new Map();
+    extraHandles = [];
     // Emulation
     emulationSettings = {};
     // Metadata
@@ -80,6 +83,151 @@ export class McpPage {
     dispose() {
         this.pptrPage.off('dialog', this.#dialogHandler);
     }
+    async executeInPageTool(toolName, params, response) {
+        // Creates array of ElementHandles from the UIDs in the params.
+        // We do not replace the uids with the ElementsHandles yet, because
+        // the `evaluate` function only turns them into DOM elements if they
+        // are passed as non-nested arguments.
+        const handles = [];
+        for (const value of Object.values(params)) {
+            if (value instanceof Object &&
+                'uid' in value &&
+                typeof value.uid === 'string' &&
+                Object.keys(value).length === 1) {
+                handles.push(await this.getElementByUid(value.uid));
+            }
+        }
+        const result = await this.pptrPage.evaluate(async (name, args, ...elements) => {
+            // Replace the UIDs with DOM elements.
+            for (const [key, value] of Object.entries(args)) {
+                if (value instanceof Object &&
+                    'uid' in value &&
+                    typeof value.uid === 'string' &&
+                    Object.keys(value).length === 1) {
+                    args[key] = elements.shift();
+                }
+            }
+            if (!window.__dtmcp?.executeTool) {
+                throw new Error('No tools found on the page');
+            }
+            const toolResult = await window.__dtmcp.executeTool(name, args);
+            const stashDOMElement = (el) => {
+                if (!window.__dtmcp) {
+                    window.__dtmcp = {};
+                }
+                if (window.__dtmcp.stashedElements === undefined) {
+                    window.__dtmcp.stashedElements = [];
+                }
+                window.__dtmcp.stashedElements.push(el);
+                return {
+                    stashedId: `stashed-${window.__dtmcp.stashedElements.length - 1}`,
+                };
+            };
+            const ancestors = [];
+            // Recursively walks the tool result:
+            // - Replaces DOM elements with an ID and stashes the DOM element on the window object
+            // - Replaces non-plain objects with a string representation of the object
+            // - Replaces circular references with the string '<Circular reference>'
+            // - Replaces functions with the string '<Function object>'
+            const processToolResult = (data, parentEl) => {
+                // 1. Handle DOM Elements
+                if (data instanceof Element) {
+                    return stashDOMElement(data);
+                }
+                // 2. Handle Arrays
+                if (Array.isArray(data)) {
+                    return data.map((item) => processToolResult(item, parentEl));
+                }
+                // 3. Handle Objects
+                if (data !== null && typeof data === 'object') {
+                    while (ancestors.length > 0 && ancestors.at(-1) !== parentEl) {
+                        ancestors.pop();
+                    }
+                    if (ancestors.includes(data)) {
+                        return '<Circular reference>';
+                    }
+                    ancestors.push(data);
+                    // If not a plain object, return a string representation of the object
+                    if (Object.getPrototypeOf(data) !== Object.prototype) {
+                        return `<${data.constructor.name} instance>`;
+                    }
+                    const processedObj = {};
+                    for (const [key, value] of Object.entries(data)) {
+                        processedObj[key] = processToolResult(value, data);
+                    }
+                    return processedObj;
+                }
+                // 4. Handle Functions
+                if (typeof data === 'function') {
+                    return '<Function object>';
+                }
+                // 5. Return primitives (strings, numbers, booleans) as-is
+                return data;
+            };
+            return {
+                result: processToolResult(toolResult),
+                stashed: window.__dtmcp?.stashedElements?.length ?? 0,
+            };
+        }, toolName, params, ...handles);
+        const elementHandles = [];
+        for (let i = 0; i < (result.stashed ?? 0); i++) {
+            const elementHandle = await this.pptrPage.evaluateHandle(index => {
+                const el = window.__dtmcp?.stashedElements?.[index];
+                if (!el) {
+                    throw new Error(`Stashed element at index ${index} not found`);
+                }
+                return el;
+            }, i);
+            elementHandles.push(elementHandle);
+        }
+        if (elementHandles.length) {
+            const oldHandles = [...this.extraHandles];
+            this.textSnapshot = await TextSnapshot.create(this, {
+                extraHandles: elementHandles,
+            });
+            response.includeSnapshot();
+            for (const handle of oldHandles) {
+                await handle
+                    .dispose()
+                    .catch(e => logger('Failed to dispose old handle', e));
+            }
+        }
+        const cdpElementIds = await Promise.all(elementHandles.map(async (elementHandle, index) => {
+            const backendNodeId = await elementHandle.backendNodeId();
+            if (!backendNodeId) {
+                logger(`No backendNodeId for stashed DOM element with index ${index}`);
+                return `stashed-${index}`;
+            }
+            const cdpElementId = this.resolveCdpElementId(backendNodeId);
+            if (!cdpElementId) {
+                logger(`Could not get cdpElementId for backend node ${backendNodeId}`);
+                return `stashed-${index}`;
+            }
+            return cdpElementId;
+        }));
+        const recursivelyReplaceStashedElements = (node) => {
+            if (Array.isArray(node)) {
+                return node.map(x => recursivelyReplaceStashedElements(x));
+            }
+            if (node !== null && typeof node === 'object') {
+                if ('stashedId' in node &&
+                    typeof node.stashedId === 'string' &&
+                    node.stashedId.startsWith('stashed-') &&
+                    Object.keys(node).length === 1) {
+                    const index = parseInt(node.stashedId.split('-')[1]);
+                    return { uid: cdpElementIds[index] };
+                }
+                const resultObj = {};
+                for (const [key, value] of Object.entries(node)) {
+                    resultObj[key] = recursivelyReplaceStashedElements(value);
+                }
+                return resultObj;
+            }
+            return node;
+        };
+        const resultWithUids = recursivelyReplaceStashedElements(result.result);
+        response.appendResponseLine(JSON.stringify(resultWithUids, null, 2));
+    }
     async getElementByUid(uid) {
         if (!this.textSnapshot) {
             throw new Error(`No snapshot found for page ${this.id ?? '?'}. Use ${takeSnapshot.name} to capture one.`);
@@ -108,4 +256,54 @@ export class McpPage {
     getAXNodeByUid(uid) {
         return this.textSnapshot?.idToNode.get(uid);
     }
+    resolveCdpElementId(cdpBackendNodeId) {
+        if (!cdpBackendNodeId) {
+            logger('no cdpBackendNodeId');
+            return;
+        }
+        const snapshot = this.textSnapshot;
+        if (!snapshot) {
+            logger('no text snapshot');
+            return;
+        }
+        // TODO: index by backendNodeId instead.
+        const queue = [snapshot.root];
+        while (queue.length) {
+            const current = queue.pop();
+            if (current.backendNodeId === cdpBackendNodeId) {
+                return current.id;
+            }
+            for (const child of current.children) {
+                queue.push(child);
+            }
+        }
+        return;
+    }
+    async getDevToolsData() {
+        try {
+            logger('Getting DevTools UI data');
+            const devtoolsPage = this.devToolsPage;
+            if (!devtoolsPage) {
+                logger('No DevTools page detected');
+                return {};
+            }
+            const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
+                // @ts-expect-error no types
+                const UI = await import('/bundled/ui/legacy/legacy.js');
+                // @ts-expect-error no types
+                const SDK = await import('/bundled/core/sdk/sdk.js');
+                const request = UI.Context.Context.instance().flavor(SDK.NetworkRequest.NetworkRequest);
+                const node = UI.Context.Context.instance().flavor(SDK.DOMModel.DOMNode);
+                return {
+                    cdpRequestId: request?.requestId(),
+                    cdpBackendNodeId: node?.backendNodeId(),
+                };
+            });
+            return { cdpBackendNodeId, cdpRequestId };
+        }
+        catch (err) {
+            logger('error getting devtools data', err);
+        }
+        return {};
+    }
 }

package/build/src/McpResponse.js

@@ -9,6 +9,7 @@ import { IssueFormatter } from './formatters/IssueFormatter.js';
 import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
 import { UncaughtError } from './PageCollector.js';
+import { TextSnapshot } from './TextSnapshot.js';
 import { DevTools } from './third_party/index.js';
 import { handleDialog } from './tools/pages.js';
 import { getInsightOutput, getTraceSummary } from './trace-processing/parse.js';
@@ -299,7 +300,10 @@ export class McpResponse {
             if (!this.#page) {
                 throw new Error('Response must have a page');
             }
-            await context.createTextSnapshot(this.#page, this.#snapshotParams.verbose, this.#devToolsData);
+            this.#page.textSnapshot = await TextSnapshot.create(this.#page, {
+                verbose: this.#snapshotParams.verbose,
+                devtoolsData: this.#devToolsData,
+            });
             const textSnapshot = this.#page.textSnapshot;
             if (textSnapshot) {
                 const formatter = new SnapshotFormatter(textSnapshot);
@@ -349,7 +353,7 @@ export class McpResponse {
                 const formatter = new IssueFormatter(message, {
                     id: consoleMessageStableId,
                     requestIdResolver: context.resolveCdpRequestId.bind(context, this.#page),
-                    elementIdResolver: context.resolveCdpElementId.bind(context, this.#page),
+                    elementIdResolver: this.#page.resolveCdpElementId.bind(this.#page),
                 });
                 if (!formatter.isValid()) {
                     throw new Error("Can't provide details for the msgid " + consoleMessageStableId);

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/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`',