opera-devtools-mcp 0.2.4 → 0.4.0

package/build/src/McpContext.js

@@ -7,17 +7,19 @@ import fs 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 { HeapSnapshotManager } from './HeapSnapshotManager.js';
+import { overrideDevToolsGlobals } from './devtools/DevtoolsUtils.js';
+import { HeapSnapshotManager } from './processors/HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
-import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
-import { Locator, PredefinedNetworkConditions, } from './third_party/index.js';
+import { ServiceWorkerConsoleCollector } from './collectors/ServiceWorkerCollector.js';
+import { Locator, } 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 { getNetworkMultiplierFromString } from './WaitForHelper.js';
-const DEFAULT_TIMEOUT = 5_000;
-const NAVIGATION_TIMEOUT = 10_000;
+import { getTempFilePath, resolveCanonicalPath } from './utils/files.js';
+// Page ids are handed out from a process-wide counter so they stay unique
+// across all contexts, in particular across browser reconnects. An id issued
+// before a reconnect then fails to resolve instead of hitting an unrelated
+// page of the reconnected browser.
+let nextPageId = 1;
 export class McpContext {
     browser;
     logger;
@@ -25,16 +27,14 @@ export class McpContext {
     #isolatedContexts = new Map();
     // Auto-generated name counter for when no name is provided.
     #nextIsolatedContextId = 1;
-    #pages = [];
     #extensionServiceWorkers = [];
     #mcpPages = new Map();
     #selectedPage;
-    #networkCollector;
-    #consoleCollector;
-    #devtoolsUniverseManager;
+    #selectedPageFallback;
+    #serviceWorkerConsoleCollector;
     #isRunningTrace = false;
     #screenRecorderData = null;
-    #nextPageId = 1;
+    #reconnectNotice = false;
     #extensionPages = new WeakMap();
     #extensionServiceWorkerMap = new WeakMap();
     #nextExtensionServiceWorkerId = 1;
@@ -43,38 +43,33 @@ export class McpContext {
     #options;
     #heapSnapshotManager = new HeapSnapshotManager();
     #roots = undefined;
+    #allowUnrestrictedPaths;
     constructor(browser, logger, options, locatorClass) {
+        overrideDevToolsGlobals({
+            loadResource: (url) => {
+                return this.loadResource(url);
+            },
+        });
         this.browser = browser;
         this.logger = logger;
         this.#locatorClass = locatorClass;
         this.#options = options;
-        this.#networkCollector = new NetworkCollector(this.browser);
-        this.#consoleCollector = new ConsoleCollector(this.browser, collect => {
-            return {
-                console: event => {
-                    collect(event);
-                },
-                uncaughtError: event => {
-                    collect(event);
-                },
-                devtoolsAggregatedIssue: event => {
-                    collect(event);
-                },
-            };
-        });
-        this.#devtoolsUniverseManager = new UniverseManager(this.browser);
+        this.#allowUnrestrictedPaths = options.allowUnrestrictedPaths ?? false;
+        this.#reconnectNotice = options.reconnected ?? false;
+        this.#serviceWorkerConsoleCollector = new ServiceWorkerConsoleCollector(this.browser);
     }
     async #init() {
-        const pages = await this.createPagesSnapshot();
-        await this.createExtensionServiceWorkersSnapshot();
-        await this.#networkCollector.init(pages);
-        await this.#consoleCollector.init(pages);
-        await this.#devtoolsUniverseManager.init(pages);
+        await this.createPagesSnapshot();
+        const workers = await this.createExtensionServiceWorkersSnapshot();
+        await this.#serviceWorkerConsoleCollector.init(workers);
+        this.browser.on('targetcreated', this.#onTargetCreated);
+        this.browser.on('targetdestroyed', this.#onTargetDestroyed);
     }
     dispose() {
-        this.#networkCollector.dispose();
-        this.#consoleCollector.dispose();
-        this.#devtoolsUniverseManager.dispose();
+        this.browser.off('targetcreated', this.#onTargetCreated);
+        this.browser.off('targetdestroyed', this.#onTargetDestroyed);
+        this.#serviceWorkerConsoleCollector.dispose();
+        this.#heapSnapshotManager.dispose();
         for (const mcpPage of this.#mcpPages.values()) {
             mcpPage.dispose();
         }
@@ -84,6 +79,40 @@ export class McpContext {
         // without destroying browser state.
         this.#isolatedContexts.clear();
     }
+    #onTargetCreated = async (target) => {
+        try {
+            const page = await target.page();
+            if (!page) {
+                return;
+            }
+            void this.#createMcpPage(page);
+        }
+        catch (err) {
+            this.logger?.('Error handling targetcreated', err);
+        }
+    };
+    #onTargetDestroyed = (target) => {
+        try {
+            let foundPage;
+            for (const page of this.#mcpPages.keys()) {
+                if (page.target() === target) {
+                    foundPage = page;
+                    break;
+                }
+            }
+            if (!foundPage) {
+                return;
+            }
+            const mcpPage = this.#mcpPages.get(foundPage);
+            if (mcpPage) {
+                mcpPage.dispose();
+                this.#mcpPages.delete(foundPage);
+            }
+        }
+        catch (err) {
+            this.logger?.('Error handling targetdestroyed', err);
+        }
+    };
     static async from(browser, logger, opts, 
     /* Let tests use unbundled Locator class to avoid overly strict checks within puppeteer that fail when mixing bundled and unbundled class instances */
     locatorClass = Locator) {
@@ -91,12 +120,12 @@ export class McpContext {
         await context.#init();
         return context;
     }
+    static resetPageIdsForTesting() {
+        nextPageId = 1;
+    }
     roots() {
-        if (this.#roots === undefined) {
-            return undefined;
-        }
         return [
-            ...this.#roots,
+            ...(this.#roots ?? []),
             {
                 uri: pathToFileURL(os.tmpdir()).href,
                 name: 'temp',
@@ -106,53 +135,64 @@ export class McpContext {
     setRoots(roots) {
         this.#roots = roots;
     }
-    validatePath(filePath) {
+    async validatePath(filePath) {
         if (filePath === undefined) {
             return;
         }
-        const roots = this.roots();
-        if (roots === undefined) {
+        // If the client never negotiated roots and the operator has explicitly
+        // opted into unrestricted access via --allow-unrestricted-paths, restore
+        // the previous permissive behavior and skip validation.
+        if (this.#roots === undefined && this.#allowUnrestrictedPaths) {
             return;
         }
-        const absolutePath = path.resolve(filePath);
-        for (const root of roots) {
-            const rootPath = path.resolve(fileURLToPath(root.uri));
-            if (absolutePath === rootPath ||
-                absolutePath.startsWith(rootPath + path.sep)) {
-                return;
+        // roots() always returns at least the temp directory, even if the
+        // connecting client never negotiated the optional `roots` capability.
+        // Path validation must not be skipped just because no workspace roots
+        // were configured.
+        const roots = this.roots();
+        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;
+        const resolvedRoots = await Promise.allSettled(roots.map(async (root) => {
+            const rootPathUri = root.uri;
+            const rootPath = path.resolve(fileURLToPath(rootPathUri));
+            return await fs.realpath(rootPath);
+        }));
+        for (let i = 0; i < roots.length; i++) {
+            const root = roots[i];
+            const result = resolvedRoots[i];
+            if (result.status === 'fulfilled') {
+                const canonicalRoot = result.value;
+                if (canonicalPath === canonicalRoot ||
+                    canonicalPath.startsWith(canonicalRoot + path.sep)) {
+                    allowed = true;
+                    break;
+                }
+            }
+            else {
+                const rootErr = result.reason;
+                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)}.`);
-    }
-    resolveCdpRequestId(page, cdpRequestId) {
-        if (!cdpRequestId) {
-            this.logger('no network request');
-            return;
+        if (!allowed) {
+            throw new Error(`Access denied: path ${filePath} (canonical: ${canonicalPath}) is not within any of the configured workspace roots.`);
         }
-        const request = this.#networkCollector.find(page.pptrPage, request => {
-            // @ts-expect-error id is internal.
-            return request.id === cdpRequestId;
-        });
-        if (!request) {
-            this.logger('no network request for ' + cdpRequestId);
-            return;
-        }
-        return this.#networkCollector.getIdForResource(request);
-    }
-    getNetworkRequests(page, includePreservedRequests) {
-        return this.#networkCollector.getData(page.pptrPage, includePreservedRequests);
-    }
-    getConsoleData(page, includePreservedMessages) {
-        return this.#consoleCollector.getData(page.pptrPage, includePreservedMessages);
-    }
-    getDevToolsUniverse(page) {
-        return this.#devtoolsUniverseManager.get(page.pptrPage);
-    }
-    getConsoleMessageStableId(message) {
-        return this.#consoleCollector.getIdForResource(message);
     }
-    getConsoleMessageById(page, id) {
-        return this.#consoleCollector.getById(page.pptrPage, id);
+    async ensureExtension(filePath, extension) {
+        const resolvedPath = path.resolve(filePath);
+        const currentExtension = path.extname(resolvedPath);
+        const outputPath = `${resolvedPath.slice(0, resolvedPath.length - currentExtension.length)}${extension}`;
+        await this.validatePath(outputPath);
+        return outputPath;
     }
     async newPage(background, isolatedContextName) {
         let page;
@@ -167,14 +207,13 @@ export class McpContext {
         else {
             page = await this.browser.newPage({ background });
         }
+        const mcpPage = await this.#createMcpPage(page);
         await this.createPagesSnapshot();
-        this.selectPage(this.#getMcpPage(page));
-        this.#networkCollector.addPage(page);
-        this.#consoleCollector.addPage(page);
-        return this.#getMcpPage(page);
+        this.selectPage(mcpPage);
+        return mcpPage;
     }
     async closePage(pageId) {
-        if (this.#pages.length === 1) {
+        if (this.#mcpPages.size === 1) {
             throw new Error(CLOSE_PAGE_ERROR);
         }
         const page = this.getPageById(pageId);
@@ -184,90 +223,20 @@ export class McpContext {
         }
         await page.pptrPage.close({ runBeforeUnload: false });
     }
-    getNetworkRequestById(page, reqid) {
-        return this.#networkCollector.getById(page.pptrPage, reqid);
-    }
-    async restoreEmulation(page) {
-        const currentSetting = page.emulationSettings;
-        await this.emulate(currentSetting, page.pptrPage);
-    }
-    async emulate(options, targetPage) {
-        const page = targetPage ?? this.getSelectedPptrPage();
-        const mcpPage = this.#getMcpPage(page);
-        const newSettings = { ...mcpPage.emulationSettings };
-        if (!options.networkConditions) {
-            await page.emulateNetworkConditions(null);
-            delete newSettings.networkConditions;
-        }
-        else if (options.networkConditions === 'Offline') {
-            await page.emulateNetworkConditions({
-                offline: true,
-                download: 0,
-                upload: 0,
-                latency: 0,
-            });
-            newSettings.networkConditions = 'Offline';
-        }
-        else if (options.networkConditions in PredefinedNetworkConditions) {
-            const networkCondition = PredefinedNetworkConditions[options.networkConditions];
-            await page.emulateNetworkConditions(networkCondition);
-            newSettings.networkConditions = options.networkConditions;
-        }
-        if (!options.cpuThrottlingRate) {
-            await page.emulateCPUThrottling(1);
-            delete newSettings.cpuThrottlingRate;
-        }
-        else {
-            await page.emulateCPUThrottling(options.cpuThrottlingRate);
-            newSettings.cpuThrottlingRate = options.cpuThrottlingRate;
-        }
-        if (!options.geolocation) {
-            await page.setGeolocation({ latitude: 0, longitude: 0 });
-            delete newSettings.geolocation;
-        }
-        else {
-            await page.setGeolocation(options.geolocation);
-            newSettings.geolocation = options.geolocation;
-        }
-        if (!options.userAgent) {
-            await page.setUserAgent({ userAgent: undefined });
-            delete newSettings.userAgent;
-        }
-        else {
-            await page.setUserAgent({ userAgent: options.userAgent });
-            newSettings.userAgent = options.userAgent;
-        }
-        if (!options.colorScheme || options.colorScheme === 'auto') {
-            await page.emulateMediaFeatures([
-                { name: 'prefers-color-scheme', value: '' },
-            ]);
-            delete newSettings.colorScheme;
-        }
-        else {
-            await page.emulateMediaFeatures([
-                { name: 'prefers-color-scheme', value: options.colorScheme },
-            ]);
-            newSettings.colorScheme = options.colorScheme;
-        }
-        if (!options.viewport) {
-            await page.setViewport(null);
-            delete newSettings.viewport;
-        }
-        else {
-            const defaults = {
-                deviceScaleFactor: 1,
-                isMobile: false,
-                hasTouch: false,
-                isLandscape: false,
-            };
-            const viewport = { ...defaults, ...options.viewport };
-            await page.setViewport(viewport);
-            newSettings.viewport = viewport;
-        }
-        mcpPage.emulationSettings = Object.keys(newSettings).length
-            ? newSettings
-            : {};
-        this.#updateSelectedPageTimeouts();
+    get #hasNetworkBlockOrAllowlist() {
+        return !!(this.#options.allowList || this.#options.blocklist);
+    }
+    installPWA(options) {
+        return this.browser.installPWA(options);
+    }
+    uninstallPWA(options) {
+        return this.browser.uninstallPWA(options);
+    }
+    launchPWA(options) {
+        return this.browser.launchPWA(options);
+    }
+    getPWAState(options) {
+        return this.browser.getPWAState(options);
     }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
@@ -284,7 +253,10 @@ export class McpContext {
     isCruxEnabled() {
         return this.#options.performanceCrux;
     }
-    getSelectedPptrPage() {
+    getPages() {
+        return Array.from(this.#mcpPages.values());
+    }
+    getSelectedMcpPage() {
         const page = this.#selectedPage;
         if (!page) {
             throw new Error('No page selected');
@@ -292,11 +264,37 @@ export class McpContext {
         if (page.pptrPage.isClosed()) {
             throw new Error(`The selected page has been closed. Call ${listPages().name} to see open pages.`);
         }
-        return page.pptrPage;
+        return page;
     }
-    getSelectedMcpPage() {
-        const page = this.getSelectedPptrPage();
-        return this.#getMcpPage(page);
+    async getDevToolsData(page) {
+        const targetPage = page ?? this.#selectedPage;
+        if (!targetPage) {
+            return undefined;
+        }
+        let timeoutId;
+        const timeoutPromise = new Promise(resolve => {
+            timeoutId = setTimeout(() => resolve(undefined), 500);
+        });
+        const dataPromise = targetPage.getDevToolsData();
+        try {
+            return await Promise.race([dataPromise, timeoutPromise]);
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Returns true once if this context was created by reconnecting after the
+     * previous browser connection was lost, so the next response can surface a
+     * note. Cleared on first call.
+     */
+    consumeReconnectNotice() {
+        const notice = this.#reconnectNotice;
+        this.#reconnectNotice = false;
+        return notice;
     }
     getPageById(pageId) {
         const page = this.#mcpPages.values().find(mcpPage => mcpPage.id === pageId);
@@ -305,55 +303,27 @@ export class McpContext {
         }
         return page;
     }
-    getPageId(page) {
-        return this.#mcpPages.get(page)?.id;
-    }
-    #getMcpPage(page) {
-        const mcpPage = this.#mcpPages.get(page);
-        if (!mcpPage) {
-            throw new Error('No McpPage found for the given page.');
-        }
-        return mcpPage;
-    }
-    #getSelectedMcpPage() {
-        return this.#getMcpPage(this.getSelectedPptrPage());
-    }
     isPageSelected(page) {
-        return this.#selectedPage?.pptrPage === page;
+        return this.#selectedPage === page;
     }
     selectPage(newPage) {
         this.#selectedPage = newPage;
-        this.#updateSelectedPageTimeouts();
-    }
-    #updateSelectedPageTimeouts() {
-        const page = this.#getSelectedMcpPage();
-        // For waiters 5sec timeout should be sufficient.
-        // Increased in case we throttle the CPU
-        const cpuMultiplier = page.cpuThrottlingRate;
-        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
-        const networkMultiplier = getNetworkMultiplierFromString(page.networkConditions);
-        page.pptrPage.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier);
-    }
-    // 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
-    // complexity it would introduce.
-    getAXNodeByUid(uid) {
-        for (const mcpPage of this.#mcpPages.values()) {
-            const node = mcpPage.textSnapshot?.idToNode.get(uid);
-            if (node) {
-                return node;
-            }
-        }
-        return undefined;
+        newPage.updateTimeouts();
+    }
+    /**
+     * Returns details about the last page snapshot automatically replacing the
+     * selection because the selected page disappeared from the page list, or
+     * `undefined` if the snapshot left the selection intact. Recomputed on every
+     * createPagesSnapshot() call.
+     */
+    getSelectedPageFallback() {
+        return this.#selectedPageFallback;
     }
     /**
      * Creates a snapshot of the extension service workers.
      */
     async createExtensionServiceWorkersSnapshot() {
-        const allTargets = await this.browser.targets();
+        const allTargets = this.browser.targets();
         const serviceWorkers = allTargets.filter(target => {
             return (target.type() === 'service_worker' &&
                 target.url().includes('chrome-extension://'));
@@ -372,74 +342,16 @@ export class McpContext {
         });
         return this.#extensionServiceWorkers;
     }
-    async createPagesSnapshot() {
-        const { pages: allPages, isolatedContextNames } = await this.#getAllPages();
-        for (const page of allPages) {
-            let mcpPage = this.#mcpPages.get(page);
-            if (!mcpPage) {
-                mcpPage = new McpPage(page, this.#nextPageId++);
-                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);
-                });
-            }
-            mcpPage.isolatedContextName = isolatedContextNames.get(page);
-        }
-        // Prune orphaned #mcpPages entries (pages that no longer exist).
-        const currentPages = new Set(allPages);
-        for (const [page, mcpPage] of this.#mcpPages) {
-            if (!currentPages.has(page)) {
-                mcpPage.dispose();
-                this.#mcpPages.delete(page);
-            }
-        }
-        this.#pages = allPages.filter(page => {
-            return (this.#options.experimentalDevToolsDebugging ||
-                !page.url().startsWith('devtools://'));
-        });
-        if ((!this.#selectedPage ||
-            this.#pages.indexOf(this.#selectedPage.pptrPage) === -1) &&
-            this.#pages[0]) {
-            this.selectPage(this.#getMcpPage(this.#pages[0]));
-        }
-        await this.detectOpenDevToolsWindows();
-        return this.#pages;
+    getServiceWorkerConsoleData(extensionId) {
+        return this.#serviceWorkerConsoleCollector.getData(extensionId);
     }
-    async #getAllPages() {
-        const defaultCtx = this.browser.defaultBrowserContext();
-        const allPages = await this.browser.pages(this.#options.experimentalIncludeAllPages);
-        const allTargets = this.browser.targets();
-        const extensionTargets = allTargets.filter(target => {
-            return (target.url().startsWith('chrome-extension://') &&
-                target.type() === 'page');
-        });
-        for (const target of extensionTargets) {
-            // Right now target.page() returns null for popup and side panel pages.
-            let page = await target.page();
-            if (!page) {
-                // We need to cache pages instances for targets because target.asPage()
-                // returns a new page instance every time.
-                page = this.#extensionPages.get(target) ?? null;
-                if (!page) {
-                    try {
-                        page = await target.asPage();
-                        this.#extensionPages.set(target, page);
-                    }
-                    catch (e) {
-                        this.logger('Failed to get page for extension target', e);
-                    }
-                }
-            }
-            if (page && !allPages.includes(page)) {
-                allPages.push(page);
-            }
-        }
+    #getBrowserContextToNameMap() {
         // Build a reverse lookup from BrowserContext instance → name.
         const contextToName = new Map();
         for (const [name, ctx] of this.#isolatedContexts) {
             contextToName.set(ctx, name);
         }
+        const defaultCtx = this.browser.defaultBrowserContext();
         // Auto-discover BrowserContexts not in our mapping (e.g., externally
         // created incognito contexts) and assign generated names.
         const knownContexts = new Set(this.#isolatedContexts.values());
@@ -450,40 +362,77 @@ export class McpContext {
                 contextToName.set(ctx, name);
             }
         }
-        // Map each page to its isolated context name (if any).
-        const isolatedContextNames = new Map();
-        for (const page of allPages) {
-            const ctx = page.browserContext();
-            const name = contextToName.get(ctx);
-            if (name) {
-                isolatedContextNames.set(page, name);
-            }
+        return contextToName;
+    }
+    async #createMcpPage(page) {
+        let mcpPage = this.#mcpPages.get(page);
+        if (!mcpPage) {
+            mcpPage = new McpPage(page, nextPageId++, {
+                locatorClass: this.#locatorClass,
+                hasNetworkBlockOrAllowlist: this.#hasNetworkBlockOrAllowlist,
+                isolatedContextName: this.#getBrowserContextToNameMap().get(page.browserContext()),
+                navigationTimeout: this.#options.navigationTimeout,
+            });
+            this.#mcpPages.set(page, mcpPage);
+            await mcpPage.init();
         }
-        return { pages: allPages, isolatedContextNames };
+        return mcpPage;
     }
-    async detectOpenDevToolsWindows() {
-        this.logger('Detecting open DevTools windows');
-        const { pages } = await this.#getAllPages();
-        await Promise.all(pages.map(async (page) => {
-            const mcpPage = this.#mcpPages.get(page);
-            if (!mcpPage) {
-                return;
+    async createPagesSnapshot() {
+        const allPages = await this.#fetchBrowserPages();
+        await Promise.allSettled(allPages.map(page => this.#createMcpPage(page)));
+        // Prune orphaned #mcpPages entries (pages that no longer exist).
+        const currentPages = new Set(allPages);
+        for (const [page, mcpPage] of this.#mcpPages) {
+            if (!currentPages.has(page)) {
+                mcpPage.dispose();
+                this.#mcpPages.delete(page);
             }
-            // Prior to Chrome 144.0.7559.59, the command fails,
-            // Some Electron apps still use older version
-            // Fall back to not exposing DevTools at all.
+        }
+        const pages = Array.from(this.#mcpPages.values());
+        // Only fall back when the selected page is actually gone. Gating on
+        // `isClosed()` instead of `pages` membership avoids silently swapping a
+        // live page that is momentarily missing from the snapshot.
+        this.#selectedPageFallback = undefined;
+        if ((!this.#selectedPage || this.#selectedPage.pptrPage.isClosed()) &&
+            pages[0]) {
+            // Record the automatic change so the response can surface it. Skipped on
+            // first connect, when there was no prior selection to replace.
+            if (this.#selectedPage) {
+                this.#selectedPageFallback = {
+                    wasClosed: this.#selectedPage.pptrPage.isClosed(),
+                };
+            }
+            this.selectPage(pages[0]);
+        }
+        return pages.map(p => p.pptrPage);
+    }
+    async #fetchBrowserPages() {
+        const allPages = (await this.browser.pages(this.#options.experimentalIncludeAllPages)).filter(page => {
+            return (this.#options.experimentalDevToolsDebugging ||
+                !page.url().startsWith('devtools://'));
+        });
+        const allTargets = this.browser.targets();
+        const extensionTargets = allTargets.filter(target => {
+            return (target.url().startsWith('chrome-extension://') &&
+                target.type() === 'page');
+        });
+        await Promise.allSettled(extensionTargets.map(async (target) => {
             try {
-                if (await page.hasDevTools()) {
-                    mcpPage.devToolsPage = await page.openDevTools();
+                let page = await target.page();
+                if (!page) {
+                    page = await target.asPage();
                 }
-                else {
-                    mcpPage.devToolsPage = undefined;
+                this.#extensionPages.set(target, page);
+                if (page && !allPages.includes(page)) {
+                    allPages.push(page);
                 }
             }
-            catch {
-                mcpPage.devToolsPage = undefined;
+            catch (e) {
+                this.logger?.('Failed to get page for extension target', e);
             }
         }));
+        return allPages;
     }
     getExtensionServiceWorkers() {
         return this.#extensionServiceWorkers;
@@ -491,35 +440,37 @@ export class McpContext {
     getExtensionServiceWorkerId(extensionServiceWorker) {
         return this.#extensionServiceWorkerMap.get(extensionServiceWorker.target);
     }
-    getPages() {
-        return this.#pages;
-    }
-    getIsolatedContextName(page) {
-        return this.#mcpPages.get(page)?.isolatedContextName;
-    }
-    async saveTemporaryFile(data, filename) {
-        const filepath = await getTempFilePath(filename);
-        this.validatePath(filepath);
+    async #writeFile(filepath, data) {
+        await this.validatePath(filepath);
         try {
-            await fs.writeFile(filepath, data);
+            await fs.mkdir(path.dirname(filepath), { recursive: true });
+            // Open the file with flags to:
+            // - O_WRONLY: Write-only
+            // - O_CREAT: Create if it doesn't exist
+            // - O_TRUNC: Truncate to zero length if it exists
+            // - O_NOFOLLOW: DO NOT follow symlinks.
+            // - 0o600: Permissions: read/write for owner, no permissions for others.
+            await fs.writeFile(filepath, data, {
+                flag: fs.constants.O_WRONLY |
+                    fs.constants.O_CREAT |
+                    fs.constants.O_TRUNC |
+                    fs.constants.O_NOFOLLOW,
+                mode: 0o600,
+            });
         }
         catch (err) {
-            throw new Error('Could not save a file', { cause: err });
+            throw new Error(`Could not write ${filepath}`, { cause: err });
         }
+    }
+    async saveTemporaryFile(data, filename) {
+        const filepath = await getTempFilePath(filename);
+        await this.#writeFile(filepath, data);
         return { filepath };
     }
     async saveFile(data, clientProvidedFilePath, extension) {
-        this.validatePath(clientProvidedFilePath);
-        try {
-            const filePath = ensureExtension(path.resolve(clientProvidedFilePath), extension);
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            await fs.writeFile(filePath, data);
-            return { filename: filePath };
-        }
-        catch (err) {
-            this.logger(err);
-            throw new Error('Could not save a file', { cause: err });
-        }
+        const filePath = await this.ensureExtension(clientProvidedFilePath, extension);
+        await this.#writeFile(filePath, data);
+        return { filename: filePath };
     }
     storeTraceRecording(result) {
         // Clear the trace results because we only consume the latest trace currently.
@@ -529,45 +480,18 @@ export class McpContext {
     recordedTraces() {
         return this.#traceResults;
     }
-    getNetworkRequestStableId(request) {
-        return this.#networkCollector.getIdForResource(request);
-    }
-    waitForTextOnPage(text, timeout, targetPage) {
-        const page = targetPage ?? this.getSelectedPptrPage();
-        const frames = page.frames();
-        let locator = this.#locatorClass.race(frames.flatMap(frame => text.flatMap(value => [
-            frame.locator(`aria/${value}`),
-            frame.locator(`text/${value}`),
-        ])));
-        if (timeout) {
-            locator = locator.setTimeout(timeout);
-        }
-        return locator.wait();
-    }
-    /**
-     * We need to ignore favicon request as they make our test flaky
-     */
-    async setUpNetworkCollectorForTesting() {
-        this.#networkCollector = new NetworkCollector(this.browser, collect => {
-            return {
-                request: req => {
-                    if (req.url().includes('favicon.ico')) {
-                        return;
-                    }
-                    collect(req);
-                },
-            };
-        });
-        const { pages } = await this.#getAllPages();
-        await this.#networkCollector.init(pages);
-    }
     async installExtension(extensionPath) {
-        this.validatePath(extensionPath);
-        const id = await this.browser.installExtension(extensionPath);
+        const id = await Promise.race([
+            this.browser.installExtension(extensionPath),
+            new Promise((_, rej) => setTimeout(() => rej(new Error('Timeout installing extension')), 30000)),
+        ]);
         return id;
     }
     async uninstallExtension(id) {
-        await this.browser.uninstallExtension(id);
+        await Promise.race([
+            this.browser.uninstallExtension(id),
+            new Promise((_, rej) => setTimeout(() => rej(new Error('Timeout uninstalling extension')), 30000)),
+        ]);
     }
     async triggerExtensionAction(id) {
         const extensions = await this.browser.extensions();
@@ -575,7 +499,7 @@ export class McpContext {
         if (!extension) {
             throw new Error(`Extension with ID ${id} not found.`);
         }
-        const page = this.getSelectedPptrPage();
+        const page = this.getSelectedMcpPage().pptrPage;
         await extension.triggerAction(page);
     }
     listExtensions() {
@@ -585,21 +509,97 @@ export class McpContext {
         const pptrExtensions = await this.browser.extensions();
         return pptrExtensions.get(id);
     }
-    async getHeapSnapshotAggregates(filePath) {
-        this.validatePath(filePath);
-        return await this.#heapSnapshotManager.getAggregates(filePath);
+    async getHeapSnapshotAggregates(filePath, filterName, objectId) {
+        return await this.#heapSnapshotManager.getAggregates(filePath, filterName, objectId);
+    }
+    async getHeapSnapshotDuplicateStrings(filePath) {
+        return await this.#heapSnapshotManager.getDuplicateStrings(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 getHeapSnapshotNativeContextSizes(filePath) {
+        return await this.#heapSnapshotManager.getNativeContextSizes(filePath);
+    }
+    async getHeapSnapshotRetainedByContextSummary(filePath) {
+        return await this.#heapSnapshotManager.getRetainedByContextSummary(filePath);
+    }
+    async getHeapSnapshotNodesById(filePath, id, filterName, objectId) {
+        return await this.#heapSnapshotManager.getNodesById(filePath, id, filterName, objectId);
+    }
+    async getHeapSnapshotRetainers(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getRetainers(filePath, nodeId);
+    }
+    async getHeapSnapshotObjectDetails(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getObjectInfo(filePath, nodeId);
+    }
+    async closeHeapSnapshot(filePath) {
+        return this.#heapSnapshotManager.disposeSnapshot(filePath);
+    }
+    hasHeapSnapshots() {
+        return this.#heapSnapshotManager.hasSnapshots();
+    }
+    async getHeapSnapshotRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
+        return await this.#heapSnapshotManager.getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings);
+    }
+    async getHeapSnapshotDominators(filePath, nodeId) {
+        return await this.#heapSnapshotManager.getDominatorsOf(filePath, nodeId);
+    }
+    #validateUrlNotBlocked(url) {
+        if (!this.#options.blocklist) {
+            return;
+        }
+        for (const block of this.#options.blocklist) {
+            const pattern = new URLPattern(block);
+            if (pattern.test(url)) {
+                throw new Error(`Blocked by blocklist: ${url}`);
+            }
+        }
+    }
+    #validateUrlAllowed(url) {
+        if (!this.#options.allowList) {
+            return;
+        }
+        for (const allow of this.#options.allowList) {
+            const pattern = new URLPattern(allow);
+            if (pattern.test(url)) {
+                return;
+            }
+        }
+        throw new Error(`Not allowed by allowlist: ${url}`);
+    }
+    async loadResource(path) {
+        const url = new URL(path);
+        this.#validateUrlNotBlocked(url);
+        switch (url.protocol) {
+            case 'https:':
+            case 'http:': {
+                this.#validateUrlAllowed(url);
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Failed to load resource: ${url}`);
+                }
+                return response.text();
+            }
+            case 'file:': {
+                await this.validatePath(fileURLToPath(url));
+                return await fs.readFile(url, 'utf-8');
+            }
+            default:
+                throw new Error(`Unsupported protocol for: ${url}`);
+        }
+    }
+    async getHeapSnapshotEdges(filePath, nodeId, options) {
+        return await this.#heapSnapshotManager.getEdges(filePath, nodeId, options);
+    }
+    async getHeapSnapshotClassDiffs(baseFilePath, currentFilePath) {
+        return await this.#heapSnapshotManager.getClassDiffs(baseFilePath, currentFilePath);
+    }
+    async getHeapSnapshotDetailedClassDiff(baseFilePath, currentFilePath, classIndex) {
+        return await this.#heapSnapshotManager.getDetailedClassDiff(baseFilePath, currentFilePath, classIndex);
     }
 }
 //# sourceMappingURL=McpContext.js.map