chrome-devtools-mcp 0.18.1 → 0.19.0

package/build/src/tools/pages.js

@@ -6,8 +6,8 @@
 import { logger } from '../logger.js';
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
-import { CLOSE_PAGE_ERROR, defineTool, timeoutSchema } from './ToolDefinition.js';
-export const listPages = defineTool(args => {
+import { CLOSE_PAGE_ERROR, definePageTool, defineTool, timeoutSchema, } from './ToolDefinition.js';
+export const listPages = definePageTool(args => {
     return {
         name: 'list_pages',
         description: `Get a list of pages ${args?.categoryExtensions ? 'including extension service workers' : ''} open in the browser.`,
@@ -42,7 +42,7 @@ export const selectPage = defineTool({
         context.selectPage(page);
         response.setIncludePages(true);
         if (request.params.bringToFront) {
-            await page.bringToFront();
+            await page.pptrPage.bringToFront();
         }
     },
 });
@@ -75,7 +75,7 @@ export const closePage = defineTool({
 });
 export const newPage = defineTool({
     name: 'new_page',
-    description: `Creates a new page`,
+    description: `Open a new tab and load a URL. Use project URL if not specified otherwise.`,
     annotations: {
         category: ToolCategory.NAVIGATION,
         readOnlyHint: false,
@@ -97,16 +97,16 @@ export const newPage = defineTool({
     handler: async (request, response, context) => {
         const page = await context.newPage(request.params.background, request.params.isolatedContext);
         await context.waitForEventsAfterAction(async () => {
-            await page.goto(request.params.url, {
+            await page.pptrPage.goto(request.params.url, {
                 timeout: request.params.timeout,
             });
         }, { timeout: request.params.timeout });
         response.setIncludePages(true);
     },
 });
-export const navigatePage = defineTool({
+export const navigatePage = definePageTool({
     name: 'navigate_page',
-    description: `Navigates the currently selected page to a URL.`,
+    description: `Go to a URL, or back, forward, or reload. Use project URL if not specified otherwise.`,
     annotations: {
         category: ToolCategory.NAVIGATION,
         readOnlyHint: false,
@@ -132,7 +132,7 @@ export const navigatePage = defineTool({
         ...timeoutSchema,
     },
     handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
+        const page = request.page;
         const options = {
             timeout: request.params.timeout,
         };
@@ -154,15 +154,15 @@ export const navigatePage = defineTool({
                     void dialog.dismiss();
                 }
                 // We are not going to report the dialog like regular dialogs.
-                context.clearDialog();
+                page.clearDialog();
             }
         };
         let initScriptId;
         if (request.params.initScript) {
-            const { identifier } = await page.evaluateOnNewDocument(request.params.initScript);
+            const { identifier } = await page.pptrPage.evaluateOnNewDocument(request.params.initScript);
             initScriptId = identifier;
         }
-        page.on('dialog', dialogHandler);
+        page.pptrPage.on('dialog', dialogHandler);
         try {
             await context.waitForEventsAfterAction(async () => {
                 switch (request.params.type) {
@@ -171,7 +171,7 @@ export const navigatePage = defineTool({
                             throw new Error('A URL is required for navigation of type=url.');
                         }
                         try {
-                            await page.goto(request.params.url, options);
+                            await page.pptrPage.goto(request.params.url, options);
                             response.appendResponseLine(`Successfully navigated to ${request.params.url}.`);
                         }
                         catch (error) {
@@ -180,8 +180,8 @@ export const navigatePage = defineTool({
                         break;
                     case 'back':
                         try {
-                            await page.goBack(options);
-                            response.appendResponseLine(`Successfully navigated back to ${page.url()}.`);
+                            await page.pptrPage.goBack(options);
+                            response.appendResponseLine(`Successfully navigated back to ${page.pptrPage.url()}.`);
                         }
                         catch (error) {
                             response.appendResponseLine(`Unable to navigate back in the selected page: ${error.message}.`);
@@ -189,8 +189,8 @@ export const navigatePage = defineTool({
                         break;
                     case 'forward':
                         try {
-                            await page.goForward(options);
-                            response.appendResponseLine(`Successfully navigated forward to ${page.url()}.`);
+                            await page.pptrPage.goForward(options);
+                            response.appendResponseLine(`Successfully navigated forward to ${page.pptrPage.url()}.`);
                         }
                         catch (error) {
                             response.appendResponseLine(`Unable to navigate forward in the selected page: ${error.message}.`);
@@ -198,7 +198,7 @@ export const navigatePage = defineTool({
                         break;
                     case 'reload':
                         try {
-                            await page.reload({
+                            await page.pptrPage.reload({
                                 ...options,
                                 ignoreCache: request.params.ignoreCache,
                             });
@@ -212,9 +212,9 @@ export const navigatePage = defineTool({
             }, { timeout: request.params.timeout });
         }
         finally {
-            page.off('dialog', dialogHandler);
+            page.pptrPage.off('dialog', dialogHandler);
             if (initScriptId) {
-                await page
+                await page.pptrPage
                     .removeScriptToEvaluateOnNewDocument(initScriptId)
                     .catch(error => {
                     logger(`Failed to remove init script`, error);
@@ -224,7 +224,7 @@ export const navigatePage = defineTool({
         response.setIncludePages(true);
     },
 });
-export const resizePage = defineTool({
+export const resizePage = definePageTool({
     name: 'resize_page',
     description: `Resizes the selected page's window so that the page has specified dimension`,
     annotations: {
@@ -235,11 +235,11 @@ export const resizePage = defineTool({
         width: zod.number().describe('Page width'),
         height: zod.number().describe('Page height'),
     },
-    handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
+    handler: async (request, response, _context) => {
+        const page = request.page;
         try {
-            const browser = page.browser();
-            const windowId = await page.windowId();
+            const browser = page.pptrPage.browser();
+            const windowId = await page.pptrPage.windowId();
             const bounds = await browser.getWindowBounds(windowId);
             if (bounds.windowState === 'fullscreen') {
                 // Have to call this twice on Ubuntu when the window is in fullscreen mode.
@@ -253,14 +253,14 @@ export const resizePage = defineTool({
         catch {
             // Window APIs are not supported on all platforms
         }
-        await page.resize({
+        await page.pptrPage.resize({
             contentWidth: request.params.width,
             contentHeight: request.params.height,
         });
         response.setIncludePages(true);
     },
 });
-export const handleDialog = defineTool({
+export const handleDialog = definePageTool({
     name: 'handle_dialog',
     description: `If a browser dialog was opened, use this command to handle it`,
     annotations: {
@@ -276,8 +276,9 @@ export const handleDialog = defineTool({
             .optional()
             .describe('Optional prompt text to enter into the dialog.'),
     },
-    handler: async (request, response, context) => {
-        const dialog = context.getDialog();
+    handler: async (request, response, _context) => {
+        const page = request.page;
+        const dialog = page.getDialog();
         if (!dialog) {
             throw new Error('No open dialog found');
         }
@@ -305,11 +306,11 @@ export const handleDialog = defineTool({
                 break;
             }
         }
-        context.clearDialog();
+        page.clearDialog();
         response.setIncludePages(true);
     },
 });
-export const getTabId = defineTool({
+export const getTabId = definePageTool({
     name: 'get_tab_id',
     description: `Get the tab ID of the page`,
     annotations: {
@@ -324,8 +325,7 @@ export const getTabId = defineTool({
     },
     handler: async (request, response, context) => {
         const page = context.getPageById(request.params.pageId);
-        // @ts-expect-error _tabId is internal.
-        const tabId = page._tabId;
+        const tabId = page.pptrPage._tabId;
         response.setTabId(tabId);
     },
 });

package/build/src/tools/performance.js

@@ -8,14 +8,14 @@ import { logger } from '../logger.js';
 import { zod, DevTools } from '../third_party/index.js';
 import { parseRawTraceBuffer, traceResultIsSuccess, } from '../trace-processing/parse.js';
 import { ToolCategory } from './categories.js';
-import { defineTool } from './ToolDefinition.js';
+import { definePageTool } from './ToolDefinition.js';
 const filePathSchema = zod
     .string()
     .optional()
     .describe('The absolute file path, or a file path relative to the current working directory, to save the raw trace data. For example, trace.json.gz (compressed) or trace.json (uncompressed).');
-export const startTrace = defineTool({
+export const startTrace = definePageTool({
     name: 'performance_start_trace',
-    description: `Starts a performance trace recording on the selected page. This can be used to look for performance problems and insights to improve the performance of the page. It will also report Core Web Vital (CWV) scores for the page.`,
+    description: `Start a performance trace on the selected webpage. Use to find frontend performance issues, Core Web Vitals (LCP, INP, CLS), and improve page load speed.`,
     annotations: {
         category: ToolCategory.PERFORMANCE,
         readOnlyHint: false,
@@ -23,9 +23,11 @@ export const startTrace = defineTool({
     schema: {
         reload: zod
             .boolean()
+            .default(true)
             .describe('Determines if, once tracing has started, the current selected page should be automatically reloaded. Navigate the page to the right URL using the navigate_page tool BEFORE starting the trace if reload or autoStop is set to true.'),
         autoStop: zod
             .boolean()
+            .default(true)
             .describe('Determines if the trace recording should be automatically stopped.'),
         filePath: filePathSchema,
     },
@@ -35,11 +37,11 @@ export const startTrace = defineTool({
             return;
         }
         context.setIsRunningPerformanceTrace(true);
-        const page = context.getSelectedPage();
-        const pageUrlForTracing = page.url();
+        const page = request.page;
+        const pageUrlForTracing = page.pptrPage.url();
         if (request.params.reload) {
             // Before starting the recording, navigate to about:blank to clear out any state.
-            await page.goto('about:blank', {
+            await page.pptrPage.goto('about:blank', {
                 waitUntil: ['networkidle0'],
             });
         }
@@ -64,26 +66,26 @@ export const startTrace = defineTool({
             'v8.execute',
             'v8',
         ];
-        await page.tracing.start({
+        await page.pptrPage.tracing.start({
             categories,
         });
         if (request.params.reload) {
-            await page.goto(pageUrlForTracing, {
+            await page.pptrPage.goto(pageUrlForTracing, {
                 waitUntil: ['load'],
             });
         }
         if (request.params.autoStop) {
             await new Promise(resolve => setTimeout(resolve, 5_000));
-            await stopTracingAndAppendOutput(page, response, context, request.params.filePath);
+            await stopTracingAndAppendOutput(page.pptrPage, response, context, request.params.filePath);
         }
         else {
             response.appendResponseLine(`The performance trace is being recorded. Use performance_stop_trace to stop it.`);
         }
     },
 });
-export const stopTrace = defineTool({
+export const stopTrace = definePageTool({
     name: 'performance_stop_trace',
-    description: 'Stops the active performance trace recording on the selected page.',
+    description: 'Stop the active performance trace recording on the selected webpage.',
     annotations: {
         category: ToolCategory.PERFORMANCE,
         readOnlyHint: false,
@@ -95,11 +97,11 @@ export const stopTrace = defineTool({
         if (!context.isRunningPerformanceTrace()) {
             return;
         }
-        const page = context.getSelectedPage();
-        await stopTracingAndAppendOutput(page, response, context, request.params.filePath);
+        const page = request.page;
+        await stopTracingAndAppendOutput(page.pptrPage, response, context, request.params.filePath);
     },
 });
-export const analyzeInsight = defineTool({
+export const analyzeInsight = definePageTool({
     name: 'performance_analyze_insight',
     description: 'Provides more detailed information on a specific Performance Insight of an insight set that was highlighted in the results of a trace recording.',
     annotations: {

package/build/src/tools/screencast.js

@@ -8,12 +8,12 @@ import os from 'node:os';
 import path from 'node:path';
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
-import { defineTool } from './ToolDefinition.js';
+import { definePageTool } from './ToolDefinition.js';
 async function generateTempFilePath() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'chrome-devtools-mcp-'));
     return path.join(dir, `screencast.mp4`);
 }
-export const startScreencast = defineTool({
+export const startScreencast = definePageTool({
     name: 'screencast_start',
     description: 'Starts recording a screencast (video) of the selected page in mp4 format.',
     annotations: {
@@ -34,10 +34,10 @@ export const startScreencast = defineTool({
         }
         const filePath = request.params.path ?? (await generateTempFilePath());
         const resolvedPath = path.resolve(filePath);
-        const page = context.getSelectedPage();
+        const page = request.page;
         let recorder;
         try {
-            recorder = await page.screencast({
+            recorder = await page.pptrPage.screencast({
                 path: resolvedPath,
                 format: 'mp4',
             });
@@ -54,7 +54,7 @@ export const startScreencast = defineTool({
         response.appendResponseLine(`Screencast recording started. The recording will be saved to ${resolvedPath}. Use ${stopScreencast.name} to stop recording.`);
     },
 });
-export const stopScreencast = defineTool({
+export const stopScreencast = definePageTool({
     name: 'screencast_stop',
     description: 'Stops the active screencast recording on the selected page.',
     annotations: {

package/build/src/tools/screenshot.js

@@ -5,8 +5,8 @@
  */
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
-import { defineTool } from './ToolDefinition.js';
-export const screenshot = defineTool({
+import { definePageTool } from './ToolDefinition.js';
+export const screenshot = definePageTool({
     name: 'take_screenshot',
     description: `Take a screenshot of the page or element.`,
     annotations: {
@@ -44,10 +44,10 @@ export const screenshot = defineTool({
         }
         let pageOrHandle;
         if (request.params.uid) {
-            pageOrHandle = await context.getElementByUid(request.params.uid);
+            pageOrHandle = await request.page.getElementByUid(request.params.uid);
         }
         else {
-            pageOrHandle = context.getSelectedPage();
+            pageOrHandle = request.page.pptrPage;
         }
         const format = request.params.format;
         const quality = format === 'png' ? undefined : request.params.quality;
@@ -71,8 +71,8 @@ export const screenshot = defineTool({
             response.appendResponseLine(`Saved screenshot to ${file.filename}.`);
         }
         else if (screenshot.length >= 2_000_000) {
-            const { filename } = await context.saveTemporaryFile(screenshot, `image/${request.params.format}`);
-            response.appendResponseLine(`Saved screenshot to ${filename}.`);
+            const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.${request.params.format}`);
+            response.appendResponseLine(`Saved screenshot to ${filepath}.`);
         }
         else {
             response.attachImage({

package/build/src/tools/script.js

@@ -5,17 +5,18 @@
  */
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
-import { defineTool } from './ToolDefinition.js';
-export const evaluateScript = defineTool({
-    name: 'evaluate_script',
-    description: `Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON,
+import { defineTool, pageIdSchema } from './ToolDefinition.js';
+export const evaluateScript = defineTool(cliArgs => {
+    return {
+        name: 'evaluate_script',
+        description: `Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON,
 so returned values have to be JSON-serializable.`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        readOnlyHint: false,
-    },
-    schema: {
-        function: zod.string().describe(`A JavaScript function declaration to be executed by the tool in the currently selected page.
+        annotations: {
+            category: ToolCategory.DEBUGGING,
+            readOnlyHint: false,
+        },
+        schema: {
+            function: zod.string().describe(`A JavaScript function declaration to be executed by the tool in the currently selected page.
 Example without arguments: \`() => {
   return document.title
 }\` or \`async () => {
@@ -25,47 +26,96 @@ Example with arguments: \`(el) => {
   return el.innerText;
 }\`
 `),
-        args: zod
-            .array(zod.object({
-            uid: zod
+            args: zod
+                .array(zod
                 .string()
-                .describe('The uid of an element on the page from the page content snapshot'),
-        }))
-            .optional()
-            .describe(`An optional list of arguments to pass to the function.`),
-    },
-    handler: async (request, response, context) => {
-        const args = [];
-        try {
-            const frames = new Set();
-            for (const el of request.params.args ?? []) {
-                const handle = await context.getElementByUid(el.uid);
-                frames.add(handle.frame);
-                args.push(handle);
+                .describe('The uid of an element on the page from the page content snapshot'))
+                .optional()
+                .describe(`An optional list of arguments to pass to the function.`),
+            ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
+            ...(cliArgs?.categoryExtensions
+                ? {
+                    serviceWorkerId: zod
+                        .string()
+                        .optional()
+                        .describe(`An optional service worker id to evaluate the script in.`),
+                }
+                : {}),
+        },
+        handler: async (request, response, context) => {
+            const { serviceWorkerId, args: uidArgs, function: fnString, pageId, } = request.params;
+            if (cliArgs?.categoryExtensions && serviceWorkerId) {
+                if (uidArgs && uidArgs.length > 0) {
+                    throw new Error('args (element uids) cannot be used when evaluating in a service worker.');
+                }
+                if (pageId) {
+                    throw new Error('specify either a pageId or a serviceWorkerId.');
+                }
+                const worker = await getWebWorker(context, serviceWorkerId);
+                await performEvaluation(worker, fnString, [], response, context);
+                return;
             }
-            let pageOrFrame;
-            // We can't evaluate the element handle across frames
-            if (frames.size > 1) {
-                throw new Error("Elements from different frames can't be evaluated together.");
+            const mcpPage = cliArgs?.experimentalPageIdRouting
+                ? context.getPageById(request.params.pageId)
+                : context.getSelectedMcpPage();
+            const page = mcpPage.pptrPage;
+            const args = [];
+            try {
+                const frames = new Set();
+                for (const uid of uidArgs ?? []) {
+                    const handle = await mcpPage.getElementByUid(uid);
+                    frames.add(handle.frame);
+                    args.push(handle);
+                }
+                const evaluatable = await getPageOrFrame(page, frames);
+                await performEvaluation(evaluatable, fnString, args, response, context);
             }
-            else {
-                pageOrFrame = [...frames.values()][0] ?? context.getSelectedPage();
+            finally {
+                void Promise.allSettled(args.map(arg => arg.dispose()));
             }
-            const fn = await pageOrFrame.evaluateHandle(`(${request.params.function})`);
-            args.unshift(fn);
-            await context.waitForEventsAfterAction(async () => {
-                const result = await pageOrFrame.evaluate(async (fn, ...args) => {
-                    // @ts-expect-error no types.
-                    return JSON.stringify(await fn(...args));
-                }, ...args);
-                response.appendResponseLine('Script ran on page and returned:');
-                response.appendResponseLine('```json');
-                response.appendResponseLine(`${result}`);
-                response.appendResponseLine('```');
-            });
-        }
-        finally {
-            void Promise.allSettled(args.map(arg => arg.dispose()));
-        }
-    },
+        },
+    };
 });
+const performEvaluation = async (evaluatable, fnString, args, response, context) => {
+    const fn = await evaluatable.evaluateHandle(`(${fnString})`);
+    try {
+        await context.waitForEventsAfterAction(async () => {
+            const result = await evaluatable.evaluate(async (fn, ...args) => {
+                // @ts-expect-error no types for function fn
+                return JSON.stringify(await fn(...args));
+            }, fn, ...args);
+            response.appendResponseLine('Script ran on page and returned:');
+            response.appendResponseLine('```json');
+            response.appendResponseLine(`${result}`);
+            response.appendResponseLine('```');
+        });
+    }
+    finally {
+        void fn.dispose();
+    }
+};
+const getPageOrFrame = async (page, frames) => {
+    let pageOrFrame;
+    // We can't evaluate the element handle across frames
+    if (frames.size > 1) {
+        throw new Error("Elements from different frames can't be evaluated together.");
+    }
+    else {
+        pageOrFrame = [...frames.values()][0] ?? page;
+    }
+    return pageOrFrame;
+};
+const getWebWorker = async (context, serviceWorkerId) => {
+    const serviceWorkers = context.getExtensionServiceWorkers();
+    const serviceWorker = serviceWorkers.find((sw) => context.getExtensionServiceWorkerId(sw) === serviceWorkerId);
+    if (serviceWorker && serviceWorker.target) {
+        const worker = await serviceWorker.target.worker();
+        if (!worker) {
+            throw new Error('Service worker target not found.');
+        }
+        return worker;
+    }
+    else {
+        throw new Error('Service worker not found.');
+    }
+};

package/build/src/tools/slim/tools.js

@@ -5,8 +5,8 @@
  */
 import { zod } from '../../third_party/index.js';
 import { ToolCategory } from '../categories.js';
-import { defineTool } from '../ToolDefinition.js';
-export const screenshot = defineTool({
+import { definePageTool } from '../ToolDefinition.js';
+export const screenshot = definePageTool({
     name: 'screenshot',
     description: `Takes a screenshot`,
     annotations: {
@@ -16,16 +16,16 @@ export const screenshot = defineTool({
     },
     schema: {},
     handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
-        const screenshot = await page.screenshot({
+        const page = request.page;
+        const screenshot = await page.pptrPage.screenshot({
             type: 'png',
             optimizeForSpeed: true,
         });
-        const { filename } = await context.saveTemporaryFile(screenshot, `image/png`);
-        response.appendResponseLine(filename);
+        const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.png`);
+        response.appendResponseLine(filepath);
     },
 });
-export const navigate = defineTool({
+export const navigate = definePageTool({
     name: 'navigate',
     description: `Loads a URL`,
     annotations: {
@@ -35,8 +35,8 @@ export const navigate = defineTool({
     schema: {
         url: zod.string().describe('URL to navigate to'),
     },
-    handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
+    handler: async (request, response) => {
+        const page = request.page;
         const options = {
             timeout: 30_000,
         };
@@ -45,20 +45,20 @@ export const navigate = defineTool({
                 response.appendResponseLine(`Accepted a beforeunload dialog.`);
                 void dialog.accept();
                 // We are not going to report the dialog like regular dialogs.
-                context.clearDialog();
+                page.clearDialog();
             }
         };
-        page.on('dialog', dialogHandler);
+        page.pptrPage.on('dialog', dialogHandler);
         try {
-            await page.goto(request.params.url, options);
-            response.appendResponseLine(`Navigated to ${page.url()}.`);
+            await page.pptrPage.goto(request.params.url, options);
+            response.appendResponseLine(`Navigated to ${page.pptrPage.url()}.`);
         }
         finally {
-            page.off('dialog', dialogHandler);
+            page.pptrPage.off('dialog', dialogHandler);
         }
     },
 });
-export const evaluate = defineTool({
+export const evaluate = definePageTool({
     name: 'evaluate',
     description: `Evaluates a JavaScript script`,
     annotations: {
@@ -68,10 +68,10 @@ export const evaluate = defineTool({
     schema: {
         script: zod.string().describe(`JS script to run on the page`),
     },
-    handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
+    handler: async (request, response) => {
+        const page = request.page;
         try {
-            const result = await page.evaluate(request.params.script);
+            const result = await page.pptrPage.evaluate(request.params.script);
             response.appendResponseLine(JSON.stringify(result));
         }
         catch (err) {

package/build/src/tools/snapshot.js

@@ -5,8 +5,8 @@
  */
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
-import { defineTool, timeoutSchema } from './ToolDefinition.js';
-export const takeSnapshot = defineTool({
+import { definePageTool, timeoutSchema } from './ToolDefinition.js';
+export const takeSnapshot = definePageTool({
     name: 'take_snapshot',
     description: `Take a text snapshot of the currently selected page based on the a11y tree. The snapshot lists page elements along with a unique
 identifier (uid). Always use the latest snapshot. Prefer taking a snapshot over taking a screenshot. The snapshot indicates the element selected
@@ -33,7 +33,7 @@ in the DevTools Elements panel (if any).`,
         });
     },
 });
-export const waitFor = defineTool({
+export const waitFor = definePageTool({
     name: 'wait_for',
     description: `Wait for the specified text to appear on the selected page.`,
     annotations: {
@@ -48,7 +48,8 @@ export const waitFor = defineTool({
         ...timeoutSchema,
     },
     handler: async (request, response, context) => {
-        await context.waitForTextOnPage(request.params.text, request.params.timeout);
+        const page = request.page;
+        await context.waitForTextOnPage(request.params.text, request.params.timeout, page.pptrPage);
         response.appendResponseLine(`Element matching one of ${JSON.stringify(request.params.text)} found.`);
         response.includeSnapshot();
     },

package/build/src/tools/tools.js

@@ -7,6 +7,7 @@ import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
 import * as extensionTools from './extensions.js';
 import * as inputTools from './input.js';
+import * as lighthouseTools from './lighthouse.js';
 import * as memoryTools from './memory.js';
 import * as networkTools from './network.js';
 import * as pagesTools from './pages.js';
@@ -24,6 +25,7 @@ export const createTools = (args) => {
             ...Object.values(emulationTools),
             ...Object.values(extensionTools),
             ...Object.values(inputTools),
+            ...Object.values(lighthouseTools),
             ...Object.values(memoryTools),
             ...Object.values(networkTools),
             ...Object.values(pagesTools),