brave-mcp 1.10.1 → 1.11.0

package/build/src/BrowserManager.js

@@ -63,17 +63,25 @@ import path from 'node:path';
 import { Mutex, puppeteer } from './third_party/index.js';
 import { logger, puppeteerLogger } from './utils/logger.js';
 import { isAllowedUrl } from './utils/url.js';
+// Node runs a timer whose delay exceeds 2^31-1 ms after 1 ms instead, which
+// would make every CDP call and tool call time out at once.
+const MAXIMUM_TIMER_DELAY_MILLISECONDS = 2_147_483_647;
+export function parseProtocolTimeoutMilliseconds(rawValue) {
+    const timeoutMilliseconds = Number(rawValue ?? '600000');
+    if (!Number.isSafeInteger(timeoutMilliseconds) ||
+        timeoutMilliseconds <= 0 ||
+        timeoutMilliseconds > MAXIMUM_TIMER_DELAY_MILLISECONDS) {
+        throw new Error(`BRAVE_DEVTOOLS_PROTOCOL_TIMEOUT_MS must be a positive integer no greater than ${MAXIMUM_TIMER_DELAY_MILLISECONDS}.`);
+    }
+    return timeoutMilliseconds;
+}
 // Heavy pages (e.g. Studio module dev bundles >100MB) cannot ack
 // `Network.enable` and other auto-attached domain calls within
 // puppeteer's default 180s. Once that fires, the CDP connection is
 // marked dead and every subsequent call throws — only daemon restart
 // recovers. Bumping the ceiling to 10min covers realistic loads;
 // override via env for power users.
