chrome-devtools-mcp 0.17.1 → 0.17.2

package/build/src/tools/screenshot.js

@@ -1,84 +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 } from './ToolDefinition.js';
-export const screenshot = defineTool({
-    name: 'take_screenshot',
-    description: `Take a screenshot of the page or element.`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        // Not read-only due to filePath param.
-        readOnlyHint: false,
-    },
-    schema: {
-        format: zod
-            .enum(['png', 'jpeg', 'webp'])
-            .default('png')
-            .describe('Type of format to save the screenshot as. Default is "png"'),
-        quality: zod
-            .number()
-            .min(0)
-            .max(100)
-            .optional()
-            .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
-        uid: zod
-            .string()
-            .optional()
-            .describe('The uid of an element on the page from the page content snapshot. If omitted takes a pages screenshot.'),
-        fullPage: zod
-            .boolean()
-            .optional()
-            .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
-        filePath: zod
-            .string()
-            .optional()
-            .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
-    },
-    handler: async (request, response, context) => {
-        if (request.params.uid && request.params.fullPage) {
-            throw new Error('Providing both "uid" and "fullPage" is not allowed.');
-        }
-        let pageOrHandle;
-        if (request.params.uid) {
-            pageOrHandle = await context.getElementByUid(request.params.uid);
-        }
-        else {
-            pageOrHandle = context.getSelectedPage();
-        }
-        const format = request.params.format;
-        const quality = format === 'png' ? undefined : request.params.quality;
-        const screenshot = await pageOrHandle.screenshot({
-            type: format,
-            fullPage: request.params.fullPage,
-            quality,
-            optimizeForSpeed: true, // Bonus: optimize encoding for speed
-        });
-        if (request.params.uid) {
-            response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
-        }
-        else if (request.params.fullPage) {
-            response.appendResponseLine('Took a screenshot of the full current page.');
-        }
-        else {
-            response.appendResponseLine("Took a screenshot of the current page's viewport.");
-        }
-        if (request.params.filePath) {
-            const file = await context.saveFile(screenshot, request.params.filePath);
-            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}.`);
-        }
-        else {
-            response.attachImage({
-                mimeType: `image/${request.params.format}`,
-                data: Buffer.from(screenshot).toString('base64'),
-            });
-        }
-    },
-});

package/build/src/tools/script.js

@@ -1,71 +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 } 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,
-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.object({
-            uid: 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);
-            }
-            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] ?? context.getSelectedPage();
-            }
-            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()));
-        }
-    },
-});

package/build/src/tools/snapshot.js

@@ -1,52 +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, timeoutSchema } from './ToolDefinition.js';
-export const takeSnapshot = defineTool({
-    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 = defineTool({
-    name: 'wait_for',
-    description: `Wait for the specified text to appear on the selected page.`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: true,
-    },
-    schema: {
-        text: zod.string().describe('Text to appear 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.`);
-        response.includeSnapshot();
-    },
-});

package/build/src/tools/tools.js

@@ -1,31 +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 networkTools from './network.js';
-import * as pagesTools from './pages.js';
-import * as performanceTools from './performance.js';
-import * as screenshotTools from './screenshot.js';
-import * as scriptTools from './script.js';
-import * as snapshotTools from './snapshot.js';
-const tools = [
-    ...Object.values(consoleTools),
-    ...Object.values(emulationTools),
-    ...Object.values(extensionTools),
-    ...Object.values(inputTools),
-    ...Object.values(networkTools),
-    ...Object.values(pagesTools),
-    ...Object.values(performanceTools),
-    ...Object.values(screenshotTools),
-    ...Object.values(scriptTools),
-    ...Object.values(snapshotTools),
-];
-tools.sort((a, b) => {
-    return a.name.localeCompare(b.name);
-});
-export { tools };

package/build/src/trace-processing/parse.js

