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

package/lib/tab.js

@@ -1,249 +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 { EventEmitter } from 'events';
-import { callOnPageNoTrace, waitForCompletion } from './tools/utils.js';
-import { logUnhandledError } from './utils/log.js';
-import { ManualPromise } from './mcp/manualPromise.js';
-export const TabEvents = {
-    modalState: 'modalState'
-};
-export class Tab extends EventEmitter {
-    context;
-    page;
-    _lastTitle = 'about:blank';
-    _consoleMessages = [];
-    _recentConsoleMessages = [];
-    _requests = new Map();
-    _onPageClose;
-    _modalStates = [];
-    _downloads = [];
-    constructor(context, page, onPageClose) {
-        super();
-        this.context = context;
-        this.page = page;
-        this._onPageClose = onPageClose;
-        page.on('console', event => this._handleConsoleMessage(messageToConsoleMessage(event)));
-        page.on('pageerror', error => this._handleConsoleMessage(pageErrorToConsoleMessage(error)));
-        page.on('request', request => this._requests.set(request, null));
-        page.on('response', response => this._requests.set(response.request(), response));
-        page.on('close', () => this._onClose());
-        page.on('filechooser', chooser => {
-            this.setModalState({
-                type: 'fileChooser',
-                description: 'File chooser',
-                fileChooser: chooser,
-            });
-        });
-        page.on('dialog', dialog => this._dialogShown(dialog));
-        page.on('download', download => {
-            void this._downloadStarted(download);
-        });
-        page.setDefaultNavigationTimeout(60000);
-        page.setDefaultTimeout(5000);
-        page[tabSymbol] = this;
-    }
-    static forPage(page) {
-        return page[tabSymbol];
-    }
-    modalStates() {
-        return this._modalStates;
-    }
-    setModalState(modalState) {
-        this._modalStates.push(modalState);
-        this.emit(TabEvents.modalState, modalState);
-    }
-    clearModalState(modalState) {
-        this._modalStates = this._modalStates.filter(state => state !== modalState);
-    }
-    modalStatesMarkdown() {
-        return renderModalStates(this.context, this.modalStates());
-    }
-    _dialogShown(dialog) {
-        this.setModalState({
-            type: 'dialog',
-            description: `"${dialog.type()}" dialog with message "${dialog.message()}"`,
-            dialog,
-        });
-    }
-    async _downloadStarted(download) {
-        const entry = {
-            download,
-            finished: false,
-            outputFile: await this.context.outputFile(download.suggestedFilename())
-        };
-        this._downloads.push(entry);
-        await download.saveAs(entry.outputFile);
-        entry.finished = true;
-    }
-    _clearCollectedArtifacts() {
-        this._consoleMessages.length = 0;
-        this._recentConsoleMessages.length = 0;
-        this._requests.clear();
-    }
-    _handleConsoleMessage(message) {
-        this._consoleMessages.push(message);
-        this._recentConsoleMessages.push(message);
-    }
-    _onClose() {
-        this._clearCollectedArtifacts();
-        this._onPageClose(this);
-    }
-    async updateTitle() {
-        await this._raceAgainstModalStates(async () => {
-            this._lastTitle = await callOnPageNoTrace(this.page, page => page.title());
-        });
-    }
-    lastTitle() {
-        return this._lastTitle;
-    }
-    isCurrentTab() {
-        return this === this.context.currentTab();
-    }
-    async waitForLoadState(state, options) {
-        await callOnPageNoTrace(this.page, page => page.waitForLoadState(state, options).catch(logUnhandledError));
-    }
-    async navigate(url) {
-        this._clearCollectedArtifacts();
-        const downloadEvent = callOnPageNoTrace(this.page, page => page.waitForEvent('download').catch(logUnhandledError));
-        try {
-            await this.page.goto(url, { waitUntil: 'domcontentloaded' });
-        }
-        catch (_e) {
-            const e = _e;
-            const mightBeDownload = e.message.includes('net::ERR_ABORTED') // chromium
-                || e.message.includes('Download is starting'); // firefox + webkit
-            if (!mightBeDownload)
-                throw e;
-            // on chromium, the download event is fired *after* page.goto rejects, so we wait a lil bit
-            const download = await Promise.race([
-                downloadEvent,
-                new Promise(resolve => setTimeout(resolve, 3000)),
-            ]);
-            if (!download)
-                throw e;
-            // Make sure other "download" listeners are notified first.
-            await new Promise(resolve => setTimeout(resolve, 500));
-            return;
-        }
-        // Cap load event to 5 seconds, the page is operational at this point.
-        await this.waitForLoadState('load', { timeout: 5000 });
-    }
-    consoleMessages() {
-        return this._consoleMessages;
-    }
-    requests() {
-        return this._requests;
-    }
-    async captureSnapshot() {
-        let tabSnapshot;
-        const modalStates = await this._raceAgainstModalStates(async () => {
-            const snapshot = await this.page._snapshotForAI();
-            tabSnapshot = {
-                url: this.page.url(),
-                title: await this.page.title(),
-                ariaSnapshot: snapshot,
-                modalStates: [],
-                consoleMessages: [],
-                downloads: this._downloads,
-            };
-        });
-        if (tabSnapshot) {
-            // Assign console message late so that we did not lose any to modal state.
-            tabSnapshot.consoleMessages = this._recentConsoleMessages;
-            this._recentConsoleMessages = [];
-        }
-        return tabSnapshot ?? {
-            url: this.page.url(),
-            title: '',
-            ariaSnapshot: '',
-            modalStates,
-            consoleMessages: [],
-            downloads: [],
-        };
-    }
-    _javaScriptBlocked() {
-        return this._modalStates.some(state => state.type === 'dialog');
-    }
-    async _raceAgainstModalStates(action) {
-        if (this.modalStates().length)
-            return this.modalStates();
-        const promise = new ManualPromise();
-        const listener = (modalState) => promise.resolve([modalState]);
-        this.once(TabEvents.modalState, listener);
-        return await Promise.race([
-            action().then(() => {
-                this.off(TabEvents.modalState, listener);
-                return [];
-            }),
-            promise,
-        ]);
-    }
-    async waitForCompletion(callback) {
-        await this._raceAgainstModalStates(() => waitForCompletion(this, callback));
-    }
-    async refLocator(params) {
-        return (await this.refLocators([params]))[0];
-    }
-    async refLocators(params) {
-        const snapshot = await this.page._snapshotForAI();
-        return params.map(param => {
-            if (!snapshot.includes(`[ref=${param.ref}]`))
-                throw new Error(`Ref ${param.ref} not found in the current page snapshot. Try capturing new snapshot.`);
-            return this.page.locator(`aria-ref=${param.ref}`).describe(param.element);
-        });
-    }
-    async waitForTimeout(time) {
-        if (this._javaScriptBlocked()) {
-            await new Promise(f => setTimeout(f, time));
-            return;
-        }
-        await callOnPageNoTrace(this.page, page => {
-            return page.evaluate(() => new Promise(f => setTimeout(f, 1000)));
-        });
-    }
-}
-function messageToConsoleMessage(message) {
-    return {
-        type: message.type(),
-        text: message.text(),
-        toString: () => `[${message.type().toUpperCase()}] ${message.text()} @ ${message.location().url}:${message.location().lineNumber}`,
-    };
-}
-function pageErrorToConsoleMessage(errorOrValue) {
-    if (errorOrValue instanceof Error) {
-        return {
-            type: undefined,
-            text: errorOrValue.message,
-            toString: () => errorOrValue.stack || errorOrValue.message,
-        };
-    }
-    return {
-        type: undefined,
-        text: String(errorOrValue),
-        toString: () => String(errorOrValue),
-    };
-}
-export function renderModalStates(context, modalStates) {
-    const result = ['### Modal state'];
-    if (modalStates.length === 0)
-        result.push('- There is no modal state present');
-    for (const state of modalStates) {
-        const tool = context.tools.filter(tool => 'clearsModalState' in tool).find(tool => tool.clearsModalState === state.type);
-        result.push(`- [${state.description}]: can be handled by the "${tool?.schema.name}" tool`);
-    }
-    return result;
-}
-const tabSymbol = Symbol('tabSymbol');