-export const PROTOCOL_TIMEOUT_MILLISECONDS = Number(process.env.BRAVE_DEVTOOLS_PROTOCOL_TIMEOUT_MS ?? '600000');
-if (!Number.isSafeInteger(PROTOCOL_TIMEOUT_MILLISECONDS) ||
-    PROTOCOL_TIMEOUT_MILLISECONDS <= 0) {
-    throw new Error('BRAVE_DEVTOOLS_PROTOCOL_TIMEOUT_MS must be a positive integer.');
-}
+export const PROTOCOL_TIMEOUT_MILLISECONDS = parseProtocolTimeoutMilliseconds(process.env.BRAVE_DEVTOOLS_PROTOCOL_TIMEOUT_MS);
 export function resolveBraveExecutablePath(channel = 'release') {
     const environmentPath = process.env['BRAVE_PATH'];
     if (environmentPath) {
@@ -255,7 +263,7 @@ export class BrowserManager {
             // a call silently adopt the freshly-rotated token as its own baseline
             // once the lock frees up, defeating the abandonment check entirely.
             const attempt = this.#browserAttempt;
-            const _guard = __addDisposableResource(env_1, await this.#mutex.acquire(), false);
+            const guard = __addDisposableResource(env_1, await this.#mutex.acquire(), false);
             if (this.#closingCount > 0) {
                 throw new Error('Browser was closed while initializing.');
             }
@@ -306,9 +314,7 @@ export class BrowserManager {
     abandonPendingAttempt() {
         this.#browserAttempt = new BrowserAttempt();
         this.#initPromise = undefined;
-        if (this.#browser) {
-            this.forget(this.#browser);
-        }
+        this.#forgetCurrentBrowser();
     }
     async #initBrowser() {
         if (this.#serverArgs.browserUrl ||
@@ -405,24 +411,31 @@ export class BrowserManager {
         }
     }
     async #connect() {
-        const { browserUrl: browserURL, wsEndpoint, wsHeaders, autoConnect: isAutoConnect, userDataDir, blockedUrlPattern: blocklist, allowedUrlPattern: allowlist, } = this.#serverArgs;
+        const { browserUrl: browserURL, wsEndpoint, wsHeaders, autoConnect: isAutoConnect, userDataDir, blockedUrlPattern: blocklist, allowedUrlPattern: allowlist, categoryExtensions: enableExtensions, } = this.#serverArgs;
         // Important: only pass channel, if autoConnect is true.
         const channel = isAutoConnect ? this.#serverArgs.channel : undefined;
         const connectOptions = {
-            targetFilter: _a.makeTargetFilter(),
+            targetFilter: _a.makeTargetFilter(enableExtensions),
             defaultViewport: null,
             handleDevToolsAsPage: true,
             protocolTimeout: PROTOCOL_TIMEOUT_MILLISECONDS,
             blocklist,
             allowlist,
             logger: puppeteerLogger,
+            // Detects a transport that died without a close frame (e.g. an adb
+            // port-forward torn down mid-call). Puppeteer pings the socket
+            // periodically and terminates it on a missed pong, which rejects the
+            // in-flight CDP calls and fires `disconnected` so #evictIfCurrent()
+            // drops the stale handle. Without this, such a call would hang until
+            // protocolTimeout while holding the tool mutex.
+            wsOptions: {
+                keepAlive: true,
+                headers: wsHeaders,
+            },
         };
         let autoConnect = false;
         if (wsEndpoint) {
             connectOptions.browserWSEndpoint = wsEndpoint;
-            if (wsHeaders) {
-                connectOptions.headers = wsHeaders;
-            }
         }
         else if (browserURL) {
             connectOptions.browserURL = browserURL;
@@ -478,32 +491,31 @@ export class BrowserManager {
         }
     }
     /**
-     * Clears the cached browser handle if it still matches `candidate`, so the
-     * next ensureBrowser() call establishes a fresh connection instead of
-     * reusing a handle that looks connected but is actually dead (e.g. its CDP
-     * transport died without ever emitting a `close`/`disconnected` event — as
-     * happens when an adb port-forward is torn down mid-call rather than
-     * closed cleanly).
+     * Drops the cached browser handle so the next ensureBrowser() call
+     * establishes a fresh connection. Only called from abandonPendingAttempt()
+     * when a getContext()-level timeout fires after ensureBrowser() already
+     * resolved, which means the handle looks connected but its CDP
+     * initialization is hanging.
      *
-     * Also actively tears `candidate` down in the background: closes it if it
-     * was launched (so the Brave subprocess doesn't leak), or disconnects if
-     * it was only connected to (so the transport and its listeners don't
-     * leak). This also settles any CDP call still pending against it —
-     * Puppeteer's connection disposal synchronously rejects in-flight
-     * callbacks — instead of leaving a hung call to leak forever.
+     * Also tears the browser down in the background: closes it if it was
+     * launched (so the Brave subprocess doesn't leak), or disconnects if it
+     * was only connected to (so the transport and its listeners don't leak).
+     * Puppeteer's connection disposal rejects any in-flight CDP call, so a hung
+     * call settles instead of leaking forever.
      */
-    forget(candidate) {
-        if (this.#browser !== candidate) {
+    #forgetCurrentBrowser() {
+        const browser = this.#browser;
+        if (!browser) {
             return;
         }
         const mode = this.#browserMode;
         this.#browser = undefined;
         this.#browserMode = undefined;
         if (mode === 'launched') {
-            void this.#closeLaunchedBrowser(candidate);
+            void this.#closeLaunchedBrowser(browser);
         }
         else {
-            void candidate.disconnect().catch(err => {
+            void browser.disconnect().catch(err => {
                 logger?.('Failed to disconnect forgotten browser', err);
             });
         }
@@ -514,9 +526,8 @@ export class BrowserManager {
      * call reconnects proactively rather than only discovering the staleness
      * lazily on the next call's `!this.#browser?.connected` check. No teardown
      * here — the browser is already disconnected/closed, that's why this
-     * fired — so this shares forget()'s identity guard without its cleanup,
-     * making a `disconnected` that fires late on an already-superseded browser
-     * a safe no-op.
+     * fired. The identity guard makes a `disconnected` that fires late on an
+     * already-superseded browser a safe no-op.
      */
     #evictIfCurrent(candidate) {
         if (this.#browser !== candidate) {
@@ -571,7 +582,7 @@ export class BrowserManager {
         try {
             this.#initPromise = undefined;
             this.#closingCount++;
-            const _guard = __addDisposableResource(env_2, await this.#mutex.acquire(), false);
+            const guard = __addDisposableResource(env_2, await this.#mutex.acquire(), false);
             try {
                 await this.#closeBrowser();
             }

package/build/src/McpContext.js

@@ -8,7 +8,6 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { overrideDevToolsGlobals } from './devtools/DevtoolsUtils.js';
-import { HeapSnapshotManager } from './processors/HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { ServiceWorkerConsoleCollector } from './collectors/ServiceWorkerCollector.js';
 import { Locator, } from './third_party/index.js';
@@ -37,12 +36,11 @@ export class McpContext {
     #selectedPageFallback;
     #serviceWorkerConsoleCollector;
     #isRunningTrace = false;
-    #screenRecorderData = null;
     #reconnectNotice = false;
     #traceResults = [];
     #locatorClass;
     #options;
-    #heapSnapshotManager = new HeapSnapshotManager();
+    #heapSnapshotManager;
     #roots = undefined;
     #allowUnrestrictedPaths;
     constructor(browser, logger, options, locatorClass) {
@@ -55,6 +53,7 @@ export class McpContext {
         this.logger = logger;
         this.#locatorClass = locatorClass;
         this.#options = options;
+        this.#heapSnapshotManager = options.heapSnapshotManager;
         this.#allowUnrestrictedPaths = options.allowUnrestrictedPaths ?? false;
         this.#reconnectNotice = options.reconnected ?? false;
         this.#serviceWorkerConsoleCollector = new ServiceWorkerConsoleCollector(this.browser);
@@ -70,7 +69,6 @@ export class McpContext {
         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();
         }
@@ -212,10 +210,10 @@ export class McpContext {
         return mcpPage;
     }
     async closePage(pageId) {
+        const page = this.getPageById(pageId);
         if (this.#mcpPages.size === 1) {
             throw new Error(CLOSE_PAGE_ERROR);
         }
-        const page = this.getPageById(pageId);
         this.#mcpPages.delete(page.target);
         await page.close();
     }
@@ -259,18 +257,30 @@ export class McpContext {
     isRunningPerformanceTrace() {
         return this.#isRunningTrace;
     }
-    getScreenRecorder() {
-        return this.#screenRecorderData;
-    }
-    setScreenRecorder(data) {
-        this.#screenRecorderData = data;
-    }
     isCruxEnabled() {
         return this.#options.performanceCrux;
     }
     getPages() {
         return Array.from(this.#mcpPages.values());
     }
+    /**
+     * Fetches current target info for all targets from the browser, keyed by
+     * target id. Unlike Puppeteer's cached target info, this reflects title
+     * changes, which Chrome does not report via `Target.targetInfoChanged`.
+     * Returns an empty map if the browser cannot be queried.
+     */
+    async getTargetInfos() {
+        try {
+            // @ts-expect-error use existing browser connection (internal Puppeteer API).
+            const connection = this.browser._connection;
+            const { targetInfos } = await connection.send('Target.getTargets');
+            return new Map(targetInfos.map(info => [info.targetId, info]));
+        }
+        catch (err) {
+            this.logger?.('Failed to fetch target infos', err);
+            return new Map();
+        }
+    }
     getSelectedMcpPage() {
         const page = this.#selectedPage;
         if (!page) {
@@ -594,10 +604,7 @@ export class McpContext {
         return await this.#heapSnapshotManager.analyzeContexts(filePath);
     }
     async closeHeapSnapshot(filePath) {
-        return this.#heapSnapshotManager.disposeSnapshot(filePath);
-    }
-    hasHeapSnapshots() {
-        return this.#heapSnapshotManager.hasSnapshots();
+        return await this.#heapSnapshotManager.disposeSnapshot(filePath);
     }
     async getHeapSnapshotRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings) {
         return await this.#heapSnapshotManager.getRetainingPaths(filePath, nodeId, maxDepth, maxNodes, maxSiblings);
@@ -628,18 +635,41 @@ export class McpContext {
         }
         throw new Error(`Not allowed by allowlist: ${url}`);
     }
+    async #loadNetworkResource(url) {
+        const redirectStatuses = new Set([301, 302, 303, 307, 308]);
+        const maxRedirects = 20;
+        let currentUrl = url;
+        for (let redirectCount = 0;; redirectCount++) {
+            this.#validateUrlNotBlocked(currentUrl);
+            this.#validateUrlAllowed(currentUrl);
+            const response = await fetch(currentUrl, { redirect: 'manual' });
+            if (!redirectStatuses.has(response.status)) {
+                if (!response.ok) {
+                    throw new Error(`Failed to load resource: ${currentUrl}`);
+                }
+                return await response.text();
+            }
+            const location = response.headers.get('location');
+            if (!location) {
+                throw new Error(`Failed to load resource: ${currentUrl}`);
+            }
+            if (redirectCount >= maxRedirects) {
+                throw new Error(`Too many redirects loading resource: ${url}`);
+            }
+            await response.body?.cancel();
+            currentUrl = new URL(location, currentUrl);
+            if (currentUrl.protocol !== 'https:' && currentUrl.protocol !== 'http:') {
+                throw new Error(`Unsupported protocol for: ${currentUrl}`);
+            }
+        }
+    }
     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();
+                return await this.#loadNetworkResource(url);
             }
             case 'file:': {
                 const resolved = await this.validatePath(fileURLToPath(url));

package/build/src/McpPage.js

@@ -55,6 +55,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { DevToolsCommentBridge } from './devtools/DevToolsCommentBridge.js';
+import { createTargetUniverse, } from './devtools/DevtoolsUtils.js';
+import { ConsoleCollector, NetworkCollector, } from './collectors/PageCollector.js';
+import { TextSnapshot } from './TextSnapshot.js';
+import { PredefinedNetworkConditions, DevTools, } from './third_party/index.js';
+import { logger } from './utils/logger.js';
+import { getNetworkMultiplierFromString, WaitForHelper, } from './utils/WaitForHelper.js';
 export function replaceHtmlElementsWithUids(schema) {
     if (typeof schema === 'boolean') {
         return;
@@ -101,15 +108,25 @@ export function replaceHtmlElementsWithUids(schema) {
         }
     }
 }
-import { DevToolsCommentBridge } from './devtools/DevToolsCommentBridge.js';
-import { createTargetUniverse, } from './devtools/DevtoolsUtils.js';
-import { ConsoleCollector, NetworkCollector, } from './collectors/PageCollector.js';
-import { TextSnapshot } from './TextSnapshot.js';
-import { PredefinedNetworkConditions, DevTools, } from './third_party/index.js';
+function isDebuggingWebMcpTool(tool) {
+    return Boolean(tool.annotations &&
+        'debugging' in tool.annotations &&
+        tool.annotations.debugging === true);
+}
 const DEFAULT_TIMEOUT = 5_000;
 const NAVIGATION_TIMEOUT = 10_000;
-import { logger } from './utils/logger.js';
-import { getNetworkMultiplierFromString, WaitForHelper, } from './utils/WaitForHelper.js';
+/**
+ * Chrome reports a URL-derived placeholder as the target title until the
+ * document provides one. The placeholder omits the `http://` / `https://`
+ * scheme and the trailing slash of a bare hostname.
+ */
+function isPlaceholderTitle(title, url) {
+    if (title === url) {
+        return true;
+    }
+    const withoutScheme = url.replace(/^https?:\/\//, '');
+    return title === withoutScheme || title === withoutScheme.replace(/\/$/, '');
+}
 function isBackendNodeId(id) {
     return typeof id === 'number';
 }
@@ -140,7 +157,9 @@ export class McpPage {
     // Dialog
     #dialog;
     #dialogHandler;
-    thirdPartyDeveloperTools = [];
+    // Screencast
+    #screenRecorder = null;
+    eventBasedThirdPartyTools = [];
     #networkCollector;
     #consoleCollector;
     #hasNetworkBlockOrAllowlist;
@@ -184,12 +203,27 @@ export class McpPage {
         return this.#consoleCollector;
     }
     url() {
-        return this.#pptrPage ? this.#pptrPage.url() : this.target.url();
+        return this.#pptrPage?.url() ?? this.target.url();
     }
-    getTitle() {
+    get targetId() {
         // @ts-expect-error internal types
         const info = this.target._getTargetInfo();
-        return info.title !== this.target.url() ? info.title : '';
+        return info.targetId;
+    }
+    /**
+     * Returns the page title or an empty string if the target only has Chrome's
+     * URL-based placeholder title.
+     *
+     * Puppeteer's cached target info is only refreshed by
+     * `Target.targetInfoChanged`, which Chrome emits on navigation commit (before
+     * the document title is known) but not on title changes. Callers should pass
+     * fresh target info (e.g., from `Target.getTargets`) when available.
+     */
+    getTitle(freshTargetInfo) {
+        // @ts-expect-error internal types
+        const cachedInfo = this.target._getTargetInfo();
+        const info = freshTargetInfo ?? cachedInfo;
+        return isPlaceholderTitle(info.title, info.url) ? '' : info.title;
     }
     isClosed() {
         if (this.#closed) {
@@ -213,7 +247,7 @@ export class McpPage {
             throw new Error(`McpPage (id=${this.id}) has already been disposed.`);
         }
         if (this.#initPromise) {
-            return this.#initPromise;
+            return await this.#initPromise;
         }
         this.#initPromise = this.#doInit();
         try {
@@ -288,13 +322,41 @@ export class McpPage {
     clearDialog() {
         this.#dialog = undefined;
     }
+    getScreenRecorder() {
+        return this.#screenRecorder;
+    }
+    setScreenRecorder(data) {
+        this.#screenRecorder = data;
+    }
     throwIfDialogOpen() {
         if (this.#dialog && !this.#dialog.handled) {
             throw new Error(`A dialog is open (${this.#dialog.type()}: ${this.#dialog.message()}).`);
         }
     }
+    #getDebuggingWebMcpToolGroups() {
+        const webmcpTools = this.pptrPage.webmcp
+            .tools()
+            .filter(isDebuggingWebMcpTool);
+        if (webmcpTools.length === 0) {
+            return [];
+        }
+        return [
+            {
+                name: 'WebMCP Tools',
+                description: 'Tools exposed via WebMCP',
+                tools: webmcpTools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: structuredClone(tool.inputSchema ?? {}),
+                })),
+            },
+        ];
+    }
     getThirdPartyDeveloperTools() {
-        return this.thirdPartyDeveloperTools;
+        return [
+            ...this.#getDebuggingWebMcpToolGroups(),
+            ...this.eventBasedThirdPartyTools,
+        ];
     }
     async getToolGroups() {
         const env_1 = { stack: [], error: void 0, hasError: false };
@@ -303,13 +365,14 @@ export class McpPage {
             const windowHandle = __addDisposableResource(env_1, await this.pptrPage.evaluateHandle(() => window), false);
             // @ts-expect-error internal API
             const client = this.pptrPage._client();
-            const { listeners } = await client.send('DOMDebugger.getEventListeners', {
+            const { listeners = [] } = await client.send('DOMDebugger.getEventListeners', {
                 objectId: windowHandle.remoteObject().objectId,
             });
             if (listeners.find(l => l.type === 'devtoolstooldiscovery') === undefined) {
-                return [];
+                this.eventBasedThirdPartyTools = [];
+                return this.getThirdPartyDeveloperTools();
             }
-            const toolGroups = await this.pptrPage.evaluate(() => {
+            const eventToolGroups = await this.pptrPage.evaluate(() => {
                 if (window.__dtmcp) {
                     window.__dtmcp.toolGroups = [];
                 }
@@ -377,13 +440,13 @@ export class McpPage {
                     }
                 });
             });
-            for (const group of toolGroups) {
+            for (const group of eventToolGroups) {
                 for (const tool of group.tools ?? []) {
                     replaceHtmlElementsWithUids(tool.inputSchema);
                 }
             }
-            this.thirdPartyDeveloperTools = toolGroups;
-            return toolGroups;
+            this.eventBasedThirdPartyTools = eventToolGroups;
+            return this.getThirdPartyDeveloperTools();
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -394,7 +457,9 @@ export class McpPage {
         }
     }
     getWebMcpTools() {
-        return this.pptrPage.webmcp.tools();
+        return this.pptrPage.webmcp
+            .tools()
+            .filter(tool => !isDebuggingWebMcpTool(tool));
     }
     resolveCdpRequestId(cdpRequestId) {
         if (!cdpRequestId) {
@@ -425,14 +490,18 @@ export class McpPage {
     get commentBridge() {
         return this.#commentBridge;
     }
+    /**
+     * Returns the comment bridge attached to the DevTools page, or undefined if
+     * the DevTools page does not support DevTools comments.
+     */
     async ensureDevToolsCommentBridge(devtoolsPage) {
         if (!this.#commentBridge) {
             this.#commentBridge = new DevToolsCommentBridge({
                 onNotification: this.#onNotification,
             });
         }
-        await this.#commentBridge.attach(devtoolsPage);
-        return this.#commentBridge;
+        const attached = await this.#commentBridge.attach(devtoolsPage);
+        return attached ? this.#commentBridge : undefined;
     }
     async getDevToolsPage() {
         try {
@@ -480,6 +549,15 @@ export class McpPage {
     get colorScheme() {
         return this.emulationSettings.colorScheme ?? null;
     }
+    get forcedColors() {
+        return this.emulationSettings.forcedColors ?? null;
+    }
+    get prefersContrast() {
+        return this.emulationSettings.prefersContrast ?? null;
+    }
+    get prefersReducedMotion() {
+        return this.emulationSettings.prefersReducedMotion ?? null;
+    }
     // Public for testability: tests spy on this method to verify throttle multipliers.
     createWaitForHelper(cpuMultiplier, networkMultiplier) {
         return new WaitForHelper(this.pptrPage, cpuMultiplier, networkMultiplier);
@@ -492,6 +570,13 @@ export class McpPage {
         this.#disposed = true;
         this.#commentBridge?.dispose();
         this.#commentBridge = undefined;
+        if (this.#screenRecorder) {
+            const { recorder } = this.#screenRecorder;
+            this.#screenRecorder = null;
+            void recorder.stop().catch(e => {
+                logger?.('Failed to stop screencast recording on dispose', e);
+            });
+        }
         this.#pptrPage?.off('dialog', this.#dialogHandler);
         this.#networkCollector?.dispose();
         this.#consoleCollector?.dispose();
@@ -503,6 +588,23 @@ export class McpPage {
         });
     }
     async executeThirdPartyDeveloperTool(toolName, params, response) {
+        const webmcpTool = this.pptrPage.webmcp
+            .tools()
+            .find(t => t.name === toolName && isDebuggingWebMcpTool(t));
+        if (webmcpTool) {
+            const { status, output, errorText, exception } = await webmcpTool.execute(params);
+            if (status !== 'Completed') {
+                const error = exception?.description ?? exception?.value ?? errorText;
+                throw new Error(error ? String(error) : `Tool execution failed: ${status}`);
+            }
+            if (output !== undefined) {
+                response.appendResponseLine(JSON.stringify(output, null, 2));
+            }
+            else {
+                response.appendResponseLine('Tool returned no result.');
+            }
+            return;
+        }
         // Creates array of ElementHandles from the UIDs in the params.
         // We do not replace the uids with the ElementsHandles yet, because
         // the `evaluate` function only turns them into DOM elements if they
@@ -677,7 +779,7 @@ export class McpPage {
                     typeof node.stashedId === 'string' &&
                     node.stashedId.startsWith('stashed-') &&
                     Object.keys(node).length === 1) {
-                    const index = parseInt(node.stashedId.split('-')[1]);
+                    const index = parseInt(node.stashedId.split('-')[1], 10);
                     return { uid: cdpElementIds[index] };
                 }
                 const resultObj = {};
@@ -705,7 +807,7 @@ export class McpPage {
         if (!node) {
             throw new Error(`Element uid "${uid}" not found on page ${this.id}.`);
         }
-        return this.#resolveElementHandle(node, uid);
+        return await this.#resolveElementHandle(node, uid);
     }
     async #resolveElementHandle(node, uid) {
         const message = `Element with uid ${uid} no longer exists on the page.`;
@@ -812,7 +914,6 @@ export class McpPage {
             }
             await this.ensureDevToolsCommentBridge(devtoolsPage);
             const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
-                window.universe?.cd4aBridge?.setAgentAttached(true);
                 // @ts-expect-error no types
                 const UI = await import('/bundled/ui/legacy/legacy.js');
                 // @ts-expect-error no types
@@ -835,6 +936,20 @@ export class McpPage {
         const currentSetting = this.emulationSettings;
         await this.emulate(currentSetting);
     }
+    async #emulateMediaFeatures(settings) {
+        // `page.emulateMediaFeatures` replaces all previously emulated media
+        // features, so every supported feature is sent on each call. An empty
+        // value disables the override for that feature.
+        await this.pptrPage.emulateMediaFeatures([
+            { name: 'prefers-color-scheme', value: settings.colorScheme ?? '' },
+            { name: 'forced-colors', value: settings.forcedColors ?? '' },
+            { name: 'prefers-contrast', value: settings.prefersContrast ?? '' },
+            {
+                name: 'prefers-reduced-motion',
+                value: settings.prefersReducedMotion ?? '',
+            },
+        ]);
+    }
     async emulate(options) {
         const page = this.pptrPage;
         const newSettings = { ...this.emulationSettings };
@@ -898,17 +1013,31 @@ export class McpPage {
             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.forcedColors || options.forcedColors === 'auto') {
+            delete newSettings.forcedColors;
+        }
+        else {
+            newSettings.forcedColors = options.forcedColors;
+        }
+        if (!options.prefersContrast || options.prefersContrast === 'auto') {
+            delete newSettings.prefersContrast;
+        }
+        else {
+            newSettings.prefersContrast = options.prefersContrast;
+        }
+        if (!options.prefersReducedMotion ||
+            options.prefersReducedMotion === 'auto') {
+            delete newSettings.prefersReducedMotion;
+        }
+        else {
+            newSettings.prefersReducedMotion = options.prefersReducedMotion;
+        }
+        await this.#emulateMediaFeatures(newSettings);
         if (!options.viewport) {
             delete newSettings.viewport;
         }
@@ -941,12 +1070,12 @@ export class McpPage {
         // For waiters 5sec timeout should be sufficient.
         // Increased in case we throttle the CPU
         const cpuMultiplier = this.cpuThrottlingRate;
-        this.#pptrPage.setDefaultTimeout(DEFAULT_TIMEOUT * cpuMultiplier);
+        this.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 or the CPU
         const networkMultiplier = getNetworkMultiplierFromString(this.networkConditions);
-        this.#pptrPage.setDefaultNavigationTimeout(this.#navigationTimeout * networkMultiplier * cpuMultiplier);
+        this.pptrPage.setDefaultNavigationTimeout(this.#navigationTimeout * networkMultiplier * cpuMultiplier);
     }
     waitForTextOnPage(text, timeout) {
         const frames = this.pptrPage.frames();