chrome-devtools-mcp 0.18.1 → 0.20.0

package/build/src/McpContext.js

@@ -4,16 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import fs from 'node:fs/promises';
-import os from 'node:os';
 import path from 'node:path';
 import { extractUrlLikeFromDevToolsTitle, UniverseManager, urlsEqual, } from './DevtoolsUtils.js';
+import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector } from './PageCollector.js';
 import { Locator } from './third_party/index.js';
 import { PredefinedNetworkConditions } from './third_party/index.js';
 import { listPages } from './tools/pages.js';
-import { takeSnapshot } from './tools/snapshot.js';
 import { CLOSE_PAGE_ERROR } from './tools/ToolDefinition.js';
 import { ExtensionRegistry, } from './utils/ExtensionRegistry.js';
+import { saveTemporaryFile } from './utils/files.js';
 import { WaitForHelper } from './WaitForHelper.js';
 const DEFAULT_TIMEOUT = 5_000;
 const NAVIGATION_TIMEOUT = 10_000;
@@ -31,49 +31,31 @@ function getNetworkMultiplierFromString(condition) {
     }
     return 1;
 }
-function getExtensionFromMimeType(mimeType) {
-    switch (mimeType) {
-        case 'image/png':
-            return 'png';
-        case 'image/jpeg':
-            return 'jpeg';
-        case 'image/webp':
-            return 'webp';
-    }
-    throw new Error(`No mapping for Mime type ${mimeType}.`);
-}
 export class McpContext {
     browser;
     logger;
     // Maps LLM-provided isolatedContext name → Puppeteer BrowserContext.
     #isolatedContexts = new Map();
-    // Reverse lookup: Page → isolatedContext name (for snapshot labeling).
-    // WeakMap so closed pages are garbage-collected automatically.
-    #pageToIsolatedContextName = new WeakMap();
     // Auto-generated name counter for when no name is provided.
     #nextIsolatedContextId = 1;
     #pages = [];
     #extensionServiceWorkers = [];
-    #pageToDevToolsPage = new Map();
+    #mcpPages = new Map();
     #selectedPage;
-    #textSnapshot = null;
     #networkCollector;
     #consoleCollector;
     #devtoolsUniverseManager;
     #extensionRegistry = new ExtensionRegistry();
     #isRunningTrace = false;
     #screenRecorderData = null;
-    #emulationSettingsMap = new WeakMap();
-    #dialog;
-    #pageIdMap = new WeakMap();
     #nextPageId = 1;
+    #extensionPages = new WeakMap();
     #extensionServiceWorkerMap = new WeakMap();
     #nextExtensionServiceWorkerId = 1;
     #nextSnapshotId = 1;
     #traceResults = [];
     #locatorClass;
     #options;
-    #uniqueBackendNodeIdToMcpId = new Map();
     constructor(browser, logger, options, locatorClass) {
         this.browser = browser;
         this.logger = logger;
@@ -106,6 +88,10 @@ export class McpContext {
         this.#networkCollector.dispose();
         this.#consoleCollector.dispose();
         this.#devtoolsUniverseManager.dispose();
+        for (const mcpPage of this.#mcpPages.values()) {
+            mcpPage.dispose();
+        }
+        this.#mcpPages.clear();
         // Isolated contexts are intentionally not closed here.
         // Either the entire browser will be closed or we disconnect
         // without destroying browser state.
@@ -118,13 +104,12 @@ export class McpContext {
         await context.#init();
         return context;
     }
-    resolveCdpRequestId(cdpRequestId) {
-        const selectedPage = this.getSelectedPage();
+    resolveCdpRequestId(page, cdpRequestId) {
         if (!cdpRequestId) {
             this.logger('no network request');
             return;
         }
-        const request = this.#networkCollector.find(selectedPage, request => {
+        const request = this.#networkCollector.find(page.pptrPage, request => {
             // @ts-expect-error id is internal.
             return request.id === cdpRequestId;
         });
@@ -134,17 +119,18 @@ export class McpContext {
         }
         return this.#networkCollector.getIdForResource(request);
     }
-    resolveCdpElementId(cdpBackendNodeId) {
+    resolveCdpElementId(page, cdpBackendNodeId) {
         if (!cdpBackendNodeId) {
             this.logger('no cdpBackendNodeId');
             return;
         }
-        if (this.#textSnapshot === null) {
+        const snapshot = page.textSnapshot;
+        if (!snapshot) {
             this.logger('no text snapshot');
             return;
         }
         // TODO: index by backendNodeId instead.
-        const queue = [this.#textSnapshot.root];
+        const queue = [snapshot.root];
         while (queue.length) {
             const current = queue.pop();
             if (current.backendNodeId === cdpBackendNodeId) {
@@ -156,22 +142,20 @@ export class McpContext {
         }
         return;
     }
-    getNetworkRequests(includePreservedRequests) {
-        const page = this.getSelectedPage();
-        return this.#networkCollector.getData(page, includePreservedRequests);
+    getNetworkRequests(page, includePreservedRequests) {
+        return this.#networkCollector.getData(page.pptrPage, includePreservedRequests);
     }
-    getConsoleData(includePreservedMessages) {
-        const page = this.getSelectedPage();
-        return this.#consoleCollector.getData(page, includePreservedMessages);
+    getConsoleData(page, includePreservedMessages) {
+        return this.#consoleCollector.getData(page.pptrPage, includePreservedMessages);
     }
-    getDevToolsUniverse() {
-        return this.#devtoolsUniverseManager.get(this.getSelectedPage());
+    getDevToolsUniverse(page) {
+        return this.#devtoolsUniverseManager.get(page.pptrPage);
     }
     getConsoleMessageStableId(message) {
         return this.#consoleCollector.getIdForResource(message);
     }
-    getConsoleMessageById(id) {
-        return this.#consoleCollector.getById(this.getSelectedPage(), id);
+    getConsoleMessageById(page, id) {
+        return this.#consoleCollector.getById(page.pptrPage, id);
     }
     async newPage(background, isolatedContextName) {
         let page;
@@ -182,150 +166,111 @@ export class McpContext {
                 this.#isolatedContexts.set(isolatedContextName, ctx);
             }
             page = await ctx.newPage();
-            this.#pageToIsolatedContextName.set(page, isolatedContextName);
         }
         else {
             page = await this.browser.newPage({ background });
         }
         await this.createPagesSnapshot();
-        this.selectPage(page);
+        this.selectPage(this.#getMcpPage(page));
         this.#networkCollector.addPage(page);
         this.#consoleCollector.addPage(page);
-        return page;
+        return this.#getMcpPage(page);
     }
     async closePage(pageId) {
         if (this.#pages.length === 1) {
             throw new Error(CLOSE_PAGE_ERROR);
         }
         const page = this.getPageById(pageId);
-        await page.close({ runBeforeUnload: false });
-        this.#pageToIsolatedContextName.delete(page);
-    }
-    getNetworkRequestById(reqid) {
-        return this.#networkCollector.getById(this.getSelectedPage(), reqid);
-    }
-    async emulate(options) {
-        const page = this.getSelectedPage();
-        const currentSettings = this.#emulationSettingsMap.get(page) ?? {};
-        const newSettings = { ...currentSettings };
-        let timeoutsNeedUpdate = false;
-        if (options.networkConditions !== undefined) {
-            timeoutsNeedUpdate = true;
-            if (options.networkConditions === null ||
-                options.networkConditions === 'No emulation') {
-                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 (page) {
+            page.dispose();
+            this.#mcpPages.delete(page.pptrPage);
+        }
+        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';
         }
-        if (options.cpuThrottlingRate !== undefined) {
-            timeoutsNeedUpdate = true;
-            if (options.cpuThrottlingRate === null) {
-                await page.emulateCPUThrottling(1);
-                delete newSettings.cpuThrottlingRate;
-            }
-            else {
-                await page.emulateCPUThrottling(options.cpuThrottlingRate);
-                newSettings.cpuThrottlingRate = options.cpuThrottlingRate;
-            }
+        else if (options.networkConditions in PredefinedNetworkConditions) {
+            const networkCondition = PredefinedNetworkConditions[options.networkConditions];
+            await page.emulateNetworkConditions(networkCondition);
+            newSettings.networkConditions = options.networkConditions;
         }
-        if (options.geolocation !== undefined) {
-            if (options.geolocation === null) {
-                await page.setGeolocation({ latitude: 0, longitude: 0 });
-                delete newSettings.geolocation;
-            }
-            else {
-                await page.setGeolocation(options.geolocation);
-                newSettings.geolocation = options.geolocation;
-            }
+        if (!options.cpuThrottlingRate) {
+            await page.emulateCPUThrottling(1);
+            delete newSettings.cpuThrottlingRate;
         }
-        if (options.userAgent !== undefined) {
-            if (options.userAgent === null) {
-                await page.setUserAgent({ userAgent: undefined });
-                delete newSettings.userAgent;
-            }
-            else {
-                await page.setUserAgent({ userAgent: options.userAgent });
-                newSettings.userAgent = options.userAgent;
-            }
+        else {
+            await page.emulateCPUThrottling(options.cpuThrottlingRate);
+            newSettings.cpuThrottlingRate = options.cpuThrottlingRate;
         }
-        if (options.colorScheme !== undefined) {
-            if (options.colorScheme === null || 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.geolocation) {
+            await page.setGeolocation({ latitude: 0, longitude: 0 });
+            delete newSettings.geolocation;
         }
-        if (options.viewport !== undefined) {
-            if (options.viewport === null) {
-                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;
-            }
+        else {
+            await page.setGeolocation(options.geolocation);
+            newSettings.geolocation = options.geolocation;
         }
-        if (Object.keys(newSettings).length) {
-            this.#emulationSettingsMap.set(page, newSettings);
+        if (!options.userAgent) {
+            await page.setUserAgent({ userAgent: undefined });
+            delete newSettings.userAgent;
         }
         else {
-            this.#emulationSettingsMap.delete(page);
+            await page.setUserAgent({ userAgent: options.userAgent });
+            newSettings.userAgent = options.userAgent;
         }
-        if (timeoutsNeedUpdate) {
-            this.#updateSelectedPageTimeouts();
+        if (!options.colorScheme || options.colorScheme === 'auto') {
+            await page.emulateMediaFeatures([
+                { name: 'prefers-color-scheme', value: '' },
+            ]);
+            delete newSettings.colorScheme;
         }
-    }
-    getNetworkConditions() {
-        const page = this.getSelectedPage();
-        return this.#emulationSettingsMap.get(page)?.networkConditions ?? null;
-    }
-    getCpuThrottlingRate() {
-        const page = this.getSelectedPage();
-        return this.#emulationSettingsMap.get(page)?.cpuThrottlingRate ?? 1;
-    }
-    getGeolocation() {
-        const page = this.getSelectedPage();
-        return this.#emulationSettingsMap.get(page)?.geolocation ?? null;
-    }
-    getViewport() {
-        const page = this.getSelectedPage();
-        return this.#emulationSettingsMap.get(page)?.viewport ?? null;
-    }
-    getUserAgent() {
-        const page = this.getSelectedPage();
-        return this.#emulationSettingsMap.get(page)?.userAgent ?? null;
-    }
-    getColorScheme() {
-        const page = this.getSelectedPage();
-        return this.#emulationSettingsMap.get(page)?.colorScheme ?? null;
+        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();
     }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
@@ -342,93 +287,70 @@ export class McpContext {
     isCruxEnabled() {
         return this.#options.performanceCrux;
     }
-    getDialog() {
-        return this.#dialog;
-    }
-    clearDialog() {
-        this.#dialog = undefined;
-    }
-    getSelectedPage() {
+    getSelectedPptrPage() {
         const page = this.#selectedPage;
         if (!page) {
             throw new Error('No page selected');
         }
-        if (page.isClosed()) {
+        if (page.pptrPage.isClosed()) {
             throw new Error(`The selected page has been closed. Call ${listPages().name} to see open pages.`);
         }
-        return page;
+        return page.pptrPage;
+    }
+    getSelectedMcpPage() {
+        const page = this.getSelectedPptrPage();
+        return this.#getMcpPage(page);
     }
     getPageById(pageId) {
-        const page = this.#pages.find(p => this.#pageIdMap.get(p) === pageId);
+        const page = this.#mcpPages.values().find(mcpPage => mcpPage.id === pageId);
         if (!page) {
             throw new Error('No page found');
         }
         return page;
     }
     getPageId(page) {
-        return this.#pageIdMap.get(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());
     }
-    #dialogHandler = (dialog) => {
-        this.#dialog = dialog;
-    };
     isPageSelected(page) {
-        return this.#selectedPage === page;
+        return this.#selectedPage?.pptrPage === page;
     }
     selectPage(newPage) {
-        const oldPage = this.#selectedPage;
-        if (oldPage) {
-            oldPage.off('dialog', this.#dialogHandler);
-            void oldPage.emulateFocusedPage(false).catch(error => {
-                this.logger('Error turning off focused page emulation', error);
-            });
-        }
         this.#selectedPage = newPage;
-        newPage.on('dialog', this.#dialogHandler);
         this.#updateSelectedPageTimeouts();
-        void newPage.emulateFocusedPage(true).catch(error => {
-            this.logger('Error turning on focused page emulation', error);
-        });
     }
     #updateSelectedPageTimeouts() {
-        const page = this.getSelectedPage();
+        const page = this.#getSelectedMcpPage();
         // For waiters 5sec timeout should be sufficient.
         // Increased in case we throttle the CPU
-        const cpuMultiplier = this.getCpuThrottlingRate();
-        page.setDefaultTimeout(DEFAULT_TIMEOUT * cpuMultiplier);
+        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(this.getNetworkConditions());
-        page.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier);
-    }
-    getNavigationTimeout() {
-        const page = this.getSelectedPage();
-        return page.getDefaultNavigationTimeout();
+        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) {
-        return this.#textSnapshot?.idToNode.get(uid);
-    }
-    async getElementByUid(uid) {
-        if (!this.#textSnapshot?.idToNode.size) {
-            throw new Error(`No snapshot found. Use ${takeSnapshot.name} to capture one.`);
-        }
-        const node = this.#textSnapshot?.idToNode.get(uid);
-        if (!node) {
-            throw new Error('No such element found in the snapshot.');
-        }
-        const message = `Element with uid ${uid} no longer exists on the page.`;
-        try {
-            const handle = await node.elementHandle();
-            if (!handle) {
-                throw new Error(message);
+        for (const mcpPage of this.#mcpPages.values()) {
+            const node = mcpPage.textSnapshot?.idToNode.get(uid);
+            if (node) {
+                return node;
             }
-            return handle;
-        }
-        catch (error) {
-            throw new Error(message, {
-                cause: error,
-            });
         }
+        return undefined;
     }
     /**
      * Creates a snapshot of the extension service workers.
@@ -454,19 +376,35 @@ export class McpContext {
         return this.#extensionServiceWorkers;
     }
     async createPagesSnapshot() {
-        const allPages = await this.#getAllPages();
+        const { pages: allPages, isolatedContextNames } = await this.#getAllPages();
         for (const page of allPages) {
-            if (!this.#pageIdMap.has(page)) {
-                this.#pageIdMap.set(page, this.#nextPageId++);
+            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) === -1) &&
+        if ((!this.#selectedPage ||
+            this.#pages.indexOf(this.#selectedPage.pptrPage) === -1) &&
             this.#pages[0]) {
-            this.selectPage(this.#pages[0]);
+            this.selectPage(this.#getMcpPage(this.#pages[0]));
         }
         await this.detectOpenDevToolsWindows();
         return this.#pages;
@@ -474,6 +412,32 @@ export class McpContext {
     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);
+            }
+        }
         // Build a reverse lookup from BrowserContext instance → name.
         const contextToName = new Map();
         for (const [name, ctx] of this.#isolatedContexts) {
@@ -489,20 +453,24 @@ export class McpContext {
                 contextToName.set(ctx, name);
             }
         }
-        // Use page.browserContext() to determine each page's context membership.
+        // 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) {
-                this.#pageToIsolatedContextName.set(page, name);
+                isolatedContextNames.set(page, name);
             }
         }
-        return allPages;
+        return { pages: allPages, isolatedContextNames };
     }
     async detectOpenDevToolsWindows() {
         this.logger('Detecting open DevTools windows');
-        const pages = await this.#getAllPages();
-        this.#pageToDevToolsPage = new Map();
+        const { pages } = await this.#getAllPages();
+        // Clear all devToolsPage references before re-detecting.
+        for (const mcpPage of this.#mcpPages.values()) {
+            mcpPage.devToolsPage = undefined;
+        }
         for (const devToolsPage of pages) {
             if (devToolsPage.url().startsWith('devtools://')) {
                 try {
@@ -519,7 +487,10 @@ export class McpContext {
                     // TODO: lookup without a loop.
                     for (const page of this.#pages) {
                         if (urlsEqual(page.url(), urlLike)) {
-                            this.#pageToDevToolsPage.set(page, devToolsPage);
+                            const mcpPage = this.#mcpPages.get(page);
+                            if (mcpPage) {
+                                mcpPage.devToolsPage = devToolsPage;
+                            }
                         }
                     }
                 }
@@ -539,16 +510,15 @@ export class McpContext {
         return this.#pages;
     }
     getIsolatedContextName(page) {
-        return this.#pageToIsolatedContextName.get(page);
+        return this.#mcpPages.get(page)?.isolatedContextName;
     }
     getDevToolsPage(page) {
-        return this.#pageToDevToolsPage.get(page);
+        return this.#mcpPages.get(page)?.devToolsPage;
     }
-    async getDevToolsData() {
+    async getDevToolsData(page) {
         try {
             this.logger('Getting DevTools UI data');
-            const selectedPage = this.getSelectedPage();
-            const devtoolsPage = this.getDevToolsPage(selectedPage);
+            const devtoolsPage = this.getDevToolsPage(page.pptrPage);
             if (!devtoolsPage) {
                 this.logger('No DevTools page detected');
                 return {};
@@ -575,15 +545,15 @@ export class McpContext {
     /**
      * Creates a text snapshot of a page.
      */
-    async createTextSnapshot(verbose = false, devtoolsData = undefined) {
-        const page = this.getSelectedPage();
-        const rootNode = await page.accessibility.snapshot({
+    async createTextSnapshot(page, verbose = false, devtoolsData = undefined) {
+        const rootNode = await page.pptrPage.accessibility.snapshot({
             includeIframes: true,
             interestingOnly: !verbose,
         });
         if (!rootNode) {
             return;
         }
+        const { uniqueBackendNodeIdToMcpId } = page;
         const snapshotId = this.#nextSnapshotId++;
         // Iterate through the whole accessibility node tree and assign node ids that
         // will be used for the tree serialization and mapping ids back to nodes.
@@ -594,14 +564,14 @@ export class McpContext {
             let id = '';
             // @ts-expect-error untyped loaderId & backendNodeId.
             const uniqueBackendId = `${node.loaderId}_${node.backendNodeId}`;
-            if (this.#uniqueBackendNodeIdToMcpId.has(uniqueBackendId)) {
+            if (uniqueBackendNodeIdToMcpId.has(uniqueBackendId)) {
                 // Re-use MCP exposed ID if the uniqueId is the same.
-                id = this.#uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
+                id = uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
             }
             else {
                 // Only generate a new ID if we have not seen the node before.
                 id = `${snapshotId}_${idCounter++}`;
-                this.#uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
+                uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
             }
             seenUniqueIds.add(uniqueBackendId);
             const nodeWithId = {
@@ -623,49 +593,39 @@ export class McpContext {
             return nodeWithId;
         };
         const rootNodeWithId = assignIds(rootNode);
-        this.#textSnapshot = {
+        const snapshot = {
             root: rootNodeWithId,
             snapshotId: String(snapshotId),
             idToNode,
             hasSelectedElement: false,
             verbose,
         };
-        const data = devtoolsData ?? (await this.getDevToolsData());
+        page.textSnapshot = snapshot;
+        const data = devtoolsData ?? (await this.getDevToolsData(page));
         if (data?.cdpBackendNodeId) {
-            this.#textSnapshot.hasSelectedElement = true;
-            this.#textSnapshot.selectedElementUid = this.resolveCdpElementId(data?.cdpBackendNodeId);
+            snapshot.hasSelectedElement = true;
+            snapshot.selectedElementUid = this.resolveCdpElementId(page, data?.cdpBackendNodeId);
         }
         // Clean up unique IDs that we did not see anymore.
-        for (const key of this.#uniqueBackendNodeIdToMcpId.keys()) {
+        for (const key of uniqueBackendNodeIdToMcpId.keys()) {
             if (!seenUniqueIds.has(key)) {
-                this.#uniqueBackendNodeIdToMcpId.delete(key);
+                uniqueBackendNodeIdToMcpId.delete(key);
             }
         }
     }
-    getTextSnapshot() {
-        return this.#textSnapshot;
-    }
-    async saveTemporaryFile(data, mimeType) {
-        try {
-            const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'chrome-devtools-mcp-'));
-            const filename = path.join(dir, `screenshot.${getExtensionFromMimeType(mimeType)}`);
-            await fs.writeFile(filename, data);
-            return { filename };
-        }
-        catch (err) {
-            this.logger(err);
-            throw new Error('Could not save a screenshot to a file', { cause: err });
-        }
+    async saveTemporaryFile(data, filename) {
+        return await saveTemporaryFile(data, filename);
     }
     async saveFile(data, filename) {
         try {
             const filePath = path.resolve(filename);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
             await fs.writeFile(filePath, data);
-            return { filename };
+            return { filename: filePath };
         }
         catch (err) {
             this.logger(err);
-            throw new Error('Could not save a screenshot to a file', { cause: err });
+            throw new Error('Could not save a file', { cause: err });
         }
     }
     storeTraceRecording(result) {
@@ -680,17 +640,17 @@ export class McpContext {
         return new WaitForHelper(page, cpuMultiplier, networkMultiplier);
     }
     waitForEventsAfterAction(action, options) {
-        const page = this.getSelectedPage();
-        const cpuMultiplier = this.getCpuThrottlingRate();
-        const networkMultiplier = getNetworkMultiplierFromString(this.getNetworkConditions());
-        const waitForHelper = this.getWaitForHelper(page, cpuMultiplier, networkMultiplier);
+        const page = this.#getSelectedMcpPage();
+        const cpuMultiplier = page.cpuThrottlingRate;
+        const networkMultiplier = getNetworkMultiplierFromString(page.networkConditions);
+        const waitForHelper = this.getWaitForHelper(page.pptrPage, cpuMultiplier, networkMultiplier);
         return waitForHelper.waitForEventsAfterAction(action, options);
     }
     getNetworkRequestStableId(request) {
         return this.#networkCollector.getIdForResource(request);
     }
-    waitForTextOnPage(text, timeout) {
-        const page = this.getSelectedPage();
+    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}`),
@@ -715,7 +675,7 @@ export class McpContext {
                 },
             };
         });
-        const pages = await this.#getAllPages();
+        const { pages } = await this.#getAllPages();
         await this.#networkCollector.init(pages);
     }
     async installExtension(extensionPath) {
@@ -727,6 +687,22 @@ export class McpContext {
         await this.browser.uninstallExtension(id);
         this.#extensionRegistry.remove(id);
     }
+    async triggerExtensionAction(id) {
+        const page = this.getSelectedPptrPage();
+        // @ts-expect-error internal puppeteer api is needed since we don't have a way to get
+        // a tab id at the moment
+        const theTarget = page._tabId;
+        const session = await this.browser.target().createCDPSession();
+        try {
+            await session.send('Extensions.triggerAction', {
+                id,
+                targetId: theTarget,
+            });
+        }
+        finally {
+            await session.detach();
+        }
+    }
     listExtensions() {
         return this.#extensionRegistry.list();
     }