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

package/lib/mcp/http.js

@@ -1,135 +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 assert from 'assert';
-import http from 'http';
-import crypto from 'crypto';
-import debug from 'debug';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import * as mcpServer from './server.js';
-const testDebug = debug('pw:mcp:test');
-export async function startHttpServer(config, abortSignal) {
-    const { host, port } = config;
-    const httpServer = http.createServer();
-    decorateServer(httpServer);
-    await new Promise((resolve, reject) => {
-        httpServer.on('error', reject);
-        abortSignal?.addEventListener('abort', () => {
-            httpServer.close();
-            reject(new Error('Aborted'));
-        });
-        httpServer.listen(port, host, () => {
-            resolve();
-            httpServer.removeListener('error', reject);
-        });
-    });
-    return httpServer;
-}
-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}`;
-}
-export async function installHttpTransport(httpServer, serverBackendFactory) {
-    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('/sse'))
-            await handleSSE(serverBackendFactory, req, res, url, sseSessions);
-        else
-            await handleStreamable(serverBackendFactory, req, res, streamableSessions);
-    });
-}
-async function handleSSE(serverBackendFactory, 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}`);
-        await mcpServer.connect(serverBackendFactory, transport, false);
-        res.on('close', () => {
-            testDebug(`delete SSE session: ${transport.sessionId}`);
-            sessions.delete(transport.sessionId);
-        });
-        return;
-    }
-    res.statusCode = 405;
-    res.end('Method not allowed');
-}
-async function handleStreamable(serverBackendFactory, 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: async (sessionId) => {
-                testDebug(`create http session: ${transport.sessionId}`);
-                await mcpServer.connect(serverBackendFactory, transport, true);
-                sessions.set(sessionId, transport);
-            }
-        });
-        transport.onclose = () => {
-            if (!transport.sessionId)
-                return;
-            sessions.delete(transport.sessionId);
-            testDebug(`delete http session: ${transport.sessionId}`);
-        };
-        await transport.handleRequest(req, res);
-        return;
-    }
-    res.statusCode = 400;
-    res.end('Invalid request');
-}
-function decorateServer(server) {
-    const sockets = new Set();
-    server.on('connection', socket => {
-        sockets.add(socket);
-        socket.once('close', () => sockets.delete(socket));
-    });
-    const close = server.close;
-    server.close = (callback) => {
-        for (const socket of sockets)
-            socket.destroy();
-        sockets.clear();
-        return close.call(server, callback);
-    };
-}

package/lib/mcp/inProcessTransport.js

@@ -1,72 +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 class InProcessTransport {
-    _server;
-    _serverTransport;
-    _connected = false;
-    constructor(server) {
-        this._server = server;
-        this._serverTransport = new InProcessServerTransport(this);
-    }
-    async start() {
-        if (this._connected)
-            throw new Error('InprocessTransport already started!');
-        await this._server.connect(this._serverTransport);
-        this._connected = true;
-    }
-    async send(message, options) {
-        if (!this._connected)
-            throw new Error('Transport not connected');
-        this._serverTransport._receiveFromClient(message);
-    }
-    async close() {
-        if (this._connected) {
-            this._connected = false;
-            this.onclose?.();
-            this._serverTransport.onclose?.();
-        }
-    }
-    onclose;
-    onerror;
-    onmessage;
-    sessionId;
-    setProtocolVersion;
-    _receiveFromServer(message, extra) {
-        this.onmessage?.(message, extra);
-    }
-}
-class InProcessServerTransport {
-    _clientTransport;
-    constructor(clientTransport) {
-        this._clientTransport = clientTransport;
-    }
-    async start() {
-    }
-    async send(message, options) {
-        this._clientTransport._receiveFromServer(message);
-    }
-    async close() {
-        this.onclose?.();
-    }
-    onclose;
-    onerror;
-    onmessage;
-    sessionId;
-    setProtocolVersion;
-    _receiveFromClient(message) {
-        this.onmessage?.(message);
-    }
-}

package/lib/mcp/manualPromise.js

