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

package/build/src/tools/input.js

@@ -1,368 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { logger } from '../logger.js';
-import { zod } from '../third_party/index.js';
-import { parseKey } from '../utils/keyboard.js';
-import { ToolCategory } from './categories.js';
-import { definePageTool } from './ToolDefinition.js';
-const dblClickSchema = zod
-    .boolean()
-    .optional()
-    .describe('Set to true for double clicks. Default is false.');
-const includeSnapshotSchema = zod
-    .boolean()
-    .optional()
-    .describe('Whether to include a snapshot in the response. Default is false.');
-const submitKeySchema = zod
-    .string()
-    .optional()
-    .describe('Optional key to press after typing. E.g., "Enter", "Tab", "Escape"');
-function handleActionError(error, uid) {
-    logger('failed to act using a locator', error);
-    throw new Error(`Failed to interact with the element with uid ${uid}. The element did not become interactive within the configured timeout.`, {
-        cause: error,
-    });
-}
-export const click = definePageTool({
-    name: 'click',
-    description: `Clicks on the provided element`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        uid: zod.string().describe('The uid of an element on the page from the page content snapshot'),
-        dblClick: dblClickSchema,
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const uid = request.params.uid;
-        const handle = await request.page.getElementByUid(uid);
-        try {
-            await context.waitForEventsAfterAction(async () => {
-                await handle.asLocator().click({
-                    count: request.params.dblClick ? 2 : 1,
-                });
-            });
-            response.appendResponseLine(request.params.dblClick
-                ? `Successfully double clicked on the element`
-                : `Successfully clicked on the element`);
-            if (request.params.includeSnapshot) {
-                response.includeSnapshot();
-            }
-        }
-        catch (error) {
-            handleActionError(error, uid);
-        }
-        finally {
-            void handle.dispose();
-        }
-    },
-});
-export const clickAt = definePageTool({
-    name: 'click_at',
-    description: `Clicks at the provided coordinates`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-        conditions: ['computerVision'],
-    },
-    schema: {
-        x: zod.number().describe('The x coordinate'),
-        y: zod.number().describe('The y coordinate'),
-        dblClick: dblClickSchema,
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = request.page;
-        await context.waitForEventsAfterAction(async () => {
-            await page.pptrPage.mouse.click(request.params.x, request.params.y, {
-                clickCount: request.params.dblClick ? 2 : 1,
-            });
-        });
-        response.appendResponseLine(request.params.dblClick
-            ? `Successfully double clicked at the coordinates`
-            : `Successfully clicked at the coordinates`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});
-export const hover = definePageTool({
-    name: 'hover',
-    description: `Hover over the provided element`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        uid: zod.string().describe('The uid of an element on the page from the page content snapshot'),
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const uid = request.params.uid;
-        const handle = await request.page.getElementByUid(uid);
-        try {
-            await context.waitForEventsAfterAction(async () => {
-                await handle.asLocator().hover();
-            });
-            response.appendResponseLine(`Successfully hovered over the element`);
-            if (request.params.includeSnapshot) {
-                response.includeSnapshot();
-            }
-        }
-        catch (error) {
-            handleActionError(error, uid);
-        }
-        finally {
-            void handle.dispose();
-        }
-    },
-});
-// The AXNode for an option doesn't contain its `value`. We set text content of the option as value.
-// If the form is a combobox, we need to find the correct option by its text value.
-// To do that, loop through the children while checking which child's text matches the requested value (requested value is actually the text content).
-// When the correct option is found, use the element handle to get the real value.
-async function selectOption(handle, aXNode, value) {
-    let optionFound = false;
-    for (const child of aXNode.children) {
-        if (child.role === 'option' && child.name === value && child.value) {
-            optionFound = true;
-            const childHandle = await child.elementHandle();
-            if (childHandle) {
-                try {
-                    const childValueHandle = await childHandle.getProperty('value');
-                    try {
-                        const childValue = await childValueHandle.jsonValue();
-                        if (childValue) {
-                            await handle.asLocator().fill(childValue.toString());
-                        }
-                    }
-                    finally {
-                        void childValueHandle.dispose();
-                    }
-                    break;
-                }
-                finally {
-                    void childHandle.dispose();
-                }
-            }
-        }
-    }
-    if (!optionFound) {
-        throw new Error(`Could not find option with text "${value}"`);
-    }
-}
-function hasOptionChildren(aXNode) {
-    return aXNode.children.some((child) => child.role === 'option');
-}
-async function fillFormElement(uid, value, context, page) {
-    const handle = await page.getElementByUid(uid);
-    try {
-        const aXNode = context.getAXNodeByUid(uid);
-        // We assume that combobox needs to be handled as select if it has
-        // role='combobox' and option children.
-        if (aXNode && aXNode.role === 'combobox' && hasOptionChildren(aXNode)) {
-            await selectOption(handle, aXNode, value);
-        }
-        else {
-            // Increase timeout for longer input values.
-            const timeoutPerChar = 10; // ms
-            const fillTimeout = page.pptrPage.getDefaultTimeout() + value.length * timeoutPerChar;
-            await handle.asLocator().setTimeout(fillTimeout).fill(value);
-        }
-    }
-    catch (error) {
-        handleActionError(error, uid);
-    }
-    finally {
-        void handle.dispose();
-    }
-}
-export const fill = definePageTool({
-    name: 'fill',
-    description: `Type text into a input, text area or select an option from a <select> element.`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        uid: zod.string().describe('The uid of an element on the page from the page content snapshot'),
-        value: zod.string().describe('The value to fill in'),
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = request.page;
-        await context.waitForEventsAfterAction(async () => {
-            await fillFormElement(request.params.uid, request.params.value, context, page);
-        });
-        response.appendResponseLine(`Successfully filled out the element`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});
-export const typeText = definePageTool({
-    name: 'type_text',
-    description: `Type text using keyboard into a previously focused input`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        text: zod.string().describe('The text to type'),
-        submitKey: submitKeySchema,
-    },
-    handler: async (request, response, context) => {
-        const page = request.page;
-        await context.waitForEventsAfterAction(async () => {
-            await page.pptrPage.keyboard.type(request.params.text);
-            if (request.params.submitKey) {
-                await page.pptrPage.keyboard.press(request.params.submitKey);
-            }
-        });
-        response.appendResponseLine(`Typed text "${request.params.text}${request.params.submitKey ? ` + ${request.params.submitKey}` : ''}"`);
-    },
-});
-export const drag = definePageTool({
-    name: 'drag',
-    description: `Drag an element onto another element`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        from_uid: zod.string().describe('The uid of the element to drag'),
-        to_uid: zod.string().describe('The uid of the element to drop into'),
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const fromHandle = await request.page.getElementByUid(request.params.from_uid);
-        const toHandle = await request.page.getElementByUid(request.params.to_uid);
-        try {
-            await context.waitForEventsAfterAction(async () => {
-                await fromHandle.drag(toHandle);
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                await toHandle.drop(fromHandle);
-            });
-            response.appendResponseLine(`Successfully dragged an element`);
-            if (request.params.includeSnapshot) {
-                response.includeSnapshot();
-            }
-        }
-        finally {
-            void fromHandle.dispose();
-            void toHandle.dispose();
-        }
-    },
-});
-export const fillForm = definePageTool({
-    name: 'fill_form',
-    description: `Fill out multiple form elements at once`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        elements: zod
-            .array(zod.object({
-            uid: zod.string().describe('The uid of the element to fill out'),
-            value: zod.string().describe('Value for the element'),
-        }))
-            .describe('Elements from snapshot to fill out.'),
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = request.page;
-        for (const element of request.params.elements) {
-            await context.waitForEventsAfterAction(async () => {
-                await fillFormElement(element.uid, element.value, context, page);
-            });
-        }
-        response.appendResponseLine(`Successfully filled out the form`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});
-export const uploadFile = definePageTool({
-    name: 'upload_file',
-    description: 'Upload a file through a provided element.',
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        uid: zod
-            .string()
-            .describe('The uid of the file input element or an element that will open file chooser on the page from the page content snapshot'),
-        filePath: zod.string().describe('The local path of the file to upload'),
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response) => {
-        const { uid, filePath } = request.params;
-        const handle = (await request.page.getElementByUid(uid));
-        try {
-            try {
-                await handle.uploadFile(filePath);
-            }
-            catch {
-                // Some sites use a proxy element to trigger file upload instead of
-                // a type=file element. In this case, we want to default to
-                // Page.waitForFileChooser() and upload the file this way.
-                try {
-                    const [fileChooser] = await Promise.all([
-                        request.page.pptrPage.waitForFileChooser({ timeout: 3000 }),
-                        handle.asLocator().click(),
-                    ]);
-                    await fileChooser.accept([filePath]);
-                }
-                catch {
-                    throw new Error(`Failed to upload file. The element could not accept the file directly, and clicking it did not trigger a file chooser.`);
-                }
-            }
-            if (request.params.includeSnapshot) {
-                response.includeSnapshot();
-            }
-            response.appendResponseLine(`File uploaded from ${filePath}.`);
-        }
-        finally {
-            void handle.dispose();
-        }
-    },
-});
-export const pressKey = definePageTool({
-    name: 'press_key',
-    description: `Press a key or key combination. Use this when other input methods like fill() cannot be used (e.g., keyboard shortcuts, navigation keys, or special key combinations).`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        key: zod
-            .string()
-            .describe('A key or a combination (e.g., "Enter", "Control+A", "Control++", "Control+Shift+R"). Modifiers: Control, Shift, Alt, Meta'),
-        includeSnapshot: includeSnapshotSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = request.page;
-        const tokens = parseKey(request.params.key);
-        const [key, ...modifiers] = tokens;
-        await context.waitForEventsAfterAction(async () => {
-            for (const modifier of modifiers) {
-                await page.pptrPage.keyboard.down(modifier);
-            }
-            await page.pptrPage.keyboard.press(key);
-            for (const modifier of modifiers.toReversed()) {
-                await page.pptrPage.keyboard.up(modifier);
-            }
-        });
-        response.appendResponseLine(`Successfully pressed key: ${request.params.key}`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});

package/build/src/tools/lighthouse.js

@@ -1,123 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import path from 'node:path';
-import { snapshot, navigation, generateReport, zod, } from '../third_party/index.js';
-import { ToolCategory } from './categories.js';
-import { startTrace } from './performance.js';
-import { definePageTool } from './ToolDefinition.js';
-export const lighthouseAudit = definePageTool({
-    name: 'lighthouse_audit',
-    description: `Get Lighthouse score and reports for accessibility, SEO and best practices. This excludes performance. For performance audits, run ${startTrace.name}`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        readOnlyHint: true,
-    },
-    schema: {
-        mode: zod
-            .enum(['navigation', 'snapshot'])
-            .default('navigation')
-            .describe('"navigation" reloads & audits. "snapshot" analyzes current state.'),
-        device: zod
-            .enum(['desktop', 'mobile'])
-            .default('desktop')
-            .describe('Device to emulate.'),
-        outputDirPath: zod
-            .string()
-            .optional()
-            .describe('Directory for reports. If omitted, uses temporary files.'),
-    },
-    handler: async (request, response, context) => {
-        const page = request.page;
-        const categories = ['accessibility', 'seo', 'best-practices'];
-        const formats = ['json', 'html'];
-        const { mode = 'navigation', device = 'desktop', outputDirPath, } = request.params;
-        const flags = {
-            onlyCategories: categories,
-            output: formats,
-            // Default 30 second timeout for page load.
-            maxWaitForLoad: 30_000,
-        };
-        if (device === 'desktop') {
-            flags.formFactor = 'desktop';
-            flags.screenEmulation = {
-                mobile: false,
-                width: 1350,
-                height: 940,
-                deviceScaleFactor: 1,
-                disabled: false,
-            };
-        }
-        else {
-            flags.formFactor = 'mobile';
-            flags.screenEmulation = {
-                mobile: true,
-                width: 412,
-                height: 823,
-                deviceScaleFactor: 1.75,
-                disabled: false,
-            };
-        }
-        let result;
-        try {
-            if (mode === 'navigation') {
-                result = await navigation(page.pptrPage, page.pptrPage.url(), {
-                    flags,
-                });
-            }
-            else {
-                result = await snapshot(page.pptrPage, {
-                    flags,
-                });
-            }
-            if (!result) {
-                throw new Error('Lighthouse audit failed.');
-            }
-        }
-        finally {
-            await context.restoreEmulation(page);
-        }
-        const lhr = result.lhr;
-        const reportPaths = [];
-        const encoder = new TextEncoder();
-        for (const format of formats) {
-            const report = generateReport(lhr, format);
-            const data = encoder.encode(report);
-            if (outputDirPath) {
-                const reportPath = path.join(outputDirPath, `report.${format}`);
-                const { filename } = await context.saveFile(data, reportPath);
-                reportPaths.push(filename);
-            }
-            else {
-                const { filepath } = await context.saveTemporaryFile(data, `report.${format}`);
-                reportPaths.push(filepath);
-            }
-        }
-        const categoryScores = Object.values(lhr.categories).map(c => ({
-            id: c.id,
-            title: c.title,
-            score: c.score,
-        }));
-        const failedAudits = Object.values(lhr.audits).filter(a => a.score !== null && a.score < 1).length;
-        const passedAudits = Object.values(lhr.audits).filter(a => a.score === 1).length;
-        const output = {
-            summary: {
-                mode,
-                device,
-                url: lhr.mainDocumentUrl,
-                scores: categoryScores,
-                audits: {
-                    failed: failedAudits,
-                    passed: passedAudits,
-                },
-                timing: {
-                    total: lhr.timing.total,
-                },
-            },
-            reports: reportPaths,
-        };
-        response.attachLighthouseResult(output);
-    },
-});

