@mcp-b/chrome-devtools-mcp 2.0.13 → 2.2.0

package/build/src/tools/performance.js

@@ -3,25 +3,33 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import zlib from 'node:zlib';
 import { logger } from '../logger.js';
-import { zod } from '../third_party/index.js';
-import { getInsightOutput, getTraceSummary, parseRawTraceBuffer, traceResultIsSuccess, } from '../trace-processing/parse.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';
-export const startTrace = defineTool({
+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 = 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: true,
+        readOnlyHint: false,
     },
     schema: {
         reload: zod
             .boolean()
-            .describe('Determines if, once tracing has started, the page should be automatically reloaded.'),
+            .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,
     },
     handler: async (request, response, context) => {
         if (context.isRunningPerformanceTrace()) {
@@ -29,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'],
             });
         }
@@ -58,40 +66,42 @@ 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);
+            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: true,
+        readOnlyHint: false,
+    },
+    schema: {
+        filePath: filePathSchema,
     },
-    schema: {},
-    handler: async (_request, response, context) => {
+    handler: async (request, response, context) => {
         if (!context.isRunningPerformanceTrace()) {
             return;
         }
-        const page = context.getSelectedPage();
-        await stopTracingAndAppendOutput(page, response, context);
+        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: {
@@ -112,36 +122,69 @@ export const analyzeInsight = defineTool({
             response.appendResponseLine('No recorded traces found. Record a performance trace so you have Insights to analyze.');
             return;
         }
-        const insightOutput = getInsightOutput(lastRecording, request.params.insightSetId, request.params.insightName);
-        if ('error' in insightOutput) {
-            response.appendResponseLine(insightOutput.error);
-            return;
-        }
-        response.appendResponseLine(insightOutput.output);
+        response.attachTraceInsight(lastRecording, request.params.insightSetId, request.params.insightName);
     },
 });
-async function stopTracingAndAppendOutput(page, response, context) {
+async function stopTracingAndAppendOutput(page, response, context, filePath) {
     try {
         const traceEventsBuffer = await page.tracing.stop();
+        if (filePath && traceEventsBuffer) {
+            let dataToWrite = traceEventsBuffer;
+            if (filePath.endsWith('.gz')) {
+                dataToWrite = await new Promise((resolve, reject) => {
+                    zlib.gzip(traceEventsBuffer, (error, result) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    });
+                });
+            }
+            const file = await context.saveFile(dataToWrite, filePath);
+            response.appendResponseLine(`The raw trace data was saved to ${file.filename}.`);
+        }
         const result = await parseRawTraceBuffer(traceEventsBuffer);
         response.appendResponseLine('The performance trace has been stopped.');
         if (traceResultIsSuccess(result)) {
+            if (context.isCruxEnabled()) {
+                await populateCruxData(result);
+            }
             context.storeTraceRecording(result);
-            const traceSummaryText = getTraceSummary(result);
-            response.appendResponseLine(traceSummaryText);
+            response.attachTraceSummary(result);
         }
         else {
-            response.appendResponseLine('There was an unexpected error parsing the trace:');
-            response.appendResponseLine(result.error);
+            throw new Error(`There was an unexpected error parsing the trace: ${result.error}`);
         }
     }
-    catch (e) {
-        const errorText = e instanceof Error ? e.message : JSON.stringify(e);
-        logger(`Error stopping performance trace: ${errorText}`);
-        response.appendResponseLine('An error occurred generating the response for this trace:');
-        response.appendResponseLine(errorText);
-    }
     finally {
         context.setIsRunningPerformanceTrace(false);
     }
 }
+/** We tell CrUXManager to fetch data so it's available when DevTools.PerformanceTraceFormatter is invoked */
+async function populateCruxData(result) {
+    logger('populateCruxData called');
+    const cruxManager = DevTools.CrUXManager.instance();
+    // go/jtfbx. Yes, we're aware this API key is public. ;)
+    cruxManager.setEndpointForTesting('https://chromeuxreport.googleapis.com/v1/records:queryRecord?key=AIzaSyBn5gimNjhiEyA_euicSKko6IlD3HdgUfk');
+    const cruxSetting = DevTools.Common.Settings.Settings.instance().createSetting('field-data', {
+        enabled: true,
+    });
+    cruxSetting.set({ enabled: true });
+    // Gather URLs to fetch CrUX data for
+    const urls = [...(result.parsedTrace.insights?.values() ?? [])].map(c => c.url.toString());
+    urls.push(result.parsedTrace.data.Meta.mainFrameURL);
+    const urlSet = new Set(urls);
+    if (urlSet.size === 0) {
+        logger('No URLs found for CrUX data');
+        return;
+    }
+    logger(`Fetching CrUX data for ${urlSet.size} URLs: ${Array.from(urlSet).join(', ')}`);
+    const cruxData = await Promise.all(Array.from(urlSet).map(async (url) => {
+        const data = await cruxManager.getFieldDataForPage(url);
+        logger(`CrUX data for ${url}: ${data ? 'found' : 'not found'}`);
+        return data;
+    }));
+    result.parsedTrace.metadata.cruxFieldData = cruxData;
+}

package/build/src/tools/screencast.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.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 = definePageTool({
+    name: 'screencast_start',
+    description: 'Starts recording a screencast (video) of the selected page in mp4 format.',
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+        conditions: ['screencast'],
+    },
+    schema: {
+        path: zod
+            .string()
+            .optional()
+            .describe('Output path. Uses mkdtemp to generate a unique path if not provided.'),
+    },
+    handler: async (request, response, context) => {
+        if (context.getScreenRecorder() !== null) {
+            response.appendResponseLine('Error: a screencast recording is already in progress. Use screencast_stop to stop it before starting a new one.');
+            return;
+        }
+        const filePath = request.params.path ?? (await generateTempFilePath());
+        const resolvedPath = path.resolve(filePath);
+        const page = request.page;
+        let recorder;
+        try {
+            recorder = await page.pptrPage.screencast({
+                path: resolvedPath,
+                format: 'mp4',
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes('ENOENT') && message.includes('ffmpeg')) {
+                throw new Error('ffmpeg is required for screencast recording but was not found. ' +
+                    'Install ffmpeg (https://ffmpeg.org/) and ensure it is available in your PATH.');
+            }
+            throw err;
+        }
+        context.setScreenRecorder({ recorder, filePath: resolvedPath });
+        response.appendResponseLine(`Screencast recording started. The recording will be saved to ${resolvedPath}. Use ${stopScreencast.name} to stop recording.`);
+    },
+});
+export const stopScreencast = definePageTool({
+    name: 'screencast_stop',
+    description: 'Stops the active screencast recording on the selected page.',
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+        conditions: ['screencast'],
+    },
+    schema: {},
+    handler: async (_request, response, context) => {
+        const data = context.getScreenRecorder();
+        if (!data) {
+            return;
+        }
+        try {
+            await data.recorder.stop();
+            response.appendResponseLine(`The screencast recording has been stopped and saved to ${data.filePath}.`);
+        }
+        finally {
+            context.setScreenRecorder(null);
+        }
+    },
+});

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