package/lib/tools/common.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 { defineTabTool, defineTool } from './tool.js';
-const close = defineTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_close',
-        title: 'Close browser',
-        description: 'Close the page',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.closeBrowserContext();
-        response.setIncludeTabs();
-        response.addCode(`await page.close()`);
-    },
-});
-const resize = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_resize',
-        title: 'Resize browser window',
-        description: 'Resize the browser window',
-        inputSchema: z.object({
-            width: z.number().describe('Width of the browser window'),
-            height: z.number().describe('Height of the browser window'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        response.addCode(`await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`);
-        await tab.waitForCompletion(async () => {
-            await tab.page.setViewportSize({ width: params.width, height: params.height });
-        });
-    },
-});
-export default [
-    close,
-    resize
-];

package/lib/tools/console.js

@@ -1,33 +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';
-const console = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_console_messages',
-        title: 'Get console messages',
-        description: 'Returns all console messages',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        tab.consoleMessages().map(message => response.addResult(message.toString()));
-    },
-});
-export default [
-    console,
-];

package/lib/tools/dialogs.js

@@ -1,47 +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';
-const handleDialog = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_handle_dialog',
-        title: 'Handle a dialog',
-        description: 'Handle a dialog',
-        inputSchema: z.object({
-            accept: z.boolean().describe('Whether to accept the dialog.'),
-            promptText: z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (tab, params, response) => {
-        response.setIncludeSnapshot();
-        const dialogState = tab.modalStates().find(state => state.type === 'dialog');
-        if (!dialogState)
-            throw new Error('No dialog visible');
-        tab.clearModalState(dialogState);
-        await tab.waitForCompletion(async () => {
-            if (params.accept)
-                await dialogState.dialog.accept(params.promptText);
-            else
-                await dialogState.dialog.dismiss();
-        });
-    },
-    clearsModalState: 'dialog',
-});
-export default [
-    handleDialog,
-];

