chrome-devtools-mcp 0.26.0 → 1.0.1

package/README.md

@@ -1,8 +1,8 @@
-# Chrome DevTools for Agents
+# Chrome DevTools for agents
 
 [![npm chrome-devtools-mcp package](https://img.shields.io/npm/v/chrome-devtools-mcp.svg)](https://npmjs.org/package/chrome-devtools-mcp)
 
-Chrome DevTools for Agents (`chrome-devtools-mcp`) lets your coding agent (such as Gemini, Claude, Cursor or Copilot)
+Chrome DevTools for agents (`chrome-devtools-mcp`) lets your coding agent (such as Gemini, Claude, Cursor or Copilot)
 control and inspect a live Chrome browser. It acts as a Model-Context-Protocol
 (MCP) server, giving your AI coding assistant access to the full power of
 Chrome DevTools for reliable automation, in-depth debugging, and performance analysis.
@@ -61,7 +61,7 @@ You can disable these update checks by setting the `CHROME_DEVTOOLS_MCP_NO_UPDAT
 
 ## Requirements
 
-- [Node.js](https://nodejs.org/) v20.19 or a newer [latest maintenance LTS](https://github.com/nodejs/Release#release-schedule) version.
+- [Node.js](https://nodejs.org/) [LTS](https://github.com/nodejs/Release#release-schedule) version.
 - [Chrome](https://www.google.com/chrome/) current stable version or newer.
 - [npm](https://www.npmjs.com/)
 
@@ -514,9 +514,10 @@ If you run into any issues, checkout our [troubleshooting guide](./docs/troubles
   - [`take_snapshot`](docs/tool-reference.md#take_snapshot)
   - [`screencast_start`](docs/tool-reference.md#screencast_start)
   - [`screencast_stop`](docs/tool-reference.md#screencast_stop)
-- **Memory** (4 tools)
+- **Memory** (5 tools)
   - [`take_memory_snapshot`](docs/tool-reference.md#take_memory_snapshot)
   - [`get_memory_snapshot_details`](docs/tool-reference.md#get_memory_snapshot_details)
+  - [`get_node_retainers`](docs/tool-reference.md#get_node_retainers)
   - [`get_nodes_by_class`](docs/tool-reference.md#get_nodes_by_class)
   - [`load_memory_snapshot`](docs/tool-reference.md#load_memory_snapshot)
 - **Extensions** (5 tools)
@@ -595,10 +596,30 @@ The Chrome DevTools MCP server supports the following configuration option:
   If enabled, ignores errors relative to self-signed and expired certificates. Use with caution.
   - **Type:** boolean
 
+- **`--experimentalPageIdRouting`/ `--experimental-page-id-routing`**
+  Whether to expose pageId on page-scoped tools and route requests by page ID (useful for concurrent agent sessions).
+  - **Type:** boolean
+
+- **`--experimentalDevtools`/ `--experimental-devtools`**
+  Whether to enable automation over DevTools targets
+  - **Type:** boolean
+
 - **`--experimentalVision`/ `--experimental-vision`**
   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.
   - **Type:** boolean
 
+- **`--experimentalMemory`/ `--experimental-memory`**
+  Whether to enable experimental memory tools.
+  - **Type:** boolean
+
+- **`--experimentalStructuredContent`/ `--experimental-structured-content`**
+  Whether to output structured formatted content.
+  - **Type:** boolean
+
+- **`--experimentalIncludeAllPages`/ `--experimental-include-all-pages`**
+  Whether to include all kinds of pages such as webviews or background pages as pages.
+  - **Type:** boolean
+
 - **`--experimentalScreencast`/ `--experimental-screencast`**
   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
@@ -659,7 +680,7 @@ The Chrome DevTools MCP server supports the following configuration option:
   - **Type:** boolean
 
 - **`--redactNetworkHeaders`/ `--redact-network-headers`**
-  If true, redacts some of the network headers considered senstive before returning to the client.
+  If true, redacts some of the network headers considered sensitive before returning to the client.
   - **Type:** boolean
   - **Default:** `false`
 
@@ -708,6 +729,34 @@ You can also run `npx chrome-devtools-mcp@latest --help` to see all available co
 
 ## Concepts
 
+### Concurrent sessions
+
+Most MCP clients start one Chrome DevTools MCP server per conversation. If your
+client shares a single server instance across concurrent agents or subagents,
+start the server with `--experimentalPageIdRouting`. This exposes `pageId` on
+page-scoped tools so each agent can route tool calls to the tab it is working
+with.
+
+```json
+{
+  "mcpServers": {
+    "chrome-devtools": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "chrome-devtools-mcp@latest",
+        "--experimentalPageIdRouting"
+      ]
+    }
+  }
+}
+```
+
+If you run multiple independent MCP client sessions and want each session to
+launch its own temporary Chrome profile, also pass `--isolated`. This avoids
+sharing the default Chrome DevTools MCP user data directory between those
+server instances.
+
 ### User data directory
 
 `chrome-devtools-mcp` starts a Chrome's stable channel instance using the following user

package/build/src/DevtoolsUtils.js

@@ -106,6 +106,7 @@ const DEFAULT_FACTORY = async (page) => {
     const connection = new PuppeteerDevToolsConnection(session);
     const targetManager = universe.context.get(DevTools.TargetManager);
     targetManager.observeModels(DevTools.DebuggerModel, SKIP_ALL_PAUSES);
+    targetManager.observeModels(DevTools.NetworkManager.NetworkManager, DISABLE_NETWORK);
     const target = targetManager.createTarget('main', '', 'frame', // eslint-disable-line @typescript-eslint/no-explicit-any
     /* parentTarget */ null, session.id(), undefined, connection);
     return { target, universe };
@@ -123,6 +124,18 @@ const SKIP_ALL_PAUSES = {
         // Do nothing.
     },
 };
+// Not recording network requests in the DevTools universe.
+//
+// The network requests are collected through pptr and there isn't a use case for
+// enabling devtools SDK's network domain.
+const DISABLE_NETWORK = {
+    modelAdded(model) {
+        void model.target().networkAgent().invoke_disable();
+    },
+    modelRemoved() {
+        // Do nothing.
+    },
+};
 /**
  * Constructed from Runtime.ExceptionDetails of an uncaught error.
  *

package/build/src/HeapSnapshotManager.js

@@ -5,6 +5,7 @@
  */
 import fsSync from 'node:fs';
 import path from 'node:path';
+import { isNodeLike } from './formatters/HeapSnapshotFormatter.js';
 import { DevTools } from './third_party/index.js';
 import { createIdGenerator, stableIdSymbol, } from './utils/id.js';
 export class HeapSnapshotManager {
@@ -64,8 +65,31 @@ export class HeapSnapshotManager {
             throw new Error(`Class with UID ${uid} not found in heap snapshot`);
         }
         const provider = snapshot.createNodesProviderForClass(className, filter);
-        const range = await provider.serializeItemsRange(0, 1);
-        return await provider.serializeItemsRange(0, range.totalLength);
+        return await provider.serializeItemsRange(0, Infinity);
+    }
+    async findNodeIndexById(filePath, nodeId) {
+        const snapshot = await this.getSnapshot(filePath);
+        const aggregates = await this.getAggregates(filePath);
+        const filter = new DevTools.HeapSnapshotModel.HeapSnapshotModel.NodeFilter();
+        for (const classKey of Object.keys(aggregates)) {
+            const provider = snapshot.createNodesProviderForClass(classKey, filter);
+            const range = await provider.serializeItemsRange(0, Infinity);
+            for (const item of range.items) {
+                if (isNodeLike(item) && item.id === nodeId) {
+                    return item.nodeIndex;
+                }
+            }
+        }
+        return undefined;
+    }
+    async getRetainers(filePath, nodeId) {
+        const nodeIndex = await this.findNodeIndexById(filePath, nodeId);
+        if (nodeIndex === undefined) {
+            throw new Error(`Node with ID ${nodeId} not found`);
+        }
+        const snapshot = await this.getSnapshot(filePath);
+        const provider = snapshot.createRetainingEdgesProvider(nodeIndex);
+        return await provider.serializeItemsRange(0, Infinity);
     }
     #getCachedSnapshot(filePath) {
         const absolutePath = path.resolve(filePath);

package/build/src/McpContext.js

@@ -601,5 +601,8 @@ export class McpContext {
         this.validatePath(filePath);
         return await this.#heapSnapshotManager.getNodesByUid(filePath, uid);
     }
+    async getHeapSnapshotRetainers(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getRetainers(filePath, nodeId);
+    }
 }
 //# sourceMappingURL=McpContext.js.map

package/build/src/McpResponse.js

@@ -5,7 +5,7 @@
  */
 import { ConsoleFormatter } from './formatters/ConsoleFormatter.js';
 import { HeapSnapshotFormatter } from './formatters/HeapSnapshotFormatter.js';
-import { isNodeLike } from './formatters/HeapSnapshotFormatter.js';
+import { isEdgeLike, isNodeLike } from './formatters/HeapSnapshotFormatter.js';
 import { IssueFormatter } from './formatters/IssueFormatter.js';
 import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
@@ -99,7 +99,7 @@ async function getToolGroup(page) {
             window.dispatchEvent(event);
             // If the page does not synchronously call `event.respondWith`, return instead of timing out
             setTimeout(() => {
-                resolve(undefined);
+                resolve(null);
             }, 0);
         });
     });
@@ -133,6 +133,7 @@ export class McpResponse {
     #page;
     #redactNetworkHeaders = true;
     #error;
+    #attachedWaitForResult;
     constructor(args) {
         this.#args = args;
     }
@@ -164,9 +165,7 @@ export class McpResponse {
         this.#listExtensions = true;
     }
     setListThirdPartyDeveloperTools() {
-        if (this.#args.categoryExperimentalThirdParty) {
-            this.#listThirdPartyDeveloperTools = true;
-        }
+        this.#listThirdPartyDeveloperTools = true;
     }
     setListWebMcpTools() {
         this.#listWebMcpTools = true;
@@ -265,6 +264,9 @@ export class McpResponse {
     appendResponseLine(value) {
         this.#textResponseLines.push(value);
     }
+    attachWaitForResult(result) {
+        this.#attachedWaitForResult = result;
+    }
     setHeapSnapshotAggregates(aggregates, options) {
         this.#heapSnapshotOptions = {
             ...this.#heapSnapshotOptions,
@@ -381,16 +383,21 @@ export class McpResponse {
         if (this.#listExtensions) {
             extensions = await context.listExtensions();
         }
+        // Null indicates no tools.
         let thirdPartyDeveloperTools;
-        if (this.#listThirdPartyDeveloperTools) {
-            const page = this.#page ?? context.getSelectedMcpPage();
-            thirdPartyDeveloperTools = await getToolGroup(page);
-            page.thirdPartyDeveloperTools = thirdPartyDeveloperTools;
+        if (this.#args.categoryExperimentalThirdParty &&
+            this.#listThirdPartyDeveloperTools &&
+            this.#page) {
+            thirdPartyDeveloperTools = await getToolGroup(this.#page);
+            if (thirdPartyDeveloperTools) {
+                this.#page.thirdPartyDeveloperTools = thirdPartyDeveloperTools;
+            }
         }
         let webmcpTools;
-        if (this.#listWebMcpTools && this.#args.categoryExperimentalWebmcp) {
-            const page = this.#page ?? context.getSelectedMcpPage();
-            webmcpTools = page.getWebMcpTools();
+        if (this.#args.categoryExperimentalWebmcp &&
+            this.#listWebMcpTools &&
+            this.#page) {
+            webmcpTools = this.#page.getWebMcpTools();
         }
         let consoleMessages;
         if (this.#consoleDataOptions?.include) {
@@ -481,6 +488,13 @@ export class McpResponse {
             structuredContent.message = this.#textResponseLines.join('\n');
             response.push(...this.#textResponseLines);
         }
+        if (this.#attachedWaitForResult) {
+            if (this.#attachedWaitForResult.navigatedToUrl) {
+                response.push(`Page navigated to ${this.#attachedWaitForResult.navigatedToUrl}.`);
+                structuredContent.navigatedToUrl =
+                    this.#attachedWaitForResult.navigatedToUrl;
+            }
+        }
         const networkConditions = this.#page?.networkConditions;
         if (networkConditions) {
             const timeout = this.#page.pptrPage.getDefaultNavigationTimeout();
@@ -489,6 +503,11 @@ export class McpResponse {
             structuredContent.networkConditions = networkConditions;
             structuredContent.navigationTimeout = timeout;
         }
+        const geolocation = this.#page?.geolocation;
+        if (geolocation) {
+            response.push(`Emulating geolocation: latitude=${geolocation.latitude}, longtitude=${geolocation.longitude}`);
+            structuredContent.geolocation = geolocation;
+        }
         const viewport = this.#page?.viewport;
         if (viewport) {
             response.push(`Emulating viewport: ${JSON.stringify(viewport)}`);
@@ -664,10 +683,19 @@ Call ${handleDialog.name} to handle it before continuing.`);
             }
             const nodes = this.#heapSnapshotOptions.nodes;
             if (nodes) {
-                const sortedItems = nodes.items
-                    .filter(isNodeLike)
-                    .sort((a, b) => b.retainedSize - a.retainedSize);
-                const paginationData = this.#dataWithPagination(sortedItems, this.#heapSnapshotOptions.pagination);
+                let items = Array.from(nodes.items);
+                const firstItem = nodes.items[0];
+                if (firstItem) {
+                    if (isNodeLike(firstItem)) {
+                        items = items
+                            .filter(isNodeLike)
+                            .sort((a, b) => b.retainedSize - a.retainedSize);
+                    }
+                    else if (isEdgeLike(firstItem)) {
+                        items = items.filter(isEdgeLike);
+                    }
+                }
+                const paginationData = this.#dataWithPagination(items, this.#heapSnapshotOptions.pagination);
                 response.push(HeapSnapshotFormatter.formatNodes(paginationData.items));
                 structuredContent.pagination = paginationData.pagination;
                 response.push(...paginationData.info);
@@ -700,12 +728,14 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(extensionsMessage);
             }
         }
-        if (this.#listThirdPartyDeveloperTools) {
-            structuredContent.thirdPartyDeveloperTools =
-                data.thirdPartyDeveloperTools ?? undefined;
+        if (data.thirdPartyDeveloperTools !== undefined) {
+            if (data.thirdPartyDeveloperTools) {
+                structuredContent.thirdPartyDeveloperTools =
+                    data.thirdPartyDeveloperTools;
+            }
             response.push('## Third-party developer tools');
-            if (!data.thirdPartyDeveloperTools ||
-                !data.thirdPartyDeveloperTools.tools) {
+            if (data.thirdPartyDeveloperTools === null ||
+                !data.thirdPartyDeveloperTools?.tools) {
                 response.push('No third-party developer tools available.');
             }
             else {

package/build/src/ToolHandler.js

@@ -7,7 +7,8 @@ import { logger } from './logger.js';
 import { McpResponse } from './McpResponse.js';
 import { SlimMcpResponse } from './SlimMcpResponse.js';
 import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
-import { bucketizeLatency } from './telemetry/metricUtils.js';
+import { bucketizeLatency } from './telemetry/transformation.js';
+import { zod } from './third_party/index.js';
 import { labels, OFF_BY_DEFAULT_CATEGORIES } from './tools/categories.js';
 import { pageIdSchema } from './tools/ToolDefinition.js';
 export function buildFlag(category) {
@@ -70,12 +71,24 @@ function getToolStatusInfo(tool, serverArgs) {
 function isPageScopedTool(tool) {
     return 'pageScoped' in tool && tool.pageScoped === true;
 }
+function formatArgumentNames(names) {
+    return names.map(name => `"${name}"`).join(', ');
+}
+function buildUnknownArgumentsMessage(toolName, unknownArgumentNames, expectedArgumentNames) {
+    const unknownLabel = unknownArgumentNames.length === 1 ? 'argument' : 'arguments';
+    const expectedArguments = expectedArgumentNames.length
+        ? `Expected arguments: ${formatArgumentNames(expectedArgumentNames)}.`
+        : 'This tool does not accept any arguments.';
+    const correction = unknownArgumentNames.length === 1 ? 'Remove it' : 'Remove them';
+    return `Unknown ${unknownLabel} for tool "${toolName}": ${formatArgumentNames(unknownArgumentNames)}. ${expectedArguments} ${correction} and retry.`;
+}
 export class ToolHandler {
     tool;
     serverArgs;
     getContext;
     toolMutex;
     inputSchema;
+    registeredInputSchema;
     shouldRegister;
     disabledReason;
     constructor(tool, serverArgs, getContext, toolMutex) {
@@ -93,6 +106,10 @@ export class ToolHandler {
                 !serverArgs.slim
                 ? { ...tool.schema, ...pageIdSchema }
                 : tool.schema;
+        this.registeredInputSchema = zod.object(this.inputSchema).passthrough();
+    }
+    unknownArgumentNames(params) {
+        return Object.keys(params).filter(key => !Object.hasOwn(this.inputSchema, key));
     }
     async handle(params) {
         if (this.disabledReason) {
@@ -106,6 +123,18 @@ export class ToolHandler {
                 isError: true,
             };
         }
+        const unknownArgumentNames = this.unknownArgumentNames(params);
+        if (unknownArgumentNames.length) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: buildUnknownArgumentsMessage(this.tool.name, unknownArgumentNames, Object.keys(this.inputSchema)),
+                    },
+                ],
+                isError: true,
+            };
+        }
         const guard = await this.toolMutex.acquire();
         const startTime = Date.now();
         let success = false;

package/build/src/WaitForHelper.js

@@ -11,12 +11,15 @@ export class WaitForHelper {
     #stableDomFor;
     #expectNavigationIn;
     #navigationTimeout;
+    #dialogOpened = false;
+    #initialUrl;
     constructor(page, cpuTimeoutMultiplier, networkTimeoutMultiplier) {
         this.#stableDomTimeout = 3000 * cpuTimeoutMultiplier;
         this.#stableDomFor = 100 * cpuTimeoutMultiplier;
         this.#expectNavigationIn = 100 * cpuTimeoutMultiplier;
         this.#navigationTimeout = 3000 * networkTimeoutMultiplier;
         this.#page = page;
+        this.#initialUrl = page.url();
     }
     /**
      * A wrapper that executes a action and waits for
@@ -104,10 +107,12 @@ export class WaitForHelper {
         });
     }
     async waitForEventsAfterAction(action, options) {
-        let dialogOpened = false;
+        if (this.#abortController.signal.aborted) {
+            throw new Error("Can't re-use a WaitForHelper");
+        }
         if (options?.handleDialog) {
             const dialogHandler = (dialog) => {
-                dialogOpened = true;
+                this.#dialogOpened = true;
                 if (options.handleDialog === 'dismiss') {
                     void dialog.dismiss();
                 }
@@ -144,8 +149,8 @@ export class WaitForHelper {
         }
         try {
             await navigationFinished;
-            if (dialogOpened) {
-                return;
+            if (this.#dialogOpened) {
+                return this.#getResult();
             }
             // Wait for stable dom after navigation so we execute in
             // the correct context
@@ -157,6 +162,15 @@ export class WaitForHelper {
         finally {
             this.#abortController.abort();
         }
+        return this.#getResult();
+    }
+    #getResult() {
+        const urlAfterAction = this.#page.url();
+        return {
+            ...(urlAfterAction !== this.#initialUrl
+                ? { navigatedToUrl: urlAfterAction }
+                : {}),
+        };
     }
 }
 export function getNetworkMultiplierFromString(condition) {

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

@@ -3,13 +3,37 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { execSync } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+function getRegistry() {
+    // Use the user's configured npm registry so update checks work behind
+    // corporate proxies and private registries. `npm config get registry`
+    // honors .npmrc files at every scope and respects npm_config_registry,
+    // so it covers direct CLI invocations as well as `npx` / `npm run`.
+    try {
+        const registry = execSync('npm config get registry', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+        })
+            .trim()
+            .replace(/\/$/, '');
+        if (registry && registry !== 'undefined' && /^https?:\/\//.test(registry)) {
+            return registry;
+        }
+    }
+    catch {
+        // npm not on PATH or other errors, fall back to default.
+    }
+    return DEFAULT_REGISTRY;
+}
 const cachePath = process.argv[2];
 if (cachePath) {
     try {
-        const response = await fetch('https://registry.npmjs.org/chrome-devtools-mcp/latest');
+        const response = await fetch(`${getRegistry()}/chrome-devtools-mcp/latest`);
         const data = response.ok ? await response.json() : null;
         if (data &&
             typeof data === 'object' &&

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

@@ -114,7 +114,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 to clear the geolocation override.',
+                description: 'Geolocation (`<latitude>,<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
                 required: false,
             },
             userAgent: {
@@ -154,6 +154,12 @@ export const commands = {
                 description: 'An optional list of arguments to pass to the function.',
                 required: false,
             },
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'The absolute or relative path to a file to save the script output to. If omitted, the output is returned inline.',
+                required: false,
+            },
             dialogAction: {
                 name: 'dialogAction',
                 type: 'string',
@@ -282,6 +288,36 @@ export const commands = {
             },
         },
     },
