@szymonrybczak/playwright-mcp 0.0.2 → 0.0.5

package/lib/tools/testing.js

@@ -1,60 +0,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.
- */
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-const generateTestSchema = z.object({
-    name: z.string().describe('The name of the test'),
-    description: z.string().describe('The description of the test'),
-    steps: z.array(z.string()).describe('The steps of the test'),
-});
-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 {
-            resultOverride: {
-                content: [{
-                        type: 'text',
-                        text: instructions(params),
-                    }],
-            },
-            code: [],
-            captureSnapshot: false,
-            waitForNetwork: false,
-        };
-    },
-});
-const instructions = (params) => [
-    `## Instructions`,
-    `- You are a playwright test generator.`,
-    `- You are given a scenario and you need to generate a playwright test for it.`,
-    '- DO NOT generate test code based on the scenario alone. DO run steps one by one using the tools provided instead.',
-    '- Only after all steps are completed, emit a Playwright TypeScript test that uses @playwright/test based on message history',
-    '- Save generated test file in the tests directory',
-    `Test name: ${params.name}`,
-    `Description: ${params.description}`,
-    `Steps:`,
-    ...params.steps.map((step, index) => `- ${index + 1}. ${step}`),
-].join('\n');
-export default [
-    generateTest,
-];

package/lib/tools/tool.js

@@ -1,18 +0,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.
- */
-export function defineTool(tool) {
-    return tool;
-}

package/lib/tools/utils.js

@@ -1,80 +0,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.
- */
-export async function waitForCompletion(context, tab, 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 tab.waitForLoadState('load').then(waitCallback);
-    };
-    const onTimeout = () => {
-        dispose();
-        waitCallback();
-    };
-    tab.page.on('request', requestListener);
-    tab.page.on('requestfinished', requestFinishedListener);
-    tab.page.on('framenavigated', frameNavigateListener);
-    const timeout = setTimeout(onTimeout, 10000);
-    const dispose = () => {
-        tab.page.off('request', requestListener);
-        tab.page.off('requestfinished', requestFinishedListener);
-        tab.page.off('framenavigated', frameNavigateListener);
-        clearTimeout(timeout);
-    };
-    try {
-        const result = await callback();
-        if (!requests.size && !frameNavigated)
-            waitCallback();
-        await waitBarrier;
-        await context.waitForTimeout(1000);
-        return result;
-    }
-    finally {
-        dispose();
-    }
-}
-export function sanitizeForFilePath(s) {
-    const sanitize = (s) => s.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, '-');
-    const separator = s.lastIndexOf('.');
-    if (separator === -1)
-        return sanitize(s);
-    return sanitize(s.substring(0, separator)) + '.' + sanitize(s.substring(separator + 1));
-}
-export async function generateLocator(locator) {
-    try {
-        return await locator._generateLocatorString();
-    }
-    catch (e) {
-        if (e instanceof Error && /locator._generateLocatorString: No element matching locator/.test(e.message))
-            throw new Error('Ref not found, likely because element was removed. Use browser_snapshot to see what elements are currently on the page.');
-        throw e;
-    }
-}
-export async function callOnPageNoTrace(page, callback) {
-    return await page._wrapApiCall(() => callback(page), { internal: true });
-}

package/lib/tools/vision.js

