chrome-devtools-mcp 0.17.0 → 0.17.2

package/build/src/tools/emulation.js

@@ -1,169 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- *
- */
-import { zod, PredefinedNetworkConditions } from '../third_party/index.js';
-import { ToolCategory } from './categories.js';
-import { defineTool } from './ToolDefinition.js';
-const throttlingOptions = [
-    'No emulation',
-    'Offline',
-    ...Object.keys(PredefinedNetworkConditions),
-];
-export const emulate = defineTool({
-    name: 'emulate',
-    description: `Emulates various features on the selected page.`,
-    annotations: {
-        category: ToolCategory.EMULATION,
-        readOnlyHint: false,
-    },
-    schema: {
-        networkConditions: zod
-            .enum(throttlingOptions)
-            .optional()
-            .describe(`Throttle network. Set to "No emulation" to disable. If omitted, conditions remain unchanged.`),
-        cpuThrottlingRate: zod
-            .number()
-            .min(1)
-            .max(20)
-            .optional()
-            .describe('Represents the CPU slowdown factor. Set the rate to 1 to disable throttling. If omitted, throttling remains unchanged.'),
-        geolocation: zod
-            .object({
-            latitude: zod
-                .number()
-                .min(-90)
-                .max(90)
-                .describe('Latitude between -90 and 90.'),
-            longitude: zod
-                .number()
-                .min(-180)
-                .max(180)
-                .describe('Longitude between -180 and 180.'),
-        })
-            .nullable()
-            .optional()
-            .describe('Geolocation to emulate. Set to null to clear the geolocation override.'),
-        userAgent: zod
-            .string()
-            .nullable()
-            .optional()
-            .describe('User agent to emulate. Set to null to clear the user agent override.'),
-        colorScheme: zod
-            .enum(['dark', 'light', 'auto'])
-            .optional()
-            .describe('Emulate the dark or the light mode. Set to "auto" to reset to the default.'),
-        viewport: zod
-            .object({
-            width: zod.number().int().min(0).describe('Page width in pixels.'),
-            height: zod.number().int().min(0).describe('Page height in pixels.'),
-            deviceScaleFactor: zod
-                .number()
-                .min(0)
-                .optional()
-                .describe('Specify device scale factor (can be thought of as dpr).'),
-            isMobile: zod
-                .boolean()
-                .optional()
-                .describe('Whether the meta viewport tag is taken into account. Defaults to false.'),
-            hasTouch: zod
-                .boolean()
-                .optional()
-                .describe('Specifies if viewport supports touch events. This should be set to true for mobile devices.'),
-            isLandscape: zod
-                .boolean()
-                .optional()
-                .describe('Specifies if viewport is in landscape mode. Defaults to false.'),
-        })
-            .nullable()
-            .optional()
-            .describe('Viewport to emulate. Set to null to reset to the default viewport.'),
-    },
-    handler: async (request, _response, context) => {
-        const page = context.getSelectedPage();
-        const { networkConditions, cpuThrottlingRate, geolocation, userAgent, viewport, } = request.params;
-        if (networkConditions) {
-            if (networkConditions === 'No emulation') {
-                await page.emulateNetworkConditions(null);
-                context.setNetworkConditions(null);
-            }
-            else if (networkConditions === 'Offline') {
-                await page.emulateNetworkConditions({
-                    offline: true,
-                    download: 0,
-                    upload: 0,
-                    latency: 0,
-                });
-                context.setNetworkConditions('Offline');
-            }
-            else if (networkConditions in PredefinedNetworkConditions) {
-                const networkCondition = PredefinedNetworkConditions[networkConditions];
-                await page.emulateNetworkConditions(networkCondition);
-                context.setNetworkConditions(networkConditions);
-            }
-        }
-        if (cpuThrottlingRate) {
-            await page.emulateCPUThrottling(cpuThrottlingRate);
-            context.setCpuThrottlingRate(cpuThrottlingRate);
-        }
-        if (geolocation !== undefined) {
-            if (geolocation === null) {
-                await page.setGeolocation({ latitude: 0, longitude: 0 });
-                context.setGeolocation(null);
-            }
-            else {
-                await page.setGeolocation(geolocation);
-                context.setGeolocation(geolocation);
-            }
-        }
-        if (userAgent !== undefined) {
-            if (userAgent === null) {
-                await page.setUserAgent({
-                    userAgent: undefined,
-                });
-                context.setUserAgent(null);
-            }
-            else {
-                await page.setUserAgent({
-                    userAgent,
-                });
-                context.setUserAgent(userAgent);
-            }
-        }
-        if (request.params.colorScheme) {
-            if (request.params.colorScheme === 'auto') {
-                await page.emulateMediaFeatures([
-                    { name: 'prefers-color-scheme', value: '' },
-                ]);
-                context.setColorScheme(null);
-            }
-            else {
-                await page.emulateMediaFeatures([
-                    {
-                        name: 'prefers-color-scheme',
-                        value: request.params.colorScheme,
-                    },
-                ]);
-                context.setColorScheme(request.params.colorScheme);
-            }
-        }
-        if (viewport !== undefined) {
-            if (viewport === null) {
-                await page.setViewport(null);
-                context.setViewport(null);
-            }
-            else {
-                const defaults = {
-                    deviceScaleFactor: 1,
-                    isMobile: false,
-                    hasTouch: false,
-                    isLandscape: false,
-                };
-                await page.setViewport({ ...defaults, ...viewport });
-                context.setViewport({ ...defaults, ...viewport });
-            }
-        }
-    },
-});

