@playwright/mcp 0.0.36-alpha-2025-09-02 → 0.0.36-alpha-2025-09-04

package/lib/{mcp → sdk}/mdb.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -13,32 +14,67 @@
  * 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;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MDBBackend = void 0;
+exports.runMainBackend = runMainBackend;
+exports.runOnPauseBackendLoop = runOnPauseBackendLoop;
+const debug_1 = __importDefault(require("debug"));
+const tool_1 = require("./tool");
+const mcpBundle = __importStar(require("./bundle"));
+const mcpServer = __importStar(require("./server"));
+const mcpHttp = __importStar(require("./http"));
+const server_1 = require("./server");
+const manualPromise_1 = require("./manualPromise");
+const mdbDebug = (0, debug_1.default)('pw:mcp:mdb');
+const errorsDebug = (0, debug_1.default)('pw:mcp:errors');
+const z = mcpBundle.z;
+class MDBBackend {
     constructor(topLevelBackend) {
+        this._stack = [];
+        this._initialized = false;
         this._topLevelBackend = topLevelBackend;
     }
     async initialize(server) {
         if (this._initialized)
             return;
         this._initialized = true;
-        const transport = await wrapInProcess(this._topLevelBackend);
+        const transport = await (0, server_1.wrapInProcess)(this._topLevelBackend);
         await this._pushClient(transport);
     }
     async listTools() {
@@ -48,7 +84,7 @@ export class MDBBackend {
     async callTool(name, args) {
         if (name === pushToolsSchema.name)
             return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
-        const interruptPromise = new ManualPromise();
+        const interruptPromise = new manualPromise_1.ManualPromise();
         this._interruptPromise = interruptPromise;
         let [entry] = this._stack;
         // Pop the client while the tool is not found.
@@ -60,7 +96,7 @@ export class MDBBackend {
         }
         if (!entry)
             throw new Error(`Tool ${name} not found in the tool stack`);
-        const resultPromise = new ManualPromise();
+        const resultPromise = new manualPromise_1.ManualPromise();
         entry.resultPromise = resultPromise;
         this._client().callTool({
             name,
@@ -90,21 +126,22 @@ export class MDBBackend {
     }
     async _pushTools(params) {
         mdbDebug('pushing tools to the stack', params.mcpUrl);
-        const transport = new StreamableHTTPClientTransport(new URL(params.mcpUrl));
+        const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(params.mcpUrl));
         await this._pushClient(transport, params.introMessage);
         return { content: [{ type: 'text', text: 'Tools pushed' }] };
     }
     async _pushClient(transport, introMessage) {
+        var _a;
         mdbDebug('pushing client to the stack');
-        const client = new Client({ name: 'Internal client', version: '0.0.0' });
-        client.setRequestHandler(PingRequestSchema, () => ({}));
+        const client = new mcpBundle.Client({ name: 'Internal client', version: '0.0.0' });
+        client.setRequestHandler(mcpBundle.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({
+        (_a = this._interruptPromise) === null || _a === void 0 ? void 0 : _a.resolve({
             content: [{
                     type: 'text',
                     text: introMessage || '',
@@ -114,7 +151,8 @@ export class MDBBackend {
         return { content: [{ type: 'text', text: 'Tools pushed' }] };
     }
 }
-const pushToolsSchema = defineToolSchema({
+exports.MDBBackend = MDBBackend;
+const pushToolsSchema = (0, tool_1.defineToolSchema)({
     name: 'mdb_push_tools',
     title: 'Push MCP tools to the tools stack',
     description: 'Push MCP tools to the tools stack',
@@ -124,21 +162,21 @@ const pushToolsSchema = defineToolSchema({
     }),
     type: 'readOnly',
 });
-export async function runMainBackend(backendFactory, options) {
+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 });
+    const url = await startAsHttp(factory, { port: (options === null || options === void 0 ? void 0 : options.port) || 0 });
     process.env.PLAYWRIGHT_DEBUGGER_MCP = url;
-    if (options?.port !== undefined)
+    if ((options === null || options === void 0 ? void 0 : options.port) !== undefined)
         return url;
     // Start stdio conditionally.
-    await mcpServer.connect(factory, new StdioServerTransport(), false);
+    await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);
 }
-export async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
+async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
     const wrappedBackend = new OnceTimeServerBackendWrapper(backend);
     const factory = {
         name: 'on-pause-backend',
@@ -149,9 +187,9 @@ export async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
     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));
+    const client = new mcpBundle.Client({ name: 'Internal client', version: '0.0.0' });
+    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(mdbUrl));
     await client.connect(transport);
     const pushToolsResult = await client.callTool({
         name: pushToolsSchema.name,
@@ -173,14 +211,14 @@ async function startAsHttp(backendFactory, options) {
     return mcpHttp.httpAddressToString(httpServer.address());
 }
 class OnceTimeServerBackendWrapper {
-    _backend;
-    _selfDestructPromise = new ManualPromise();
     constructor(backend) {
+        this._selfDestructPromise = new manualPromise_1.ManualPromise();
         this._backend = backend;
         this._backend.requestSelfDestruct = () => this._selfDestructPromise.resolve();
     }
     async initialize(server, clientVersion, roots) {
-        await this._backend.initialize?.(server, clientVersion, roots);
+        var _a, _b;
+        await ((_b = (_a = this._backend).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, server, clientVersion, roots));
     }
     async listTools() {
         return this._backend.listTools();
@@ -189,7 +227,8 @@ class OnceTimeServerBackendWrapper {
         return this._backend.callTool(name, args);
     }
     serverClosed(server) {
-        this._backend.serverClosed?.(server);
+        var _a, _b;
+        (_b = (_a = this._backend).serverClosed) === null || _b === void 0 ? void 0 : _b.call(_a, server);
         this._selfDestructPromise.resolve();
     }
     async waitForClosed() {

package/lib/{mcp → sdk}/proxyBackend.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -13,18 +14,51 @@
  * 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 = [];
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyBackend = void 0;
+const debug_1 = __importDefault(require("debug"));
+const mcpBundle = __importStar(require("./bundle"));
+const errorsDebug = (0, debug_1.default)('pw:mcp:errors');
+const { z, zodToJsonSchema } = mcpBundle;
+class ProxyBackend {
     constructor(mcpProviders) {
+        this._roots = [];
         this._mcpProviders = mcpProviders;
         this._contextSwitchTool = this._defineContextSwitchTool();
     }
@@ -50,7 +84,8 @@ export class ProxyBackend {
         });
     }
     serverClosed() {
-        void this._currentClient?.close().catch(errorsDebug);
+        var _a;
+        void ((_a = this._currentClient) === null || _a === void 0 ? void 0 : _a.close().catch(errorsDebug));
     }
     async _callContextSwitchTool(params) {
         try {
@@ -87,18 +122,20 @@ export class ProxyBackend {
         };
     }
     async _setCurrentClient(factory) {
-        await this._currentClient?.close();
+        var _a;
+        await ((_a = this._currentClient) === null || _a === void 0 ? void 0 : _a.close());
         this._currentClient = undefined;
-        const client = new Client({ name: 'Playwright MCP Proxy', version: '0.0.0' });
+        const client = new mcpBundle.Client({ name: 'Playwright MCP Proxy', version: '0.0.0' });
         client.registerCapabilities({
             roots: {
                 listRoots: true,
             },
         });
-        client.setRequestHandler(ListRootsRequestSchema, () => ({ roots: this._roots }));
-        client.setRequestHandler(PingRequestSchema, () => ({}));
+        client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._roots }));
+        client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
         const transport = await factory.connect();
         await client.connect(transport);
         this._currentClient = client;
     }
 }
+exports.ProxyBackend = ProxyBackend;

package/lib/sdk/server.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = connect;
+exports.wrapInProcess = wrapInProcess;
+exports.createServer = createServer;
+exports.start = start;
+const debug_1 = __importDefault(require("debug"));
+const mcpBundle = __importStar(require("./bundle"));
+const http_1 = require("./http");
+const inProcessTransport_1 = require("./inProcessTransport");
+const serverDebug = (0, debug_1.default)('pw:mcp:server');
+const errorsDebug = (0, debug_1.default)('pw:mcp:errors');
+async function connect(factory, transport, runHeartbeat) {
+    const server = createServer(factory.name, factory.version, factory.create(), runHeartbeat);
+    await server.connect(transport);
+}
+async function wrapInProcess(backend) {
+    const server = createServer('Internal', '0.0.0', backend, false);
+    return new inProcessTransport_1.InProcessTransport(server);
+}
+function createServer(name, version, backend, runHeartbeat) {
+    let initializedPromiseResolve = () => { };
+    const initializedPromise = new Promise(resolve => initializedPromiseResolve = resolve);
+    const server = new mcpBundle.Server({ name, version }, {
+        capabilities: {
+            tools: {},
+        }
+    });
+    server.setRequestHandler(mcpBundle.ListToolsRequestSchema, async () => {
+        serverDebug('listTools');
+        await initializedPromise;
+        const tools = await backend.listTools();
+        return { tools };
+    });
+    let heartbeatRunning = false;
+    server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request) => {
+        serverDebug('callTool', request);
+        await initializedPromise;
+        if (runHeartbeat && !heartbeatRunning) {
+            heartbeatRunning = true;
+            startHeartbeat(server);
+        }
+        try {
+            return await backend.callTool(request.params.name, request.params.arguments || {});
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: '### Result\n' + String(error) }],
+                isError: true,
+            };
+        }
+    });
+    addServerListener(server, 'initialized', async () => {
+        var _a, _b;
+        try {
+            const capabilities = server.getClientCapabilities();
+            let clientRoots = [];
+            if (capabilities === null || capabilities === void 0 ? void 0 : capabilities.roots) {
+                const { roots } = await server.listRoots(undefined, { timeout: 2000 }).catch(() => ({ roots: [] }));
+                clientRoots = roots;
+            }
+            const clientVersion = (_a = server.getClientVersion()) !== null && _a !== void 0 ? _a : { name: 'unknown', version: 'unknown' };
+            await ((_b = backend.initialize) === null || _b === void 0 ? void 0 : _b.call(backend, server, clientVersion, clientRoots));
+            initializedPromiseResolve();
+        }
+        catch (e) {
+            errorsDebug(e);
+        }
+    });
+    addServerListener(server, 'close', () => { var _a; return (_a = backend.serverClosed) === null || _a === void 0 ? void 0 : _a.call(backend, server); });
+    return server;
+}
+const startHeartbeat = (server) => {
+    const beat = () => {
+        Promise.race([
+            server.ping(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('ping timeout')), 5000)),
+        ]).then(() => {
+            setTimeout(beat, 3000);
+        }).catch(() => {
+            void server.close();
+        });
+    };
+    beat();
+};
+function addServerListener(server, event, listener) {
+    const oldListener = server[`on${event}`];
+    server[`on${event}`] = () => {
+        oldListener === null || oldListener === void 0 ? void 0 : oldListener();
+        listener();
+    };
+}
+async function start(serverBackendFactory, options) {
+    if (options.port === undefined) {
+        await connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
+        return;
+    }
+    const httpServer = await (0, http_1.startHttpServer)(options);
+    await (0, http_1.installHttpTransport)(httpServer, serverBackendFactory);
+    const url = (0, http_1.httpAddressToString)(httpServer.address());
+    const mcpConfig = { mcpServers: {} };
+    mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {
+        url: `${url}/mcp`
+    };
+    const message = [
+        `Listening on ${url}`,
+        'Put this in your client config:',
+        JSON.stringify(mcpConfig, undefined, 2),
+        'For legacy SSE transport support, you can use the /sse endpoint instead.',
+    ].join('\n');
+    // eslint-disable-next-line no-console
+    console.error(message);
+}

package/lib/{mcp → sdk}/tool.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -13,12 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { zodToJsonSchema } from 'zod-to-json-schema';
-export function toMcpTool(tool) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMcpTool = toMcpTool;
+exports.defineToolSchema = defineToolSchema;
+const bundle_1 = require("../sdk/bundle");
+function toMcpTool(tool) {
     return {
         name: tool.name,
         description: tool.description,
-        inputSchema: zodToJsonSchema(tool.inputSchema, { strictUnions: true }),
+        inputSchema: (0, bundle_1.zodToJsonSchema)(tool.inputSchema, { strictUnions: true }),
         annotations: {
             title: tool.title,
             readOnlyHint: tool.type === 'readOnly',
@@ -27,6 +31,6 @@ export function toMcpTool(tool) {
         },
     };
 }
-export function defineToolSchema(tool) {
+function defineToolSchema(tool) {
     return tool;
 }