@playwright/mcp 0.0.36 → 0.0.37-alpha-2025-09-09

package/lib/tools/verify.js

@@ -1,137 +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 { defineTabTool } from './tool.js';
-import * as javascript from '../utils/codegen.js';
-import { generateLocator } from './utils.js';
-const verifyElement = defineTabTool({
-    capability: 'verify',
-    schema: {
-        name: 'browser_verify_element_visible',
-        title: 'Verify element visible',
-        description: 'Verify element is visible on the page',
-        inputSchema: z.object({
-            role: z.string().describe('ROLE of the element. Can be found in the snapshot like this: \`- {ROLE} "Accessible Name":\`'),
-            accessibleName: z.string().describe('ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: \`- role "{ACCESSIBLE_NAME}"\`'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const locator = tab.page.getByRole(params.role, { name: params.accessibleName });
-        if (await locator.count() === 0) {
-            response.addError(`Element with role "${params.role}" and accessible name "${params.accessibleName}" not found`);
-            return;
-        }
-        response.addCode(`await expect(page.getByRole(${javascript.escapeWithQuotes(params.role)}, { name: ${javascript.escapeWithQuotes(params.accessibleName)} })).toBeVisible();`);
-        response.addResult('Done');
-    },
-});
-const verifyText = defineTabTool({
-    capability: 'verify',
-    schema: {
-        name: 'browser_verify_text_visible',
-        title: 'Verify text visible',
-        description: `Verify text is visible on the page. Prefer ${verifyElement.schema.name} if possible.`,
-        inputSchema: z.object({
-            text: z.string().describe('TEXT to verify. Can be found in the snapshot like this: \`- role "Accessible Name": {TEXT}\` or like this: \`- text: {TEXT}\`'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const locator = tab.page.getByText(params.text).filter({ visible: true });
-        if (await locator.count() === 0) {
-            response.addError('Text not found');
-            return;
-        }
-        response.addCode(`await expect(page.getByText(${javascript.escapeWithQuotes(params.text)})).toBeVisible();`);
-        response.addResult('Done');
-    },
-});
-const verifyList = defineTabTool({
-    capability: 'verify',
-    schema: {
-        name: 'browser_verify_list_visible',
-        title: 'Verify list visible',
-        description: 'Verify list is visible on the page',
-        inputSchema: z.object({
-            element: z.string().describe('Human-readable list description'),
-            ref: z.string().describe('Exact target element reference that points to the list'),
-            items: z.array(z.string()).describe('Items to verify'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const locator = await tab.refLocator({ ref: params.ref, element: params.element });
-        const itemTexts = [];
-        for (const item of params.items) {
-            const itemLocator = locator.getByText(item);
-            if (await itemLocator.count() === 0) {
-                response.addError(`Item "${item}" not found`);
-                return;
-            }
-            itemTexts.push((await itemLocator.textContent()));
-        }
-        const ariaSnapshot = `\`
-- list:
-${itemTexts.map(t => `  - listitem: ${javascript.escapeWithQuotes(t, '"')}`).join('\n')}
-\``;
-        response.addCode(`await expect(page.locator('body')).toMatchAriaSnapshot(${ariaSnapshot});`);
-        response.addResult('Done');
-    },
-});
-const verifyValue = defineTabTool({
-    capability: 'verify',
-    schema: {
-        name: 'browser_verify_value',
-        title: 'Verify value',
-        description: 'Verify element value',
-        inputSchema: z.object({
-            type: z.enum(['textbox', 'checkbox', 'radio', 'combobox', 'slider']).describe('Type of the element'),
-            element: z.string().describe('Human-readable element description'),
-            ref: z.string().describe('Exact target element reference that points to the element'),
-            value: z.string().describe('Value to verify. For checkbox, use "true" or "false".'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const locator = await tab.refLocator({ ref: params.ref, element: params.element });
-        const locatorSource = `page.${await generateLocator(locator)}`;
-        if (params.type === 'textbox' || params.type === 'slider' || params.type === 'combobox') {
-            const value = await locator.inputValue();
-            if (value !== params.value) {
-                response.addError(`Expected value "${params.value}", but got "${value}"`);
-                return;
-            }
-            response.addCode(`await expect(${locatorSource}).toHaveValue(${javascript.quote(params.value)});`);
-        }
-        else if (params.type === 'checkbox' || params.type === 'radio') {
-            const value = await locator.isChecked();
-            if (value !== (params.value === 'true')) {
-                response.addError(`Expected value "${params.value}", but got "${value}"`);
-                return;
-            }
-            const matcher = value ? 'toBeChecked' : 'not.toBeChecked';
-            response.addCode(`await expect(${locatorSource}).${matcher}();`);
-        }
-        response.addResult('Done');
-    },
-});
-export default [
-    verifyElement,
-    verifyText,
-    verifyList,
-    verifyValue,
-];

package/lib/tools/wait.js

@@ -1,55 +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 = defineTool({
-    capability: 'core',
-    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.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, response) => {
-        if (!params.text && !params.textGone && !params.time)
-            throw new Error('Either time, text or textGone must be provided');
-        if (params.time) {
-            response.addCode(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
-            await new Promise(f => setTimeout(f, Math.min(30000, 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) {
-            response.addCode(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
-            await goneLocator.waitFor({ state: 'hidden' });
-        }
-        if (locator) {
-            response.addCode(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
-            await locator.waitFor({ state: 'visible' });
-        }
-        response.addResult(`Waited for ${params.text || params.textGone || params.time}`);
-        response.setIncludeSnapshot();
-    },
-});
-export default [
-    wait,
-];

package/lib/tools.js

@@ -1,54 +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 evaluate from './tools/evaluate.js';
-import files from './tools/files.js';
-import form from './tools/form.js';
-import install from './tools/install.js';
-import keyboard from './tools/keyboard.js';
-import mouse from './tools/mouse.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 wait from './tools/wait.js';
-import verify from './tools/verify.js';
-export const allTools = [
-    ...common,
-    ...console,
-    ...dialogs,
-    ...evaluate,
-    ...files,
-    ...form,
-    ...install,
-    ...keyboard,
-    ...navigate,
-    ...network,
-    ...mouse,
-    ...pdf,
-    ...screenshot,
-    ...snapshot,
-    ...tabs,
-    ...wait,
-    ...verify,
-];
-export function filteredTools(config) {
-    return allTools.filter(tool => tool.capability.startsWith('core') || config.capabilities?.includes(tool.capability));
-}

package/lib/utils/codegen.js

@@ -1,49 +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.
- */
-// adapted from:
-// - https://github.com/microsoft/playwright/blob/76ee48dc9d4034536e3ec5b2c7ce8be3b79418a8/packages/playwright-core/src/utils/isomorphic/stringUtils.ts
-// - https://github.com/microsoft/playwright/blob/76ee48dc9d4034536e3ec5b2c7ce8be3b79418a8/packages/playwright-core/src/server/codegen/javascript.ts
-// NOTE: this function should not be used to escape any selectors.
-export function escapeWithQuotes(text, char = '\'') {
-    const stringified = JSON.stringify(text);
-    const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
-    if (char === '\'')
-        return char + escapedText.replace(/[']/g, '\\\'') + char;
-    if (char === '"')
-        return char + escapedText.replace(/["]/g, '\\"') + char;
-    if (char === '`')
-        return char + escapedText.replace(/[`]/g, '\\`') + char;
-    throw new Error('Invalid escape char');
-}
-export function quote(text) {
-    return escapeWithQuotes(text, '\'');
-}
-export function formatObject(value, indent = '  ') {
-    if (typeof value === 'string')
-        return quote(value);
-    if (Array.isArray(value))
-        return `[${value.map(o => formatObject(o)).join(', ')}]`;
-    if (typeof value === 'object') {
-        const keys = Object.keys(value).filter(key => value[key] !== undefined).sort();
-        if (!keys.length)
-            return '{}';
-        const tokens = [];
-        for (const key of keys)
-            tokens.push(`${key}: ${formatObject(value[key])}`);
-        return `{\n${indent}${tokens.join(`,\n${indent}`)}\n}`;
-    }
-    return String(value);
-}

package/lib/utils/fileUtils.js

@@ -1,36 +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 os from 'node:os';
-import path from 'node:path';
-export function cacheDir() {
-    let cacheDirectory;
-    if (process.platform === 'linux')
-        cacheDirectory = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
-    else if (process.platform === 'darwin')
-        cacheDirectory = path.join(os.homedir(), 'Library', 'Caches');
-    else if (process.platform === 'win32')
-        cacheDirectory = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
-    else
-        throw new Error('Unsupported platform: ' + process.platform);
-    return path.join(cacheDirectory, 'ms-playwright');
-}
-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));
-}

package/lib/utils/guid.js

@@ -1,22 +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 crypto from 'crypto';
-export function createGuid() {
-    return crypto.randomBytes(16).toString('hex');
-}
-export function createHash(data) {
-    return crypto.createHash('sha256').update(data).digest('hex').slice(0, 7);
-}

package/lib/utils/log.js

@@ -1,21 +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 debug from 'debug';
-const errorsDebug = debug('pw:mcp:errors');
-export function logUnhandledError(error) {
-    errorsDebug(error);
-}
-export const testDebug = debug('pw:mcp:test');

package/lib/utils/package.js

@@ -1,20 +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 fs from 'fs';
-import path from 'path';
-import url from 'url';
-const __filename = url.fileURLToPath(import.meta.url);
-export const packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename), '..', '..', 'package.json'), 'utf8'));

package/lib/vscode/host.js

@@ -1,128 +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 { fileURLToPath } from 'url';
-import path from 'path';
-import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { ListRootsRequestSchema, PingRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import * as mcpServer from '../mcp/server.js';
-import { logUnhandledError } from '../utils/log.js';
-import { packageJSON } from '../utils/package.js';
-import { BrowserServerBackend } from '../browserServerBackend.js';
-import { contextFactory } from '../browserContextFactory.js';
-const contextSwitchOptions = z.object({
-    connectionString: z.string().optional().describe('The connection string to use to connect to the browser'),
-    lib: z.string().optional().describe('The library to use for the connection'),
-});
-class VSCodeProxyBackend {
-    _config;
-    _defaultTransportFactory;
-    name = 'Playwright MCP Client Switcher';
-    version = packageJSON.version;
-    _currentClient;
-    _contextSwitchTool;
-    _roots = [];
-    _clientVersion;
-    constructor(_config, _defaultTransportFactory) {
-        this._config = _config;
-        this._defaultTransportFactory = _defaultTransportFactory;
-        this._contextSwitchTool = this._defineContextSwitchTool();
-    }
-    async initialize(server, clientVersion, roots) {
-        this._clientVersion = clientVersion;
-        this._roots = roots;
-        const transport = await this._defaultTransportFactory();
-        await this._setCurrentClient(transport);
-    }
-    async listTools() {
-        const response = await this._currentClient.listTools();
-        return [
-            ...response.tools,
-            this._contextSwitchTool,
-        ];
-    }
-    async callTool(name, args) {
-        if (name === this._contextSwitchTool.name)
-            return this._callContextSwitchTool(args);
-        return await this._currentClient.callTool({
-            name,
-            arguments: args,
-        });
-    }
-    serverClosed(server) {
-        void this._currentClient?.close().catch(logUnhandledError);
-    }
-    async _callContextSwitchTool(params) {
-        if (!params.connectionString || !params.lib) {
-            const transport = await this._defaultTransportFactory();
-            await this._setCurrentClient(transport);
-            return {
-                content: [{ type: 'text', text: '### Result\nSuccessfully disconnected.\n' }],
-            };
-        }
-        await this._setCurrentClient(new StdioClientTransport({
-            command: process.execPath,
-            cwd: process.cwd(),
-            args: [
-                path.join(fileURLToPath(import.meta.url), '..', 'main.js'),
-                JSON.stringify(this._config),
-                params.connectionString,
-                params.lib,
-            ],
-        }));
-        return {
-            content: [{ type: 'text', text: '### Result\nSuccessfully connected.\n' }],
-        };
-    }
-    _defineContextSwitchTool() {
-        return {
-            name: 'browser_connect',
-            description: 'Do not call, this tool is used in the integration with the Playwright VS Code Extension and meant for programmatic usage only.',
-            inputSchema: zodToJsonSchema(contextSwitchOptions, { strictUnions: true }),
-            annotations: {
-                title: 'Connect to a browser running in VS Code.',
-                readOnlyHint: true,
-                openWorldHint: false,
-            },
-        };
-    }
-    async _setCurrentClient(transport) {
-        await this._currentClient?.close();
-        this._currentClient = undefined;
-        const client = new Client(this._clientVersion);
-        client.registerCapabilities({
-            roots: {
-                listRoots: true,
-            },
-        });
-        client.setRequestHandler(ListRootsRequestSchema, () => ({ roots: this._roots }));
-        client.setRequestHandler(PingRequestSchema, () => ({}));
-        await client.connect(transport);
-        this._currentClient = client;
-    }
-}
-export async function runVSCodeTools(config) {
-    const serverBackendFactory = {
-        name: 'Playwright w/ vscode',
-        nameInConfig: 'playwright-vscode',
-        version: packageJSON.version,
-        create: () => new VSCodeProxyBackend(config, () => mcpServer.wrapInProcess(new BrowserServerBackend(config, contextFactory(config))))
-    };
-    await mcpServer.start(serverBackendFactory, config.server);
-    return;
-}

package/lib/vscode/main.js

@@ -1,62 +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 { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import * as mcpServer from '../mcp/server.js';
-import { BrowserServerBackend } from '../browserServerBackend.js';
-class VSCodeBrowserContextFactory {
-    _config;
-    _playwright;
-    _connectionString;
-    name = 'vscode';
-    description = 'Connect to a browser running in the Playwright VS Code extension';
-    constructor(_config, _playwright, _connectionString) {
-        this._config = _config;
-        this._playwright = _playwright;
-        this._connectionString = _connectionString;
-    }
-    async createContext(clientInfo, abortSignal) {
-        let launchOptions = this._config.browser.launchOptions;
-        if (this._config.browser.userDataDir) {
-            launchOptions = {
-                ...launchOptions,
-                ...this._config.browser.contextOptions,
-                userDataDir: this._config.browser.userDataDir,
-            };
-        }
-        const connectionString = new URL(this._connectionString);
-        connectionString.searchParams.set('launch-options', JSON.stringify(launchOptions));
-        const browserType = this._playwright.chromium; // it could also be firefox or webkit, we just need some browser type to call `connect` on
-        const browser = await browserType.connect(connectionString.toString());
-        const context = browser.contexts()[0] ?? await browser.newContext(this._config.browser.contextOptions);
-        return {
-            browserContext: context,
-            close: async () => {
-                await browser.close();
-            }
-        };
-    }
-}
-async function main(config, connectionString, lib) {
-    const playwright = await import(lib).then(mod => mod.default ?? mod);
-    const factory = new VSCodeBrowserContextFactory(config, playwright, connectionString);
-    await mcpServer.connect({
-        name: 'Playwright MCP',
-        nameInConfig: 'playwright-vscode',
-        create: () => new BrowserServerBackend(config, factory),
-        version: 'unused'
-    }, new StdioServerTransport(), false);
-}
-await main(JSON.parse(process.argv[2]), process.argv[3], process.argv[4]);