package/build/src/tools/extensions.js

@@ -1,79 +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 { defineTool } from './ToolDefinition.js';
-const EXTENSIONS_CONDITION = 'experimentalExtensionSupport';
-export const installExtension = defineTool({
-    name: 'install_extension',
-    description: 'Installs a Chrome extension from the given path.',
-    annotations: {
-        category: ToolCategory.EXTENSIONS,
-        readOnlyHint: false,
-        conditions: [EXTENSIONS_CONDITION],
-    },
-    schema: {
-        path: zod
-            .string()
-            .describe('Absolute path to the unpacked extension folder.'),
-    },
-    handler: async (request, response, context) => {
-        const { path } = request.params;
-        const id = await context.installExtension(path);
-        response.appendResponseLine(`Extension installed. Id: ${id}`);
-    },
-});
-export const uninstallExtension = defineTool({
-    name: 'uninstall_extension',
-    description: 'Uninstalls a Chrome extension by its ID.',
-    annotations: {
-        category: ToolCategory.EXTENSIONS,
-        readOnlyHint: false,
-        conditions: [EXTENSIONS_CONDITION],
-    },
-    schema: {
-        id: zod.string().describe('ID of the extension to uninstall.'),
-    },
-    handler: async (request, response, context) => {
-        const { id } = request.params;
-        await context.uninstallExtension(id);
-        response.appendResponseLine(`Extension uninstalled. Id: ${id}`);
-    },
-});
-export const listExtensions = defineTool({
-    name: 'list_extensions',
-    description: 'Lists all extensions via this server, including their name, ID, version, and enabled status.',
-    annotations: {
-        category: ToolCategory.EXTENSIONS,
-        readOnlyHint: true,
-        conditions: [EXTENSIONS_CONDITION],
-    },
-    schema: {},
-    handler: async (_request, response, _context) => {
-        response.setListExtensions();
-    },
-});
-export const reloadExtension = defineTool({
-    name: 'reload_extension',
-    description: 'Reloads an unpacked Chrome extension by its ID.',
-    annotations: {
-        category: ToolCategory.EXTENSIONS,
-        readOnlyHint: false,
-        conditions: [EXTENSIONS_CONDITION],
-    },
-    schema: {
-        id: zod.string().describe('ID of the extension to reload.'),
-    },
-    handler: async (request, response, context) => {
-        const { id } = request.params;
-        const extension = context.getExtension(id);
-        if (!extension) {
-            throw new Error(`Extension with ID ${id} not found.`);
-        }
-        await context.installExtension(extension.path);
-        response.appendResponseLine('Extension reloaded.');
-    },
-});

package/build/src/tools/input.js

@@ -1,343 +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 { defineTool } 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.');
-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 = defineTool({
-    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 context.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 = defineTool({
-    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 = context.getSelectedPage();
-        await context.waitForEventsAfterAction(async () => {
-            await page.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 = defineTool({
-    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 context.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}"`);
-    }
-}
-async function fillFormElement(uid, value, context) {
-    const handle = await context.getElementByUid(uid);
-    try {
-        const aXNode = context.getAXNodeByUid(uid);
-        if (aXNode && aXNode.role === 'combobox') {
-            await selectOption(handle, aXNode, value);
-        }
-        else {
-            // Increase timeout for longer input values.
-            const timeoutPerChar = 10; // ms
-            const fillTimeout = context.getSelectedPage().getDefaultTimeout() +
-                value.length * timeoutPerChar;
-            await handle.asLocator().setTimeout(fillTimeout).fill(value);
-        }
-    }
-    catch (error) {
-        handleActionError(error, uid);
-    }
-    finally {
-        void handle.dispose();
-    }
-}
-export const fill = defineTool({
-    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) => {
-        await context.waitForEventsAfterAction(async () => {
-            await fillFormElement(request.params.uid, request.params.value, context);
-        });
-        response.appendResponseLine(`Successfully filled out the element`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});
-export const drag = defineTool({
-    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 context.getElementByUid(request.params.from_uid);
-        const toHandle = await context.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 = defineTool({
-    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) => {
-        for (const element of request.params.elements) {
-            await context.waitForEventsAfterAction(async () => {
-                await fillFormElement(element.uid, element.value, context);
-            });
-        }
-        response.appendResponseLine(`Successfully filled out the form`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});
-export const uploadFile = defineTool({
-    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, context) => {
-        const { uid, filePath } = request.params;
-        const handle = (await context.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 page = context.getSelectedPage();
-                    const [fileChooser] = await Promise.all([
-                        page.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 = defineTool({
-    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 = context.getSelectedPage();
-        const tokens = parseKey(request.params.key);
-        const [key, ...modifiers] = tokens;
-        await context.waitForEventsAfterAction(async () => {
-            for (const modifier of modifiers) {
-                await page.keyboard.down(modifier);
-            }
-            await page.keyboard.press(key);
-            for (const modifier of modifiers.toReversed()) {
-                await page.keyboard.up(modifier);
-            }
-        });
-        response.appendResponseLine(`Successfully pressed key: ${request.params.key}`);
-        if (request.params.includeSnapshot) {
-            response.includeSnapshot();
-        }
-    },
-});