@@ -1,189 +0,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.
- */
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-import * as javascript from '../javascript.js';
-const elementSchema = z.object({
-    element: z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
-});
-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();
-        const options = { type: 'jpeg', quality: 50, scale: 'css' };
-        const code = [
-            `// Take a screenshot of the current page`,
-            `await page.screenshot(${javascript.formatObject(options)});`,
-        ];
-        const action = () => tab.page.screenshot(options).then(buffer => {
-            return {
-                content: [{ type: 'image', data: buffer.toString('base64'), mimeType: 'image/jpeg' }],
-            };
-        });
-        return {
-            code,
-            action,
-            captureSnapshot: false,
-            waitForNetwork: false
-        };
-    },
-});
-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.coerce.number().describe('X coordinate'),
-            y: z.coerce.number().describe('Y coordinate'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params) => {
-        const tab = context.currentTabOrDie();
-        const code = [
-            `// Move mouse to (${params.x}, ${params.y})`,
-            `await page.mouse.move(${params.x}, ${params.y});`,
-        ];
-        const action = () => tab.page.mouse.move(params.x, params.y);
-        return {
-            code,
-            action,
-            captureSnapshot: false,
-            waitForNetwork: false
-        };
-    },
-});
-const click = defineTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_screen_click',
-        title: 'Click',
-        description: 'Click left mouse button',
-        inputSchema: elementSchema.extend({
-            x: z.coerce.number().describe('X coordinate'),
-            y: z.coerce.number().describe('Y coordinate'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (context, params) => {
-        const tab = context.currentTabOrDie();
-        const code = [
-            `// 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(params.x, params.y);
-            await tab.page.mouse.down();
-            await tab.page.mouse.up();
-        };
-        return {
-            code,
-            action,
-            captureSnapshot: false,
-            waitForNetwork: true,
-        };
-    },
-});
-const drag = defineTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_screen_drag',
-        title: 'Drag mouse',
-        description: 'Drag left mouse button',
-        inputSchema: elementSchema.extend({
-            startX: z.coerce.number().describe('Start X coordinate'),
-            startY: z.coerce.number().describe('Start Y coordinate'),
-            endX: z.coerce.number().describe('End X coordinate'),
-            endY: z.coerce.number().describe('End Y coordinate'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (context, params) => {
-        const tab = context.currentTabOrDie();
-        const code = [
-            `// 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(${params.endX}, ${params.endY});`,
-            `await page.mouse.up();`,
-        ];
-        const action = async () => {
-            await tab.page.mouse.move(params.startX, params.startY);
-            await tab.page.mouse.down();
-            await tab.page.mouse.move(params.endX, params.endY);
-            await tab.page.mouse.up();
-        };
-        return {
-            code,
-            action,
-            captureSnapshot: false,
-            waitForNetwork: true,
-        };
-    },
-});
-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.coerce.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (context, params) => {
-        const tab = context.currentTabOrDie();
-        const code = [
-            `// Type ${params.text}`,
-            `await page.keyboard.type('${params.text}');`,
-        ];
-        const action = async () => {
-            await tab.page.keyboard.type(params.text);
-            if (params.submit)
-                await tab.page.keyboard.press('Enter');
-        };
-        if (params.submit) {
-            code.push(`// Submit text`);
-            code.push(`await page.keyboard.press('Enter');`);
-        }
-        return {
-            code,
-            action,
-            captureSnapshot: false,
-            waitForNetwork: true,
-        };
-    },
-});
-export default [
-    screenshot,
-    moveMouse,
-    click,
-    drag,
-    type,
-];

package/lib/tools/wait.js