@@ -1,111 +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 class ManualPromise extends Promise {
-    _resolve;
-    _reject;
-    _isDone;
-    constructor() {
-        let resolve;
-        let reject;
-        super((f, r) => {
-            resolve = f;
-            reject = r;
-        });
-        this._isDone = false;
-        this._resolve = resolve;
-        this._reject = reject;
-    }
-    isDone() {
-        return this._isDone;
-    }
-    resolve(t) {
-        this._isDone = true;
-        this._resolve(t);
-    }
-    reject(e) {
-        this._isDone = true;
-        this._reject(e);
-    }
-    static get [Symbol.species]() {
-        return Promise;
-    }
-    get [Symbol.toStringTag]() {
-        return 'ManualPromise';
-    }
-}
-export class LongStandingScope {
-    _terminateError;
-    _closeError;
-    _terminatePromises = new Map();
-    _isClosed = false;
-    reject(error) {
-        this._isClosed = true;
-        this._terminateError = error;
-        for (const p of this._terminatePromises.keys())
-            p.resolve(error);
-    }
-    close(error) {
-        this._isClosed = true;
-        this._closeError = error;
-        for (const [p, frames] of this._terminatePromises)
-            p.resolve(cloneError(error, frames));
-    }
-    isClosed() {
-        return this._isClosed;
-    }
-    static async raceMultiple(scopes, promise) {
-        return Promise.race(scopes.map(s => s.race(promise)));
-    }
-    async race(promise) {
-        return this._race(Array.isArray(promise) ? promise : [promise], false);
-    }
-    async safeRace(promise, defaultValue) {
-        return this._race([promise], true, defaultValue);
-    }
-    async _race(promises, safe, defaultValue) {
-        const terminatePromise = new ManualPromise();
-        const frames = captureRawStack();
-        if (this._terminateError)
-            terminatePromise.resolve(this._terminateError);
-        if (this._closeError)
-            terminatePromise.resolve(cloneError(this._closeError, frames));
-        this._terminatePromises.set(terminatePromise, frames);
-        try {
-            return await Promise.race([
-                terminatePromise.then(e => safe ? defaultValue : Promise.reject(e)),
-                ...promises
-            ]);
-        }
-        finally {
-            this._terminatePromises.delete(terminatePromise);
-        }
-    }
-}
-function cloneError(error, frames) {
-    const clone = new Error();
-    clone.name = error.name;
-    clone.message = error.message;
-    clone.stack = [error.name + ':' + error.message, ...frames].join('\n');
-    return clone;
-}
-function captureRawStack() {
-    const stackTraceLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 50;
-    const error = new Error();
-    const stack = error.stack || '';
-    Error.stackTraceLimit = stackTraceLimit;
-    return stack.split('\n');
-}

package/lib/mcp/mdb.js

