chrome-devtools-mcp 0.2.0 → 0.2.1

package/build/src/McpContext.js

@@ -3,6 +3,23 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { listPages } from './tools/pages.js';
+import { WaitForHelper } from './WaitForHelper.js';
+const DEFAULT_TIMEOUT = 5_000;
+const NAVIGATION_TIMEOUT = 10_000;
+function getNetworkMultiplierFromString(condition) {
+    const puppeteerCondition = condition;
+    switch (puppeteerCondition) {
+        case 'Fast 4G':
+            return 1;
+        case 'Slow 4G':
+            return 2.5;
+        case 'Fast 3G':
+            return 5;
+        case 'Slow 3G':
+            return 10;
+    }
+    return 1;
+}
 export class McpContext {
     browser;
     logger;
@@ -14,8 +31,8 @@ export class McpContext {
     #networkCollector;
     #consoleCollector;
     #isRunningTrace = false;
-    #networkConditions = null;
-    #cpuThrottlingRate = 1;
+    #networkConditionsMap = new WeakMap();
+    #cpuThrottlingRateMap = new WeakMap();
     #dialog;
     #nextSnapshotId = 1;
     #traceResults = [];
@@ -28,10 +45,10 @@ export class McpContext {
             });
         });
         this.#consoleCollector = new PageCollector(this.browser, (page, collect) => {
