@playwright/mcp 0.0.13 → 0.0.15

package/lib/server.js

@@ -19,10 +19,11 @@ exports.ServerList = void 0;
 exports.createServerWithTools = createServerWithTools;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const context_1 = require("./context");
 function createServerWithTools(options) {
     const { name, version, tools, resources } = options;
-    const context = new context_1.Context(options);
+    const context = new context_1.Context(tools, options);
     const server = new index_js_1.Server({ name, version }, {
         capabilities: {
             tools: {},
@@ -30,7 +31,13 @@ function createServerWithTools(options) {
         }
     });
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-        return { tools: tools.map(tool => tool.schema) };
+        return {
+            tools: tools.map(tool => ({
+                name: tool.schema.name,
+                description: tool.schema.description,
+                inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema.inputSchema)
+            })),
+        };
     });
     server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
         return { resources: resources.map(resource => resource.schema) };
@@ -43,9 +50,20 @@ function createServerWithTools(options) {
                 isError: true,
             };
         }
+        const modalStates = context.modalStates().map(state => state.type);
+        if ((tool.clearsModalState && !modalStates.includes(tool.clearsModalState)) ||
+            (!tool.clearsModalState && modalStates.length)) {
+            const text = [
+                `Tool "${request.params.name}" does not handle the modal state.`,
+                ...context.modalStatesMarkdown(),
+            ].join('\n');
+            return {
+                content: [{ type: 'text', text }],
+                isError: true,
+            };
+        }
         try {
-            const result = await tool.handle(context, request.params.arguments);
-            return result;
+            return await context.run(tool, request.params.arguments);
         }
         catch (error) {
             return {
@@ -75,7 +93,7 @@ class ServerList {
         this._serverFactory = serverFactory;
     }
     async create() {
-        const server = this._serverFactory();
+        const server = await this._serverFactory();
         this._servers.push(server);
         return server;
     }

package/lib/tools/common.js

@@ -16,74 +16,70 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const waitSchema = zod_1.z.object({
-    time: zod_1.z.number().describe('The time to wait in seconds'),
-});
-const wait = {
+const tool_1 = require("./tool");
+const wait = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'wait',
     schema: {
         name: 'browser_wait',
         description: 'Wait for a specified time in seconds',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(waitSchema),
+        inputSchema: zod_1.z.object({
+            time: zod_1.z.number().describe('The time to wait in seconds'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = waitSchema.parse(params);
-        await new Promise(f => setTimeout(f, Math.min(10000, validatedParams.time * 1000)));
+        await new Promise(f => setTimeout(f, Math.min(10000, params.time * 1000)));
         return {
-            content: [{
-                    type: 'text',
-                    text: `Waited for ${validatedParams.time} seconds`,
-                }],
+            code: [`// Waited for ${params.time} seconds`],
+            captureSnapshot,
+            waitForNetwork: false,
         };
     },
-};
-const closeSchema = zod_1.z.object({});
-const close = {
+});
+const close = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_close',
         description: 'Close the page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(closeSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         await context.close();
         return {
-            content: [{
-                    type: 'text',
-                    text: `Page closed`,
-                }],
+            code: [`// Internal to close the page`],
+            captureSnapshot: false,
+            waitForNetwork: false,
         };
     },
-};
-const resizeSchema = zod_1.z.object({
-    width: zod_1.z.number().describe('Width of the browser window'),
-    height: zod_1.z.number().describe('Height of the browser window'),
 });
-const resize = captureSnapshot => ({
+const resize = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_resize',
         description: 'Resize the browser window',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(resizeSchema),
+        inputSchema: zod_1.z.object({
+            width: zod_1.z.number().describe('Width of the browser window'),
+            height: zod_1.z.number().describe('Height of the browser window'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = resizeSchema.parse(params);
-        const tab = context.currentTab();
-        return await tab.run(async (tab) => {
-            await tab.page.setViewportSize({ width: validatedParams.width, height: validatedParams.height });
-            const code = [
-                `// Resize browser window to ${validatedParams.width}x${validatedParams.height}`,
-                `await page.setViewportSize({ width: ${validatedParams.width}, height: ${validatedParams.height} });`
-            ];
-            return { code };
-        }, {
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Resize browser window to ${params.width}x${params.height}`,
+            `await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`
+        ];
+        const action = async () => {
+            await tab.page.setViewportSize({ width: params.width, height: params.height });
+        };
+        return {
+            code,
+            action,
             captureSnapshot,
-        });
+            waitForNetwork: true
+        };
     },
 });
 exports.default = (captureSnapshot) => [
     close,
-    wait,
+    wait(captureSnapshot),
     resize(captureSnapshot)
 ];

package/lib/{resources → tools}/console.js

@@ -15,20 +15,30 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.console = void 0;
-exports.console = {
+const zod_1 = require("zod");
+const tool_1 = require("./tool");
+const console = (0, tool_1.defineTool)({
+    capability: 'core',
     schema: {
-        uri: 'browser://console',
-        name: 'Page console',
-        mimeType: 'text/plain',
+        name: 'browser_console_messages',
+        description: 'Returns all console messages',
+        inputSchema: zod_1.z.object({}),
     },
-    read: async (context, uri) => {
-        const messages = await context.currentTab().console();
+    handle: async (context) => {
+        const messages = context.currentTabOrDie().console();
         const log = messages.map(message => `[${message.type().toUpperCase()}] ${message.text()}`).join('\n');
-        return [{
-                uri,
-                mimeType: 'text/plain',
-                text: log
-            }];
+        return {
+            code: [`// <internal code to get console messages>`],
+            action: async () => {
+                return {
+                    content: [{ type: 'text', text: log }]
+                };
+            },
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
     },
-};
+});
+exports.default = [
+    console,
+];

package/lib/tools/dialogs.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const tool_1 = require("./tool");
+const handleDialog = captureSnapshot => (0, tool_1.defineTool)({
+    capability: 'core',
+    schema: {
+        name: 'browser_handle_dialog',
+        description: 'Handle a dialog',
+        inputSchema: zod_1.z.object({
+            accept: zod_1.z.boolean().describe('Whether to accept the dialog.'),
+            promptText: zod_1.z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
+        }),
+    },
+    handle: async (context, params) => {
+        const dialogState = context.modalStates().find(state => state.type === 'dialog');
+        if (!dialogState)
+            throw new Error('No dialog visible');
+        if (params.accept)
+            await dialogState.dialog.accept(params.promptText);
+        else
+            await dialogState.dialog.dismiss();
+        context.clearModalState(dialogState);
+        const code = [
+            `// <internal code to handle "${dialogState.dialog.type()}" dialog>`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+    clearsModalState: 'dialog',
+});
+exports.default = (captureSnapshot) => [
+    handleDialog(captureSnapshot),
+];

package/lib/tools/files.js

@@ -16,31 +16,35 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const uploadFileSchema = zod_1.z.object({
-    paths: zod_1.z.array(zod_1.z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
-});
-const uploadFile = captureSnapshot => ({
+const tool_1 = require("./tool");
+const uploadFile = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'files',
     schema: {
         name: 'browser_file_upload',
         description: 'Upload one or multiple files',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(uploadFileSchema),
+        inputSchema: zod_1.z.object({
+            paths: zod_1.z.array(zod_1.z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = uploadFileSchema.parse(params);
-        const tab = context.currentTab();
-        return await tab.runAndWait(async () => {
-            await tab.submitFileChooser(validatedParams.paths);
-            const code = [
-                `// <internal code to chose files ${validatedParams.paths.join(', ')}`,
-            ];
-            return { code };
-        }, {
+        const modalState = context.modalStates().find(state => state.type === 'fileChooser');
+        if (!modalState)
+            throw new Error('No file chooser visible');
+        const code = [
+            `// <internal code to chose files ${params.paths.join(', ')}`,
+        ];
+        const action = async () => {
+            await modalState.fileChooser.setFiles(params.paths);
+            context.clearModalState(modalState);
+        };
+        return {
+            code,
+            action,
             captureSnapshot,
-            noClearFileChooser: true,
-        });
+            waitForNetwork: true,
+        };
     },
+    clearsModalState: 'fileChooser',
 });
 exports.default = (captureSnapshot) => [
     uploadFile(captureSnapshot),

package/lib/tools/install.js

@@ -21,13 +21,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const install = {
+const tool_1 = require("./tool");
+const install = (0, tool_1.defineTool)({
     capability: 'install',
     schema: {
         name: 'browser_install',
         description: 'Install the browser specified in the config. Call this if you get an error about the browser not being installed.',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const channel = context.options.launchOptions?.channel ?? context.options.browserName ?? 'chrome';
@@ -47,13 +47,12 @@ const install = {
             });
         });
         return {
-            content: [{
-                    type: 'text',
-                    text: `Browser ${channel} installed`,
-                }],
+            code: [`// Browser ${channel} installed`],
+            captureSnapshot: false,
+            waitForNetwork: false,
         };
     },
-};
+});
 exports.default = [
     install,
 ];

package/lib/tools/keyboard.js

@@ -14,34 +14,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-const pressKeySchema = zod_1.z.object({
-    key: zod_1.z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
-});
-const pressKey = captureSnapshot => ({
+const tool_1 = require("./tool");
+const pressKey = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_press_key',
         description: 'Press a key on the keyboard',
-        inputSchema: (0, zod_to_json_schema_1.default)(pressKeySchema),
+        inputSchema: zod_1.z.object({
+            key: zod_1.z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = pressKeySchema.parse(params);
-        return await context.currentTab().runAndWait(async (tab) => {
-            await tab.page.keyboard.press(validatedParams.key);
-            const code = [
-                `// Press ${validatedParams.key}`,
-                `await page.keyboard.press('${validatedParams.key}');`,
-            ];
-            return { code };
-        }, {
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Press ${params.key}`,
+            `await page.keyboard.press('${params.key}');`,
+        ];
+        const action = () => tab.page.keyboard.press(params.key);
+        return {
+            code,
+            action,
             captureSnapshot,
-        });
+            waitForNetwork: true
+        };
     },
 });
 exports.default = (captureSnapshot) => [

package/lib/tools/navigate.js

@@ -16,72 +16,70 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const navigateSchema = zod_1.z.object({
-    url: zod_1.z.string().describe('The URL to navigate to'),
-});
-const navigate = captureSnapshot => ({
+const tool_1 = require("./tool");
+const navigate = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_navigate',
         description: 'Navigate to a URL',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(navigateSchema),
+        inputSchema: zod_1.z.object({
+            url: zod_1.z.string().describe('The URL to navigate to'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = navigateSchema.parse(params);
-        const currentTab = await context.ensureTab();
-        return await currentTab.run(async (tab) => {
-            await tab.navigate(validatedParams.url);
-            const code = [
-                `// Navigate to ${validatedParams.url}`,
-                `await page.goto('${validatedParams.url}');`,
-            ];
-            return { code };
-        }, {
+        const tab = await context.ensureTab();
+        await tab.navigate(params.url);
+        const code = [
+            `// Navigate to ${params.url}`,
+            `await page.goto('${params.url}');`,
+        ];
+        return {
+            code,
             captureSnapshot,
-        });
+            waitForNetwork: false,
+        };
     },
 });
-const goBackSchema = zod_1.z.object({});
-const goBack = snapshot => ({
+const goBack = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'history',
     schema: {
         name: 'browser_navigate_back',
         description: 'Go back to the previous page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(goBackSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
-        return await context.currentTab().runAndWait(async (tab) => {
-            await tab.page.goBack();
-            const code = [
-                `// Navigate back`,
-                `await page.goBack();`,
-            ];
-            return { code };
-        }, {
-            captureSnapshot: snapshot,
-        });
+        const tab = await context.ensureTab();
+        await tab.page.goBack();
+        const code = [
+            `// Navigate back`,
+            `await page.goBack();`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
     },
 });
-const goForwardSchema = zod_1.z.object({});
-const goForward = snapshot => ({
+const goForward = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'history',
     schema: {
         name: 'browser_navigate_forward',
         description: 'Go forward to the next page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(goForwardSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
-        return await context.currentTab().runAndWait(async (tab) => {
-            await tab.page.goForward();
-            const code = [
-                `// Navigate forward`,
-                `await page.goForward();`,
-            ];
-            return { code };
-        }, {
-            captureSnapshot: snapshot,
-        });
+        const tab = context.currentTabOrDie();
+        await tab.page.goForward();
+        const code = [
+            `// Navigate forward`,
+            `await page.goForward();`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
     },
 });
 exports.default = (captureSnapshot) => [

package/lib/tools/network.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const tool_1 = require("./tool");
+const requests = (0, tool_1.defineTool)({
+    capability: 'core',
+    schema: {
+        name: 'browser_network_requests',
+        description: 'Returns all network requests since loading the page',
+        inputSchema: zod_1.z.object({}),
+    },
+    handle: async (context) => {
+        const requests = context.currentTabOrDie().requests();
+        const log = [...requests.entries()].map(([request, response]) => renderRequest(request, response)).join('\n');
+        return {
+            code: [`// <internal code to list network requests>`],
+            action: async () => {
+                return {
+                    content: [{ type: 'text', text: log }]
+                };
+            },
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+function renderRequest(request, response) {
+    const result = [];
+    result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
+    if (response)
+        result.push(`=> [${response.status()}] ${response.statusText()}`);
+    return result.join(' ');
+}
+exports.default = [
+    requests,
+];

package/lib/tools/pdf.js

@@ -14,6 +14,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -21,28 +54,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const tool_1 = require("./tool");
 const utils_1 = require("./utils");
-const pdfSchema = zod_1.z.object({});
-const pdf = {
+const javascript = __importStar(require("../javascript"));
+const pdf = (0, tool_1.defineTool)({
     capability: 'pdf',
     schema: {
         name: 'browser_pdf_save',
         description: 'Save page as PDF',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(pdfSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
-        const tab = context.currentTab();
+        const tab = context.currentTabOrDie();
         const fileName = path_1.default.join(os_1.default.tmpdir(), (0, utils_1.sanitizeForFilePath)(`page-${new Date().toISOString()}`)) + '.pdf';
-        await tab.page.pdf({ path: fileName });
+        const code = [
+            `// Save page as ${fileName}`,
+            `await page.pdf(${javascript.formatObject({ path: fileName })});`,
+        ];
         return {
-            content: [{
-                    type: 'text',
-                    text: `Saved as ${fileName}`,
-                }],
+            code,
+            action: async () => tab.page.pdf({ path: fileName }).then(() => { }),
+            captureSnapshot: false,
+            waitForNetwork: false,
         };
     },
-};
+});
 exports.default = [
     pdf,
 ];