@@ -1,84 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { logger } from '../logger.js';
-import { DevTools } from '../third_party/index.js';
-const engine = DevTools.TraceEngine.TraceModel.Model.createWithAllHandlers();
-export function traceResultIsSuccess(x) {
-    return 'parsedTrace' in x;
-}
-export async function parseRawTraceBuffer(buffer) {
-    engine.resetProcessor();
-    if (!buffer) {
-        return {
-            error: 'No buffer was provided.',
-        };
-    }
-    const asString = new TextDecoder().decode(buffer);
-    if (!asString) {
-        return {
-            error: 'Decoding the trace buffer returned an empty string.',
-        };
-    }
-    try {
-        const data = JSON.parse(asString);
-        const events = Array.isArray(data) ? data : data.traceEvents;
-        await engine.parse(events);
-        const parsedTrace = engine.parsedTrace();
-        if (!parsedTrace) {
-            return {
-                error: 'No parsed trace was returned from the trace engine.',
-            };
-        }
-        const insights = parsedTrace?.insights ?? null;
-        return {
-            parsedTrace,
-            insights,
-        };
-    }
-    catch (e) {
-        const errorText = e instanceof Error ? e.message : JSON.stringify(e);
-        logger(`Unexpected error parsing trace: ${errorText}`);
-        return {
-            error: errorText,
-        };
-    }
-}
-const extraFormatDescriptions = `Information on performance traces may contain main thread activity represented as call frames and network requests.
-
-${DevTools.PerformanceTraceFormatter.callFrameDataFormatDescription}
-
-${DevTools.PerformanceTraceFormatter.networkDataFormatDescription}`;
-export function getTraceSummary(result) {
-    const focus = DevTools.AgentFocus.fromParsedTrace(result.parsedTrace);
-    const formatter = new DevTools.PerformanceTraceFormatter(focus);
-    const summaryText = formatter.formatTraceSummary();
-    return `## Summary of Performance trace findings:
-${summaryText}
-
-## Details on call tree & network request formats:
-${extraFormatDescriptions}`;
-}
-export function getInsightOutput(result, insightSetId, insightName) {
-    if (!result.insights) {
-        return {
-            error: 'No Performance insights are available for this trace.',
-        };
-    }
-    const insightSet = result.insights.get(insightSetId);
-    if (!insightSet) {
-        return {
-            error: 'No Performance Insights for the given insight set id. Only use ids given in the "Available insight sets" list.',
-        };
-    }
-    const matchingInsight = insightName in insightSet.model ? insightSet.model[insightName] : null;
-    if (!matchingInsight) {
-        return {
-            error: `No Insight with the name ${insightName} found. Double check the name you provided is accurate and try again.`,
-        };
-    }
-    const formatter = new DevTools.PerformanceInsightFormatter(DevTools.AgentFocus.fromParsedTrace(result.parsedTrace), matchingInsight);
-    return { output: formatter.formatInsight() };
-}

package/build/src/utils/ExtensionRegistry.js

