@playwright/mcp 0.0.10 → 0.0.14

package/lib/program.js

@@ -19,9 +19,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const http_1 = __importDefault(require("http"));
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
 const commander_1 = require("commander");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
@@ -41,43 +38,11 @@ commander_1.program
     .option('--user-data-dir <path>', 'Path to the user data directory')
     .option('--vision', 'Run server that uses screenshots (Aria snapshots are used by default)')
     .action(async (options) => {
-    let browserName;
-    let channel;
-    switch (options.browser) {
-        case 'chrome':
-        case 'chrome-beta':
-        case 'chrome-canary':
-        case 'chrome-dev':
-        case 'msedge':
-        case 'msedge-beta':
-        case 'msedge-canary':
-        case 'msedge-dev':
-            browserName = 'chromium';
-            channel = options.browser;
-            break;
-        case 'chromium':
-            browserName = 'chromium';
-            break;
-        case 'firefox':
-            browserName = 'firefox';
-            break;
-        case 'webkit':
-            browserName = 'webkit';
-            break;
-        default:
-            browserName = 'chromium';
-            channel = 'chrome';
-    }
-    const launchOptions = {
-        headless: !!options.headless,
-        channel,
-        executablePath: options.executablePath,
-    };
-    const userDataDir = options.userDataDir ?? await createUserDataDir(browserName);
     const serverList = new server_1.ServerList(() => (0, index_1.createServer)({
-        browserName,
-        userDataDir,
-        launchOptions,
+        browser: options.browser,
+        userDataDir: options.userDataDir,
+        headless: options.headless,
+        executablePath: options.executablePath,
         vision: !!options.vision,
         cdpEndpoint: options.cdpEndpoint,
         capabilities: options.caps?.split(',').map((c) => c.trim()),
@@ -92,27 +57,16 @@ commander_1.program
     }
 });
 function setupExitWatchdog(serverList) {
-    process.stdin.on('close', async () => {
+    const handleExit = async () => {
         setTimeout(() => process.exit(0), 15000);
         await serverList.closeAll();
         process.exit(0);
-    });
+    };
+    process.stdin.on('close', handleExit);
+    process.on('SIGINT', handleExit);
+    process.on('SIGTERM', handleExit);
 }
 commander_1.program.parse(process.argv);
-async function createUserDataDir(browserName) {
-    let cacheDirectory;
-    if (process.platform === 'linux')
-        cacheDirectory = process.env.XDG_CACHE_HOME || path_1.default.join(os_1.default.homedir(), '.cache');
-    else if (process.platform === 'darwin')
-        cacheDirectory = path_1.default.join(os_1.default.homedir(), 'Library', 'Caches');
-    else if (process.platform === 'win32')
-        cacheDirectory = process.env.LOCALAPPDATA || path_1.default.join(os_1.default.homedir(), 'AppData', 'Local');
-    else
-        throw new Error('Unsupported platform: ' + process.platform);
-    const result = path_1.default.join(cacheDirectory, 'ms-playwright', `mcp-${browserName}-profile`);
-    await fs_1.default.promises.mkdir(result, { recursive: true });
-    return result;
-}
 async function startSSEServer(port, serverList) {
     const sessions = new Map();
     const httpServer = http_1.default.createServer(async (req, res) => {

package/lib/server.js

@@ -22,7 +22,7 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 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: {},
@@ -43,9 +43,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 +86,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

@@ -20,7 +20,7 @@ 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 wait = captureSnapshot => ({
     capability: 'wait',
     schema: {
         name: 'browser_wait',
@@ -31,13 +31,12 @@ const wait = {
         const validatedParams = waitSchema.parse(params);
         await new Promise(f => setTimeout(f, Math.min(10000, validatedParams.time * 1000)));
         return {
-            content: [{
-                    type: 'text',
-                    text: `Waited for ${validatedParams.time} seconds`,
-                }],
+            code: [`// Waited for ${validatedParams.time} seconds`],
+            captureSnapshot,
+            waitForNetwork: false,
         };
     },
-};
+});
 const closeSchema = zod_1.z.object({});
 const close = {
     capability: 'core',
@@ -49,14 +48,43 @@ const close = {
     handle: async (context) => {
         await context.close();
         return {
-            content: [{
-                    type: 'text',
-                    text: `Page closed`,
-                }],
+            code: [`// Internal to close the page`],
+            captureSnapshot: false,
+            waitForNetwork: false,
         };
     },
 };
-exports.default = [
+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 => ({
+    capability: 'core',
+    schema: {
+        name: 'browser_resize',
+        description: 'Resize the browser window',
+        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(resizeSchema),
+    },
+    handle: async (context, params) => {
+        const validatedParams = resizeSchema.parse(params);
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Resize browser window to ${validatedParams.width}x${validatedParams.height}`,
+            `await page.setViewportSize({ width: ${validatedParams.width}, height: ${validatedParams.height} });`
+        ];
+        const action = async () => {
+            await tab.page.setViewportSize({ width: validatedParams.width, height: validatedParams.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,31 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.console = void 0;
-exports.console = {
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const consoleSchema = zod_1.z.object({});
+const console = {
+    capability: 'core',
     schema: {
-        uri: 'browser://console',
-        name: 'Page console',
-        mimeType: 'text/plain',
+        name: 'browser_console_messages',
+        description: 'Returns all console messages',
+        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(consoleSchema),
     },
-    read: async (context, uri) => {
-        const messages = await context.currentTab().console();
+    handle: async (context) => {
+        const messages = await 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,54 @@
+"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 zod_to_json_schema_1 = require("zod-to-json-schema");
+const handleDialogSchema = 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.'),
+});
+const handleDialog = captureSnapshot => ({
+    capability: 'core',
+    schema: {
+        name: 'browser_handle_dialog',
+        description: 'Handle a dialog',
+        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(handleDialogSchema),
+    },
+    handle: async (context, params) => {
+        const validatedParams = handleDialogSchema.parse(params);
+        const dialogState = context.modalStates().find(state => state.type === 'dialog');
+        if (!dialogState)
+            throw new Error('No dialog visible');
+        if (validatedParams.accept)
+            await dialogState.dialog.accept(validatedParams.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

@@ -29,15 +29,24 @@ const uploadFile = captureSnapshot => ({
     },
     handle: async (context, params) => {
         const validatedParams = uploadFileSchema.parse(params);
-        const tab = context.currentTab();
-        return await tab.runAndWait(async () => {
-            await tab.submitFileChooser(validatedParams.paths);
-        }, {
-            status: `Chose files ${validatedParams.paths.join(', ')}`,
+        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 ${validatedParams.paths.join(', ')}`,
+        ];
+        const action = async () => {
+            await modalState.fileChooser.setFiles(validatedParams.paths);
+            context.clearModalState(modalState);
+        };
+        return {
+            code,
+            action,
             captureSnapshot,
-            noClearFileChooser: true,
-        });
+            waitForNetwork: true,
+        };
     },
+    clearsModalState: 'fileChooser',
 });
 exports.default = (captureSnapshot) => [
     uploadFile(captureSnapshot),

package/lib/tools/install.js

@@ -47,10 +47,9 @@ const install = {
             });
         });
         return {
-            content: [{
-                    type: 'text',
-                    text: `Browser ${channel} installed`,
-                }],
+            code: [`// Browser ${channel} installed`],
+            captureSnapshot: false,
+            waitForNetwork: false,
         };
     },
 };

