chrome-devtools-mcp 0.22.0 → 0.24.0

package/build/src/tools/pages.js

@@ -7,6 +7,51 @@ import { logger } from '../logger.js';
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
 import { CLOSE_PAGE_ERROR, definePageTool, defineTool, timeoutSchema, } from './ToolDefinition.js';
+async function navigateWithInterception(page, action, allowListString, timeout) {
+    const allowList = allowListString
+        ? allowListString.split(',').map((p) => new URLPattern(p.trim()))
+        : undefined;
+    const requestHandler = (interceptedRequest) => {
+        if (!interceptedRequest.isNavigationRequest()) {
+            void interceptedRequest.continue();
+            return;
+        }
+        const requestUrl = interceptedRequest.url();
+        const isAllowed = allowList.some((pattern) => pattern.test(requestUrl));
+        if (isAllowed) {
+            void interceptedRequest.continue();
+        }
+        else {
+            logger(`Blocking request to: ${requestUrl}`);
+            void interceptedRequest.abort('blockedbyclient');
+        }
+    };
+    const cleanupInterception = async () => {
+        if (allowList) {
+            page.pptrPage.off('request', requestHandler);
+            await page.pptrPage.setRequestInterception(false).catch(error => {
+                logger(`Failed to disable request interception`, error);
+            });
+        }
+    };
+    if (allowList) {
+        await page.pptrPage.setRequestInterception(true);
+        page.pptrPage.on('request', requestHandler);
+    }
+    try {
+        await page.waitForEventsAfterAction(async () => {
+            try {
+                await action();
+            }
+            finally {
+                await cleanupInterception();
+            }
+        }, { timeout });
+    }
+    finally {
+        await cleanupInterception();
+    }
+}
 export const listPages = defineTool(args => {
     return {
         name: 'list_pages',
@@ -16,6 +61,7 @@ export const listPages = defineTool(args => {
             readOnlyHint: true,
         },
         schema: {},
+        blockedByDialog: false,
         handler: async (_request, response) => {
             response.setIncludePages(true);
             response.setListInPageTools();
@@ -39,6 +85,7 @@ export const selectPage = defineTool({
             .optional()
             .describe('Whether to focus the page and bring it to the top.'),
     },
+    blockedByDialog: false,
     handler: async (request, response, context) => {
         const page = context.getPageById(request.params.pageId);
         context.selectPage(page);
@@ -62,6 +109,7 @@ export const closePage = defineTool({
             .number()
             .describe('The ID of the page to close. Call list_pages to list pages.'),
     },
+    blockedByDialog: false,
     handler: async (request, response, context) => {
         try {
             await context.closePage(request.params.pageId);
@@ -78,159 +126,179 @@ export const closePage = defineTool({
         response.setListInPageTools();
     },
 });
-export const newPage = defineTool({
-    name: 'new_page',
-    description: `Open a new tab and load a URL. Use project URL if not specified otherwise.`,
-    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).'),
-        isolatedContext: zod
-            .string()
-            .optional()
-            .describe('If specified, the page is created in an isolated browser context with the given name. ' +
-            'Pages in the same browser context share cookies and storage. ' +
-            'Pages in different browser contexts are fully isolated.'),
-        ...timeoutSchema,
-    },
-    handler: async (request, response, context) => {
-        const page = await context.newPage(request.params.background, request.params.isolatedContext);
-        await page.waitForEventsAfterAction(async () => {
-            await page.pptrPage.goto(request.params.url, {
+export const newPage = defineTool(args => {
+    return {
+        name: 'new_page',
+        description: `Open a new tab and load a URL. Use project URL if not specified otherwise.`,
+        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).'),
+            isolatedContext: zod
+                .string()
+                .optional()
+                .describe('If specified, the page is created in an isolated browser context with the given name. ' +
+                'Pages in the same browser context share cookies and storage. ' +
+                'Pages in different browser contexts are fully isolated.'),
+            ...(args?.experimentalNavigationAllowlist
+                ? {
+                    allowList: zod
+                        .string()
+                        .optional()
+                        .describe('Optional comma-separated list of URL patterns to allow. If provided, all other navigations will be blocked.'),
+                }
+                : {}),
+            ...timeoutSchema,
+        },
+        blockedByDialog: false,
+        handler: async (request, response, context) => {
+            const page = await context.newPage(request.params.background, request.params.isolatedContext);
+            await navigateWithInterception(page, () => page.pptrPage.goto(request.params.url, {
                 timeout: request.params.timeout,
-            });
-        }, { timeout: request.params.timeout });
-        response.setIncludePages(true);
-        response.setListInPageTools();
-    },
+            }), request.params.allowList, request.params.timeout);
+            response.setIncludePages(true);
+            response.setListInPageTools();
+        },
+    };
 });
-export const navigatePage = definePageTool({
-    name: 'navigate_page',
-    description: `Go to a URL, or back, forward, or reload. Use project URL if not specified otherwise.`,
-    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) => {
-        const page = request.page;
-        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();
+export const navigatePage = definePageTool(args => {
+    return {
+        name: 'navigate_page',
+        description: `Go to a URL, or back, forward, or reload. Use project URL if not specified otherwise.`,
+        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.'),
+            ...(args?.experimentalNavigationAllowlist
+                ? {
+                    allowList: zod
+                        .string()
+                        .optional()
+                        .describe('Optional comma-separated list of URL patterns to allow. If provided, all other navigations will be blocked.'),
                 }
-                else {
-                    response.appendResponseLine(`Declined a beforeunload dialog.`);
-                    void dialog.dismiss();
+                : {}),
+            ...timeoutSchema,
+        },
+        blockedByDialog: false,
+        handler: async (request, response) => {
+            const page = request.page;
+            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.
+                    page.clearDialog();
                 }
-                // We are not going to report the dialog like regular dialogs.
-                page.clearDialog();
+            };
+            let initScriptId;
+            if (request.params.initScript) {
+                const { identifier } = await page.pptrPage.evaluateOnNewDocument(request.params.initScript);
+                initScriptId = identifier;
             }
-        };
-        let initScriptId;
-        if (request.params.initScript) {
-            const { identifier } = await page.pptrPage.evaluateOnNewDocument(request.params.initScript);
-            initScriptId = identifier;
-        }
-        page.pptrPage.on('dialog', dialogHandler);
-        try {
-            await page.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.pptrPage.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.pptrPage.goBack(options);
-                            response.appendResponseLine(`Successfully navigated back to ${page.pptrPage.url()}.`);
-                        }
-                        catch (error) {
-                            response.appendResponseLine(`Unable to navigate back in the selected page: ${error.message}.`);
-                        }
-                        break;
-                    case 'forward':
-                        try {
-                            await page.pptrPage.goForward(options);
-                            response.appendResponseLine(`Successfully navigated forward to ${page.pptrPage.url()}.`);
-                        }
-                        catch (error) {
-                            response.appendResponseLine(`Unable to navigate forward in the selected page: ${error.message}.`);
-                        }
-                        break;
-                    case 'reload':
-                        try {
-                            await page.pptrPage.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;
+            page.pptrPage.on('dialog', dialogHandler);
+            try {
+                await navigateWithInterception(page, 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.pptrPage.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.pptrPage.goBack(options);
+                                response.appendResponseLine(`Successfully navigated back to ${page.pptrPage.url()}.`);
+                            }
+                            catch (error) {
+                                response.appendResponseLine(`Unable to navigate back in the selected page: ${error.message}.`);
+                            }
+                            break;
+                        case 'forward':
+                            try {
+                                await page.pptrPage.goForward(options);
+                                response.appendResponseLine(`Successfully navigated forward to ${page.pptrPage.url()}.`);
+                            }
+                            catch (error) {
+                                response.appendResponseLine(`Unable to navigate forward in the selected page: ${error.message}.`);
+                            }
+                            break;
+                        case 'reload':
+                            try {
+                                await page.pptrPage.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;
+                    }
+                }, request.params.allowList, request.params.timeout);
+            }
+            finally {
+                page.pptrPage.off('dialog', dialogHandler);
+                if (initScriptId) {
+                    await page.pptrPage
+                        .removeScriptToEvaluateOnNewDocument(initScriptId)
+                        .catch(error => {
+                        logger(`Failed to remove init script`, error);
+                    });
                 }
-            }, { timeout: request.params.timeout });
-        }
-        finally {
-            page.pptrPage.off('dialog', dialogHandler);
-            if (initScriptId) {
-                await page.pptrPage
-                    .removeScriptToEvaluateOnNewDocument(initScriptId)
-                    .catch(error => {
-                    logger(`Failed to remove init script`, error);
-                });
             }
-        }
-        response.setIncludePages(true);
-        response.setListInPageTools();
-        response.setListWebMcpTools();
-    },
+            response.setIncludePages(true);
+            response.setListInPageTools();
+            response.setListWebMcpTools();
+        },
+    };
 });
 export const resizePage = definePageTool({
     name: 'resize_page',
@@ -243,6 +311,7 @@ export const resizePage = definePageTool({
         width: zod.number().describe('Page width'),
         height: zod.number().describe('Page height'),
     },
+    blockedByDialog: false,
     handler: async (request, response, _context) => {
         const page = request.page;
         try {
@@ -284,6 +353,7 @@ export const handleDialog = definePageTool({
             .optional()
             .describe('Optional prompt text to enter into the dialog.'),
     },
+    blockedByDialog: false,
     handler: async (request, response, _context) => {
         const page = request.page;
         const dialog = page.getDialog();
@@ -331,9 +401,11 @@ export const getTabId = definePageTool({
             .number()
             .describe(`The ID of the page to get the tab ID for. Call ${listPages().name} to get available pages.`),
     },
+    blockedByDialog: false,
     handler: async (request, response, context) => {
         const page = context.getPageById(request.params.pageId);
         const tabId = page.pptrPage._tabId;
         response.setTabId(tabId);
     },
 });
+//# sourceMappingURL=pages.js.map

package/build/src/tools/performance.js

@@ -31,7 +31,9 @@ export const startTrace = definePageTool({
             .describe('Determines if the trace recording should be automatically stopped.'),
         filePath: filePathSchema,
     },
+    blockedByDialog: true,
     handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
         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;
@@ -93,7 +95,9 @@ export const stopTrace = definePageTool({
     schema: {
         filePath: filePathSchema,
     },
+    blockedByDialog: true,
     handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
         if (!context.isRunningPerformanceTrace()) {
             return;
         }
@@ -116,6 +120,7 @@ export const analyzeInsight = definePageTool({
             .string()
             .describe('The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"'),
     },
+    blockedByDialog: false,
     handler: async (request, response, context) => {
         const lastRecording = context.recordedTraces().at(-1);
         if (!lastRecording) {
@@ -188,3 +193,4 @@ async function populateCruxData(result) {
     }));
     result.parsedTrace.metadata.cruxFieldData = cruxData;
 }
+//# sourceMappingURL=performance.js.map

package/build/src/tools/screencast.js

@@ -14,33 +14,46 @@ async function generateTempFilePath() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'chrome-devtools-mcp-'));
     return path.join(dir, `screencast.mp4`);
 }
-export const startScreencast = definePageTool({
+const supportedExtensions = ['.webm', '.mp4'];
+export const startScreencast = definePageTool(args => ({
     name: 'screencast_start',
-    description: 'Starts recording a screencast (video) of the selected page in mp4 format.',
+    description: `Starts recording a screencast (video) of the selected page in specified format.`,
     annotations: {
         category: ToolCategory.DEBUGGING,
         readOnlyHint: false,
-        conditions: ['screencast'],
+        conditions: ['experimentalScreencast'],
     },
     schema: {
-        path: zod
+        filePath: zod
             .string()
             .optional()
-            .describe('Output path. Uses mkdtemp to generate a unique path if not provided.'),
+            .describe(`Output file path (${supportedExtensions.join(',')} are supported). Uses mkdtemp to generate a unique path if not provided.`),
     },
+    blockedByDialog: false,
     handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
         if (context.getScreenRecorder() !== null) {
             response.appendResponseLine('Error: a screencast recording is already in progress. Use screencast_stop to stop it before starting a new one.');
             return;
         }
-        const filePath = request.params.path ?? (await generateTempFilePath());
-        const resolvedPath = ensureExtension(path.resolve(filePath), '.mp4');
+        const filePath = request.params.filePath ?? (await generateTempFilePath());
+        let enforcedExtension = '.mp4';
+        let format = 'mp4';
+        for (const supportedExtension of supportedExtensions) {
+            if (filePath.endsWith(supportedExtension)) {
+                enforcedExtension = supportedExtension;
+                format = supportedExtension.substring(1);
+                break;
+            }
+        }
+        const resolvedPath = ensureExtension(path.resolve(filePath), enforcedExtension);
         const page = request.page;
         let recorder;
         try {
             recorder = await page.pptrPage.screencast({
                 path: resolvedPath,
-                format: 'mp4',
+                format: format,
+                ffmpegPath: args?.experimentalFfmpegPath,
             });
         }
         catch (err) {
@@ -54,16 +67,17 @@ export const startScreencast = definePageTool({
         context.setScreenRecorder({ recorder, filePath: resolvedPath });
         response.appendResponseLine(`Screencast recording started. The recording will be saved to ${resolvedPath}. Use ${stopScreencast.name} to stop recording.`);
     },
-});
+}));
 export const stopScreencast = definePageTool({
     name: 'screencast_stop',
     description: 'Stops the active screencast recording on the selected page.',
     annotations: {
         category: ToolCategory.DEBUGGING,
         readOnlyHint: false,
-        conditions: ['screencast'],
+        conditions: ['experimentalScreencast'],
     },
     schema: {},
+    blockedByDialog: false,
     handler: async (_request, response, context) => {
         const data = context.getScreenRecorder();
         if (!data) {
@@ -78,3 +92,4 @@ export const stopScreencast = definePageTool({
         }
     },
 });
+//# sourceMappingURL=screencast.js.map

package/build/src/tools/screenshot.js

@@ -38,7 +38,9 @@ export const screenshot = definePageTool({
             .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.'),
     },
+    blockedByDialog: true,
     handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
         if (request.params.uid && request.params.fullPage) {
             throw new Error('Providing both "uid" and "fullPage" is not allowed.');
         }
@@ -82,3 +84,4 @@ export const screenshot = definePageTool({
         }
     },
 });
+//# sourceMappingURL=screenshot.js.map

package/build/src/tools/script.js

@@ -46,6 +46,7 @@ Example with arguments: \`(el) => {
                 }
                 : {}),
         },
+        blockedByDialog: true,
         handler: async (request, response, context) => {
             const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, } = request.params;
             if (cliArgs?.categoryExtensions && serviceWorkerId) {
@@ -125,3 +126,4 @@ const getWebWorker = async (context, serviceWorkerId) => {
         throw new Error('Service worker not found.');
     }
 };
+//# sourceMappingURL=script.js.map

package/build/src/tools/slim/tools.js

@@ -15,6 +15,7 @@ export const screenshot = definePageTool({
         readOnlyHint: false,
     },
     schema: {},
+    blockedByDialog: true,
     handler: async (request, response, context) => {
         const page = request.page;
         const screenshot = await page.pptrPage.screenshot({
@@ -35,6 +36,7 @@ export const navigate = definePageTool({
     schema: {
         url: zod.string().describe('URL to navigate to'),
     },
+    blockedByDialog: false,
     handler: async (request, response) => {
         const page = request.page;
         const options = {
@@ -68,6 +70,7 @@ export const evaluate = definePageTool({
     schema: {
         script: zod.string().describe(`JS script to run on the page`),
     },
+    blockedByDialog: true,
     handler: async (request, response) => {
         const page = request.page;
         try {
@@ -79,3 +82,4 @@ export const evaluate = definePageTool({
         }
     },
 });
+//# sourceMappingURL=tools.js.map

package/build/src/tools/snapshot.js

@@ -26,7 +26,9 @@ in the DevTools Elements panel (if any).`,
             .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) => {
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
         response.includeSnapshot({
             verbose: request.params.verbose ?? false,
             filePath: request.params.filePath,
@@ -47,6 +49,7 @@ export const waitFor = definePageTool({
             .describe('Non-empty list of texts. Resolves when any value appears on the page.'),
         ...timeoutSchema,
     },
+    blockedByDialog: true,
     handler: async (request, response, context) => {
         const page = request.page;
         await context.waitForTextOnPage(request.params.text, request.params.timeout, page.pptrPage);
@@ -54,3 +57,4 @@ export const waitFor = definePageTool({
         response.includeSnapshot();
     },
 });
+//# sourceMappingURL=snapshot.js.map

package/build/src/tools/tools.js

@@ -53,3 +53,4 @@ export const createTools = (args) => {
     });
     return tools;
 };
+//# sourceMappingURL=tools.js.map

package/build/src/tools/webmcp.js

@@ -15,6 +15,7 @@ export const listWebMcpTools = definePageTool({
         conditions: ['experimentalWebmcp'],
     },
     schema: {},
+    blockedByDialog: false,
     handler: async (_request, response, _context) => {
         response.setListWebMcpTools();
     },
@@ -34,6 +35,7 @@ export const executeWebMcpTool = definePageTool({
             .optional()
             .describe('The JSON-stringified parameters to pass to the WebMCP tool'),
     },
+    blockedByDialog: false,
     handler: async (request, response) => {
         const toolName = request.params.toolName;
         let input = {};
@@ -61,3 +63,4 @@ export const executeWebMcpTool = definePageTool({
         response.appendResponseLine(JSON.stringify({ status, output, errorText }, null, 2));
     },
 });
+//# sourceMappingURL=webmcp.js.map

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

@@ -82,3 +82,4 @@ export function getInsightOutput(result, insightSetId, insightName) {
     const formatter = new DevTools.PerformanceInsightFormatter(DevTools.AgentFocus.fromParsedTrace(result.parsedTrace), matchingInsight);
     return { output: formatter.formatInsight() };
 }
+//# sourceMappingURL=parse.js.map