@one2x/playwright 1.57.0-alpha.1

package/lib/mcp/sdk/inProcessTransport.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inProcessTransport_exports = {};
+__export(inProcessTransport_exports, {
+  InProcessTransport: () => InProcessTransport
+});
+module.exports = __toCommonJS(inProcessTransport_exports);
+class InProcessTransport {
+  constructor(server) {
+    this._connected = false;
+    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?.();
+    }
+  }
+  _receiveFromServer(message, extra) {
+    this.onmessage?.(message, extra);
+  }
+}
+class InProcessServerTransport {
+  constructor(clientTransport) {
+    this._clientTransport = clientTransport;
+  }
+  async start() {
+  }
+  async send(message, options) {
+    this._clientTransport._receiveFromServer(message);
+  }
+  async close() {
+    this.onclose?.();
+  }
+  _receiveFromClient(message) {
+    this.onmessage?.(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InProcessTransport
+});

package/lib/mcp/sdk/inProcessTransport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/inProcessTransport.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { JSONRPCMessage, MessageExtraInfo } from '@modelcontextprotocol/sdk/types.js';\n\nexport class InProcessTransport implements Transport {\n  private _server: Server;\n  private _serverTransport: InProcessServerTransport;\n  private _connected: boolean = false;\n\n  constructor(server: Server) {\n    this._server = server;\n    this._serverTransport = new InProcessServerTransport(this);\n  }\n\n  async start(): Promise<void> {\n    if (this._connected)\n      throw new Error('InprocessTransport already started!');\n\n    await this._server.connect(this._serverTransport);\n    this._connected = true;\n  }\n\n  async send(message: JSONRPCMessage, options?: TransportSendOptions): Promise<void> {\n    if (!this._connected)\n      throw new Error('Transport not connected');\n\n\n    this._serverTransport._receiveFromClient(message);\n  }\n\n  async close(): Promise<void> {\n    if (this._connected) {\n      this._connected = false;\n      this.onclose?.();\n      this._serverTransport.onclose?.();\n    }\n  }\n\n  onclose?: (() => void) | undefined;\n  onerror?: ((error: Error) => void) | undefined;\n  onmessage?: ((message: JSONRPCMessage, extra?: MessageExtraInfo) => void) | undefined;\n  sessionId?: string | undefined;\n  setProtocolVersion?: ((version: string) => void) | undefined;\n\n  _receiveFromServer(message: JSONRPCMessage, extra?: MessageExtraInfo): void {\n    this.onmessage?.(message, extra);\n  }\n}\n\nclass InProcessServerTransport implements Transport {\n  private _clientTransport: InProcessTransport;\n\n  constructor(clientTransport: InProcessTransport) {\n    this._clientTransport = clientTransport;\n  }\n\n  async start(): Promise<void> {\n  }\n\n  async send(message: JSONRPCMessage, options?: TransportSendOptions): Promise<void> {\n    this._clientTransport._receiveFromServer(message);\n  }\n\n  async close(): Promise<void> {\n    this.onclose?.();\n  }\n\n  onclose?: (() => void) | undefined;\n  onerror?: ((error: Error) => void) | undefined;\n  onmessage?: ((message: JSONRPCMessage, extra?: MessageExtraInfo) => void) | undefined;\n  sessionId?: string | undefined;\n  setProtocolVersion?: ((version: string) => void) | undefined;\n  _receiveFromClient(message: JSONRPCMessage): void {\n    this.onmessage?.(message);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,MAAM,mBAAwC;AAAA,EAKnD,YAAY,QAAgB;AAF5B,SAAQ,aAAsB;AAG5B,SAAK,UAAU;AACf,SAAK,mBAAmB,IAAI,yBAAyB,IAAI;AAAA,EAC3D;AAAA,EAEA,MAAM,QAAuB;AAC3B,QAAI,KAAK;AACP,YAAM,IAAI,MAAM,qCAAqC;AAEvD,UAAM,KAAK,QAAQ,QAAQ,KAAK,gBAAgB;AAChD,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,MAAM,KAAK,SAAyB,SAA+C;AACjF,QAAI,CAAC,KAAK;AACR,YAAM,IAAI,MAAM,yBAAyB;AAG3C,SAAK,iBAAiB,mBAAmB,OAAO;AAAA,EAClD;AAAA,EAEA,MAAM,QAAuB;AAC3B,QAAI,KAAK,YAAY;AACnB,WAAK,aAAa;AAClB,WAAK,UAAU;AACf,WAAK,iBAAiB,UAAU;AAAA,IAClC;AAAA,EACF;AAAA,EAQA,mBAAmB,SAAyB,OAAgC;AAC1E,SAAK,YAAY,SAAS,KAAK;AAAA,EACjC;AACF;AAEA,MAAM,yBAA8C;AAAA,EAGlD,YAAY,iBAAqC;AAC/C,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEA,MAAM,QAAuB;AAAA,EAC7B;AAAA,EAEA,MAAM,KAAK,SAAyB,SAA+C;AACjF,SAAK,iBAAiB,mBAAmB,OAAO;AAAA,EAClD;AAAA,EAEA,MAAM,QAAuB;AAC3B,SAAK,UAAU;AAAA,EACjB;AAAA,EAOA,mBAAmB,SAA+B;AAChD,SAAK,YAAY,OAAO;AAAA,EAC1B;AACF;",
+  "names": []
+}

package/lib/mcp/sdk/mdb.js

@@ -0,0 +1,208 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mdb_exports = {};
+__export(mdb_exports, {
+  MDBBackend: () => MDBBackend,
+  runMainBackend: () => runMainBackend,
+  runOnPauseBackendLoop: () => runOnPauseBackendLoop
+});
+module.exports = __toCommonJS(mdb_exports);
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_tool = require("./tool");
+var mcpBundle = __toESM(require("./bundle"));
+var mcpServer = __toESM(require("./server"));
+var mcpHttp = __toESM(require("./http"));
+const mdbDebug = (0, import_utilsBundle.debug)("pw:mcp:mdb");
+const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
+const z = mcpBundle.z;
+class MDBBackend {
+  constructor(mainBackend) {
+    this._progress = [];
+    this._mainBackend = mainBackend;
+    this._progressCallback = (params) => {
+      if (params.message)
+        this._progress.push({ type: "text", text: params.message });
+    };
+  }
+  async initialize(server, clientInfo) {
+    if (!this._clientInfo) {
+      this._clientInfo = clientInfo;
+      await this._mainBackend.initialize?.(server, clientInfo);
+    }
+  }
+  async listTools() {
+    return await this._mainBackend.listTools();
+  }
+  async callTool(name, args) {
+    if (name === pushToolsSchema.name) {
+      await this._createOnPauseClient(pushToolsSchema.inputSchema.parse(args || {}));
+      return { content: [{ type: "text", text: "Tools pushed" }] };
+    }
+    if (this._onPauseClient?.tools.find((tool) => tool.name === name)) {
+      const result2 = await this._onPauseClient.client.callTool({
+        name,
+        arguments: args
+      });
+      await this._mainBackend.afterCallTool?.(name, args, result2);
+      return result2;
+    }
+    await this._onPauseClient?.transport.terminateSession().catch(errorsDebug);
+    await this._onPauseClient?.client.close().catch(errorsDebug);
+    this._onPauseClient = void 0;
+    const resultPromise = new import_utils.ManualPromise();
+    const interruptPromise = new import_utils.ManualPromise();
+    this._interruptPromise = interruptPromise;
+    this._mainBackend.callTool(name, args, this._progressCallback).then((result2) => {
+      resultPromise.resolve(result2);
+    }).catch((e) => {
+      resultPromise.resolve({ content: [{ type: "text", text: String(e) }], isError: true });
+    });
+    const result = await Promise.race([interruptPromise, resultPromise]);
+    if (interruptPromise.isDone())
+      mdbDebug("client call intercepted", result);
+    else
+      mdbDebug("client call result", result);
+    result.content.unshift(...this._progress);
+    this._progress.length = 0;
+    return result;
+  }
+  async _createOnPauseClient(params) {
+    if (this._onPauseClient)
+      await this._onPauseClient.client.close().catch(errorsDebug);
+    this._onPauseClient = await this._createClient(params.mcpUrl);
+    this._interruptPromise?.resolve({
+      content: [{
+        type: "text",
+        text: params.introMessage || ""
+      }]
+    });
+    this._interruptPromise = void 0;
+  }
+  async _createClient(url) {
+    const client = new mcpBundle.Client({ name: "Interrupting client", version: "0.0.0" }, { capabilities: { roots: {} } });
+    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));
+    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    client.setNotificationHandler(mcpBundle.ProgressNotificationSchema, (notification) => {
+      if (notification.method === "notifications/progress") {
+        const { message } = notification.params;
+        if (message)
+          this._progress.push({ type: "text", text: message });
+      }
+    });
+    const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(url));
+    await client.connect(transport);
+    const { tools } = await client.listTools();
+    return { client, tools, transport };
+  }
+}
+const pushToolsSchema = (0, import_tool.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"
+});
+async function runMainBackend(backendFactory, options) {
+  const mdbBackend = new MDBBackend(backendFactory.create(backendFactory.config));
+  const factory = {
+    ...backendFactory,
+    create: (cfg) => mdbBackend
+  };
+  const url = await startAsHttp(factory, { port: options?.port || 0 });
+  process.env.PLAYWRIGHT_DEBUGGER_MCP = url;
+  if (options?.port !== void 0)
+    return url;
+  await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);
+}
+async function runOnPauseBackendLoop(backend, introMessage) {
+  const wrappedBackend = new ServerBackendWithCloseListener(backend);
+  const factory = {
+    name: "on-pause-backend",
+    nameInConfig: "on-pause-backend",
+    version: "0.0.0",
+    config: {},
+    // MDB doesn't use config
+    create: () => wrappedBackend
+  };
+  const httpServer = await mcpHttp.startHttpServer({ port: 0 });
+  const url = await mcpHttp.installHttpTransport(httpServer, factory, true);
+  const client = new mcpBundle.Client({ name: "Pushing client", version: "0.0.0" });
+  client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+  const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(process.env.PLAYWRIGHT_DEBUGGER_MCP));
+  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);
+  return await mcpHttp.installHttpTransport(httpServer, backendFactory, true);
+}
+class ServerBackendWithCloseListener {
+  constructor(backend) {
+    this._serverClosedPromise = new import_utils.ManualPromise();
+    this._backend = backend;
+  }
+  async initialize(server, clientInfo) {
+    await this._backend.initialize?.(server, clientInfo);
+  }
+  async listTools() {
+    return this._backend.listTools();
+  }
+  async callTool(name, args, progress) {
+    return this._backend.callTool(name, args, progress);
+  }
+  serverClosed(server) {
+    this._backend.serverClosed?.(server);
+    this._serverClosedPromise.resolve();
+  }
+  async waitForClosed() {
+    await this._serverClosedPromise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MDBBackend,
+  runMainBackend,
+  runOnPauseBackendLoop
+});

