@mcp-b/chrome-devtools-mcp 2.3.0 → 2.3.1-beta.20260528050333

package/build/src/tools/script.js

@@ -1,119 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { zod } from '../third_party/index.js';
-import { ToolCategory } from './categories.js';
-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 () => {
-  return await fetch("example.com")
-}\`.
-Example with arguments: \`(el) => {
-  return el.innerText;
-}\`
-`),
-            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.`),
-            ...(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 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);
-            }
-            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

@@ -1,81 +0,0 @@
-/**
- * @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

@@ -1,56 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { zod } from '../third_party/index.js';
-import { ToolCategory } from './categories.js';
-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
-in the DevTools Elements panel (if any).`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        // Not read-only due to filePath param.
-        readOnlyHint: false,
-    },
-    schema: {
-        verbose: zod
-            .boolean()
-            .optional()
-            .describe('Whether to include all possible information available in the full a11y tree. Default is false.'),
-        filePath: zod
-            .string()
-            .optional()
-            .describe('The absolute path, or a path relative to the current working directory, to save the snapshot to instead of attaching it to the response.'),
-    },
-    handler: async (request, response) => {
-        response.includeSnapshot({
-            verbose: request.params.verbose ?? false,
-            filePath: request.params.filePath,
-        });
-    },
-});
-export const waitFor = definePageTool({
-    name: 'wait_for',
-    description: `Wait for the specified text to appear on the selected page.`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: true,
-    },
-    schema: {
-        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) => {
-        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

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-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';
-import * as performanceTools from './performance.js';
-import * as screencastTools from './screencast.js';
-import * as screenshotTools from './screenshot.js';
-import * as scriptTools from './script.js';
-import * as slimTools from './slim/tools.js';
-import * as snapshotTools from './snapshot.js';
-export const createTools = (args) => {
-    const rawTools = args.slim
-        ? Object.values(slimTools)
-        : [
-            ...Object.values(consoleTools),
-            ...Object.values(emulationTools),
-            ...Object.values(extensionTools),
-            ...Object.values(inputTools),
-            ...Object.values(lighthouseTools),
-            ...Object.values(memoryTools),
-            ...Object.values(networkTools),
-            ...Object.values(pagesTools),
-            ...Object.values(performanceTools),
-            ...Object.values(screencastTools),
-            ...Object.values(screenshotTools),
-            ...Object.values(scriptTools),
-            ...Object.values(snapshotTools),
-            ...Object.values(webmcpTools),
-        ];
-    const tools = [];
-    for (const tool of rawTools) {
-        if (typeof tool === 'function') {
-            tools.push(tool(args));
-        }
-        else {
-            tools.push(tool);
-        }
-    }
-    tools.sort((a, b) => {
-        return a.name.localeCompare(b.name);
-    });
-    return tools;
-};