@@ -1,35 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export class ExtensionRegistry {
-    #extensions = new Map();
-    async registerExtension(id, extensionPath) {
-        const manifestPath = path.join(extensionPath, 'manifest.json');
-        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
-        const manifest = JSON.parse(manifestContent);
-        const name = manifest.name ?? 'Unknown';
-        const version = manifest.version ?? 'Unknown';
-        const extension = {
-            id,
-            name,
-            version,
-            isEnabled: true,
-            path: extensionPath,
-        };
-        this.#extensions.set(extension.id, extension);
-        return extension;
-    }
-    remove(id) {
-        this.#extensions.delete(id);
-    }
-    list() {
-        return Array.from(this.#extensions.values());
-    }
-    getById(id) {
-        return this.#extensions.get(id);
-    }
-}

package/build/src/utils/keyboard.js

@@ -1,296 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-// See the KeyInput type for the list of supported keys.
-const validKeys = new Set([
-    '0',
-    '1',
-    '2',
-    '3',
-    '4',
-    '5',
-    '6',
-    '7',
-    '8',
-    '9',
-    'Power',
-    'Eject',
-    'Abort',
-    'Help',
-    'Backspace',
-    'Tab',
-    'Numpad5',
-    'NumpadEnter',
-    'Enter',
-    '\r',
-    '\n',
-    'ShiftLeft',
-    'ShiftRight',
-    'ControlLeft',
-    'ControlRight',
-    'AltLeft',
-    'AltRight',
-    'Pause',
-    'CapsLock',
-    'Escape',
-    'Convert',
-    'NonConvert',
-    'Space',
-    'Numpad9',
-    'PageUp',
-    'Numpad3',
-    'PageDown',
-    'End',
-    'Numpad1',
-    'Home',
-    'Numpad7',
-    'ArrowLeft',
-    'Numpad4',
-    'Numpad8',
-    'ArrowUp',
-    'ArrowRight',
-    'Numpad6',
-    'Numpad2',
-    'ArrowDown',
-    'Select',
-    'Open',
-    'PrintScreen',
-    'Insert',
-    'Numpad0',
-    'Delete',
-    'NumpadDecimal',
-    'Digit0',
-    'Digit1',
-    'Digit2',
-    'Digit3',
-    'Digit4',
-    'Digit5',
-    'Digit6',
-    'Digit7',
-    'Digit8',
-    'Digit9',
-    'KeyA',
-    'KeyB',
-    'KeyC',
-    'KeyD',
-    'KeyE',
-    'KeyF',
-    'KeyG',
-    'KeyH',
-    'KeyI',
-    'KeyJ',
-    'KeyK',
-    'KeyL',
-    'KeyM',
-    'KeyN',
-    'KeyO',
-    'KeyP',
-    'KeyQ',
-    'KeyR',
-    'KeyS',
-    'KeyT',
-    'KeyU',
-    'KeyV',
-    'KeyW',
-    'KeyX',
-    'KeyY',
-    'KeyZ',
-    'MetaLeft',
-    'MetaRight',
-    'ContextMenu',
-    'NumpadMultiply',
-    'NumpadAdd',
-    'NumpadSubtract',
-    'NumpadDivide',
-    'F1',
-    'F2',
-    'F3',
-    'F4',
-    'F5',
-    'F6',
-    'F7',
-    'F8',
-    'F9',
-    'F10',
-    'F11',
-    'F12',
-    'F13',
-    'F14',
-    'F15',
-    'F16',
-    'F17',
-    'F18',
-    'F19',
-    'F20',
-    'F21',
-    'F22',
-    'F23',
-    'F24',
-    'NumLock',
-    'ScrollLock',
-    'AudioVolumeMute',
-    'AudioVolumeDown',
-    'AudioVolumeUp',
-    'MediaTrackNext',
-    'MediaTrackPrevious',
-    'MediaStop',
-    'MediaPlayPause',
-    'Semicolon',
-    'Equal',
-    'NumpadEqual',
-    'Comma',
-    'Minus',
-    'Period',
-    'Slash',
-    'Backquote',
-    'BracketLeft',
-    'Backslash',
-    'BracketRight',
-    'Quote',
-    'AltGraph',
-    'Props',
-    'Cancel',
-    'Clear',
-    'Shift',
-    'Control',
-    'Alt',
-    'Accept',
-    'ModeChange',
-    ' ',
-    'Print',
-    'Execute',
-    '\u0000',
-    'a',
-    'b',
-    'c',
-    'd',
-    'e',
-    'f',
-    'g',
-    'h',
-    'i',
-    'j',
-    'k',
-    'l',
-    'm',
-    'n',
-    'o',
-    'p',
-    'q',
-    'r',
-    's',
-    't',
-    'u',
-    'v',
-    'w',
-    'x',
-    'y',
-    'z',
-    'Meta',
-    '*',
-    '+',
-    '-',
-    '/',
-    ';',
-    '=',
-    ',',
-    '.',
-    '`',
-    '[',
-    '\\',
-    ']',
-    "'",
-    'Attn',
-    'CrSel',
-    'ExSel',
-    'EraseEof',
-    'Play',
-    'ZoomOut',
-    ')',
-    '!',
-    '@',
-    '#',
-    '$',
-    '%',
-    '^',
-    '&',
-    '(',
-    'A',
-    'B',
-    'C',
-    'D',
-    'E',
-    'F',
-    'G',
-    'H',
-    'I',
-    'J',
-    'K',
-    'L',
-    'M',
-    'N',
-    'O',
-    'P',
-    'Q',
-    'R',
-    'S',
-    'T',
-    'U',
-    'V',
-    'W',
-    'X',
-    'Y',
-    'Z',
-    ':',
-    '<',
-    '_',
-    '>',
-    '?',
-    '~',
-    '{',
-    '|',
-    '}',
-    '"',
-    'SoftLeft',
-    'SoftRight',
-    'Camera',
-    'Call',
-    'EndCall',
-    'VolumeDown',
-    'VolumeUp',
-]);
-function throwIfInvalidKey(key) {
-    if (validKeys.has(key)) {
-        return key;
-    }
-    throw new Error(`${key} is invalid. Valid keys are: ${Array.from(validKeys.values()).join(',')}.`);
-}
-/**
- * Returns the primary key, followed by modifiers in original order.
- */
-export function parseKey(keyInput) {
-    let key = '';
-    const result = [];
-    for (const ch of keyInput) {
-        // Handle cases like Shift++.
-        if (ch === '+' && key) {
-            result.push(throwIfInvalidKey(key));
-            key = '';
-        }
-        else {
-            key += ch;
-        }
-    }
-    if (key) {
-        result.push(throwIfInvalidKey(key));
-    }
-    if (result.length === 0) {
-        throw new Error(`Key ${keyInput} could not be parsed.`);
-    }
-    if (new Set(result).size !== result.length) {
-        throw new Error(`Key ${keyInput} contains duplicate keys.`);
-    }
-    return [result.at(-1), ...result.slice(0, -1)];
-}

package/build/src/utils/pagination.js

@@ -1,49 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-const DEFAULT_PAGE_SIZE = 20;
-export function paginate(items, options) {
-    const total = items.length;
-    if (!options || noPaginationOptions(options)) {
-        return {
-            items,
-            currentPage: 0,
-            totalPages: 1,
-            hasNextPage: false,
-            hasPreviousPage: false,
-            startIndex: 0,
-            endIndex: total,
-            invalidPage: false,
-        };
-    }
-    const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
-    const totalPages = Math.max(1, Math.ceil(total / pageSize));
-    const { currentPage, invalidPage } = resolvePageIndex(options.pageIdx, totalPages);
-    const startIndex = currentPage * pageSize;
-    const pageItems = items.slice(startIndex, startIndex + pageSize);
-    const endIndex = startIndex + pageItems.length;
-    return {
-        items: pageItems,
-        currentPage,
-        totalPages,
-        hasNextPage: currentPage < totalPages - 1,
-        hasPreviousPage: currentPage > 0,
-        startIndex,
-        endIndex,
-        invalidPage,
-    };
-}
-function noPaginationOptions(options) {
-    return options.pageSize === undefined && options.pageIdx === undefined;
-}
-function resolvePageIndex(pageIdx, totalPages) {
-    if (pageIdx === undefined) {
-        return { currentPage: 0, invalidPage: false };
-    }
-    if (pageIdx < 0 || pageIdx >= totalPages) {
-        return { currentPage: 0, invalidPage: true };
-    }
-    return { currentPage: pageIdx, invalidPage: false };
-}