package/lib/tools/keyboard.js

@@ -32,12 +32,18 @@ const pressKey = captureSnapshot => ({
     },
     handle: async (context, params) => {
         const validatedParams = pressKeySchema.parse(params);
-        return await context.currentTab().runAndWait(async (tab) => {
-            await tab.page.keyboard.press(validatedParams.key);
-        }, {
-            status: `Pressed key ${validatedParams.key}`,
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Press ${validatedParams.key}`,
+            `await page.keyboard.press('${validatedParams.key}');`,
+        ];
+        const action = () => tab.page.keyboard.press(validatedParams.key);
+        return {
+            code,
+            action,
             captureSnapshot,
-        });
+            waitForNetwork: true
+        };
     },
 });
 exports.default = (captureSnapshot) => [

package/lib/tools/navigate.js

@@ -29,17 +29,21 @@ const navigate = captureSnapshot => ({
     },
     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);
-        }, {
-            status: `Navigated to ${validatedParams.url}`,
+        const tab = await context.ensureTab();
+        await tab.navigate(validatedParams.url);
+        const code = [
+            `// Navigate to ${validatedParams.url}`,
+            `await page.goto('${validatedParams.url}');`,
+        ];
+        return {
+            code,
             captureSnapshot,
-        });
+            waitForNetwork: false,
+        };
     },
 });
 const goBackSchema = zod_1.z.object({});
-const goBack = snapshot => ({
+const goBack = captureSnapshot => ({
     capability: 'history',
     schema: {
         name: 'browser_navigate_back',
@@ -47,16 +51,21 @@ const goBack = snapshot => ({
         inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(goBackSchema),
     },
     handle: async (context) => {
-        return await context.currentTab().runAndWait(async (tab) => {
-            await tab.page.goBack();
-        }, {
-            status: 'Navigated back',
-            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 => ({
     capability: 'history',
     schema: {
         name: 'browser_navigate_forward',
@@ -64,12 +73,17 @@ const goForward = snapshot => ({
         inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(goForwardSchema),
     },
     handle: async (context) => {
-        return await context.currentTab().runAndWait(async (tab) => {
-            await tab.page.goForward();
-        }, {
-            status: 'Navigated forward',
-            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/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 };
 };
@@ -23,6 +56,7 @@ const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const utils_1 = require("./utils");
+const javascript = __importStar(require("../javascript"));
 const pdfSchema = zod_1.z.object({});
 const pdf = {
     capability: 'pdf',
@@ -32,14 +66,17 @@ const pdf = {
         inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(pdfSchema),
     },
     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,
         };
     },
 };