@@ -1,198 +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';
-import { z } from 'zod';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { PingRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { defineToolSchema } from './tool.js';
-import * as mcpServer from './server.js';
-import * as mcpHttp from './http.js';
-import { wrapInProcess } from './server.js';
-import { ManualPromise } from './manualPromise.js';
-const mdbDebug = debug('pw:mcp:mdb');
-const errorsDebug = debug('pw:mcp:errors');
-export class MDBBackend {
-    _stack = [];
-    _interruptPromise;
-    _topLevelBackend;
-    _initialized = false;
-    constructor(topLevelBackend) {
-        this._topLevelBackend = topLevelBackend;
-    }
-    async initialize(server) {
-        if (this._initialized)
-            return;
-        this._initialized = true;
-        const transport = await wrapInProcess(this._topLevelBackend);
-        await this._pushClient(transport);
-    }
-    async listTools() {
-        const response = await this._client().listTools();
-        return response.tools;
-    }
-    async callTool(name, args) {
-        if (name === pushToolsSchema.name)
-            return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
-        const interruptPromise = new ManualPromise();
-        this._interruptPromise = interruptPromise;
-        let [entry] = this._stack;
-        // Pop the client while the tool is not found.
-        while (entry && !entry.toolNames.includes(name)) {
-            mdbDebug('popping client from stack for ', name);
-            this._stack.shift();
-            await entry.client.close();
-            entry = this._stack[0];
-        }
-        if (!entry)
-            throw new Error(`Tool ${name} not found in the tool stack`);
-        const resultPromise = new ManualPromise();
-        entry.resultPromise = resultPromise;
-        this._client().callTool({
-            name,
-            arguments: args,
-        }).then(result => {
-            resultPromise.resolve(result);
-        }).catch(e => {
-            mdbDebug('error in client call', e);
-            if (this._stack.length < 2)
-                throw e;
-            this._stack.shift();
-            const prevEntry = this._stack[0];
-            void prevEntry.resultPromise.then(result => resultPromise.resolve(result));
-        });
-        const result = await Promise.race([interruptPromise, resultPromise]);
-        if (interruptPromise.isDone())
-            mdbDebug('client call intercepted', result);
-        else
-            mdbDebug('client call result', result);
-        return result;
-    }
-    _client() {
-        const [entry] = this._stack;
-        if (!entry)
-            throw new Error('No debugging backend available');
-        return entry.client;
-    }
-    async _pushTools(params) {
-        mdbDebug('pushing tools to the stack', params.mcpUrl);
-        const transport = new StreamableHTTPClientTransport(new URL(params.mcpUrl));
-        await this._pushClient(transport, params.introMessage);
-        return { content: [{ type: 'text', text: 'Tools pushed' }] };
-    }
-    async _pushClient(transport, introMessage) {
-        mdbDebug('pushing client to the stack');
-        const client = new Client({ name: 'Internal client', version: '0.0.0' });
-        client.setRequestHandler(PingRequestSchema, () => ({}));
-        await client.connect(transport);
-        mdbDebug('connected to the new client');
-        const { tools } = await client.listTools();
-        this._stack.unshift({ client, toolNames: tools.map(tool => tool.name), resultPromise: undefined });
-        mdbDebug('new tools added to the stack:', tools.map(tool => tool.name));
-        mdbDebug('interrupting current call:', !!this._interruptPromise);
-        this._interruptPromise?.resolve({
-            content: [{
-                    type: 'text',
-                    text: introMessage || '',
-                }],
-        });
-        this._interruptPromise = undefined;
-        return { content: [{ type: 'text', text: 'Tools pushed' }] };
-    }
-}
-const pushToolsSchema = defineToolSchema({
-    name: 'mdb_push_tools',
-    title: 'Push MCP tools to the tools stack',
-    description: 'Push MCP tools to the tools stack',
-    inputSchema: z.object({
-        mcpUrl: z.string(),
-        introMessage: z.string().optional(),
-    }),
-    type: 'readOnly',
-});
-export async function runMainBackend(backendFactory, options) {
-    const mdbBackend = new MDBBackend(backendFactory.create());
-    // Start HTTP unconditionally.
-    const factory = {
-        ...backendFactory,
-        create: () => mdbBackend
-    };
-    const url = await startAsHttp(factory, { port: options?.port || 0 });
-    process.env.PLAYWRIGHT_DEBUGGER_MCP = url;
-    if (options?.port !== undefined)
-        return url;
-    // Start stdio conditionally.
-    await mcpServer.connect(factory, new StdioServerTransport(), false);
-}
-export async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
-    const wrappedBackend = new OnceTimeServerBackendWrapper(backend);
-    const factory = {
-        name: 'on-pause-backend',
-        nameInConfig: 'on-pause-backend',
-        version: '0.0.0',
-        create: () => wrappedBackend,
-    };
-    const httpServer = await mcpHttp.startHttpServer({ port: 0 });
-    await mcpHttp.installHttpTransport(httpServer, factory);
-    const url = mcpHttp.httpAddressToString(httpServer.address());
-    const client = new Client({ name: 'Internal client', version: '0.0.0' });
-    client.setRequestHandler(PingRequestSchema, () => ({}));
-    const transport = new StreamableHTTPClientTransport(new URL(mdbUrl));
-    await client.connect(transport);
-    const pushToolsResult = await client.callTool({
-        name: pushToolsSchema.name,
-        arguments: {
-            mcpUrl: url,
-            introMessage,
-        },
-    });
-    if (pushToolsResult.isError)
-        errorsDebug('Failed to push tools', pushToolsResult.content);
-    await transport.terminateSession();
-    await client.close();
-    await wrappedBackend.waitForClosed();
-    httpServer.close();
-}
-async function startAsHttp(backendFactory, options) {
-    const httpServer = await mcpHttp.startHttpServer(options);
-    await mcpHttp.installHttpTransport(httpServer, backendFactory);
-    return mcpHttp.httpAddressToString(httpServer.address());
-}
-class OnceTimeServerBackendWrapper {
-    _backend;
-    _selfDestructPromise = new ManualPromise();
-    constructor(backend) {
-        this._backend = backend;
-        this._backend.requestSelfDestruct = () => this._selfDestructPromise.resolve();
-    }
-    async initialize(server, clientVersion, roots) {
-        await this._backend.initialize?.(server, clientVersion, roots);
-    }
-    async listTools() {
-        return this._backend.listTools();
-    }
-    async callTool(name, args) {
-        return this._backend.callTool(name, args);
-    }
-    serverClosed(server) {
-        this._backend.serverClosed?.(server);
-        this._selfDestructPromise.resolve();
-    }
-    async waitForClosed() {
-        await this._selfDestructPromise;
-    }
-}

