chrome-devtools-mcp 0.17.1 → 0.17.2

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 { defineTool } 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 = defineTool({
-    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();
-        response.attachDevToolsData(data);
-        const reqid = data?.cdpRequestId
-            ? context.resolveCdpRequestId(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 = defineTool({
-    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();
-            response.attachDevToolsData(data);
-            const reqid = data?.cdpRequestId
-                ? context.resolveCdpRequestId(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.`);
-            }
-        }
-    },
-});

package/build/src/tools/pages.js

@@ -1,323 +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 { ToolCategory } from './categories.js';
-import { CLOSE_PAGE_ERROR, defineTool, timeoutSchema } from './ToolDefinition.js';
-export const listPages = defineTool({
-    name: 'list_pages',
-    description: `Get a list of pages open in the browser.`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: true,
-    },
-    schema: {},
-    handler: async (_request, response) => {
-        response.setIncludePages(true);
-    },
-});
-export const selectPage = defineTool({
-    name: 'select_page',
-    description: `Select a page as a context for future tool calls.`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: true,
-    },
-    schema: {
-        pageId: zod
-            .number()
-            .describe(`The ID of the page to select. Call ${listPages.name} to get available pages.`),
-        bringToFront: zod
-            .boolean()
-            .optional()
-            .describe('Whether to focus the page and bring it to the top.'),
-    },
-    handler: async (request, response, context) => {
-        const page = context.getPageById(request.params.pageId);
-        context.selectPage(page);
-        response.setIncludePages(true);
-        if (request.params.bringToFront) {
-            await page.bringToFront();
-        }
-    },
-});
-export const closePage = defineTool({
-    name: 'close_page',
-    description: `Closes the page by its index. The last open page cannot be closed.`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: false,
-    },
-    schema: {
-        pageId: zod
-            .number()
-            .describe('The ID of the page to close. Call list_pages to list pages.'),
-    },
-    handler: async (request, response, context) => {
-        try {
-            await context.closePage(request.params.pageId);
-        }
-        catch (err) {
-            if (err.message === CLOSE_PAGE_ERROR) {
-                response.appendResponseLine(err.message);
-            }
-            else {
-                throw err;
-            }
-        }
-        response.setIncludePages(true);
-    },
-});
-export const newPage = defineTool({
-    name: 'new_page',
-    description: `Creates a new page`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: false,
-    },
-    schema: {
-        url: zod.string().describe('URL to load in a new page.'),
-        background: zod
-            .boolean()
-            .optional()
-            .describe('Whether to open the page in the background without bringing it to the front. Default is false (foreground).'),
-        ...timeoutSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = await context.newPage(request.params.background);
-        await context.waitForEventsAfterAction(async () => {
-            await page.goto(request.params.url, {
-                timeout: request.params.timeout,
-            });
-        }, { timeout: request.params.timeout });
-        response.setIncludePages(true);
-    },
-});
-export const navigatePage = defineTool({
-    name: 'navigate_page',
-    description: `Navigates the currently selected page to a URL.`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: false,
-    },
-    schema: {
-        type: zod
-            .enum(['url', 'back', 'forward', 'reload'])
-            .optional()
-            .describe('Navigate the page by URL, back or forward in history, or reload.'),
-        url: zod.string().optional().describe('Target URL (only type=url)'),
-        ignoreCache: zod
-            .boolean()
-            .optional()
-            .describe('Whether to ignore cache on reload.'),
-        handleBeforeUnload: zod
-            .enum(['accept', 'decline'])
-            .optional()
-            .describe('Whether to auto accept or beforeunload dialogs triggered by this navigation. Default is accept.'),
-        initScript: zod
-            .string()
-            .optional()
-            .describe('A JavaScript script to be executed on each new document before any other scripts for the next navigation.'),
-        ...timeoutSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
-        const options = {
-            timeout: request.params.timeout,
-        };
-        if (!request.params.type && !request.params.url) {
-            throw new Error('Either URL or a type is required.');
-        }
-        if (!request.params.type) {
-            request.params.type = 'url';
-        }
-        const handleBeforeUnload = request.params.handleBeforeUnload ?? 'accept';
-        const dialogHandler = (dialog) => {
-            if (dialog.type() === 'beforeunload') {
-                if (handleBeforeUnload === 'accept') {
-                    response.appendResponseLine(`Accepted a beforeunload dialog.`);
-                    void dialog.accept();
-                }
-                else {
-                    response.appendResponseLine(`Declined a beforeunload dialog.`);
-                    void dialog.dismiss();
-                }
-                // We are not going to report the dialog like regular dialogs.
-                context.clearDialog();
-            }
-        };
-        let initScriptId;
-        if (request.params.initScript) {
-            const { identifier } = await page.evaluateOnNewDocument(request.params.initScript);
-            initScriptId = identifier;
-        }
-        page.on('dialog', dialogHandler);
-        try {
-            await context.waitForEventsAfterAction(async () => {
-                switch (request.params.type) {
-                    case 'url':
-                        if (!request.params.url) {
-                            throw new Error('A URL is required for navigation of type=url.');
-                        }
-                        try {
-                            await page.goto(request.params.url, options);
-                            response.appendResponseLine(`Successfully navigated to ${request.params.url}.`);
-                        }
-                        catch (error) {
-                            response.appendResponseLine(`Unable to navigate in the  selected page: ${error.message}.`);
-                        }
-                        break;
-                    case 'back':
-                        try {
-                            await page.goBack(options);
-                            response.appendResponseLine(`Successfully navigated back to ${page.url()}.`);
-                        }
-                        catch (error) {
-                            response.appendResponseLine(`Unable to navigate back in the selected page: ${error.message}.`);
-                        }
-                        break;
-                    case 'forward':
-                        try {
-                            await page.goForward(options);
-                            response.appendResponseLine(`Successfully navigated forward to ${page.url()}.`);
-                        }
-                        catch (error) {
-                            response.appendResponseLine(`Unable to navigate forward in the selected page: ${error.message}.`);
-                        }
-                        break;
-                    case 'reload':
-                        try {
-                            await page.reload({
-                                ...options,
-                                ignoreCache: request.params.ignoreCache,
-                            });
-                            response.appendResponseLine(`Successfully reloaded the page.`);
-                        }
-                        catch (error) {
-                            response.appendResponseLine(`Unable to reload the selected page: ${error.message}.`);
-                        }
-                        break;
-                }
-            }, { timeout: request.params.timeout });
-        }
-        finally {
-            page.off('dialog', dialogHandler);
-            if (initScriptId) {
-                await page
-                    .removeScriptToEvaluateOnNewDocument(initScriptId)
-                    .catch(error => {
-                    logger(`Failed to remove init script`, error);
-                });
-            }
-        }
-        response.setIncludePages(true);
-    },
-});
-export const resizePage = defineTool({
-    name: 'resize_page',
-    description: `Resizes the selected page's window so that the page has specified dimension`,
-    annotations: {
-        category: ToolCategory.EMULATION,
-        readOnlyHint: false,
-    },
-    schema: {
-        width: zod.number().describe('Page width'),
-        height: zod.number().describe('Page height'),
-    },
-    handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
-        try {
-            const browser = page.browser();
-            const windowId = await page.windowId();
-            const bounds = await browser.getWindowBounds(windowId);
-            if (bounds.windowState === 'fullscreen') {
-                // Have to call this twice on Ubuntu when the window is in fullscreen mode.
-                await browser.setWindowBounds(windowId, { windowState: 'normal' });
-                await browser.setWindowBounds(windowId, { windowState: 'normal' });
-            }
-            else if (bounds.windowState !== 'normal') {
-                await browser.setWindowBounds(windowId, { windowState: 'normal' });
-            }
-        }
-        catch {
-            // Window APIs are not supported on all platforms
-        }
-        await page.resize({
-            contentWidth: request.params.width,
-            contentHeight: request.params.height,
-        });
-        response.setIncludePages(true);
-    },
-});
-export const handleDialog = defineTool({
-    name: 'handle_dialog',
-    description: `If a browser dialog was opened, use this command to handle it`,
-    annotations: {
-        category: ToolCategory.INPUT,
-        readOnlyHint: false,
-    },
-    schema: {
-        action: zod
-            .enum(['accept', 'dismiss'])
-            .describe('Whether to dismiss or accept the dialog'),
-        promptText: zod
-            .string()
-            .optional()
-            .describe('Optional prompt text to enter into the dialog.'),
-    },
-    handler: async (request, response, context) => {
-        const dialog = context.getDialog();
-        if (!dialog) {
-            throw new Error('No open dialog found');
-        }
-        switch (request.params.action) {
-            case 'accept': {
-                try {
-                    await dialog.accept(request.params.promptText);
-                }
-                catch (err) {
-                    // Likely already handled by the user outside of MCP.
-                    logger(err);
-                }
-                response.appendResponseLine('Successfully accepted the dialog');
-                break;
-            }
-            case 'dismiss': {
-                try {
-                    await dialog.dismiss();
-                }
-                catch (err) {
-                    // Likely already handled.
-                    logger(err);
-                }
-                response.appendResponseLine('Successfully dismissed the dialog');
-                break;
-            }
-        }
-        context.clearDialog();
-        response.setIncludePages(true);
-    },
-});
-export const getTabId = defineTool({
-    name: 'get_tab_id',
-    description: `Get the tab ID of the page`,
-    annotations: {
-        category: ToolCategory.NAVIGATION,
-        readOnlyHint: true,
-        conditions: ['experimentalInteropTools'],
-    },
-    schema: {
-        pageId: zod
-            .number()
-            .describe(`The ID of the page to get the tab ID for. Call ${listPages.name} to get available pages.`),
-    },
-    handler: async (request, response, context) => {
-        const page = context.getPageById(request.params.pageId);
-        // @ts-expect-error _tabId is internal.
-        const tabId = page._tabId;
-        response.setTabId(tabId);
-    },
-});

package/build/src/tools/performance.js

@@ -1,188 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import zlib from 'node:zlib';
-import { logger } from '../logger.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';
-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 = defineTool({
-    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.`,
-    annotations: {
-        category: ToolCategory.PERFORMANCE,
-        readOnlyHint: false,
-    },
-    schema: {
-        reload: zod
-            .boolean()
-            .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()
-            .describe('Determines if the trace recording should be automatically stopped.'),
-        filePath: filePathSchema,
-    },
-    handler: async (request, response, context) => {
-        if (context.isRunningPerformanceTrace()) {
-            response.appendResponseLine('Error: a performance trace is already running. Use performance_stop_trace to stop it. Only one trace can be running at any given time.');
-            return;
-        }
-        context.setIsRunningPerformanceTrace(true);
-        const page = context.getSelectedPage();
-        const pageUrlForTracing = page.url();
-        if (request.params.reload) {
-            // Before starting the recording, navigate to about:blank to clear out any state.
-            await page.goto('about:blank', {
-                waitUntil: ['networkidle0'],
-            });
-        }
-        // Keep in sync with the categories arrays in:
-        // https://source.chromium.org/chromium/chromium/src/+/main:third_party/devtools-frontend/src/front_end/panels/timeline/TimelineController.ts
-        // https://github.com/GoogleChrome/lighthouse/blob/master/lighthouse-core/gather/gatherers/trace.js
-        const categories = [
-            '-*',
-            'blink.console',
-            'blink.user_timing',
-            'devtools.timeline',
-            'disabled-by-default-devtools.screenshot',
-            'disabled-by-default-devtools.timeline',
-            'disabled-by-default-devtools.timeline.invalidationTracking',
-            'disabled-by-default-devtools.timeline.frame',
-            'disabled-by-default-devtools.timeline.stack',
-            'disabled-by-default-v8.cpu_profiler',
-            'disabled-by-default-v8.cpu_profiler.hires',
-            'latencyInfo',
-            'loading',
-            'disabled-by-default-lighthouse',
-            'v8.execute',
-            'v8',
-        ];
-        await page.tracing.start({
-            categories,
-        });
-        if (request.params.reload) {
-            await page.goto(pageUrlForTracing, {
-                waitUntil: ['load'],
-            });
-        }
-        if (request.params.autoStop) {
-            await new Promise(resolve => setTimeout(resolve, 5_000));
-            await stopTracingAndAppendOutput(page, 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({
-    name: 'performance_stop_trace',
-    description: 'Stops the active performance trace recording on the selected page.',
-    annotations: {
-        category: ToolCategory.PERFORMANCE,
-        readOnlyHint: false,
-    },
-    schema: {
-        filePath: filePathSchema,
-    },
-    handler: async (request, response, context) => {
-        if (!context.isRunningPerformanceTrace()) {
-            return;
-        }
-        const page = context.getSelectedPage();
-        await stopTracingAndAppendOutput(page, response, context, request.params.filePath);
-    },
-});
-export const analyzeInsight = defineTool({
-    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: {
-        category: ToolCategory.PERFORMANCE,
-        readOnlyHint: true,
-    },
-    schema: {
-        insightSetId: zod
-            .string()
-            .describe('The id for the specific insight set. Only use the ids given in the "Available insight sets" list.'),
-        insightName: zod
-            .string()
-            .describe('The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"'),
-    },
-    handler: async (request, response, context) => {
-        const lastRecording = context.recordedTraces().at(-1);
-        if (!lastRecording) {
-            response.appendResponseLine('No recorded traces found. Record a performance trace so you have Insights to analyze.');
-            return;
-        }
-        response.attachTraceInsight(lastRecording, request.params.insightSetId, request.params.insightName);
-    },
-});
-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);
-            response.attachTraceSummary(result);
-        }
-        else {
-            throw new Error(`There was an unexpected error parsing the trace: ${result.error}`);
-        }
-    }
-    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;
-}