@playwright/mcp 0.0.20 → 0.0.22

package/lib/index.js

@@ -13,55 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createServerWithTools } from './server.js';
-import common from './tools/common.js';
-import console from './tools/console.js';
-import dialogs from './tools/dialogs.js';
-import files from './tools/files.js';
-import install from './tools/install.js';
-import keyboard from './tools/keyboard.js';
-import navigate from './tools/navigate.js';
-import network from './tools/network.js';
-import pdf from './tools/pdf.js';
-import snapshot from './tools/snapshot.js';
-import tabs from './tools/tabs.js';
-import screen from './tools/screen.js';
-import testing from './tools/testing.js';
-const snapshotTools = [
-    ...common(true),
-    ...console,
-    ...dialogs(true),
-    ...files(true),
-    ...install,
-    ...keyboard(true),
-    ...navigate(true),
-    ...network,
-    ...pdf,
-    ...snapshot,
-    ...tabs(true),
-    ...testing,
-];
-const screenshotTools = [
-    ...common(false),
-    ...console,
-    ...dialogs(false),
-    ...files(false),
-    ...install,
-    ...keyboard(false),
-    ...navigate(false),
-    ...network,
-    ...pdf,
-    ...screen,
-    ...tabs(false),
-    ...testing,
-];
-import packageJSON from '../package.json' with { type: 'json' };
-export async function createServer(config = {}) {
-    const allTools = config.vision ? screenshotTools : snapshotTools;
-    const tools = allTools.filter(tool => !config.capabilities || tool.capability === 'core' || config.capabilities.includes(tool.capability));
-    return createServerWithTools({
-        name: 'Playwright',
-        version: packageJSON.version,
-        tools,
-    }, config);
+export async function createConnection(config = {}) {
+    return createConnection(config);
 }

package/lib/program.js

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 import { program } from 'commander';
-import { createServer } from './index.js';
-import { ServerList } from './server.js';
 import { startHttpTransport, startStdioTransport } from './transport.js';
 import { resolveConfig } from './config.js';
-import packageJSON from '../package.json' with { type: 'json' };
+import { packageJSON } from './context.js';
 program
     .version('Version ' + packageJSON.version)
     .name(packageJSON.name)
@@ -31,25 +29,33 @@ program
     .option('--user-data-dir <path>', 'Path to the user data directory')
     .option('--port <port>', 'Port to listen on for SSE transport.')
     .option('--host <host>', 'Host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.')
+    .option('--allowed-origins <origins>', 'Semicolon-separated list of origins to allow the browser to request. Default is to allow all.', semicolonSeparatedList)
+    .option('--blocked-origins <origins>', 'Semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed.', semicolonSeparatedList)
     .option('--vision', 'Run server that uses screenshots (Aria snapshots are used by default)')
+    .option('--no-image-responses', 'Do not send image responses to the client.')
+    .option('--output-dir <path>', 'Path to the directory for output files.')
     .option('--config <path>', 'Path to the configuration file.')
     .action(async (options) => {
     const config = await resolveConfig(options);
-    const serverList = new ServerList(() => createServer(config));
-    setupExitWatchdog(serverList);
+    const connectionList = [];
+    setupExitWatchdog(connectionList);
     if (options.port)
-        startHttpTransport(+options.port, options.host, serverList);
+        startHttpTransport(config, +options.port, options.host, connectionList);
     else
-        await startStdioTransport(serverList);
+        await startStdioTransport(config, connectionList);
 });
-function setupExitWatchdog(serverList) {
+function setupExitWatchdog(connectionList) {
     const handleExit = async () => {
         setTimeout(() => process.exit(0), 15000);
-        await serverList.closeAll();
+        for (const connection of connectionList)
+            await connection.close();
         process.exit(0);
     };
     process.stdin.on('close', handleExit);
     process.on('SIGINT', handleExit);
     process.on('SIGTERM', handleExit);
 }
+function semicolonSeparatedList(value) {
+    return value.split(';').map(v => v.trim());
+}
 program.parse(process.argv);

package/lib/tab.js

@@ -56,7 +56,24 @@ export class Tab {
         this._onPageClose(this);
     }
     async navigate(url) {
-        await this.page.goto(url, { waitUntil: 'domcontentloaded' });
+        const downloadEvent = this.page.waitForEvent('download').catch(() => { });
+        try {
+            await this.page.goto(url, { waitUntil: 'domcontentloaded' });
+        }
+        catch (_e) {
+            const e = _e;
+            const mightBeDownload = e.message.includes('net::ERR_ABORTED') // chromium
+                || e.message.includes('Download is starting'); // firefox + webkit
+            if (!mightBeDownload)
+                throw e;
+            // on chromium, the download event is fired *after* page.goto rejects, so we wait a lil bit
+            const download = await Promise.race([
+                downloadEvent,
+                new Promise(resolve => setTimeout(resolve, 500)),
+            ]);
+            if (!download)
+                throw e;
+        }
         // Cap load event to 5 seconds, the page is operational at this point.
         await this.page.waitForLoadState('load', { timeout: 5000 }).catch(() => { });
     }

package/lib/tools/common.js

@@ -19,10 +19,12 @@ const wait = captureSnapshot => defineTool({
     capability: 'wait',
     schema: {
         name: 'browser_wait',
+        title: 'Wait',
         description: 'Wait for a specified time in seconds',
         inputSchema: z.object({
             time: z.number().describe('The time to wait in seconds'),
         }),
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         await new Promise(f => setTimeout(f, Math.min(10000, params.time * 1000)));
@@ -37,8 +39,10 @@ const close = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_close',
+        title: 'Close browser',
         description: 'Close the page',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         await context.close();
@@ -53,11 +57,13 @@ const resize = captureSnapshot => defineTool({
     capability: 'core',
     schema: {
         name: 'browser_resize',
+        title: 'Resize browser window',
         description: 'Resize the browser window',
         inputSchema: z.object({
             width: z.number().describe('Width of the browser window'),
             height: z.number().describe('Height of the browser window'),
         }),
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();

package/lib/tools/console.js

@@ -19,8 +19,10 @@ const console = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_console_messages',
+        title: 'Get console messages',
         description: 'Returns all console messages',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         const messages = context.currentTabOrDie().console();

package/lib/tools/dialogs.js

@@ -19,11 +19,13 @@ const handleDialog = captureSnapshot => defineTool({
     capability: 'core',
     schema: {
         name: 'browser_handle_dialog',
+        title: 'Handle a dialog',
         description: 'Handle a dialog',
         inputSchema: z.object({
             accept: z.boolean().describe('Whether to accept the dialog.'),
             promptText: z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const dialogState = context.modalStates().find(state => state.type === 'dialog');

package/lib/tools/files.js

@@ -19,10 +19,12 @@ const uploadFile = captureSnapshot => defineTool({
     capability: 'files',
     schema: {
         name: 'browser_file_upload',
+        title: 'Upload files',
         description: 'Upload one or multiple files',
         inputSchema: z.object({
             paths: z.array(z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const modalState = context.modalStates().find(state => state.type === 'fileChooser');

package/lib/tools/install.js

@@ -17,19 +17,21 @@ import { fork } from 'child_process';
 import path from 'path';
 import { z } from 'zod';
 import { defineTool } from './tool.js';
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
+import { fileURLToPath } from 'node:url';
 const install = defineTool({
     capability: 'install',
     schema: {
         name: 'browser_install',
+        title: 'Install the browser specified in the config',
         description: 'Install the browser specified in the config. Call this if you get an error about the browser not being installed.',
         inputSchema: z.object({}),
+        type: 'destructive',
     },
     handle: async (context) => {
         const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.launchOptions.browserName ?? 'chrome';
-        const cli = path.join(require.resolve('playwright/package.json'), '..', 'cli.js');
-        const child = fork(cli, ['install', channel], {
+        const cliUrl = import.meta.resolve('playwright/package.json');
+        const cliPath = path.join(fileURLToPath(cliUrl), '..', 'cli.js');
+        const child = fork(cliPath, ['install', channel], {
             stdio: 'pipe',
         });
         const output = [];

package/lib/tools/keyboard.js

@@ -19,10 +19,12 @@ const pressKey = captureSnapshot => defineTool({
     capability: 'core',
     schema: {
         name: 'browser_press_key',
+        title: 'Press a key',
         description: 'Press a key on the keyboard',
         inputSchema: z.object({
             key: z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();

package/lib/tools/navigate.js

@@ -19,10 +19,12 @@ const navigate = captureSnapshot => defineTool({
     capability: 'core',
     schema: {
         name: 'browser_navigate',
+        title: 'Navigate to a URL',
         description: 'Navigate to a URL',
         inputSchema: z.object({
             url: z.string().describe('The URL to navigate to'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const tab = await context.ensureTab();
@@ -42,8 +44,10 @@ const goBack = captureSnapshot => defineTool({
     capability: 'history',
     schema: {
         name: 'browser_navigate_back',
+        title: 'Go back',
         description: 'Go back to the previous page',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         const tab = await context.ensureTab();
@@ -63,8 +67,10 @@ const goForward = captureSnapshot => defineTool({
     capability: 'history',
     schema: {
         name: 'browser_navigate_forward',
+        title: 'Go forward',
         description: 'Go forward to the next page',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         const tab = context.currentTabOrDie();

package/lib/tools/network.js

@@ -19,8 +19,10 @@ const requests = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_network_requests',
+        title: 'List network requests',
         description: 'Returns all network requests since loading the page',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         const requests = context.currentTabOrDie().requests();

package/lib/tools/pdf.js

@@ -21,8 +21,10 @@ const pdf = defineTool({
     capability: 'pdf',
     schema: {
         name: 'browser_pdf_save',
+        title: 'Save as PDF',
         description: 'Save page as PDF',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         const tab = context.currentTabOrDie();

package/lib/tools/screen.js

@@ -23,8 +23,10 @@ const screenshot = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_screen_capture',
+        title: 'Take a screenshot',
         description: 'Take a screenshot of the current page',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         const tab = await context.ensureTab();
@@ -50,11 +52,13 @@ const moveMouse = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_screen_move_mouse',
+        title: 'Move mouse',
         description: 'Move mouse to a given position',
         inputSchema: elementSchema.extend({
             x: z.number().describe('X coordinate'),
             y: z.number().describe('Y coordinate'),
         }),
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();
@@ -75,11 +79,13 @@ const click = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_screen_click',
+        title: 'Click',
         description: 'Click left mouse button',
         inputSchema: elementSchema.extend({
             x: z.number().describe('X coordinate'),
             y: z.number().describe('Y coordinate'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();
@@ -106,6 +112,7 @@ const drag = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_screen_drag',
+        title: 'Drag mouse',
         description: 'Drag left mouse button',
         inputSchema: elementSchema.extend({
             startX: z.number().describe('Start X coordinate'),
@@ -113,6 +120,7 @@ const drag = defineTool({
             endX: z.number().describe('End X coordinate'),
             endY: z.number().describe('End Y coordinate'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();
@@ -141,11 +149,13 @@ const type = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_screen_type',
+        title: 'Type text',
         description: 'Type text',
         inputSchema: z.object({
             text: z.string().describe('Text to type into the element'),
             submit: z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();

package/lib/tools/snapshot.js

@@ -21,8 +21,10 @@ const snapshot = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_snapshot',
+        title: 'Page snapshot',
         description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         await context.ensureTab();
@@ -41,8 +43,10 @@ const click = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_click',
+        title: 'Click',
         description: 'Perform click on a web page',
         inputSchema: elementSchema,
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();
@@ -63,6 +67,7 @@ const drag = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_drag',
+        title: 'Drag mouse',
         description: 'Perform drag and drop between two elements',
         inputSchema: z.object({
             startElement: z.string().describe('Human-readable source element description used to obtain the permission to interact with the element'),
@@ -70,6 +75,7 @@ const drag = defineTool({
             endElement: z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
             endRef: z.string().describe('Exact target element reference from the page snapshot'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const snapshot = context.currentTabOrDie().snapshotOrDie();
@@ -91,8 +97,10 @@ const hover = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_hover',
+        title: 'Hover mouse',
         description: 'Hover over element on page',
         inputSchema: elementSchema,
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         const snapshot = context.currentTabOrDie().snapshotOrDie();
@@ -118,8 +126,10 @@ const type = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_type',
+        title: 'Type text',
         description: 'Type text into editable element',
         inputSchema: typeSchema,
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const snapshot = context.currentTabOrDie().snapshotOrDie();
@@ -156,8 +166,10 @@ const selectOption = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_select_option',
+        title: 'Select option',
         description: 'Select an option in a dropdown',
         inputSchema: selectOptionSchema,
+        type: 'destructive',
     },
     handle: async (context, params) => {
         const snapshot = context.currentTabOrDie().snapshotOrDie();
@@ -188,8 +200,10 @@ const screenshot = defineTool({
     capability: 'core',
     schema: {
         name: 'browser_take_screenshot',
+        title: 'Take a screenshot',
         description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
         inputSchema: screenshotSchema,
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         const tab = context.currentTabOrDie();
@@ -206,7 +220,7 @@ const screenshot = defineTool({
             code.push(`await page.${await generateLocator(locator)}.screenshot(${javascript.formatObject(options)});`);
         else
             code.push(`await page.screenshot(${javascript.formatObject(options)});`);
-        const includeBase64 = !context.config.tools?.browser_take_screenshot?.omitBase64;
+        const includeBase64 = !context.config.noImageResponses;
         const action = async () => {
             const screenshot = locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
             return {

package/lib/tools/tabs.js

@@ -19,8 +19,10 @@ const listTabs = defineTool({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_list',
+        title: 'List tabs',
         description: 'List browser tabs',
         inputSchema: z.object({}),
+        type: 'readOnly',
     },
     handle: async (context) => {
         await context.ensureTab();
@@ -41,10 +43,12 @@ const selectTab = captureSnapshot => defineTool({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_select',
+        title: 'Select a tab',
         description: 'Select a tab by index',
         inputSchema: z.object({
             index: z.number().describe('The index of the tab to select'),
         }),
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         await context.selectTab(params.index);
@@ -62,10 +66,12 @@ const newTab = captureSnapshot => defineTool({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_new',
+        title: 'Open a new tab',
         description: 'Open a new tab',
         inputSchema: z.object({
             url: z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
         }),
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         await context.newTab();
@@ -85,10 +91,12 @@ const closeTab = captureSnapshot => defineTool({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_close',
+        title: 'Close a tab',
         description: 'Close a tab',
         inputSchema: z.object({
             index: z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
         }),
+        type: 'destructive',
     },
     handle: async (context, params) => {
         await context.closeTab(params.index);

package/lib/tools/testing.js

@@ -24,8 +24,10 @@ const generateTest = defineTool({
     capability: 'testing',
     schema: {
         name: 'browser_generate_playwright_test',
+        title: 'Generate a Playwright test',
         description: 'Generate a Playwright test for given scenario',
         inputSchema: generateTestSchema,
+        type: 'readOnly',
     },
     handle: async (context, params) => {
         return {

package/lib/tools.js

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import common from './tools/common.js';
+import console from './tools/console.js';
+import dialogs from './tools/dialogs.js';
+import files from './tools/files.js';
+import install from './tools/install.js';
+import keyboard from './tools/keyboard.js';
+import navigate from './tools/navigate.js';
+import network from './tools/network.js';
+import pdf from './tools/pdf.js';
+import snapshot from './tools/snapshot.js';
+import tabs from './tools/tabs.js';
+import screen from './tools/screen.js';
+import testing from './tools/testing.js';
+export const snapshotTools = [
+    ...common(true),
+    ...console,
+    ...dialogs(true),
+    ...files(true),
+    ...install,
+    ...keyboard(true),
+    ...navigate(true),
+    ...network,
+    ...pdf,
+    ...snapshot,
+    ...tabs(true),
+    ...testing,
+];
+export const screenshotTools = [
+    ...common(false),
+    ...console,
+    ...dialogs(false),
+    ...files(false),
+    ...install,
+    ...keyboard(false),
+    ...navigate(false),
+    ...network,
+    ...pdf,
+    ...screen,
+    ...tabs(false),
+    ...testing,
+];