package/lib/tools/evaluate.js

@@ -1,53 +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 evaluateSchema = z.object({
-    function: z.string().describe('() => { /* code */ } or (element) => { /* code */ } when element is provided'),
-    element: z.string().optional().describe('Human-readable element description used to obtain permission to interact with the element'),
-    ref: z.string().optional().describe('Exact target element reference from the page snapshot'),
-});
-const evaluate = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_evaluate',
-        title: 'Evaluate JavaScript',
-        description: 'Evaluate JavaScript expression on page or element',
-        inputSchema: evaluateSchema,
-        type: 'destructive',
-    },
-    handle: async (tab, params, response) => {
-        response.setIncludeSnapshot();
-        let locator;
-        if (params.ref && params.element) {
-            locator = await tab.refLocator({ ref: params.ref, element: params.element });
-            response.addCode(`await page.${await generateLocator(locator)}.evaluate(${javascript.quote(params.function)});`);
-        }
-        else {
-            response.addCode(`await page.evaluate(${javascript.quote(params.function)});`);
-        }
-        await tab.waitForCompletion(async () => {
-            const receiver = locator ?? tab.page;
-            const result = await receiver._evaluateFunction(params.function);
-            response.addResult(JSON.stringify(result, null, 2) || 'undefined');
-        });
-    },
-});
-export default [
-    evaluate,
-];

package/lib/tools/files.js

