@playwright/mcp 0.0.14 → 0.0.16

package/lib/tools/screen.js

@@ -49,14 +49,17 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const tool_1 = require("./tool");
 const javascript = __importStar(require("../javascript"));
-const screenshot = {
+const elementSchema = zod_1.z.object({
+    element: zod_1.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
+});
+const screenshot = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_capture',
         description: 'Take a screenshot of the current page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const tab = await context.ensureTab();
@@ -77,29 +80,24 @@ const screenshot = {
             waitForNetwork: false
         };
     },
-};
-const elementSchema = zod_1.z.object({
-    element: zod_1.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
-});
-const moveMouseSchema = elementSchema.extend({
-    x: zod_1.z.number().describe('X coordinate'),
-    y: zod_1.z.number().describe('Y coordinate'),
 });
-const moveMouse = {
+const moveMouse = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_move_mouse',
         description: 'Move mouse to a given position',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(moveMouseSchema),
+        inputSchema: elementSchema.extend({
+            x: zod_1.z.number().describe('X coordinate'),
+            y: zod_1.z.number().describe('Y coordinate'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = moveMouseSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Move mouse to (${validatedParams.x}, ${validatedParams.y})`,
-            `await page.mouse.move(${validatedParams.x}, ${validatedParams.y});`,
+            `// Move mouse to (${params.x}, ${params.y})`,
+            `await page.mouse.move(${params.x}, ${params.y});`,
         ];
-        const action = () => tab.page.mouse.move(validatedParams.x, validatedParams.y);
+        const action = () => tab.page.mouse.move(params.x, params.y);
         return {
             code,
             action,
@@ -107,29 +105,27 @@ const moveMouse = {
             waitForNetwork: false
         };
     },
-};
-const clickSchema = elementSchema.extend({
-    x: zod_1.z.number().describe('X coordinate'),
-    y: zod_1.z.number().describe('Y coordinate'),
 });
-const click = {
+const click = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_click',
         description: 'Click left mouse button',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(clickSchema),
+        inputSchema: elementSchema.extend({
+            x: zod_1.z.number().describe('X coordinate'),
+            y: zod_1.z.number().describe('Y coordinate'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = clickSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Click mouse at coordinates (${validatedParams.x}, ${validatedParams.y})`,
-            `await page.mouse.move(${validatedParams.x}, ${validatedParams.y});`,
+            `// Click mouse at coordinates (${params.x}, ${params.y})`,
+            `await page.mouse.move(${params.x}, ${params.y});`,
             `await page.mouse.down();`,
             `await page.mouse.up();`,
         ];
         const action = async () => {
-            await tab.page.mouse.move(validatedParams.x, validatedParams.y);
+            await tab.page.mouse.move(params.x, params.y);
             await tab.page.mouse.down();
             await tab.page.mouse.up();
         };
@@ -140,34 +136,32 @@ const click = {
             waitForNetwork: true,
         };
     },
-};
-const dragSchema = elementSchema.extend({
-    startX: zod_1.z.number().describe('Start X coordinate'),
-    startY: zod_1.z.number().describe('Start Y coordinate'),
-    endX: zod_1.z.number().describe('End X coordinate'),
-    endY: zod_1.z.number().describe('End Y coordinate'),
 });
-const drag = {
+const drag = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_drag',
         description: 'Drag left mouse button',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(dragSchema),
+        inputSchema: elementSchema.extend({
+            startX: zod_1.z.number().describe('Start X coordinate'),
+            startY: zod_1.z.number().describe('Start Y coordinate'),
+            endX: zod_1.z.number().describe('End X coordinate'),
+            endY: zod_1.z.number().describe('End Y coordinate'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = dragSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Drag mouse from (${validatedParams.startX}, ${validatedParams.startY}) to (${validatedParams.endX}, ${validatedParams.endY})`,
-            `await page.mouse.move(${validatedParams.startX}, ${validatedParams.startY});`,
+            `// Drag mouse from (${params.startX}, ${params.startY}) to (${params.endX}, ${params.endY})`,
+            `await page.mouse.move(${params.startX}, ${params.startY});`,
             `await page.mouse.down();`,
-            `await page.mouse.move(${validatedParams.endX}, ${validatedParams.endY});`,
+            `await page.mouse.move(${params.endX}, ${params.endY});`,
             `await page.mouse.up();`,
         ];
         const action = async () => {
-            await tab.page.mouse.move(validatedParams.startX, validatedParams.startY);
+            await tab.page.mouse.move(params.startX, params.startY);
             await tab.page.mouse.down();
-            await tab.page.mouse.move(validatedParams.endX, validatedParams.endY);
+            await tab.page.mouse.move(params.endX, params.endY);
             await tab.page.mouse.up();
         };
         return {
@@ -177,31 +171,29 @@ const drag = {
             waitForNetwork: true,
         };
     },
-};
-const typeSchema = zod_1.z.object({
-    text: zod_1.z.string().describe('Text to type into the element'),
-    submit: zod_1.z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
 });
-const type = {
+const type = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_type',
         description: 'Type text',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(typeSchema),
+        inputSchema: zod_1.z.object({
+            text: zod_1.z.string().describe('Text to type into the element'),
+            submit: zod_1.z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = typeSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Type ${validatedParams.text}`,
-            `await page.keyboard.type('${validatedParams.text}');`,
+            `// Type ${params.text}`,
+            `await page.keyboard.type('${params.text}');`,
         ];
         const action = async () => {
-            await tab.page.keyboard.type(validatedParams.text);
-            if (validatedParams.submit)
+            await tab.page.keyboard.type(params.text);
+            if (params.submit)
                 await tab.page.keyboard.press('Enter');
         };
-        if (validatedParams.submit) {
+        if (params.submit) {
             code.push(`// Submit text`);
             code.push(`await page.keyboard.press('Enter');`);
         }
@@ -212,7 +204,7 @@ const type = {
             waitForNetwork: true,
         };
     },
-};
+});
 exports.default = [
     screenshot,
     moveMouse,

package/lib/tools/snapshot.js

@@ -47,23 +47,18 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
+exports.generateLocator = generateLocator;
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-const utils_1 = require("./utils");
-const context_1 = require("../context");
+const tool_1 = require("./tool");
 const javascript = __importStar(require("../javascript"));
-const snapshot = {
+const config_1 = require("../config");
+const snapshot = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_snapshot',
         description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
-        inputSchema: (0, zod_to_json_schema_1.default)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         await context.ensureTab();
@@ -73,25 +68,24 @@ const snapshot = {
             waitForNetwork: false,
         };
     },
-};
+});
 const elementSchema = zod_1.z.object({
     element: zod_1.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
     ref: zod_1.z.string().describe('Exact target element reference from the page snapshot'),
 });
-const click = {
+const click = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_click',
         description: 'Perform click on a web page',
-        inputSchema: (0, zod_to_json_schema_1.default)(elementSchema),
+        inputSchema: elementSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = elementSchema.parse(params);
         const tab = context.currentTabOrDie();
-        const locator = tab.snapshotOrDie().refLocator(validatedParams.ref);
+        const locator = tab.snapshotOrDie().refLocator(params.ref);
         const code = [
-            `// Click ${validatedParams.element}`,
-            `await page.${await (0, context_1.generateLocator)(locator)}.click();`
+            `// Click ${params.element}`,
+            `await page.${await generateLocator(locator)}.click();`
         ];
         return {
             code,
@@ -100,28 +94,26 @@ const click = {
             waitForNetwork: true,
         };
     },
-};
-const dragSchema = zod_1.z.object({
-    startElement: zod_1.z.string().describe('Human-readable source element description used to obtain the permission to interact with the element'),
-    startRef: zod_1.z.string().describe('Exact source element reference from the page snapshot'),
-    endElement: zod_1.z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
-    endRef: zod_1.z.string().describe('Exact target element reference from the page snapshot'),
 });
-const drag = {
+const drag = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_drag',
         description: 'Perform drag and drop between two elements',
-        inputSchema: (0, zod_to_json_schema_1.default)(dragSchema),
+        inputSchema: zod_1.z.object({
+            startElement: zod_1.z.string().describe('Human-readable source element description used to obtain the permission to interact with the element'),
+            startRef: zod_1.z.string().describe('Exact source element reference from the page snapshot'),
+            endElement: zod_1.z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
+            endRef: zod_1.z.string().describe('Exact target element reference from the page snapshot'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = dragSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const startLocator = snapshot.refLocator(validatedParams.startRef);
-        const endLocator = snapshot.refLocator(validatedParams.endRef);
+        const startLocator = snapshot.refLocator(params.startRef);
+        const endLocator = snapshot.refLocator(params.endRef);
         const code = [
-            `// Drag ${validatedParams.startElement} to ${validatedParams.endElement}`,
-            `await page.${await (0, context_1.generateLocator)(startLocator)}.dragTo(page.${await (0, context_1.generateLocator)(endLocator)});`
+            `// Drag ${params.startElement} to ${params.endElement}`,
+            `await page.${await generateLocator(startLocator)}.dragTo(page.${await generateLocator(endLocator)});`
         ];
         return {
             code,
@@ -130,21 +122,20 @@ const drag = {
             waitForNetwork: true,
         };
     },
-};
-const hover = {
+});
+const hover = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_hover',
         description: 'Hover over element on page',
-        inputSchema: (0, zod_to_json_schema_1.default)(elementSchema),
+        inputSchema: elementSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = elementSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const locator = snapshot.refLocator(validatedParams.ref);
+        const locator = snapshot.refLocator(params.ref);
         const code = [
-            `// Hover over ${validatedParams.element}`,
-            `await page.${await (0, context_1.generateLocator)(locator)}.hover();`
+            `// Hover over ${params.element}`,
+            `await page.${await generateLocator(locator)}.hover();`
         ];
         return {
             code,
@@ -153,38 +144,37 @@ const hover = {
             waitForNetwork: true,
         };
     },
-};
+});
 const typeSchema = elementSchema.extend({
     text: zod_1.z.string().describe('Text to type into the element'),
     submit: zod_1.z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
     slowly: zod_1.z.boolean().optional().describe('Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.'),
 });
-const type = {
+const type = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_type',
         description: 'Type text into editable element',
-        inputSchema: (0, zod_to_json_schema_1.default)(typeSchema),
+        inputSchema: typeSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = typeSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const locator = snapshot.refLocator(validatedParams.ref);
+        const locator = snapshot.refLocator(params.ref);
         const code = [];
         const steps = [];
-        if (validatedParams.slowly) {
-            code.push(`// Press "${validatedParams.text}" sequentially into "${validatedParams.element}"`);
-            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.pressSequentially(${javascript.quote(validatedParams.text)});`);
-            steps.push(() => locator.pressSequentially(validatedParams.text));
+        if (params.slowly) {
+            code.push(`// Press "${params.text}" sequentially into "${params.element}"`);
+            code.push(`await page.${await generateLocator(locator)}.pressSequentially(${javascript.quote(params.text)});`);
+            steps.push(() => locator.pressSequentially(params.text));
         }
         else {
-            code.push(`// Fill "${validatedParams.text}" into "${validatedParams.element}"`);
-            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.fill(${javascript.quote(validatedParams.text)});`);
-            steps.push(() => locator.fill(validatedParams.text));
+            code.push(`// Fill "${params.text}" into "${params.element}"`);
+            code.push(`await page.${await generateLocator(locator)}.fill(${javascript.quote(params.text)});`);
+            steps.push(() => locator.fill(params.text));
         }
-        if (validatedParams.submit) {
+        if (params.submit) {
             code.push(`// Submit text`);
-            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.press('Enter');`);
+            code.push(`await page.${await generateLocator(locator)}.press('Enter');`);
             steps.push(() => locator.press('Enter'));
         }
         return {
@@ -194,33 +184,32 @@ const type = {
             waitForNetwork: true,
         };
     },
-};
+});
 const selectOptionSchema = elementSchema.extend({
     values: zod_1.z.array(zod_1.z.string()).describe('Array of values to select in the dropdown. This can be a single value or multiple values.'),
 });
-const selectOption = {
+const selectOption = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_select_option',
         description: 'Select an option in a dropdown',
-        inputSchema: (0, zod_to_json_schema_1.default)(selectOptionSchema),
+        inputSchema: selectOptionSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = selectOptionSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const locator = snapshot.refLocator(validatedParams.ref);
+        const locator = snapshot.refLocator(params.ref);
         const code = [
-            `// Select options [${validatedParams.values.join(', ')}] in ${validatedParams.element}`,
-            `await page.${await (0, context_1.generateLocator)(locator)}.selectOption(${javascript.formatObject(validatedParams.values)});`
+            `// Select options [${params.values.join(', ')}] in ${params.element}`,
+            `await page.${await generateLocator(locator)}.selectOption(${javascript.formatObject(params.values)});`
         ];
         return {
             code,
-            action: () => locator.selectOption(validatedParams.values).then(() => { }),
+            action: () => locator.selectOption(params.values).then(() => { }),
             captureSnapshot: true,
             waitForNetwork: true,
         };
     },
-};
+});
 const screenshotSchema = zod_1.z.object({
     raw: zod_1.z.boolean().optional().describe('Whether to return without compression (in PNG format). Default is false, which returns a JPEG image.'),
     element: zod_1.z.string().optional().describe('Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too.'),
@@ -231,37 +220,37 @@ const screenshotSchema = zod_1.z.object({
     message: 'Both element and ref must be provided or neither.',
     path: ['ref', 'element']
 });
-const screenshot = {
+const screenshot = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_take_screenshot',
         description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
-        inputSchema: (0, zod_to_json_schema_1.default)(screenshotSchema),
+        inputSchema: screenshotSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = screenshotSchema.parse(params);
         const tab = context.currentTabOrDie();
         const snapshot = tab.snapshotOrDie();
-        const fileType = validatedParams.raw ? 'png' : 'jpeg';
-        const fileName = path_1.default.join(os_1.default.tmpdir(), (0, utils_1.sanitizeForFilePath)(`page-${new Date().toISOString()}`)) + `.${fileType}`;
+        const fileType = params.raw ? 'png' : 'jpeg';
+        const fileName = await (0, config_1.outputFile)(context.config, `page-${new Date().toISOString()}.${fileType}`);
         const options = { type: fileType, quality: fileType === 'png' ? undefined : 50, scale: 'css', path: fileName };
-        const isElementScreenshot = validatedParams.element && validatedParams.ref;
+        const isElementScreenshot = params.element && params.ref;
         const code = [
-            `// Screenshot ${isElementScreenshot ? validatedParams.element : 'viewport'} and save it as ${fileName}`,
+            `// Screenshot ${isElementScreenshot ? params.element : 'viewport'} and save it as ${fileName}`,
         ];
-        const locator = validatedParams.ref ? snapshot.refLocator(validatedParams.ref) : null;
+        const locator = params.ref ? snapshot.refLocator(params.ref) : null;
         if (locator)
-            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.screenshot(${javascript.formatObject(options)});`);
+            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 action = async () => {
             const screenshot = locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
             return {
-                content: [{
+                content: includeBase64 ? [{
                         type: 'image',
                         data: screenshot.toString('base64'),
                         mimeType: fileType === 'png' ? 'image/png' : 'image/jpeg',
-                    }]
+                    }] : []
             };
         };
         return {
@@ -271,7 +260,10 @@ const screenshot = {
             waitForNetwork: false,
         };
     }
-};
+});
+async function generateLocator(locator) {
+    return locator._generateLocatorString();
+}
 exports.default = [
     snapshot,
     click,

package/lib/tools/tabs.js

@@ -16,13 +16,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const listTabs = {
+const tool_1 = require("./tool");
+const listTabs = (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_list',
         description: 'List browser tabs',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         await context.ensureTab();
@@ -38,22 +38,20 @@ const listTabs = {
             },
         };
     },
-};
-const selectTabSchema = zod_1.z.object({
-    index: zod_1.z.number().describe('The index of the tab to select'),
 });
-const selectTab = captureSnapshot => ({
+const selectTab = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_select',
         description: 'Select a tab by index',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(selectTabSchema),
+        inputSchema: zod_1.z.object({
+            index: zod_1.z.number().describe('The index of the tab to select'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = selectTabSchema.parse(params);
-        await context.selectTab(validatedParams.index);
+        await context.selectTab(params.index);
         const code = [
-            `// <internal code to select tab ${validatedParams.index}>`,
+            `// <internal code to select tab ${params.index}>`,
         ];
         return {
             code,
@@ -62,21 +60,19 @@ const selectTab = captureSnapshot => ({
         };
     },
 });
-const newTabSchema = zod_1.z.object({
-    url: zod_1.z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
-});
-const newTab = captureSnapshot => ({
+const newTab = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_new',
         description: 'Open a new tab',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(newTabSchema),
+        inputSchema: zod_1.z.object({
+            url: zod_1.z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = newTabSchema.parse(params);
         await context.newTab();
-        if (validatedParams.url)
-            await context.currentTabOrDie().navigate(validatedParams.url);
+        if (params.url)
+            await context.currentTabOrDie().navigate(params.url);
         const code = [
             `// <internal code to open a new tab>`,
         ];
@@ -87,21 +83,19 @@ const newTab = captureSnapshot => ({
         };
     },
 });
-const closeTabSchema = zod_1.z.object({
-    index: zod_1.z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
-});
-const closeTab = captureSnapshot => ({
+const closeTab = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_close',
         description: 'Close a tab',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(closeTabSchema),
+        inputSchema: zod_1.z.object({
+            index: zod_1.z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = closeTabSchema.parse(params);
-        await context.closeTab(validatedParams.index);
+        await context.closeTab(params.index);
         const code = [
-            `// <internal code to close tab ${validatedParams.index}>`,
+            `// <internal code to close tab ${params.index}>`,
         ];
         return {
             code,

package/lib/tools/tool.js

@@ -15,3 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTool = defineTool;
+function defineTool(tool) {
+    return tool;
+}