package/build/src/tools/memory.js

@@ -1,28 +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 } from './ToolDefinition.js';
-export const takeMemorySnapshot = definePageTool({
-    name: 'take_memory_snapshot',
-    description: `Capture a memory heapsnapshot of the currently selected page to memory leak debugging`,
-    annotations: {
-        category: ToolCategory.PERFORMANCE,
-        readOnlyHint: true,
-    },
-    schema: {
-        filePath: zod
-            .string()
-            .describe('A path to a .heapsnapshot file to save the heapsnapshot to.'),
-    },
-    handler: async (request, response, _context) => {
-        const page = request.page;
-        await page.pptrPage.captureHeapSnapshot({
-            path: request.params.filePath,
-        });
-        response.appendResponseLine(`Heap snapshot saved to ${request.params.filePath}`);
-    },
-});

package/build/src/tools/network.js

@@ -1,120 +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 } from './ToolDefinition.js';
-const FILTERABLE_RESOURCE_TYPES = [
-    'document',
-    'stylesheet',
-    'image',
-    'media',
-    'font',
-    'script',
-    'texttrack',
-    'xhr',
-    'fetch',
-    'prefetch',
-    'eventsource',
-    'websocket',
-    'manifest',
-    'signedexchange',
-    'ping',
-    'cspviolationreport',
-    'preflight',
-    'fedcm',
-    'other',
-];
-export const listNetworkRequests = definePageTool({
-    name: 'list_network_requests',
-    description: `List all requests for the currently selected page since the last navigation.`,
-    annotations: {
-        category: ToolCategory.NETWORK,
-        readOnlyHint: true,
-    },
-    schema: {
-        pageSize: zod
-            .number()
-            .int()
-            .positive()
-            .optional()
-            .describe('Maximum number of requests to return. When omitted, returns all requests.'),
-        pageIdx: zod
-            .number()
-            .int()
-            .min(0)
-            .optional()
-            .describe('Page number to return (0-based). When omitted, returns the first page.'),
-        resourceTypes: zod
-            .array(zod.enum(FILTERABLE_RESOURCE_TYPES))
-            .optional()
-            .describe('Filter requests to only return requests of the specified resource types. When omitted or empty, returns all requests.'),
-        includePreservedRequests: zod
-            .boolean()
-            .default(false)
-            .optional()
-            .describe('Set to true to return the preserved requests over the last 3 navigations.'),
-    },
-    handler: async (request, response, context) => {
-        const data = await context.getDevToolsData(request.page);
-        response.attachDevToolsData(data);
-        const reqid = data?.cdpRequestId
-            ? context.resolveCdpRequestId(request.page, data.cdpRequestId)
-            : undefined;
-        response.setIncludeNetworkRequests(true, {
-            pageSize: request.params.pageSize,
-            pageIdx: request.params.pageIdx,
-            resourceTypes: request.params.resourceTypes,
-            includePreservedRequests: request.params.includePreservedRequests,
-            networkRequestIdInDevToolsUI: reqid,
-        });
-    },
-});
-export const getNetworkRequest = definePageTool({
-    name: 'get_network_request',
-    description: `Gets a network request by an optional reqid, if omitted returns the currently selected request in the DevTools Network panel.`,
-    annotations: {
-        category: ToolCategory.NETWORK,
-        readOnlyHint: false,
-    },
-    schema: {
-        reqid: zod
-            .number()
-            .optional()
-            .describe('The reqid of the network request. If omitted returns the currently selected request in the DevTools Network panel.'),
-        requestFilePath: zod
-            .string()
-            .optional()
-            .describe('The absolute or relative path to save the request body to. If omitted, the body is returned inline.'),
-        responseFilePath: zod
-            .string()
-            .optional()
-            .describe('The absolute or relative path to save the response body to. If omitted, the body is returned inline.'),
-    },
-    handler: async (request, response, context) => {
-        if (request.params.reqid) {
-            response.attachNetworkRequest(request.params.reqid, {
-                requestFilePath: request.params.requestFilePath,
-                responseFilePath: request.params.responseFilePath,
-            });
-        }
-        else {
-            const data = await context.getDevToolsData(request.page);
-            response.attachDevToolsData(data);
-            const reqid = data?.cdpRequestId
-                ? context.resolveCdpRequestId(request.page, data.cdpRequestId)
-                : undefined;
-            if (reqid) {
-                response.attachNetworkRequest(reqid, {
-                    requestFilePath: request.params.requestFilePath,
-                    responseFilePath: request.params.responseFilePath,
-                });
-            }
-            else {
-                response.appendResponseLine(`Nothing is currently selected in the DevTools Network panel.`);
-            }
-        }
-    },
-});