package/lib/mcp/proxyBackend.js

@@ -1,104 +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';
-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';
-const errorsDebug = debug('pw:mcp:errors');
-export class ProxyBackend {
-    _mcpProviders;
-    _currentClient;
-    _contextSwitchTool;
-    _roots = [];
-    constructor(mcpProviders) {
-        this._mcpProviders = mcpProviders;
-        this._contextSwitchTool = this._defineContextSwitchTool();
-    }
-    async initialize(server, clientVersion, roots) {
-        this._roots = roots;
-        await this._setCurrentClient(this._mcpProviders[0]);
-    }
-    async listTools() {
-        const response = await this._currentClient.listTools();
-        if (this._mcpProviders.length === 1)
-            return response.tools;
-        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() {
-        void this._currentClient?.close().catch(errorsDebug);
-    }
-    async _callContextSwitchTool(params) {
-        try {
-            const factory = this._mcpProviders.find(factory => factory.name === params.name);
-            if (!factory)
-                throw new Error('Unknown connection method: ' + params.name);
-            await this._setCurrentClient(factory);
-            return {
-                content: [{ type: 'text', text: '### Result\nSuccessfully changed connection method.\n' }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{ type: 'text', text: `### Result\nError: ${error}\n` }],
-                isError: true,
-            };
-        }
-    }
-    _defineContextSwitchTool() {
-        return {
-            name: 'browser_connect',
-            description: [
-                'Connect to a browser using one of the available methods:',
-                ...this._mcpProviders.map(factory => `- "${factory.name}": ${factory.description}`),
-            ].join('\n'),
-            inputSchema: zodToJsonSchema(z.object({
-                name: z.enum(this._mcpProviders.map(factory => factory.name)).default(this._mcpProviders[0].name).describe('The method to use to connect to the browser'),
-            }), { strictUnions: true }),
-            annotations: {
-                title: 'Connect to a browser context',
-                readOnlyHint: true,
-                openWorldHint: false,
-            },
-        };
-    }
-    async _setCurrentClient(factory) {
-        await this._currentClient?.close();
-        this._currentClient = undefined;
-        const client = new Client({ name: 'Playwright MCP Proxy', version: '0.0.0' });
-        client.registerCapabilities({
-            roots: {
-                listRoots: true,
-            },
-        });
-        client.setRequestHandler(ListRootsRequestSchema, () => ({ roots: this._roots }));
-        client.setRequestHandler(PingRequestSchema, () => ({}));
-        const transport = await factory.connect();
-        await client.connect(transport);
-        this._currentClient = client;
-    }
-}