@@ -3,26 +3,20 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { readFile } from 'node:fs/promises';
 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 or inject a script file into the currently selected page.
-
-When \`function\` is provided, evaluates it and returns the result as JSON (values must be JSON-serializable).
-When \`filePath\` is provided, reads the file from disk and injects it as a <script> tag (useful for large scripts like polyfills that are too big to pass inline).
-Exactly one of \`function\` or \`filePath\` must be provided.`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        readOnlyHint: false,
-    },
-    schema: {
-        function: zod
-            .string()
-            .optional()
-            .describe(`A JavaScript function declaration to be executed by the tool in the currently selected page.
+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.
 Example without arguments: \`() => {
   return document.title
 }\` or \`async () => {
@@ -32,67 +26,96 @@ Example with arguments: \`(el) => {
   return el.innerText;
 }\`
 `),
-        filePath: zod
-            .string()
-            .optional()
-            .describe('Absolute path to a local JavaScript file to inject into the page via <script> tag. The file is read server-side so there are no size limits or CSP/mixed-content restrictions. Use this for large scripts (polyfills, bundled tools, etc).'),
-        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. Only used with \`function\`, not \`filePath\`.`),
-    },
-    handler: async (request, response, context) => {
-        const { filePath } = request.params;
-        // File injection mode
-        if (filePath) {
-            if (request.params.function) {
-                throw new Error('Provide either `function` or `filePath`, not both.');
+                .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;
             }
-            const content = await readFile(filePath, 'utf-8');
-            const page = context.getSelectedPage();
-            await page.addScriptTag({ content });
-            response.appendResponseLine(`Injected script from \`${filePath}\` (${content.length} bytes) into page.`);
-            return;
-        }
-        // Function evaluation mode (original behavior)
-        if (!request.params.function) {
-            throw new Error('Either `function` or `filePath` must be provided.');
-        }
-        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);
-            }
-            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

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../../third_party/index.js';
+import { ToolCategory } from '../categories.js';
+import { definePageTool } from '../ToolDefinition.js';
+export const screenshot = definePageTool({
+    name: 'screenshot',
+    description: `Takes a screenshot`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        // Not read-only due to filePath param.
+        readOnlyHint: false,
+    },
+    schema: {},
+    handler: async (request, response, context) => {
+        const page = request.page;
+        const screenshot = await page.pptrPage.screenshot({
+            type: 'png',
+            optimizeForSpeed: true,
+        });
+        const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.png`);
+        response.appendResponseLine(filepath);
+    },
+});
+export const navigate = definePageTool({
+    name: 'navigate',
+    description: `Loads a URL`,
+    annotations: {
+        category: ToolCategory.NAVIGATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        url: zod.string().describe('URL to navigate to'),
+    },
+    handler: async (request, response) => {
+        const page = request.page;
+        const options = {
+            timeout: 30_000,
+        };
+        const dialogHandler = (dialog) => {
+            if (dialog.type() === 'beforeunload') {
+                response.appendResponseLine(`Accepted a beforeunload dialog.`);
+                void dialog.accept();
+                // We are not going to report the dialog like regular dialogs.
+                page.clearDialog();
+            }
+        };
+        page.pptrPage.on('dialog', dialogHandler);
+        try {
+            await page.pptrPage.goto(request.params.url, options);
+            response.appendResponseLine(`Navigated to ${page.pptrPage.url()}.`);
+        }
+        finally {
+            page.pptrPage.off('dialog', dialogHandler);
+        }
+    },
+});
+export const evaluate = definePageTool({
+    name: 'evaluate',
+    description: `Evaluates a JavaScript script`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+    },
+    schema: {
+        script: zod.string().describe(`JS script to run on the page`),
+    },
+    handler: async (request, response) => {
+        const page = request.page;
+        try {
+            const result = await page.pptrPage.evaluate(request.params.script);
+            response.appendResponseLine(JSON.stringify(result));
+        }
+        catch (err) {
+            response.appendResponseLine(String(err.message));
+        }
+    },
+});

package/build/src/tools/snapshot.js

@@ -5,13 +5,12 @@
  */
 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). IMPORTANT: UIDs expire when the page changes. Always take a fresh snapshot immediately before using UIDs for click/type/etc.
-Workflow: 1) take_snapshot, 2) find the uid you need, 3) use it in click/type, 4) take_snapshot again for next action.
-Prefer taking a snapshot over taking a screenshot. The snapshot indicates the element selected in the DevTools Elements panel (if any).`,
+identifier (uid). Always use the latest snapshot. Prefer taking a snapshot over taking a screenshot. The snapshot indicates the element selected
+in the DevTools Elements panel (if any).`,
     annotations: {
         category: ToolCategory.DEBUGGING,
         // Not read-only due to filePath param.
@@ -34,7 +33,7 @@ Prefer taking a snapshot over taking a screenshot. The snapshot indicates the el
         });
     },
 });
-export const waitFor = defineTool({
+export const waitFor = definePageTool({
     name: 'wait_for',
     description: `Wait for the specified text to appear on the selected page.`,
     annotations: {
@@ -42,12 +41,16 @@ export const waitFor = defineTool({
         readOnlyHint: true,
     },
     schema: {
-        text: zod.string().describe('Text to appear on the page'),
+        text: zod
+            .array(zod.string())
+            .min(1)
+            .describe('Non-empty list of texts. Resolves when any value appears on the page.'),
         ...timeoutSchema,
     },
     handler: async (request, response, context) => {
-        await context.waitForTextOnPage(request.params.text, request.params.timeout);
-        response.appendResponseLine(`Element with text "${request.params.text}" found.`);
+        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();
     },
 });