+    get_node_retainers: {
+        description: 'Loads a memory heapsnapshot and returns retainers for a specific node ID. (requires flag: --experimentalMemory=true)',
+        category: 'Memory',
+        args: {
+            filePath: {
+                name: 'filePath',
+                type: 'string',
+                description: 'A path to a .heapsnapshot file to read.',
+                required: true,
+            },
+            nodeId: {
+                name: 'nodeId',
+                type: 'number',
+                description: 'The stable node ID to get retainers for.',
+                required: true,
+            },
+            pageIdx: {
+                name: 'pageIdx',
+                type: 'number',
+                description: 'The page index for pagination.',
+                required: false,
+            },
+            pageSize: {
+                name: 'pageSize',
+                type: 'number',
+                description: 'The page size for pagination.',
+                required: false,
+            },
+        },
+    },
     get_nodes_by_class: {
         description: 'Loads a memory heapsnapshot and returns instances of a specific class with their stable IDs. (requires flag: --experimentalMemory=true)',
         category: 'Memory',

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

@@ -136,33 +136,27 @@ export const cliOptions = {
     },
     experimentalPageIdRouting: {
         type: 'boolean',
-        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID.',
-        hidden: true,
+        describe: 'Whether to expose pageId on page-scoped tools and route requests by page ID (useful for concurrent agent sessions).',
     },
     experimentalDevtools: {
         type: 'boolean',
         describe: 'Whether to enable automation over DevTools targets',
-        hidden: true,
     },
     experimentalVision: {
         type: 'boolean',
         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: {
         type: 'boolean',
         describe: 'Whether to output structured formatted content.',
-        hidden: true,
     },
     experimentalIncludeAllPages: {
         type: 'boolean',
         describe: 'Whether to include all kinds of pages such as webviews or background pages as pages.',
-        hidden: true,
     },
     experimentalNavigationAllowlist: {
         type: 'boolean',
@@ -257,7 +251,7 @@ export const cliOptions = {
     },
     redactNetworkHeaders: {
         type: 'boolean',
-        describe: 'If true, redacts some of the network headers considered senstive before returning to the client.',
+        describe: 'If true, redacts some of the network headers considered sensitive before returning to the client.',
         default: false,
     },
 };

package/build/src/daemon/client.js

@@ -115,13 +115,8 @@ export async function handleResponse(response, format) {
     if (response.isError) {
         return JSON.stringify(response.content);
     }
-    if (format === 'json') {
-        if (response.structuredContent) {
-            return JSON.stringify(response.structuredContent);
-        }
-        // Fall-through to text for backward compatibility.
-    }
     const chunks = [];
+    const images = [];
     for (const content of response.content) {
         if (content.type === 'text') {
             chunks.push(content.text);
@@ -143,12 +138,23 @@ export async function handleResponse(response, format) {
             const name = crypto.randomUUID();
             const filepath = await getTempFilePath(`${name}${extension}`);
             fs.writeFileSync(filepath, data);
+            images.push({ filePath: filepath, mimeType });
             chunks.push(`Saved to ${filepath}.`);
         }
         else {
             throw new Error('Not supported response content type');
         }
     }
+    if (format === 'json') {
+        if (response.structuredContent) {
+            const structuredContent = {
+                ...response.structuredContent,
+                ...(images.length ? { images } : {}),
+            };
+            return JSON.stringify(structuredContent);
+        }
+        // Fall-through to text for backward compatibility.
+    }
     return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
 }
 //# sourceMappingURL=client.js.map