package/lib/mcp/sdk/mdb.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/mdb.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\nimport { ManualPromise } from 'playwright-core/lib/utils';\n\nimport { defineToolSchema } from './tool';\nimport * as mcpBundle from './bundle';\nimport * as mcpServer from './server';\nimport * as mcpHttp from './http';\n\nimport type { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js';\n\nconst mdbDebug = debug('pw:mcp:mdb');\nconst errorsDebug = debug('pw:mcp:errors');\nconst z = mcpBundle.z;\n\nexport class MDBBackend implements mcpServer.ServerBackend {\n  private _onPauseClient: { client: Client, tools: mcpServer.Tool[], transport: StreamableHTTPClientTransport } | undefined;\n  private _interruptPromise: ManualPromise<mcpServer.CallToolResult> | undefined;\n  private _mainBackend: mcpServer.ServerBackend;\n  private _clientInfo: mcpServer.ClientInfo | undefined;\n  private _progress: mcpServer.CallToolResult['content'] = [];\n  private _progressCallback: mcpServer.ProgressCallback;\n\n  constructor(mainBackend: mcpServer.ServerBackend) {\n    this._mainBackend = mainBackend;\n    this._progressCallback = (params: mcpServer.ProgressParams) => {\n      if (params.message)\n        this._progress.push({ type: 'text', text: params.message });\n    };\n  }\n\n  async initialize(server: mcpServer.Server, clientInfo: mcpServer.ClientInfo): Promise<void> {\n    if (!this._clientInfo) {\n      this._clientInfo = clientInfo;\n      await this._mainBackend.initialize?.(server, clientInfo);\n    }\n  }\n\n  async listTools(): Promise<mcpServer.Tool[]> {\n    return await this._mainBackend.listTools();\n  }\n\n  async callTool(name: string, args: mcpServer.CallToolRequest['params']['arguments']): Promise<mcpServer.CallToolResult> {\n    if (name === pushToolsSchema.name) {\n      await this._createOnPauseClient(pushToolsSchema.inputSchema.parse(args || {}));\n      return { content: [{ type: 'text', text: 'Tools pushed' }] };\n    }\n\n    if (this._onPauseClient?.tools.find(tool => tool.name === name)) {\n      const result = await this._onPauseClient.client.callTool({\n        name,\n        arguments: args,\n      }) as mcpServer.CallToolResult;\n      await this._mainBackend.afterCallTool?.(name, args, result);\n      return result;\n    }\n\n    await this._onPauseClient?.transport.terminateSession().catch(errorsDebug);\n    await this._onPauseClient?.client.close().catch(errorsDebug);\n    this._onPauseClient = undefined;\n\n    const resultPromise = new ManualPromise<mcpServer.CallToolResult>();\n    const interruptPromise = new ManualPromise<mcpServer.CallToolResult>();\n    this._interruptPromise = interruptPromise;\n\n    this._mainBackend.callTool(name, args, this._progressCallback).then(result => {\n      resultPromise.resolve(result as mcpServer.CallToolResult);\n    }).catch(e => {\n      resultPromise.resolve({ content: [{ type: 'text', text: String(e) }], isError: true });\n    });\n\n    const result = await Promise.race([interruptPromise, resultPromise]);\n    if (interruptPromise.isDone())\n      mdbDebug('client call intercepted', result);\n    else\n      mdbDebug('client call result', result);\n    result.content.unshift(...this._progress);\n    this._progress.length = 0;\n    return result;\n  }\n\n  private async _createOnPauseClient(params: { mcpUrl: string, introMessage?: string }) {\n    if (this._onPauseClient)\n      await this._onPauseClient.client.close().catch(errorsDebug);\n\n    this._onPauseClient = await this._createClient(params.mcpUrl);\n\n    this._interruptPromise?.resolve({\n      content: [{\n        type: 'text',\n        text: params.introMessage || '',\n      }],\n    });\n    this._interruptPromise = undefined;\n  }\n\n  private async _createClient(url: string): Promise<{ client: Client, tools: mcpServer.Tool[], transport: StreamableHTTPClientTransport }> {\n    const client = new mcpBundle.Client({ name: 'Interrupting client', version: '0.0.0' }, { capabilities: { roots: {} } });\n    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));\n    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));\n    client.setNotificationHandler(mcpBundle.ProgressNotificationSchema, notification => {\n      if (notification.method === 'notifications/progress') {\n        const { message } = notification.params;\n        if (message)\n          this._progress.push({ type: 'text', text: message });\n      }\n    });\n    const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(url));\n    await client.connect(transport);\n    const { tools } = await client.listTools();\n    return { client, tools, transport };\n  }\n}\n\nconst pushToolsSchema = defineToolSchema({\n  name: 'mdb_push_tools',\n  title: 'Push MCP tools to the tools stack',\n  description: 'Push MCP tools to the tools stack',\n  inputSchema: z.object({\n    mcpUrl: z.string(),\n    introMessage: z.string().optional(),\n  }),\n  type: 'readOnly',\n});\n\nexport async function runMainBackend(backendFactory: mcpServer.ServerBackendFactory, options?: { port?: number }): Promise<string | undefined> {\n  const mdbBackend = new MDBBackend(backendFactory.create(backendFactory.config));\n  // Start HTTP unconditionally.\n  const factory: mcpServer.ServerBackendFactory = {\n    ...backendFactory,\n    create: (cfg) => mdbBackend\n  };\n  const url = await startAsHttp(factory, { port: options?.port || 0 });\n  process.env.PLAYWRIGHT_DEBUGGER_MCP = url;\n\n  if (options?.port !== undefined)\n    return url;\n\n  // Start stdio conditionally.\n  await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);\n}\n\nexport async function runOnPauseBackendLoop(backend: mcpServer.ServerBackend, introMessage: string) {\n  const wrappedBackend = new ServerBackendWithCloseListener(backend);\n\n  const factory: mcpServer.ServerBackendFactory = {\n    name: 'on-pause-backend',\n    nameInConfig: 'on-pause-backend',\n    version: '0.0.0',\n    config: {} as any, // MDB doesn't use config\n    create: () => wrappedBackend,\n  };\n\n  const httpServer = await mcpHttp.startHttpServer({ port: 0 });\n  const url = await mcpHttp.installHttpTransport(httpServer, factory, true);\n\n  const client = new mcpBundle.Client({ name: 'Pushing client', version: '0.0.0' });\n  client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));\n  const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(process.env.PLAYWRIGHT_DEBUGGER_MCP!));\n  await client.connect(transport);\n\n  const pushToolsResult = await client.callTool({\n    name: pushToolsSchema.name,\n    arguments: {\n      mcpUrl: url,\n      introMessage,\n    },\n  });\n  if (pushToolsResult.isError)\n    errorsDebug('Failed to push tools', pushToolsResult.content);\n  await transport.terminateSession();\n  await client.close();\n\n  await wrappedBackend.waitForClosed();\n  httpServer.close();\n}\n\nasync function startAsHttp(backendFactory: mcpServer.ServerBackendFactory, options: { port: number }) {\n  const httpServer = await mcpHttp.startHttpServer(options);\n  return await mcpHttp.installHttpTransport(httpServer, backendFactory, true);\n}\n\n\nclass ServerBackendWithCloseListener implements mcpServer.ServerBackend {\n  private _backend: mcpServer.ServerBackend;\n  private _serverClosedPromise = new ManualPromise<void>();\n\n  constructor(backend: mcpServer.ServerBackend) {\n    this._backend = backend;\n  }\n\n  async initialize(server: mcpServer.Server, clientInfo: mcpServer.ClientInfo): Promise<void> {\n    await this._backend.initialize?.(server, clientInfo);\n  }\n\n  async listTools(): Promise<mcpServer.Tool[]> {\n    return this._backend.listTools();\n  }\n\n  async callTool(name: string, args: mcpServer.CallToolRequest['params']['arguments'], progress: mcpServer.ProgressCallback): Promise<mcpServer.CallToolResult> {\n    return this._backend.callTool(name, args, progress);\n  }\n\n  serverClosed(server: mcpServer.Server) {\n    this._backend.serverClosed?.(server);\n    this._serverClosedPromise.resolve();\n  }\n\n  async waitForClosed() {\n    await this._serverClosedPromise;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["result"]
+}

package/lib/mcp/sdk/proxyBackend.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxyBackend_exports = {};
+__export(proxyBackend_exports, {
+  ProxyBackend: () => ProxyBackend
+});
+module.exports = __toCommonJS(proxyBackend_exports);
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var mcpBundle = __toESM(require("./bundle"));
+const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
+const { z, zodToJsonSchema } = mcpBundle;
+class ProxyBackend {
+  constructor(mcpProviders) {
+    this._mcpProviders = mcpProviders;
+    this._contextSwitchTool = this._defineContextSwitchTool();
+  }
+  async initialize(server, clientInfo) {
+    this._clientInfo = clientInfo;
+  }
+  async listTools() {
+    const currentClient = await this._ensureCurrentClient();
+    const response = await 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);
+    const currentClient = await this._ensureCurrentClient();
+    return await currentClient.callTool({
+      name,
+      arguments: args
+    });
+  }
+  serverClosed() {
+    void this._currentClient?.close().catch(errorsDebug);
+  }
+  async _callContextSwitchTool(params) {
+    try {
+      const factory = this._mcpProviders.find((factory2) => factory2.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
+Error: ${error}
+` }],
+        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 _ensureCurrentClient() {
+    if (this._currentClient)
+      return this._currentClient;
+    return await this._setCurrentClient(this._mcpProviders[0]);
+  }
+  async _setCurrentClient(factory) {
+    await this._currentClient?.close();
+    this._currentClient = void 0;
+    const client = new mcpBundle.Client({ name: "Playwright MCP Proxy", version: "0.0.0" });
+    client.registerCapabilities({
+      roots: {
+        listRoots: true
+      }
+    });
+    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));
+    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    const transport = await factory.connect();
+    await client.connect(transport);
+    this._currentClient = client;
+    return client;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProxyBackend
+});

package/lib/mcp/sdk/proxyBackend.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/proxyBackend.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\n\nimport * as mcpBundle from './bundle';\n\nimport type { ServerBackend, ClientInfo, Server } from './server';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { Tool, CallToolResult, CallToolRequest } from '@modelcontextprotocol/sdk/types.js';\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js';\n\nexport type MCPProvider = {\n  name: string;\n  description: string;\n  connect(): Promise<Transport>;\n};\n\nconst errorsDebug = debug('pw:mcp:errors');\nconst { z, zodToJsonSchema } = mcpBundle;\n\nexport class ProxyBackend implements ServerBackend {\n  private _mcpProviders: MCPProvider[];\n  private _currentClient: Client | undefined;\n  private _contextSwitchTool: Tool;\n  private _clientInfo: ClientInfo | undefined;\n\n  constructor(mcpProviders: MCPProvider[]) {\n    this._mcpProviders = mcpProviders;\n    this._contextSwitchTool = this._defineContextSwitchTool();\n  }\n\n  async initialize(server: Server, clientInfo: ClientInfo): Promise<void> {\n    this._clientInfo = clientInfo;\n  }\n\n  async listTools(): Promise<Tool[]> {\n    const currentClient = await this._ensureCurrentClient();\n    const response = await currentClient.listTools();\n    if (this._mcpProviders.length === 1)\n      return response.tools;\n    return [\n      ...response.tools,\n      this._contextSwitchTool,\n    ];\n  }\n\n  async callTool(name: string, args: CallToolRequest['params']['arguments']): Promise<CallToolResult> {\n    if (name === this._contextSwitchTool.name)\n      return this._callContextSwitchTool(args);\n    const currentClient = await this._ensureCurrentClient();\n    return await currentClient.callTool({\n      name,\n      arguments: args,\n    }) as CallToolResult;\n  }\n\n  serverClosed?(): void {\n    void this._currentClient?.close().catch(errorsDebug);\n  }\n\n  private async _callContextSwitchTool(params: any): Promise<CallToolResult> {\n    try {\n      const factory = this._mcpProviders.find(factory => factory.name === params.name);\n      if (!factory)\n        throw new Error('Unknown connection method: ' + params.name);\n\n      await this._setCurrentClient(factory);\n      return {\n        content: [{ type: 'text', text: '### Result\\nSuccessfully changed connection method.\\n' }],\n      };\n    } catch (error) {\n      return {\n        content: [{ type: 'text', text: `### Result\\nError: ${error}\\n` }],\n        isError: true,\n      };\n    }\n  }\n\n  private _defineContextSwitchTool(): Tool {\n    return {\n      name: 'browser_connect',\n      description: [\n        'Connect to a browser using one of the available methods:',\n        ...this._mcpProviders.map(factory => `- \"${factory.name}\": ${factory.description}`),\n      ].join('\\n'),\n      inputSchema: zodToJsonSchema(z.object({\n        name: z.enum(this._mcpProviders.map(factory => factory.name) as [string, ...string[]]).default(this._mcpProviders[0].name).describe('The method to use to connect to the browser'),\n      }), { strictUnions: true }) as Tool['inputSchema'],\n      annotations: {\n        title: 'Connect to a browser context',\n        readOnlyHint: true,\n        openWorldHint: false,\n      },\n    };\n  }\n\n  private async _ensureCurrentClient(): Promise<Client> {\n    if (this._currentClient)\n      return this._currentClient;\n    return await this._setCurrentClient(this._mcpProviders[0]);\n  }\n\n  private async _setCurrentClient(factory: MCPProvider) {\n    await this._currentClient?.close();\n    this._currentClient = undefined;\n\n    const client = new mcpBundle.Client({ name: 'Playwright MCP Proxy', version: '0.0.0' });\n    client.registerCapabilities({\n      roots: {\n        listRoots: true,\n      },\n    });\n    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));\n    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));\n\n    const transport = await factory.connect();\n    await client.connect(transport);\n    this._currentClient = client;\n    return client;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["factory"]
+}

package/lib/mcp/sdk/server.js

@@ -0,0 +1,190 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  connect: () => connect,
+  createServer: () => createServer,
+  firstRootPath: () => firstRootPath,
+  start: () => start,
+  wrapInProcess: () => wrapInProcess
+});
+module.exports = __toCommonJS(server_exports);
+var import_url = require("url");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var mcpBundle = __toESM(require("./bundle"));
+var import_http = require("./http");
+var import_inProcessTransport = require("./inProcessTransport");
+const serverDebug = (0, import_utilsBundle.debug)("pw:mcp:server");
+async function connect(factory, transport, runHeartbeat, config) {
+  const backend = factory.create(config || factory.config);
+  const server = createServer(factory.name, factory.version, backend, runHeartbeat);
+  await server.connect(transport);
+}
+async function wrapInProcess(backend) {
+  const server = createServer("Internal", "0.0.0", backend, false);
+  return new import_inProcessTransport.InProcessTransport(server);
+}
+function createServer(name, version, backend, runHeartbeat) {
+  const server = new mcpBundle.Server({ name, version }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(mcpBundle.ListToolsRequestSchema, async () => {
+    serverDebug("listTools");
+    const tools = await backend.listTools();
+    return { tools };
+  });
+  let initializePromise;
+  server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request, extra) => {
+    serverDebug("callTool", request);
+    const progressToken = request.params._meta?.progressToken;
+    let progressCounter = 0;
+    const progress = progressToken ? (params) => {
+      extra.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress: params.progress ?? ++progressCounter,
+          total: params.total,
+          message: params.message
+        }
+      }).catch(serverDebug);
+    } : () => {
+    };
+    try {
+      if (!initializePromise)
+        initializePromise = initializeServer(server, backend, runHeartbeat);
+      await initializePromise;
+      return mergeTextParts(await backend.callTool(request.params.name, request.params.arguments || {}, progress));
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: "### Result\n" + String(error) }],
+        isError: true
+      };
+    }
+  });
+  addServerListener(server, "close", () => backend.serverClosed?.(server));
+  return server;
+}
+const initializeServer = async (server, backend, runHeartbeat) => {
+  const capabilities = server.getClientCapabilities();
+  let clientRoots = [];
+  if (capabilities?.roots) {
+    const { roots } = await server.listRoots().catch((e) => {
+      serverDebug(e);
+      return { roots: [] };
+    });
+    clientRoots = roots;
+  }
+  const clientInfo = {
+    name: server.getClientVersion()?.name ?? "unknown",
+    version: server.getClientVersion()?.version ?? "unknown",
+    roots: clientRoots,
+    timestamp: Date.now()
+  };
+  await backend.initialize?.(server, clientInfo);
+  if (runHeartbeat)
+    startHeartbeat(server);
+};
+const startHeartbeat = (server) => {
+  const beat = () => {
+    Promise.race([
+      server.ping(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("ping timeout")), 5e3))
+    ]).then(() => {
+      setTimeout(beat, 3e3);
+    }).catch(() => {
+      void server.close();
+    });
+  };
+  beat();
+};
+function addServerListener(server, event, listener) {
+  const oldListener = server[`on${event}`];
+  server[`on${event}`] = () => {
+    oldListener?.();
+    listener();
+  };
+}
+async function start(serverBackendFactory, options) {
+  if (options.port === void 0) {
+    await connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
+    return;
+  }
+  const httpServer = await (0, import_http.startHttpServer)(options);
+  const url = await (0, import_http.installHttpTransport)(httpServer, serverBackendFactory, false, options.allowedHosts);
+  const mcpConfig = { mcpServers: {} };
+  mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {
+    url: `${url}/mcp`
+  };
+  const message = [
+    `Listening on ${url}`,
+    "Put this in your client config:",
+    JSON.stringify(mcpConfig, void 0, 2),
+    "For legacy SSE transport support, you can use the /sse endpoint instead."
+  ].join("\n");
+  console.error(message);
+}
+function firstRootPath(clientInfo) {
+  if (clientInfo.roots.length === 0)
+    return void 0;
+  const firstRootUri = clientInfo.roots[0]?.uri;
+  const url = firstRootUri ? new URL(firstRootUri) : void 0;
+  return url ? (0, import_url.fileURLToPath)(url) : void 0;
+}
+function mergeTextParts(result) {
+  const content = [];
+  const testParts = [];
+  for (const part of result.content) {
+    if (part.type === "text") {
+      testParts.push(part.text);
+      continue;
+    }
+    if (testParts.length > 0) {
+      content.push({ type: "text", text: testParts.join("\n") });
+      testParts.length = 0;
+    }
+    content.push(part);
+  }
+  if (testParts.length > 0)
+    content.push({ type: "text", text: testParts.join("\n") });
+  return {
+    ...result,
+    content
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connect,
+  createServer,
+  firstRootPath,
+  start,
+  wrapInProcess
+});