@@ -1,44 +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';
-const uploadFile = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_file_upload',
-        title: 'Upload files',
-        description: 'Upload one or multiple files',
-        inputSchema: z.object({
-            paths: z.array(z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (tab, params, response) => {
-        response.setIncludeSnapshot();
-        const modalState = tab.modalStates().find(state => state.type === 'fileChooser');
-        if (!modalState)
-            throw new Error('No file chooser visible');
-        response.addCode(`await fileChooser.setFiles(${JSON.stringify(params.paths)})`);
-        tab.clearModalState(modalState);
-        await tab.waitForCompletion(async () => {
-            await modalState.fileChooser.setFiles(params.paths);
-        });
-    },
-    clearsModalState: 'fileChooser',
-});
-export default [
-    uploadFile,
-];

package/lib/tools/form.js

@@ -1,57 +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 { generateLocator } from './utils.js';
-import * as javascript from '../utils/codegen.js';
-const fillForm = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_fill_form',
-        title: 'Fill form',
-        description: 'Fill multiple form fields',
-        inputSchema: z.object({
-            fields: z.array(z.object({
-                name: z.string().describe('Human-readable field name'),
-                type: z.enum(['textbox', 'checkbox', 'radio', 'combobox', 'slider']).describe('Type of the field'),
-                ref: z.string().describe('Exact target field reference from the page snapshot'),
-                value: z.string().describe('Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.'),
-            })).describe('Fields to fill in'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (tab, params, response) => {
-        for (const field of params.fields) {
-            const locator = await tab.refLocator({ element: field.name, ref: field.ref });
-            const locatorSource = `await page.${await generateLocator(locator)}`;
-            if (field.type === 'textbox' || field.type === 'slider') {
-                await locator.fill(field.value);
-                response.addCode(`${locatorSource}.fill(${javascript.quote(field.value)});`);
-            }
-            else if (field.type === 'checkbox' || field.type === 'radio') {
-                await locator.setChecked(field.value === 'true');
-                response.addCode(`${locatorSource}.setChecked(${javascript.quote(field.value)});`);
-            }
-            else if (field.type === 'combobox') {
-                await locator.selectOption({ label: field.value });
-                response.addCode(`${locatorSource}.selectOption(${javascript.quote(field.value)});`);
-            }
-        }
-    },
-});
-export default [
-    fillForm,
-];

package/lib/tools/install.js

@@ -1,53 +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 { fork } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-const install = defineTool({
-    capability: 'core-install',
-    schema: {
-        name: 'browser_install',
-        title: 'Install the browser specified in the config',
-        description: 'Install the browser specified in the config. Call this if you get an error about the browser not being installed.',
-        inputSchema: z.object({}),
-        type: 'destructive',
-    },
-    handle: async (context, params, response) => {
-        const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.browserName ?? 'chrome';
-        const cliUrl = import.meta.resolve('playwright/package.json');
-        const cliPath = path.join(fileURLToPath(cliUrl), '..', 'cli.js');
-        const child = fork(cliPath, ['install', channel], {
-            stdio: 'pipe',
-        });
-        const output = [];
-        child.stdout?.on('data', data => output.push(data.toString()));
-        child.stderr?.on('data', data => output.push(data.toString()));
-        await new Promise((resolve, reject) => {
-            child.on('close', code => {
-                if (code === 0)
-                    resolve();
-                else
-                    reject(new Error(`Failed to install browser: ${output.join('')}`));
-            });
-        });
-        response.setIncludeTabs();
-    },
-});
-export default [
-    install,
-];

package/lib/tools/keyboard.js

@@ -1,78 +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 { elementSchema } from './snapshot.js';
-import { generateLocator } from './utils.js';
-import * as javascript from '../utils/codegen.js';
-const pressKey = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_press_key',
-        title: 'Press a key',
-        description: 'Press a key on the keyboard',
-        inputSchema: z.object({
-            key: z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
-        }),
-        type: 'destructive',
-    },
-    handle: async (tab, params, response) => {
-        response.setIncludeSnapshot();
-        response.addCode(`// Press ${params.key}`);
-        response.addCode(`await page.keyboard.press('${params.key}');`);
-        await tab.waitForCompletion(async () => {
-            await tab.page.keyboard.press(params.key);
-        });
-    },
-});
-const typeSchema = elementSchema.extend({
-    text: z.string().describe('Text to type into the element'),
-    submit: z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
-    slowly: 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 = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_type',
-        title: 'Type text',
-        description: 'Type text into editable element',
-        inputSchema: typeSchema,
-        type: 'destructive',
-    },
-    handle: async (tab, params, response) => {
-        const locator = await tab.refLocator(params);
-        await tab.waitForCompletion(async () => {
-            if (params.slowly) {
-                response.setIncludeSnapshot();
-                response.addCode(`await page.${await generateLocator(locator)}.pressSequentially(${javascript.quote(params.text)});`);
-                await locator.pressSequentially(params.text);
-            }
-            else {
-                response.addCode(`await page.${await generateLocator(locator)}.fill(${javascript.quote(params.text)});`);
-                await locator.fill(params.text);
-            }
-            if (params.submit) {
-                response.setIncludeSnapshot();
-                response.addCode(`await page.${await generateLocator(locator)}.press('Enter');`);
-                await locator.press('Enter');
-            }
-        });
-    },
-});
-export default [
-    pressKey,
-    type,
-];