brave-mcp 0.5.0 → 1.2.0

package/README.md

@@ -38,7 +38,7 @@ You can explicitly enable them with `--usage-statistics` if desired.
 
 ## 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.
 - [Brave Browser](https://brave.com/) current release version or newer.
 - [npm](https://www.npmjs.com/)
 
@@ -279,7 +279,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`).
@@ -367,7 +367,7 @@ and the expert guidance it needs to use them effectively.
 
 1.  Open the **Command Palette** (`Cmd+Shift+P` on macOS or `Ctrl+Shift+P` on Windows/Linux).
 2.  Search for and run the **Chat: Install Plugin From Source** command.
-3.  Paste in our repository URL: `https://github.com/ChromeDevTools/chrome-devtools-mcp`
+3.  Paste in our repository name: `ChromeDevTools/chrome-devtools-mcp`.
 
 That's it! Your agent is now supercharged with Chrome DevTools capabilities.
 
@@ -632,11 +632,14 @@ 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)
-  - [`take_memory_snapshot`](docs/tool-reference.md#take_memory_snapshot)
-  - [`get_memory_snapshot_details`](docs/tool-reference.md#get_memory_snapshot_details)
-  - [`get_nodes_by_class`](docs/tool-reference.md#get_nodes_by_class)
-  - [`load_memory_snapshot`](docs/tool-reference.md#load_memory_snapshot)
+- **Memory** (7 tools)
+  - [`take_heapsnapshot`](docs/tool-reference.md#take_heapsnapshot)
+  - [`close_heapsnapshot`](docs/tool-reference.md#close_heapsnapshot)
+  - [`get_heapsnapshot_class_nodes`](docs/tool-reference.md#get_heapsnapshot_class_nodes)
+  - [`get_heapsnapshot_details`](docs/tool-reference.md#get_heapsnapshot_details)
+  - [`get_heapsnapshot_retainers`](docs/tool-reference.md#get_heapsnapshot_retainers)
+  - [`get_heapsnapshot_retaining_paths`](docs/tool-reference.md#get_heapsnapshot_retaining_paths)
+  - [`get_heapsnapshot_summary`](docs/tool-reference.md#get_heapsnapshot_summary)
 - **Extensions** (5 tools)
   - [`install_extension`](docs/tool-reference.md#install_extension)
   - [`list_extensions`](docs/tool-reference.md#list_extensions)
@@ -713,10 +716,30 @@ The Brave DevTools MCP server supports the following configuration options:
   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
 
+- **`--memoryDebugging`/ `--memory-debugging`, `-experimentalMemory`**
+  Whether to enable memory debugging 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
@@ -733,6 +756,14 @@ The Brave DevTools MCP server supports the following configuration options:
   Additional arguments for Brave. Only applies when Brave is launched by brave-devtools-mcp.
   - **Type:** array
 
+- **`--blockedUrlPattern`/ `--blocked-url-pattern`**
+  Restricts network access by blocking specified URL patterns (uses https://urlpattern.spec.whatwg.org/). Silently detaches from targets with blocked URLs upon connection, and blocks runtime requests (including navigations and subresources). Accepts an array of patterns.
+  - **Type:** array
+
+- **`--allowedUrlPattern`/ `--allowed-url-pattern`**
+  Restricts network access by allowing only specified URL patterns (uses https://urlpattern.spec.whatwg.org/). Requires Chrome 149+. Silently detaches from targets with unallowed URLs upon connection, and blocks runtime requests (including navigations and subresources). Accepts an array of patterns.
+  - **Type:** array
+
 - **`--ignoreDefaultBraveArg`/ `--ignore-default-brave-arg`**
   Explicitly disable default arguments for Brave. Only applies when Brave is launched by brave-devtools-mcp.
   - **Type:** array
@@ -777,7 +808,7 @@ The Brave DevTools MCP server supports the following configuration options:
   - **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`
 
@@ -826,6 +857,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
 
 `brave-devtools-mcp` starts a Brave release channel instance using the following user

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 {
@@ -19,8 +20,8 @@ export class HeapSnapshotManager {
         this.#snapshots.set(absolutePath, {
             snapshot,
             worker,
-            uidToClassKey: new Map(),
-            classKeyToUid: new Map(),
+            idToClassKey: new Map(),
+            classKeyToId: new Map(),
             idGenerator: createIdGenerator(),
         });
         return snapshot;
@@ -30,10 +31,10 @@ export class HeapSnapshotManager {
         const filter = new DevTools.HeapSnapshotModel.HeapSnapshotModel.NodeFilter();
         const aggregates = await snapshot.aggregatesWithFilter(filter);
         for (const key of Object.keys(aggregates)) {
-            const uid = await this.getOrCreateUidForClassKey(filePath, key);
+            const id = await this.getOrCreateIdForClassKey(filePath, key);
             const aggregate = aggregates[key];
             if (aggregate) {
-                aggregate[stableIdSymbol] = uid;
+                aggregate[stableIdSymbol] = id;
             }
         }
         return aggregates;
@@ -46,26 +47,57 @@ export class HeapSnapshotManager {
         const snapshot = await this.getSnapshot(filePath);
         return snapshot.staticData;
     }
-    async getOrCreateUidForClassKey(filePath, classKey) {
+    async getOrCreateIdForClassKey(filePath, classKey) {
         const cached = this.#getCachedSnapshot(filePath);
-        let uid = cached.classKeyToUid.get(classKey);
-        if (!uid) {
-            uid = cached.idGenerator();
-            cached.classKeyToUid.set(classKey, uid);
-            cached.uidToClassKey.set(uid, classKey);
+        let id = cached.classKeyToId.get(classKey);
+        if (!id) {
+            id = cached.idGenerator();
+            cached.classKeyToId.set(classKey, id);
+            cached.idToClassKey.set(id, classKey);
         }
-        return uid;
+        return id;
     }
-    async getNodesByUid(filePath, uid) {
+    async getNodesById(filePath, id) {
         const snapshot = await this.getSnapshot(filePath);
         const filter = new DevTools.HeapSnapshotModel.HeapSnapshotModel.NodeFilter();
-        const className = await this.resolveClassKeyFromUid(filePath, uid);
+        const className = await this.resolveClassKeyFromId(filePath, id);
         if (!className) {
-            throw new Error(`Class with UID ${uid} not found in heap snapshot`);
+            throw new Error(`Class with ID ${id} 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);
+    }
+    async getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
+        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);
+        return await snapshot.getRetainingPaths(nodeIndex, maxDepth, maxNodes, maxSiblings);
     }
     #getCachedSnapshot(filePath) {
         const absolutePath = path.resolve(filePath);
@@ -75,9 +107,9 @@ export class HeapSnapshotManager {
         }
         return cached;
     }
-    async resolveClassKeyFromUid(filePath, uid) {
+    async resolveClassKeyFromId(filePath, id) {
         const cached = this.#getCachedSnapshot(filePath);
-        return cached.uidToClassKey.get(uid);
+        return cached.idToClassKey.get(id);
     }
     async #loadSnapshot(absolutePath) {
         const workerProxy = new DevTools.HeapSnapshotModel.HeapSnapshotProxy.HeapSnapshotWorkerProxy(() => {
@@ -98,13 +130,18 @@ export class HeapSnapshotManager {
         const snapshot = await snapshotPromise;
         return { snapshot, worker: workerProxy };
     }
+    hasSnapshots() {
+        return this.#snapshots.size > 0;
+    }
     dispose(filePath) {
         const absolutePath = path.resolve(filePath);
         const cached = this.#snapshots.get(absolutePath);
         if (cached) {
             cached.worker.dispose();
             this.#snapshots.delete(absolutePath);
+            return true;
         }
+        return false;
     }
 }
 //# sourceMappingURL=HeapSnapshotManager.js.map

package/build/src/McpContext.js

@@ -4,17 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import fs from 'node:fs/promises';
+import fsPromises from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { UniverseManager } from './DevtoolsUtils.js';
+import { overrideDevToolsGlobals, UniverseManager, } from './devtools/DevtoolsUtils.js';
 import { HeapSnapshotManager } from './HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
+import { ServiceWorkerConsoleCollector } from './ServiceWorkerCollector.js';
 import { Locator, PredefinedNetworkConditions, } from './third_party/index.js';
 import { listPages } from './tools/pages.js';
 import { CLOSE_PAGE_ERROR } from './tools/ToolDefinition.js';
-import { ensureExtension, getTempFilePath } from './utils/files.js';
+import { ensureExtension, getTempFilePath, resolveCanonicalPath, } from './utils/files.js';
 import { getNetworkMultiplierFromString } from './WaitForHelper.js';
 const DEFAULT_TIMEOUT = 5_000;
 const NAVIGATION_TIMEOUT = 10_000;
@@ -32,6 +34,7 @@ export class McpContext {
     #networkCollector;
     #consoleCollector;
     #devtoolsUniverseManager;
+    #serviceWorkerConsoleCollector;
     #isRunningTrace = false;
     #screenRecorderData = null;
     #nextPageId = 1;
@@ -44,6 +47,7 @@ export class McpContext {
     #heapSnapshotManager = new HeapSnapshotManager();
     #roots = undefined;
     constructor(browser, logger, options, locatorClass) {
+        overrideDevToolsGlobals();
         this.browser = browser;
         this.logger = logger;
         this.#locatorClass = locatorClass;
@@ -62,19 +66,22 @@ export class McpContext {
                 },
             };
         });
+        this.#serviceWorkerConsoleCollector = new ServiceWorkerConsoleCollector(this.browser);
         this.#devtoolsUniverseManager = new UniverseManager(this.browser);
     }
     async #init() {
         const pages = await this.createPagesSnapshot();
-        await this.createExtensionServiceWorkersSnapshot();
+        const workers = await this.createExtensionServiceWorkersSnapshot();
         await this.#networkCollector.init(pages);
         await this.#consoleCollector.init(pages);
         await this.#devtoolsUniverseManager.init(pages);
+        await this.#serviceWorkerConsoleCollector.init(workers);
     }
     dispose() {
         this.#networkCollector.dispose();
         this.#consoleCollector.dispose();
         this.#devtoolsUniverseManager.dispose();
+        this.#serviceWorkerConsoleCollector.dispose();
         for (const mcpPage of this.#mcpPages.values()) {
             mcpPage.dispose();
         }
@@ -106,7 +113,7 @@ export class McpContext {
     setRoots(roots) {
         this.#roots = roots;
     }
-    validatePath(filePath) {
+    async validatePath(filePath) {
         if (filePath === undefined) {
             return;
         }
@@ -114,19 +121,40 @@ export class McpContext {
         if (roots === undefined) {
             return;
         }
-        const absolutePath = path.resolve(filePath);
+        let canonicalPath;
+        try {
+            canonicalPath = await resolveCanonicalPath(filePath);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            console.error(`[MCP Context] Error resolving real path for ${filePath}: ${errMsg}`);
+            throw new Error(`Access denied: Cannot resolve base path for ${filePath}.`);
+        }
+        let allowed = false;
         for (const root of roots) {
-            const rootPath = path.resolve(fileURLToPath(root.uri));
-            if (absolutePath === rootPath ||
-                absolutePath.startsWith(rootPath + path.sep)) {
-                return;
+            try {
+                const rootPathUri = root.uri;
+                const rootPath = path.resolve(fileURLToPath(rootPathUri));
+                const canonicalRoot = await fsPromises.realpath(rootPath);
+                if (canonicalPath === canonicalRoot ||
+                    canonicalPath.startsWith(canonicalRoot + path.sep)) {
+                    allowed = true;
+                    break;
+                }
+            }
+            catch (rootErr) {
+                const errMsg = rootErr instanceof Error ? rootErr.message : String(rootErr);
+                console.warn(`[MCP Context] Could not resolve configured root ${root.uri}: ${errMsg}`);
+                // Skip this root if it cannot be resolved.
             }
         }
-        throw new Error(`Access denied: path ${filePath} is not within any of the workspace roots ${JSON.stringify(roots)}.`);
+        if (!allowed) {
+            throw new Error(`Access denied: path ${filePath} (canonical: ${canonicalPath}) is not within any of the configured workspace roots.`);
+        }
     }
     resolveCdpRequestId(page, cdpRequestId) {
         if (!cdpRequestId) {
-            this.logger('no network request');
+            this.logger?.('no network request');
             return;
         }
         const request = this.#networkCollector.find(page.pptrPage, request => {
@@ -134,7 +162,7 @@ export class McpContext {
             return request.id === cdpRequestId;
         });
         if (!request) {
-            this.logger('no network request for ' + cdpRequestId);
+            this.logger?.('no network request for ' + cdpRequestId);
             return;
         }
         return this.#networkCollector.getIdForResource(request);
@@ -195,7 +223,13 @@ export class McpContext {
         const page = targetPage ?? this.getSelectedPptrPage();
         const mcpPage = this.#getMcpPage(page);
         const newSettings = { ...mcpPage.emulationSettings };
-        if (!options.networkConditions) {
+        // Skip network emulation if blocklist/allowlist is configured, as it conflicts with blocking rules in Puppeteer.
+        if (this.#options.hasNetworkBlockOrAllowlist) {
+            if (options.networkConditions !== undefined) {
+                throw new Error('Network throttling is not supported when network blocking (allowlist/blocklist) is configured.');
+            }
+        }
+        else if (!options.networkConditions) {
             await page.emulateNetworkConditions(null);
             delete newSettings.networkConditions;
         }
@@ -213,12 +247,23 @@ export class McpContext {
             await page.emulateNetworkConditions(networkCondition);
             newSettings.networkConditions = options.networkConditions;
         }
+        const secondarySession = this.getDevToolsUniverse(mcpPage)?.session;
         if (!options.cpuThrottlingRate) {
             await page.emulateCPUThrottling(1);
+            if (secondarySession) {
+                await secondarySession.send('Emulation.setCPUThrottlingRate', {
+                    rate: 1,
+                });
+            }
             delete newSettings.cpuThrottlingRate;
         }
         else {
             await page.emulateCPUThrottling(options.cpuThrottlingRate);
+            if (secondarySession) {
+                await secondarySession.send('Emulation.setCPUThrottlingRate', {
+                    rate: options.cpuThrottlingRate,
+                });
+            }
             newSettings.cpuThrottlingRate = options.cpuThrottlingRate;
         }
         if (!options.geolocation) {
@@ -250,7 +295,6 @@ export class McpContext {
             newSettings.colorScheme = options.colorScheme;
         }
         if (!options.viewport) {
-            await page.setViewport(null);
             delete newSettings.viewport;
         }
         else {
@@ -260,14 +304,22 @@ export class McpContext {
                 hasTouch: false,
                 isLandscape: false,
             };
-            const viewport = { ...defaults, ...options.viewport };
-            await page.setViewport(viewport);
-            newSettings.viewport = viewport;
+            newSettings.viewport = { ...defaults, ...options.viewport };
+        }
+        if (options.extraHttpHeaders !== undefined) {
+            await page.setExtraHTTPHeaders(options.extraHttpHeaders);
+            newSettings.extraHttpHeaders = options.extraHttpHeaders;
+            if (Object.keys(options.extraHttpHeaders).length === 0) {
+                delete newSettings.extraHttpHeaders;
+            }
         }
         mcpPage.emulationSettings = Object.keys(newSettings).length
             ? newSettings
             : {};
         this.#updateSelectedPageTimeouts();
+        // This should happen after updating the page timeouts.
+        // Setting the viewport can trigger a reload which we don't want to timeout.
+        await page.setViewport(newSettings.viewport ?? null);
     }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
@@ -333,9 +385,9 @@ export class McpContext {
         page.pptrPage.setDefaultTimeout(DEFAULT_TIMEOUT * cpuMultiplier);
         // 10sec should be enough for the load event to be emitted during
         // navigations.
-        // Increased in case we throttle the network requests
+        // Increased in case we throttle the network requests or the CPU
         const networkMultiplier = getNetworkMultiplierFromString(page.networkConditions);
-        page.pptrPage.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier);
+        page.pptrPage.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier * cpuMultiplier);
     }
     // Linear scan over per-page snapshots. The page count is small (typically
     // 2-10) so a reverse index isn't worthwhile given the uid-reuse lifecycle
@@ -372,6 +424,9 @@ export class McpContext {
         });
         return this.#extensionServiceWorkers;
     }
+    getServiceWorkerConsoleData(extensionId) {
+        return this.#serviceWorkerConsoleCollector.getData(extensionId);
+    }
     async createPagesSnapshot() {
         const { pages: allPages, isolatedContextNames } = await this.#getAllPages();
         for (const page of allPages) {
@@ -381,7 +436,7 @@ export class McpContext {
                 this.#mcpPages.set(page, mcpPage);
                 // We emulate a focused page for all pages to support multi-agent workflows.
                 void page.emulateFocusedPage(true).catch(error => {
-                    this.logger('Error turning on focused page emulation', error);
+                    this.logger?.('Error turning on focused page emulation', error);
                 });
             }
             mcpPage.isolatedContextName = isolatedContextNames.get(page);
@@ -427,7 +482,7 @@ export class McpContext {
                         this.#extensionPages.set(target, page);
                     }
                     catch (e) {
-                        this.logger('Failed to get page for extension target', e);
+                        this.logger?.('Failed to get page for extension target', e);
                     }
                 }
             }
@@ -462,7 +517,7 @@ export class McpContext {
         return { pages: allPages, isolatedContextNames };
     }
     async detectOpenDevToolsWindows() {
-        this.logger('Detecting open DevTools windows');
+        this.logger?.('Detecting open DevTools windows');
         const { pages } = await this.#getAllPages();
         await Promise.all(pages.map(async (page) => {
             const mcpPage = this.#mcpPages.get(page);
@@ -499,7 +554,7 @@ export class McpContext {
     }
     async saveTemporaryFile(data, filename) {
         const filepath = await getTempFilePath(filename);
-        this.validatePath(filepath);
+        await this.validatePath(filepath);
         try {
             await fs.writeFile(filepath, data);
         }
@@ -509,7 +564,7 @@ export class McpContext {
         return { filepath };
     }
     async saveFile(data, clientProvidedFilePath, extension) {
-        this.validatePath(clientProvidedFilePath);
+        await this.validatePath(clientProvidedFilePath);
         try {
             const filePath = ensureExtension(path.resolve(clientProvidedFilePath), extension);
             await fs.mkdir(path.dirname(filePath), { recursive: true });
@@ -517,7 +572,7 @@ export class McpContext {
             return { filename: filePath };
         }
         catch (err) {
-            this.logger(err);
+            this.logger?.(err);
             throw new Error('Could not save a file', { cause: err });
         }
     }
@@ -562,7 +617,6 @@ export class McpContext {
         await this.#networkCollector.init(pages);
     }
     async installExtension(extensionPath) {
-        this.validatePath(extensionPath);
         const id = await this.browser.installExtension(extensionPath);
         return id;
     }
@@ -586,20 +640,28 @@ export class McpContext {
         return pptrExtensions.get(id);
     }
     async getHeapSnapshotAggregates(filePath) {
-        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getAggregates(filePath);
     }
     async getHeapSnapshotStats(filePath) {
-        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getStats(filePath);
     }
     async getHeapSnapshotStaticData(filePath) {
-        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getStaticData(filePath);
     }
-    async getHeapSnapshotNodesByUid(filePath, uid) {
-        this.validatePath(filePath);
-        return await this.#heapSnapshotManager.getNodesByUid(filePath, uid);
+    async getHeapSnapshotNodesById(filePath, id) {
+        return await this.#heapSnapshotManager.getNodesById(filePath, id);
+    }
+    async getHeapSnapshotRetainers(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getRetainers(filePath, nodeId);
+    }
+    async closeHeapSnapshot(filePath) {
+        return this.#heapSnapshotManager.dispose(filePath);
+    }
+    hasHeapSnapshots() {
+        return this.#heapSnapshotManager.hasSnapshots();
+    }
+    async getHeapSnapshotRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
+        return await this.#heapSnapshotManager.getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings);
     }
 }
 //# sourceMappingURL=McpContext.js.map

package/build/src/McpPage.js

@@ -30,7 +30,7 @@ export class McpPage {
     // Dialog
     #dialog;
     #dialogHandler;
-    thirdPartyDeveloperTools;
+    thirdPartyDeveloperTools = [];
     constructor(page, id) {
         this.pptrPage = page;
         this.id = id;
@@ -194,18 +194,18 @@ export class McpPage {
             for (const handle of oldHandles) {
                 await handle
                     .dispose()
-                    .catch(e => logger('Failed to dispose old handle', e));
+                    .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}`);
+                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}`);
+                logger?.(`Could not get cdpElementId for backend node ${backendNodeId}`);
                 return `stashed-${index}`;
             }
             return cdpElementId;
@@ -263,12 +263,12 @@ export class McpPage {
     }
     resolveCdpElementId(cdpBackendNodeId) {
         if (!cdpBackendNodeId) {
-            logger('no cdpBackendNodeId');
+            logger?.('no cdpBackendNodeId');
             return;
         }
         const snapshot = this.textSnapshot;
         if (!snapshot) {
-            logger('no text snapshot');
+            logger?.('no text snapshot');
             return;
         }
         // TODO: index by backendNodeId instead.
@@ -286,10 +286,10 @@ export class McpPage {
     }
     async getDevToolsData() {
         try {
-            logger('Getting DevTools UI data');
+            logger?.('Getting DevTools UI data');
             const devtoolsPage = this.devToolsPage;
             if (!devtoolsPage) {
-                logger('No DevTools page detected');
+                logger?.('No DevTools page detected');
                 return {};
             }
             const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
@@ -307,7 +307,7 @@ export class McpPage {
             return { cdpBackendNodeId, cdpRequestId };
         }
         catch (err) {
-            logger('error getting devtools data', err);
+            logger?.('error getting devtools data', err);
         }
         return {};
     }