chrome-devtools-mcp 0.25.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/)
 
@@ -161,7 +161,7 @@ To install Chrome DevTools MCP with skills, add the marketplace registry in Clau
 Then, install the plugin:
 
 ```sh
-/plugin install chrome-devtools-mcp
+/plugin install chrome-devtools-mcp@chrome-devtools-plugins
 ```
 
 Restart Claude Code to have the MCP server and skills load (check with `/skills`).
@@ -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

@@ -0,0 +1,217 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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/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) {
+    return `category${category.charAt(0).toUpperCase() + category.slice(1)}`;
+}
+function buildDisabledMessage(toolName, flag, categoryLabel) {
+    const reason = categoryLabel
+        ? `is in category ${categoryLabel} which`
+        : `requires experimental feature ${flag} and`;
+    return `Tool ${toolName} ${reason} is currently disabled. Enable it by running chrome-devtools start ${flag}=true. For more information check the README.`;
+}
+function getCategoryStatus(category, serverArgs) {
+    const categoryFlag = buildFlag(category);
+    const flagValue = serverArgs[categoryFlag];
+    const isDisabled = OFF_BY_DEFAULT_CATEGORIES.includes(category)
+        ? !flagValue
+        : flagValue === false;
+    if (isDisabled) {
+        return {
+            categoryFlag,
+            disabled: true,
+        };
+    }
+    return {
+        disabled: false,
+    };
+}
+function getConditionStatus(condition, serverArgs) {
+    if (condition && !serverArgs[condition]) {
+        return { conditionFlag: condition, disabled: true };
+    }
+    return { disabled: false };
+}
+function getToolStatusInfo(tool, serverArgs) {
+    const category = tool.annotations.category;
+    const categoryCheck = getCategoryStatus(category, serverArgs);
+    if (category && categoryCheck.disabled) {
+        if (!categoryCheck.categoryFlag) {
+            throw new Error('when the category is disabled there should always be a flag set');
+        }
+        return {
+            disabled: true,
+            reason: buildDisabledMessage(tool.name, `--${categoryCheck.categoryFlag}`, labels[category]),
+        };
+    }
+    for (const condition of tool.annotations.conditions || []) {
+        const conditionCheck = getConditionStatus(condition, serverArgs);
+        if (conditionCheck.disabled) {
+            if (!conditionCheck.conditionFlag) {
+                throw new Error('when the condition is disabled there should always be a flag set');
+            }
+            return {
+                disabled: true,
+                reason: buildDisabledMessage(tool.name, `--${conditionCheck.conditionFlag}`),
+            };
+        }
+    }
+    return { disabled: false };
+}
+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) {
+        this.tool = tool;
+        this.serverArgs = serverArgs;
+        this.getContext = getContext;
+        this.toolMutex = toolMutex;
+        const { disabled, reason } = getToolStatusInfo(tool, serverArgs);
+        this.disabledReason = reason;
+        this.shouldRegister = !(disabled && !serverArgs.viaCli);
+        this.inputSchema =
+            'pageScoped' in tool &&
+                tool.pageScoped &&
+                serverArgs.experimentalPageIdRouting &&
+                !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) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: this.disabledReason,
+                    },
+                ],
+                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;
+        try {
+            logger(`${this.tool.name} request: ${JSON.stringify(params, null, '  ')}`);
+            const context = await this.getContext();
+            logger(`${this.tool.name} context: resolved`);
+            await context.detectOpenDevToolsWindows();
+            const response = this.serverArgs.slim
+                ? new SlimMcpResponse(this.serverArgs)
+                : new McpResponse(this.serverArgs);
+            response.setRedactNetworkHeaders(this.serverArgs.redactNetworkHeaders);
+            try {
+                if (isPageScopedTool(this.tool)) {
+                    const pageId = typeof params.pageId === 'number' ? params.pageId : undefined;
+                    const page = this.serverArgs.experimentalPageIdRouting &&
+                        pageId !== undefined &&
+                        !this.serverArgs.slim
+                        ? context.getPageById(pageId)
+                        : context.getSelectedMcpPage();
+                    response.setPage(page);
+                    if (this.tool.blockedByDialog) {
+                        page.throwIfDialogOpen();
+                    }
+                    await this.tool.handler({
+                        params,
+                        page,
+                    }, response, context);
+                }
+                else {
+                    await this.tool.handler({
+                        params,
+                    }, response, context);
+                }
+            }
+            catch (err) {
+                response.setError(err);
+            }
+            const { content, structuredContent } = await response.handle(this.tool.name, context);
+            const result = {
+                content,
+            };
+            if (response.error) {
+                result.isError = true;
+            }
+            success = true;
+            if (this.serverArgs.experimentalStructuredContent) {
+                result.structuredContent = structuredContent;
+            }
+            return result;
+        }
+        catch (err) {
+            logger(`${this.tool.name} error:`, err, err?.stack);
+            let errorText = err && 'message' in err ? err.message : String(err);
+            if ('cause' in err && err.cause) {
+                errorText += `\nCause: ${err.cause.message}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errorText,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        finally {
+            void ClearcutLogger.get()?.logToolInvocation({
+                toolName: this.tool.name,
+                params,
+                schema: this.inputSchema,
+                success,
+                latencyMs: bucketizeLatency(Date.now() - startTime),
+            });
+            guard.dispose();
+        }
+    }
+}
+//# sourceMappingURL=ToolHandler.js.map

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' &&