@playwright/mcp 1.52.0-alpha-1742413599000 → 1.52.0-alpha-2025-03-20

package/lib/context.js

@@ -60,7 +60,10 @@ class Context {
       url.searchParams.set('launch-options', JSON.stringify(this._launchOptions));
       return await playwright.chromium.connect(String(url));
     }
-    return await playwright.chromium.launch(this._launchOptions);
+    return await playwright.chromium.launch({
+      channel: 'chrome',
+      ...this._launchOptions
+    });
   }
 }
 exports.Context = Context;

package/lib/resources/console.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.console = void 0;
+/**
+ * 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.
+ */
+
+const console = exports.console = {
+  schema: {
+    uri: 'browser://console',
+    name: 'Page console',
+    mimeType: 'text/plain'
+  },
+  read: async (context, uri) => {
+    const result = [];
+    for (const message of await context.ensureConsole()) {
+      result.push({
+        uri,
+        mimeType: 'text/plain',
+        text: `[${message.type().toUpperCase()}] ${message.text()}`
+      });
+    }
+    return result;
+  }
+};

package/lib/resources/resource.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/tools/common.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wait = exports.pressKey = exports.pdf = exports.navigate = exports.goForward = exports.goBack = exports.close = void 0;
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _zod = require("zod");
+var _zodToJsonSchema = require("zod-to-json-schema");
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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.
+ */
+
+const navigateSchema = _zod.z.object({
+  url: _zod.z.string().describe('The URL to navigate to')
+});
+const navigate = snapshot => ({
+  schema: {
+    name: 'browser_navigate',
+    description: 'Navigate to a URL',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(navigateSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = navigateSchema.parse(params);
+    const page = await context.ensurePage();
+    await page.goto(validatedParams.url, {
+      waitUntil: 'domcontentloaded'
+    });
+    // Cap load event to 5 seconds, the page is operational at this point.
+    await page.waitForLoadState('load', {
+      timeout: 5000
+    }).catch(() => {});
+    if (snapshot) return (0, _utils.captureAriaSnapshot)(page);
+    return {
+      content: [{
+        type: 'text',
+        text: `Navigated to ${validatedParams.url}`
+      }]
+    };
+  }
+});
+exports.navigate = navigate;
+const goBackSchema = _zod.z.object({});
+const goBack = snapshot => ({
+  schema: {
+    name: 'browser_go_back',
+    description: 'Go back to the previous page',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(goBackSchema)
+  },
+  handle: async context => {
+    return await (0, _utils.runAndWait)(context, 'Navigated back', async () => {
+      const page = await context.ensurePage();
+      await page.goBack();
+    }, snapshot);
+  }
+});
+exports.goBack = goBack;
+const goForwardSchema = _zod.z.object({});
+const goForward = snapshot => ({
+  schema: {
+    name: 'browser_go_forward',
+    description: 'Go forward to the next page',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(goForwardSchema)
+  },
+  handle: async context => {
+    return await (0, _utils.runAndWait)(context, 'Navigated forward', async () => {
+      const page = await context.ensurePage();
+      await page.goForward();
+    }, snapshot);
+  }
+});
+exports.goForward = goForward;
+const waitSchema = _zod.z.object({
+  time: _zod.z.number().describe('The time to wait in seconds')
+});
+const wait = exports.wait = {
+  schema: {
+    name: 'browser_wait',
+    description: 'Wait for a specified time in seconds',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(waitSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = waitSchema.parse(params);
+    const page = await context.ensurePage();
+    await page.waitForTimeout(Math.min(10000, validatedParams.time * 1000));
+    return {
+      content: [{
+        type: 'text',
+        text: `Waited for ${validatedParams.time} seconds`
+      }]
+    };
+  }
+};
+const pressKeySchema = _zod.z.object({
+  key: _zod.z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`')
+});
+const pressKey = exports.pressKey = {
+  schema: {
+    name: 'browser_press_key',
+    description: 'Press a key on the keyboard',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(pressKeySchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = pressKeySchema.parse(params);
+    return await (0, _utils.runAndWait)(context, `Pressed key ${validatedParams.key}`, async page => {
+      await page.keyboard.press(validatedParams.key);
+    });
+  }
+};
+const pdfSchema = _zod.z.object({});
+const pdf = exports.pdf = {
+  schema: {
+    name: 'browser_save_as_pdf',
+    description: 'Save page as PDF',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(pdfSchema)
+  },
+  handle: async context => {
+    const page = await context.ensurePage();
+    const fileName = _path.default.join(_os.default.tmpdir(), `/page-${new Date().toISOString()}.pdf`);
+    await page.pdf({
+      path: fileName
+    });
+    return {
+      content: [{
+        type: 'text',
+        text: `Saved as ${fileName}`
+      }]
+    };
+  }
+};
+const closeSchema = _zod.z.object({});
+const close = exports.close = {
+  schema: {
+    name: 'browser_close',
+    description: 'Close the page',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(closeSchema)
+  },
+  handle: async context => {
+    await context.close();
+    return {
+      content: [{
+        type: 'text',
+        text: `Page closed`
+      }]
+    };
+  }
+};

package/lib/tools/screenshot.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.type = exports.screenshot = exports.moveMouse = exports.drag = exports.click = void 0;
+var _zod = require("zod");
+var _zodToJsonSchema = require("zod-to-json-schema");
+var _utils = require("./utils");
+/**
+ * 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.
+ */
+
+const screenshot = exports.screenshot = {
+  schema: {
+    name: 'browser_screenshot',
+    description: 'Take a screenshot of the current page',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(_zod.z.object({}))
+  },
+  handle: async context => {
+    const page = await context.ensurePage();
+    const screenshot = await page.screenshot({
+      type: 'jpeg',
+      quality: 50,
+      scale: 'css'
+    });
+    return {
+      content: [{
+        type: 'image',
+        data: screenshot.toString('base64'),
+        mimeType: 'image/jpeg'
+      }]
+    };
+  }
+};
+const elementSchema = _zod.z.object({
+  element: _zod.z.string().describe('Human-readable element description used to obtain permission to interact with the element')
+});
+const moveMouseSchema = elementSchema.extend({
+  x: _zod.z.number().describe('X coordinate'),
+  y: _zod.z.number().describe('Y coordinate')
+});
+const moveMouse = exports.moveMouse = {
+  schema: {
+    name: 'browser_move_mouse',
+    description: 'Move mouse to a given position',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(moveMouseSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = moveMouseSchema.parse(params);
+    const page = await context.ensurePage();
+    await page.mouse.move(validatedParams.x, validatedParams.y);
+    return {
+      content: [{
+        type: 'text',
+        text: `Moved mouse to (${validatedParams.x}, ${validatedParams.y})`
+      }]
+    };
+  }
+};
+const clickSchema = elementSchema.extend({
+  x: _zod.z.number().describe('X coordinate'),
+  y: _zod.z.number().describe('Y coordinate')
+});
+const click = exports.click = {
+  schema: {
+    name: 'browser_click',
+    description: 'Click left mouse button',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(clickSchema)
+  },
+  handle: async (context, params) => {
+    return await (0, _utils.runAndWait)(context, 'Clicked mouse', async page => {
+      const validatedParams = clickSchema.parse(params);
+      await page.mouse.move(validatedParams.x, validatedParams.y);
+      await page.mouse.down();
+      await page.mouse.up();
+    });
+  }
+};
+const dragSchema = elementSchema.extend({
+  startX: _zod.z.number().describe('Start X coordinate'),
+  startY: _zod.z.number().describe('Start Y coordinate'),
+  endX: _zod.z.number().describe('End X coordinate'),
+  endY: _zod.z.number().describe('End Y coordinate')
+});
+const drag = exports.drag = {
+  schema: {
+    name: 'browser_drag',
+    description: 'Drag left mouse button',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(dragSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = dragSchema.parse(params);
+    return await (0, _utils.runAndWait)(context, `Dragged mouse from (${validatedParams.startX}, ${validatedParams.startY}) to (${validatedParams.endX}, ${validatedParams.endY})`, async page => {
+      await page.mouse.move(validatedParams.startX, validatedParams.startY);
+      await page.mouse.down();
+      await page.mouse.move(validatedParams.endX, validatedParams.endY);
+      await page.mouse.up();
+    });
+  }
+};
+const typeSchema = _zod.z.object({
+  text: _zod.z.string().describe('Text to type into the element'),
+  submit: _zod.z.boolean().describe('Whether to submit entered text (press Enter after)')
+});
+const type = exports.type = {
+  schema: {
+    name: 'browser_type',
+    description: 'Type text',
+    inputSchema: (0, _zodToJsonSchema.zodToJsonSchema)(typeSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = typeSchema.parse(params);
+    return await (0, _utils.runAndWait)(context, `Typed text "${validatedParams.text}"`, async page => {
+      await page.keyboard.type(validatedParams.text);
+      if (validatedParams.submit) await page.keyboard.press('Enter');
+    });
+  }
+};

package/lib/tools/snapshot.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.type = exports.snapshot = exports.hover = exports.drag = exports.click = void 0;
+var _zod = require("zod");
+var _zodToJsonSchema = _interopRequireDefault(require("zod-to-json-schema"));
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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.
+ */
+
+const snapshot = exports.snapshot = {
+  schema: {
+    name: 'browser_snapshot',
+    description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
+    inputSchema: (0, _zodToJsonSchema.default)(_zod.z.object({}))
+  },
+  handle: async context => {
+    return await (0, _utils.captureAriaSnapshot)(await context.ensurePage());
+  }
+};
+const elementSchema = _zod.z.object({
+  element: _zod.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
+  ref: _zod.z.string().describe('Exact target element reference from the page snapshot')
+});
+const click = exports.click = {
+  schema: {
+    name: 'browser_click',
+    description: 'Perform click on a web page',
+    inputSchema: (0, _zodToJsonSchema.default)(elementSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = elementSchema.parse(params);
+    return (0, _utils.runAndWait)(context, `"${validatedParams.element}" clicked`, page => refLocator(page, validatedParams.ref).click(), true);
+  }
+};
+const dragSchema = _zod.z.object({
+  startElement: _zod.z.string().describe('Human-readable source element description used to obtain the permission to interact with the element'),
+  startRef: _zod.z.string().describe('Exact source element reference from the page snapshot'),
+  endElement: _zod.z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
+  endRef: _zod.z.string().describe('Exact target element reference from the page snapshot')
+});
+const drag = exports.drag = {
+  schema: {
+    name: 'browser_drag',
+    description: 'Perform drag and drop between two elements',
+    inputSchema: (0, _zodToJsonSchema.default)(dragSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = dragSchema.parse(params);
+    return (0, _utils.runAndWait)(context, `Dragged "${validatedParams.startElement}" to "${validatedParams.endElement}"`, async page => {
+      const startLocator = refLocator(page, validatedParams.startRef);
+      const endLocator = refLocator(page, validatedParams.endRef);
+      await startLocator.dragTo(endLocator);
+    }, true);
+  }
+};
+const hover = exports.hover = {
+  schema: {
+    name: 'browser_hover',
+    description: 'Hover over element on page',
+    inputSchema: (0, _zodToJsonSchema.default)(elementSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = elementSchema.parse(params);
+    return (0, _utils.runAndWait)(context, `Hovered over "${validatedParams.element}"`, page => refLocator(page, validatedParams.ref).hover(), true);
+  }
+};
+const typeSchema = elementSchema.extend({
+  text: _zod.z.string().describe('Text to type into the element'),
+  submit: _zod.z.boolean().describe('Whether to submit entered text (press Enter after)')
+});
+const type = exports.type = {
+  schema: {
+    name: 'browser_type',
+    description: 'Type text into editable element',
+    inputSchema: (0, _zodToJsonSchema.default)(typeSchema)
+  },
+  handle: async (context, params) => {
+    const validatedParams = typeSchema.parse(params);
+    return await (0, _utils.runAndWait)(context, `Typed "${validatedParams.text}" into "${validatedParams.element}"`, async page => {
+      const locator = refLocator(page, validatedParams.ref);
+      await locator.fill(validatedParams.text);
+      if (validatedParams.submit) await locator.press('Enter');
+    }, true);
+  }
+};
+function refLocator(page, ref) {
+  return page.locator(`aria-ref=${ref}`);
+}

package/lib/tools/tool.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/tools/utils.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.captureAriaSnapshot = captureAriaSnapshot;
+exports.runAndWait = runAndWait;
+/**
+ * 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.
+ */
+
+async function waitForCompletion(page, callback) {
+  const requests = new Set();
+  let frameNavigated = false;
+  let waitCallback = () => {};
+  const waitBarrier = new Promise(f => {
+    waitCallback = f;
+  });
+  const requestListener = request => requests.add(request);
+  const requestFinishedListener = request => {
+    requests.delete(request);
+    if (!requests.size) waitCallback();
+  };
+  const frameNavigateListener = frame => {
+    if (frame.parentFrame()) return;
+    frameNavigated = true;
+    dispose();
+    clearTimeout(timeout);
+    void frame.waitForLoadState('load').then(() => {
+      waitCallback();
+    });
+  };
+  const onTimeout = () => {
+    dispose();
+    waitCallback();
+  };
+  page.on('request', requestListener);
+  page.on('requestfinished', requestFinishedListener);
+  page.on('framenavigated', frameNavigateListener);
+  const timeout = setTimeout(onTimeout, 10000);
+  const dispose = () => {
+    page.off('request', requestListener);
+    page.off('requestfinished', requestFinishedListener);
+    page.off('framenavigated', frameNavigateListener);
+    clearTimeout(timeout);
+  };
+  try {
+    const result = await callback();
+    if (!requests.size && !frameNavigated) waitCallback();
+    await waitBarrier;
+    await page.evaluate(() => new Promise(f => setTimeout(f, 1000)));
+    return result;
+  } finally {
+    dispose();
+  }
+}
+async function runAndWait(context, status, callback, snapshot = false) {
+  const page = await context.ensurePage();
+  await waitForCompletion(page, () => callback(page));
+  return snapshot ? captureAriaSnapshot(page, status) : {
+    content: [{
+      type: 'text',
+      text: status
+    }]
+  };
+}
+async function captureAriaSnapshot(page, status = '') {
+  const snapshot = await page.locator('html').ariaSnapshot({
+    ref: true
+  });
+  return {
+    content: [{
+      type: 'text',
+      text: `${status ? `${status}\n` : ''}
+- Page URL: ${page.url()}
+- Page Title: ${await page.title()}
+- Page Snapshot
+\`\`\`yaml
+${snapshot}
+\`\`\`
+`
+    }]
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwright/mcp",
-  "version": "1.52.0-alpha-1742413599000",
+  "version": "1.52.0-alpha-2025-03-20",
   "description": "Playwright Tools for MCP",
   "repository": {
     "type": "git",
@@ -24,12 +24,12 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
     "commander": "^13.1.0",
-    "playwright": "1.52.0-alpha-1742413599000",
+    "playwright": "1.52.0-alpha-2025-03-20",
     "zod-to-json-schema": "^3.24.4"
   },
   "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.6.1",
     "@types/node": "^22.13.10"
   },
   "bin": {