@@ -1,59 +0,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.
- */
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-const wait = captureSnapshot => defineTool({
-    capability: 'wait',
-    schema: {
-        name: 'browser_wait_for',
-        title: 'Wait for',
-        description: 'Wait for text to appear or disappear or a specified time to pass',
-        inputSchema: z.object({
-            time: z.coerce.number().optional().describe('The time to wait in seconds'),
-            text: z.string().optional().describe('The text to wait for'),
-            textGone: z.string().optional().describe('The text to wait for to disappear'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params) => {
-        if (!params.text && !params.textGone && !params.time)
-            throw new Error('Either time, text or textGone must be provided');
-        const code = [];
-        if (params.time) {
-            code.push(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
-            await new Promise(f => setTimeout(f, Math.min(10000, params.time * 1000)));
-        }
-        const tab = context.currentTabOrDie();
-        const locator = params.text ? tab.page.getByText(params.text).first() : undefined;
-        const goneLocator = params.textGone ? tab.page.getByText(params.textGone).first() : undefined;
-        if (goneLocator) {
-            code.push(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
-            await goneLocator.waitFor({ state: 'hidden' });
-        }
-        if (locator) {
-            code.push(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
-            await locator.waitFor({ state: 'visible' });
-        }
-        return {
-            code,
-            captureSnapshot,
-            waitForNetwork: false,
-        };
-    },
-});
-export default (captureSnapshot) => [
-    wait(captureSnapshot),
-];

package/lib/tools.js

@@ -1,61 +0,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.
- */
-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 screenshot from './tools/screenshot.js';
-import testing from './tools/testing.js';
-import vision from './tools/vision.js';
-import wait from './tools/wait.js';
-export const snapshotTools = [
-    ...common(true),
-    ...console,
-    ...dialogs(true),
-    ...files(true),
-    ...install,
-    ...keyboard(true),
-    ...navigate(true),
-    ...network,
-    ...pdf,
-    ...screenshot,
-    ...snapshot,
-    ...tabs(true),
-    ...testing,
-    ...wait(true),
-];
-export const visionTools = [
-    ...common(false),
-    ...console,
-    ...dialogs(false),
-    ...files(false),
-    ...install,
-    ...keyboard(false),
-    ...navigate(false),
-    ...network,
-    ...pdf,
-    ...tabs(false),
-    ...testing,
-    ...vision,
-    ...wait(false),
-];

package/lib/transport.js

@@ -1,133 +0,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.
- */
-import http from 'node:http';
-import assert from 'node:assert';
-import crypto from 'node:crypto';
-import debug from 'debug';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-export async function startStdioTransport(server) {
-    await server.createConnection(new StdioServerTransport());
-}
-const testDebug = debug('pw:mcp:test');
-async function handleSSE(server, req, res, url, sessions) {
-    if (req.method === 'POST') {
-        const sessionId = url.searchParams.get('sessionId');
-        if (!sessionId) {
-            res.statusCode = 400;
-            return res.end('Missing sessionId');
-        }
-        const transport = sessions.get(sessionId);
-        if (!transport) {
-            res.statusCode = 404;
-            return res.end('Session not found');
-        }
-        return await transport.handlePostMessage(req, res);
-    }
-    else if (req.method === 'GET') {
-        const transport = new SSEServerTransport('/sse', res);
-        sessions.set(transport.sessionId, transport);
-        testDebug(`create SSE session: ${transport.sessionId}`);
-        const connection = await server.createConnection(transport);
-        res.on('close', () => {
-            testDebug(`delete SSE session: ${transport.sessionId}`);
-            sessions.delete(transport.sessionId);
-            // eslint-disable-next-line no-console
-            void connection.close().catch(e => console.error(e));
-        });
-        return;
-    }
-    res.statusCode = 405;
-    res.end('Method not allowed');
-}
-async function handleStreamable(server, req, res, sessions) {
-    const sessionId = req.headers['mcp-session-id'];
-    if (sessionId) {
-        const transport = sessions.get(sessionId);
-        if (!transport) {
-            res.statusCode = 404;
-            res.end('Session not found');
-            return;
-        }
-        return await transport.handleRequest(req, res);
-    }
-    if (req.method === 'POST') {
-        const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => crypto.randomUUID(),
-            onsessioninitialized: sessionId => {
-                sessions.set(sessionId, transport);
-            }
-        });
-        transport.onclose = () => {
-            if (transport.sessionId)
-                sessions.delete(transport.sessionId);
-        };
-        await server.createConnection(transport);
-        await transport.handleRequest(req, res);
-        return;
-    }
-    res.statusCode = 400;
-    res.end('Invalid request');
-}
-export async function startHttpServer(config) {
-    const { host, port } = config;
-    const httpServer = http.createServer();
-    await new Promise((resolve, reject) => {
-        httpServer.on('error', reject);
-        httpServer.listen(port, host, () => {
-            resolve();
-            httpServer.removeListener('error', reject);
-        });
-    });
-    return httpServer;
-}
-export function startHttpTransport(httpServer, mcpServer) {
-    const sseSessions = new Map();
-    const streamableSessions = new Map();
-    httpServer.on('request', async (req, res) => {
-        const url = new URL(`http://localhost${req.url}`);
-        if (url.pathname.startsWith('/mcp'))
-            await handleStreamable(mcpServer, req, res, streamableSessions);
-        else
-            await handleSSE(mcpServer, req, res, url, sseSessions);
-    });
-    const url = httpAddressToString(httpServer.address());
-    const message = [
-        `Listening on ${url}`,
-        'Put this in your client config:',
-        JSON.stringify({
-            'mcpServers': {
-                'playwright': {
-                    'url': `${url}/sse`
-                }
-            }
-        }, undefined, 2),
-        'If your client supports streamable HTTP, you can use the /mcp endpoint instead.',
-    ].join('\n');
-    // eslint-disable-next-line no-console
-    console.error(message);
-}
-export function httpAddressToString(address) {
-    assert(address, 'Could not bind server socket');
-    if (typeof address === 'string')
-        return address;
-    const resolvedPort = address.port;
-    let resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;
-    if (resolvedHost === '0.0.0.0' || resolvedHost === '[::]')
-        resolvedHost = 'localhost';
-    return `http://${resolvedHost}:${resolvedPort}`;
-}