-            page.on('console', (event) => {
+            page.on('console', event => {
                 collect(event);
             });
-            page.on('pageerror', (event) => {
+            page.on('pageerror', event => {
                 collect(event);
             });
         });
@@ -76,16 +93,27 @@ export class McpContext {
         throw new Error('Request not found for selected page');
     }
     setNetworkConditions(conditions) {
-        this.#networkConditions = conditions;
+        const page = this.getSelectedPage();
+        if (conditions === null) {
+            this.#networkConditionsMap.delete(page);
+        }
+        else {
+            this.#networkConditionsMap.set(page, conditions);
+        }
+        this.#updateSelectedPageTimeouts();
     }
     getNetworkConditions() {
-        return this.#networkConditions;
+        const page = this.getSelectedPage();
+        return this.#networkConditionsMap.get(page) ?? null;
     }
     setCpuThrottlingRate(rate) {
-        this.#cpuThrottlingRate = rate;
+        const page = this.getSelectedPage();
+        this.#cpuThrottlingRateMap.set(page, rate);
+        this.#updateSelectedPageTimeouts();
     }
     getCpuThrottlingRate() {
-        return this.#cpuThrottlingRate;
+        const page = this.getSelectedPage();
+        return this.#cpuThrottlingRateMap.get(page) ?? 1;
     }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
@@ -129,11 +157,23 @@ export class McpContext {
         this.#selectedPageIdx = idx;
         const newPage = this.getSelectedPage();
         newPage.on('dialog', this.#dialogHandler);
+        this.#updateSelectedPageTimeouts();
+    }
+    #updateSelectedPageTimeouts() {
+        const page = this.getSelectedPage();
         // For waiters 5sec timeout should be sufficient.
-        newPage.setDefaultTimeout(5_000);
+        // Increased in case we throttle the CPU
+        const cpuMultiplier = this.getCpuThrottlingRate();
+        page.setDefaultTimeout(DEFAULT_TIMEOUT * cpuMultiplier);
         // 10sec should be enough for the load event to be emitted during
         // navigations.
-        newPage.setDefaultNavigationTimeout(10_000);
+        // 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();
     }
     async getElementByUid(uid) {
         if (!this.#textSnapshot?.idToNode.size) {
@@ -216,4 +256,14 @@ export class McpContext {
     recordedTraces() {
         return this.#traceResults;
     }
+    getWaitForHelper(page, cpuMultiplier, networkMultiplier) {
+        return new WaitForHelper(page, cpuMultiplier, networkMultiplier);
+    }
+    waitForEventsAfterAction(action) {
+        const page = this.getSelectedPage();
+        const cpuMultiplier = this.getCpuThrottlingRate();
+        const networkMultiplier = getNetworkMultiplierFromString(this.getNetworkConditions());
+        const waitForHelper = this.getWaitForHelper(page, cpuMultiplier, networkMultiplier);
+        return waitForHelper.waitForEventsAfterAction(action);
+    }
 }

package/build/src/McpResponse.js

@@ -8,7 +8,7 @@ export class McpResponse {
     #attachedNetworkRequestUrl;
     #includeConsoleData = false;
     #textResponseLines = [];
-    #formatedConsoleData;
+    #formattedConsoleData;
     #images = [];
     setIncludePages(value) {
         this.#includePages = value;
@@ -64,7 +64,7 @@ export class McpResponse {
             const consoleMessages = context.getConsoleData();
             if (consoleMessages) {
                 formattedConsoleMessages = await Promise.all(consoleMessages.map(message => formatConsoleEvent(message)));
-                this.#formatedConsoleData = formattedConsoleMessages;
+                this.#formattedConsoleData = formattedConsoleMessages;
             }
         }
         return this.format(toolName, context);
@@ -78,6 +78,7 @@ export class McpResponse {
         if (networkConditions) {
             response.push(`## Network emulation`);
             response.push(`Emulating: ${networkConditions}`);
+            response.push(`Navigation timeout set to ${context.getNavigationTimeout()} ms`);
         }
         const cpuThrottlingRate = context.getCpuThrottlingRate();
         if (cpuThrottlingRate > 1) {
@@ -120,9 +121,9 @@ Call browser_handle_dialog to handle it before continuing.`);
                 response.push('No requests found.');
             }
         }
-        if (this.#includeConsoleData && this.#formatedConsoleData) {
+        if (this.#includeConsoleData && this.#formattedConsoleData) {
             response.push('## Console messages');
-            response.push(...this.#formatedConsoleData);
+            response.push(...this.#formattedConsoleData);
         }
         const text = {
             type: 'text',

package/build/src/WaitForHelper.js

@@ -0,0 +1,123 @@
+import { logger } from './logger.js';
+export class WaitForHelper {
+    #abortController = new AbortController();
+    #page;
+    #stableDomTimeout;
+    #stableDomFor;
+    #expectNavigationIn;
+    #navigationTimeout;
+    constructor(page, cpuTimeoutMultiplier, networkTimeoutMultiplier) {
+        this.#stableDomTimeout = 3000 * cpuTimeoutMultiplier;
+        this.#stableDomFor = 100 * cpuTimeoutMultiplier;
+        this.#expectNavigationIn = 100 * cpuTimeoutMultiplier;
+        this.#navigationTimeout = 3000 * networkTimeoutMultiplier;
+        this.#page = page;
+    }
+    /**
+     * A wrapper that executes a action and waits for
+     * a potential navigation, after which it waits
+     * for the DOM to be stable before returning.
+     */
+    async waitForStableDom() {
+        const stableDomObserver = await this.#page.evaluateHandle(timeout => {
+            let timeoutId;
+            function callback() {
+                clearTimeout(timeoutId);
+                timeoutId = setTimeout(() => {
+                    domObserver.resolver.resolve();
+                    domObserver.observer.disconnect();
+                }, timeout);
+            }
+            const domObserver = {
+                resolver: Promise.withResolvers(),
+                observer: new MutationObserver(callback),
+            };
+            // It's possible that the DOM is not gonna change so we
+            // need to start the timeout initially.
+            callback();
+            domObserver.observer.observe(document.body, {
+                childList: true,
+                subtree: true,
+                attributes: true,
+            });
+            return domObserver;
+        }, this.#stableDomFor);
+        this.#abortController.signal.addEventListener('abort', async () => {
+            try {
+                await stableDomObserver.evaluate(observer => {
+                    observer.observer.disconnect();
+                    observer.resolver.resolve();
+                });
+                await stableDomObserver.dispose();
+            }
+            catch {
+                // Ignored cleanup errors
+            }
+        });
+        return Promise.race([
+            stableDomObserver.evaluate(async (observer) => {
+                return await observer.resolver.promise;
+            }),
+            this.timeout(this.#stableDomTimeout).then(() => {
+                throw new Error('Timeout');
+            }),
+        ]);
+    }
+    async waitForNavigationStarted() {
+        // Currently Puppeteer does not have API
+        // For when a navigation is about to start
+        const navigationStartedPromise = new Promise(resolve => {
+            const listener = (event) => {
+                if ([
+                    'historySameDocument',
+                    'historyDifferentDocument',
+                    'sameDocument',
+                ].includes(event.navigationType)) {
+                    resolve(false);
+                    return;
+                }
+                resolve(true);
+            };
+            this.#page._client().on('Page.frameStartedNavigating', listener);
+            this.#abortController.signal.addEventListener('abort', () => {
+                resolve(false);
+                this.#page._client().off('Page.frameStartedNavigating', listener);
+            });
+        });
+        return await Promise.race([
+            navigationStartedPromise,
+            this.timeout(this.#expectNavigationIn).then(() => false),
+        ]);
+    }
+    timeout(time) {
+        return new Promise(res => {
+            const id = setTimeout(res, time);
+            this.#abortController.signal.addEventListener('abort', () => {
+                res();
+                clearTimeout(id);
+            });
+        });
+    }
+    async waitForEventsAfterAction(action) {
+        const navigationStartedPromise = this.waitForNavigationStarted();
+        await action();
+        try {
+            const navigationStated = await navigationStartedPromise;
+            if (navigationStated) {
+                await this.#page.waitForNavigation({
+                    timeout: this.#navigationTimeout,
+                    signal: this.#abortController.signal,
+                });
+            }
+            // Wait for stable dom after navigation so we execute in
+            // the correct context
+            await this.waitForStableDom();
+        }
+        catch (error) {
+            logger(error);
+        }
+        finally {
+            this.#abortController.abort();
+        }
+    }
+}

package/build/src/browser.js

@@ -53,11 +53,7 @@ export async function launch(options) {
             recursive: true,
         });
     }
-    const args = [
-        '--remote-debugging-pipe',
-        '--no-first-run',
-        '--hide-crash-restore-bubble',
-    ];
+    const args = ['--hide-crash-restore-bubble'];
     if (customDevTools) {
         args.push(`--custom-devtools-frontend=file://${customDevTools}`);
     }
@@ -69,7 +65,7 @@ export async function launch(options) {
                 : 'chrome';
     }
     try {
-        return await puppeteer.launch({
+        const browser = await puppeteer.launch({
             ...connectOptions,
             channel: puppeterChannel,
             executablePath,
@@ -79,12 +75,19 @@ export async function launch(options) {
             headless,
             args,
         });
+        if (options.logFile) {
+            // FIXME: we are probably subscribing too late to catch startup logs. We
+            // should expose the process earlier or expose the getRecentLogs() getter.
+            browser.process()?.stderr?.pipe(options.logFile);
+            browser.process()?.stdout?.pipe(options.logFile);
+        }
+        return browser;
     }
     catch (error) {
-        // TODO: check browser logs for `Failed to create a ProcessSingleton for
-        // your profile directory` instead.
         if (userDataDir &&
-            error.message.includes('The browser is already running')) {
+            (error.message.includes('The browser is already running') ||
+                error.message.includes('Target closed') ||
+                error.message.includes('Connection closed'))) {
             throw new Error(`The browser is already running for ${userDataDir}. Use --isolated to run multiple browser instances.`, {
                 cause: error,
             });

package/build/src/index.js

@@ -61,10 +61,9 @@ export const cliOptions = {
     },
     channel: {
         type: 'string',
-        description: 'Specify a different Chrome channel that should be used.',
+        description: 'Specify a different Chrome channel that should be used. The default is the stable channel version.',
         choices: ['stable', 'canary', 'beta', 'dev'],
         conflicts: ['browserUrl', 'executablePath'],
-        default: 'stable',
     },
     logFile: {
         type: 'string',
@@ -99,9 +98,7 @@ export const args = yargsInstance
     .wrap(Math.min(120, yargsInstance.terminalWidth()))
     .help()
     .parseSync();
-if (args.logFile) {
-    saveLogsToFile(args.logFile);
-}
+const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 function readPackageJson() {
     const currentDir = import.meta.dirname;
     const packageJsonPath = path.join(currentDir, '..', '..', 'package.json');
@@ -136,6 +133,7 @@ async function getContext() {
         customDevTools: args.customDevtools,
         channel: args.channel,
         isolated: args.isolated,
+        logFile,
     });
     if (context?.browser !== browser) {
         context = await McpContext.from(browser, logger);

package/build/src/logger.js

@@ -22,5 +22,6 @@ export function saveLogsToFile(fileName) {
         logFile.end();
         process.exit(1);
     });
+    return logFile;
 }
 export const logger = debug(mcpDebugNamespace);

package/build/src/tools/input.js

@@ -6,7 +6,6 @@
 import z from 'zod';
 import { defineTool } from './ToolDefinition.js';
 import { ToolCategories } from './categories.js';
-import { waitForEventsAfterAction } from '../waitForHelpers.js';
 export const click = defineTool({
     name: 'click',
     description: `Clicks on the provided element`,
@@ -27,7 +26,7 @@ export const click = defineTool({
         const uid = request.params.uid;
         const handle = await context.getElementByUid(uid);
         try {
-            await waitForEventsAfterAction(handle.frame.page(), async () => {
+            await context.waitForEventsAfterAction(async () => {
                 await handle.asLocator().click({
                     count: request.params.dblClick ? 2 : 1,
                 });
@@ -58,7 +57,7 @@ export const hover = defineTool({
         const uid = request.params.uid;
         const handle = await context.getElementByUid(uid);
         try {
-            await waitForEventsAfterAction(handle.frame.page(), async () => {
+            await context.waitForEventsAfterAction(async () => {
                 await handle.asLocator().hover();
             });
             response.appendResponseLine(`Successfully hovered over the element`);
@@ -85,7 +84,7 @@ export const fill = defineTool({
     handler: async (request, response, context) => {
         const handle = await context.getElementByUid(request.params.uid);
         try {
-            await waitForEventsAfterAction(handle.frame.page(), async () => {
+            await context.waitForEventsAfterAction(async () => {
                 await handle.asLocator().fill(request.params.value);
             });
             response.appendResponseLine(`Successfully filled out the element`);
@@ -111,7 +110,7 @@ export const drag = defineTool({
         const fromHandle = await context.getElementByUid(request.params.from_uid);
         const toHandle = await context.getElementByUid(request.params.to_uid);
         try {
-            await waitForEventsAfterAction(fromHandle.frame.page(), async () => {
+            await context.waitForEventsAfterAction(async () => {
                 await fromHandle.drag(toHandle);
                 await new Promise(resolve => setTimeout(resolve, 50));
                 await toHandle.drop(fromHandle);
@@ -144,7 +143,7 @@ export const fillForm = defineTool({
         for (const element of request.params.elements) {
             const handle = await context.getElementByUid(element.uid);
             try {
-                await waitForEventsAfterAction(handle.frame.page(), async () => {
+                await context.waitForEventsAfterAction(async () => {
                     await handle.asLocator().fill(element.value);
                 });
             }

package/build/src/tools/pages.js

@@ -6,7 +6,6 @@
 import z from 'zod';
 import { defineTool } from './ToolDefinition.js';
 import { ToolCategories } from './categories.js';
-import { waitForEventsAfterAction } from '../waitForHelpers.js';
 export const listPages = defineTool({
     name: 'list_pages',
     description: `Get a list of pages open in the browser.`,
@@ -69,7 +68,7 @@ export const newPage = defineTool({
     },
     handler: async (request, response, context) => {
         const page = await context.newPage();
-        await waitForEventsAfterAction(page, async () => {
+        await context.waitForEventsAfterAction(async () => {
             await page.goto(request.params.url);
         });
         response.setIncludePages(true);
@@ -87,7 +86,7 @@ export const navigatePage = defineTool({
     },
     handler: async (request, response, context) => {
         const page = context.getSelectedPage();
-        await waitForEventsAfterAction(page, async () => {
+        await context.waitForEventsAfterAction(async () => {
             await page.goto(request.params.url);
         });
         response.setIncludePages(true);

package/build/src/tools/performance.js

@@ -10,7 +10,7 @@ import { logger } from '../logger.js';
 import { ToolCategories } from './categories.js';
 export const startTrace = defineTool({
     name: 'performance_start_trace',
-    description: 'Starts a performance trace recording',
+    description: 'Starts a performance trace recording on the selected page.',
     annotations: {
         category: ToolCategories.PERFORMANCE,
         readOnlyHint: true,
@@ -77,7 +77,7 @@ export const startTrace = defineTool({
 });
 export const stopTrace = defineTool({
     name: 'performance_stop_trace',
-    description: 'Stops the active performance trace recording',
+    description: 'Stops the active performance trace recording on the selected page.',
     annotations: {
         category: ToolCategories.PERFORMANCE,
         readOnlyHint: true,
@@ -93,7 +93,7 @@ export const stopTrace = defineTool({
 });
 export const analyzeInsight = defineTool({
     name: 'performance_analyze_insight',
-    description: 'Provides more detailed information on a specific Performance Insight that was highlighed in the results of a trace recording',
+    description: 'Provides more detailed information on a specific Performance Insight that was highlighed in the results of a trace recording.',
     annotations: {
         category: ToolCategories.PERFORMANCE,
         readOnlyHint: true,

package/build/src/tools/script.js

@@ -6,7 +6,6 @@
 import z from 'zod';
 import { defineTool } from './ToolDefinition.js';
 import { ToolCategories } from './categories.js';
-import { waitForEventsAfterAction } from '../waitForHelpers.js';
 export const evaluateScript = defineTool({
     name: 'evaluate_script',
     description: `Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON
@@ -43,7 +42,7 @@ Example with arguments: \`(el) => {
             for (const el of request.params.args ?? []) {
                 args.push(await context.getElementByUid(el.uid));
             }
-            await waitForEventsAfterAction(page, async () => {
+            await context.waitForEventsAfterAction(async () => {
                 const result = await page.evaluate(async (fn, ...args) => {
                     // @ts-expect-error no types.
                     return JSON.stringify(await fn(...args));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "MCP server for Chrome DevTools",
   "type": "module",
   "bin": {
@@ -8,17 +8,18 @@
   },
   "main": "index.js",
   "scripts": {
-    "build": "tsc && node --experimental-strip-types scripts/post-build.ts",
+    "build": "tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
     "typecheck": "tsc --noEmit",
-    "format": "eslint --cache --fix . ;prettier --write --cache .",
-    "check-format": "eslint --cache .; prettier --check --cache .;",
-    "generate-docs": "npm run build && node --experimental-strip-types scripts/generate-docs.ts",
+    "format": "eslint --cache --fix . && prettier --write --cache .",
+    "check-format": "eslint --cache . && prettier --check --cache .;",
+    "docs": "npm run build && npm run docs:generate && npm run format",
+    "docs:generate": "node --experimental-strip-types scripts/generate-docs.ts",
     "start": "npm run build && node build/src/index.js",
     "start-debug": "DEBUG=mcp:* DEBUG_COLORS=false npm run build && node build/src/index.js",
-    "test": "npm run build && node --require ./build/tests/setup.js --test-reporter spec --test-force-exit --test 'build/tests/**/*.test.js'",
-    "test:only": "npm run build && node --require ./build/tests/setup.js --test-reporter spec --test-force-exit --test --test-only 'build/tests/**/*.test.js'",
-    "test:only:no-build": "node --require ./build/tests/setup.js --test-reporter spec --test-force-exit --test --test-only 'build/tests/**/*.test.js'",
-    "test:update-snapshots": "npm run build && node --require ./build/tests/setup.js --test-force-exit --test --test-update-snapshots 'build/tests/**/*.test.js'",
+    "test": "npm run build && node --require ./build/tests/setup.js --no-warnings=ExperimentalWarning --test-reporter spec --test-force-exit --test \"build/tests/**/*.test.js\"",
+    "test:only": "npm run build && node --require ./build/tests/setup.js --no-warnings=ExperimentalWarning --test-reporter spec --test-force-exit --test --test-only \"build/tests/**/*.test.js\"",
+    "test:only:no-build": "node --require ./build/tests/setup.js --no-warnings=ExperimentalWarning --test-reporter spec --test-force-exit --test --test-only \"build/tests/**/*.test.js\"",
+    "test:update-snapshots": "npm run build && node --require ./build/tests/setup.js --no-warnings=ExperimentalWarning --test-force-exit --test --test-update-snapshots \"build/tests/**/*.test.js\"",
     "prepare": "node --experimental-strip-types scripts/prepare.ts"
   },
   "files": [
@@ -35,7 +36,7 @@
   },
   "homepage": "https://github.com/ChromeDevTools/chrome-devtools-mcp#readme",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.18.0",
+    "@modelcontextprotocol/sdk": "1.18.1",
     "debug": "4.4.3",
     "puppeteer-core": "24.22.0",
     "yargs": "18.0.0"
@@ -49,7 +50,7 @@
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.43.0",
     "@typescript-eslint/parser": "^8.43.0",
-    "chrome-devtools-frontend": "1.0.1515796",
+    "chrome-devtools-frontend": "1.0.1516909",
     "eslint": "^9.35.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",

package/build/src/waitForHelpers.js

@@ -1,109 +0,0 @@
-import { logger } from './logger.js';
-async function waitForStableDom(page, signal) {
-    const stableDomObserver = await page.evaluateHandle(() => {
-        let timeoutId;
-        function callback() {
-            clearTimeout(timeoutId);
-            timeoutId = setTimeout(() => {
-                domObserver.resolver.resolve();
-                domObserver.observer.disconnect();
-            }, 100);
-        }
-        const domObserver = {
-            resolver: Promise.withResolvers(),
-            observer: new MutationObserver(callback),
-        };
-        // It's possible that the DOM is not gonna change so we
-        // need to start the timeout initially.
-        callback();
-        domObserver.observer.observe(document.body, {
-            childList: true,
-            subtree: true,
-            attributes: true,
-        });
-        return domObserver;
-    });
-    signal.addEventListener('abort', async () => {
-        try {
-            await stableDomObserver.evaluate(observer => {
-                observer.observer.disconnect();
-                observer.resolver.resolve();
-            });
-            await stableDomObserver.dispose();
-        }
-        catch {
-            // Ignored cleanup errors
-        }
-    });
-    return Promise.race([
-        stableDomObserver.evaluate(async (observer) => {
-            return await observer.resolver.promise;
-        }),
-        timeout(3000, signal).then(() => {
-            throw new Error('Timeout');
-        }),
-    ]);
-}
-async function waitForNavigationStarted(page, signal) {
-    // Currently Puppeteer does not have API
-    // For when a navigation is about to start
-    const navigationStartedPromise = new Promise(resolve => {
-        const listener = (event) => {
-            if ([
-                'historySameDocument',
-                'historyDifferentDocument',
-                'sameDocument',
-            ].includes(event.navigationType)) {
-                resolve(false);
-                return;
-            }
-            resolve(true);
-        };
-        page._client().on('Page.frameStartedNavigating', listener);
-        signal.addEventListener('abort', () => {
-            resolve(false);
-            page._client().off('Page.frameStartedNavigating', listener);
-        });
-    });
-    return await Promise.race([
-        navigationStartedPromise,
-        timeout(100).then(() => false),
-    ]);
-}
-function timeout(time, signal) {
-    return new Promise(res => {
-        const id = setTimeout(res, time);
-        signal?.addEventListener('abort', () => {
-            res();
-            clearTimeout(id);
-        });
-    });
-}
-/**
- * A wrapper that executes a action and waits for
- * a potential navigation, after which it waits
- * for the DOM to be stable before returning.
- */
-export async function waitForEventsAfterAction(page, callback) {
-    const controller = new AbortController();
-    const navigationStartedPromise = waitForNavigationStarted(page, controller.signal);
-    await callback();
-    try {
-        const navigationStated = await navigationStartedPromise;
-        if (navigationStated) {
-            await page.waitForNavigation({
-                timeout: 3000,
-                signal: controller.signal,
-            });
-        }
-        // Wait for stable dom after navigation so we execute in
-        // the correct context
-        await waitForStableDom(page, controller.signal);
-    }
-    catch (error) {
-        logger(error);
-    }
-    finally {
-        controller.abort();
-    }
-}