playwright 1.55.1 → 1.56.1

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

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 bundle_exports = {};
 __export(bundle_exports, {
@@ -23,23 +33,31 @@ __export(bundle_exports, {
   ListRootsRequestSchema: () => ListRootsRequestSchema,
   ListToolsRequestSchema: () => ListToolsRequestSchema,
   PingRequestSchema: () => PingRequestSchema,
+  ProgressNotificationSchema: () => ProgressNotificationSchema,
+  SSEClientTransport: () => SSEClientTransport,
   SSEServerTransport: () => SSEServerTransport,
   Server: () => Server,
+  StdioClientTransport: () => StdioClientTransport,
   StdioServerTransport: () => StdioServerTransport,
+  StreamableHTTPClientTransport: () => StreamableHTTPClientTransport,
   StreamableHTTPServerTransport: () => StreamableHTTPServerTransport,
   z: () => z,
   zodToJsonSchema: () => zodToJsonSchema
 });
 module.exports = __toCommonJS(bundle_exports);
-const bundle = require("./mcpBundleImpl");
-const zodToJsonSchema = require("./mcpBundleImpl").zodToJsonSchema;
+var bundle = __toESM(require("../../mcpBundleImpl"));
+const zodToJsonSchema = bundle.zodToJsonSchema;
 const Client = bundle.Client;
 const Server = bundle.Server;
+const SSEClientTransport = bundle.SSEClientTransport;
 const SSEServerTransport = bundle.SSEServerTransport;
+const StdioClientTransport = bundle.StdioClientTransport;
 const StdioServerTransport = bundle.StdioServerTransport;
 const StreamableHTTPServerTransport = bundle.StreamableHTTPServerTransport;
+const StreamableHTTPClientTransport = bundle.StreamableHTTPClientTransport;
 const CallToolRequestSchema = bundle.CallToolRequestSchema;
 const ListRootsRequestSchema = bundle.ListRootsRequestSchema;
+const ProgressNotificationSchema = bundle.ProgressNotificationSchema;
 const ListToolsRequestSchema = bundle.ListToolsRequestSchema;
 const PingRequestSchema = bundle.PingRequestSchema;
 const z = bundle.z;
@@ -50,9 +68,13 @@ const z = bundle.z;
   ListRootsRequestSchema,
   ListToolsRequestSchema,
   PingRequestSchema,
+  ProgressNotificationSchema,
+  SSEClientTransport,
   SSEServerTransport,
   Server,
+  StdioClientTransport,
   StdioServerTransport,
+  StreamableHTTPClientTransport,
   StreamableHTTPServerTransport,
   z,
   zodToJsonSchema

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

@@ -15,16 +15,18 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var exports_exports = {};
 module.exports = __toCommonJS(exports_exports);
-__reExport(exports_exports, require("./inProcessTransport.js"), module.exports);
-__reExport(exports_exports, require("./proxyBackend.js"), module.exports);
-__reExport(exports_exports, require("./server.js"), module.exports);
-__reExport(exports_exports, require("./tool.js"), module.exports);
-__reExport(exports_exports, require("./transport.js"), module.exports);
+__reExport(exports_exports, require("./inProcessTransport"), module.exports);
+__reExport(exports_exports, require("./proxyBackend"), module.exports);
+__reExport(exports_exports, require("./server"), module.exports);
+__reExport(exports_exports, require("./tool"), module.exports);
+__reExport(exports_exports, require("./http"), module.exports);
+__reExport(exports_exports, require("./mdb"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./inProcessTransport.js"),
-  ...require("./proxyBackend.js"),
-  ...require("./server.js"),
-  ...require("./tool.js"),
-  ...require("./transport.js")
+  ...require("./inProcessTransport"),
+  ...require("./proxyBackend"),
+  ...require("./server"),
+  ...require("./tool"),
+  ...require("./http"),
+  ...require("./mdb")
 });

package/lib/mcp/{transport.js → sdk/http.js}

@@ -26,29 +26,79 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var transport_exports = {};
-__export(transport_exports, {
-  start: () => start
+var http_exports = {};
+__export(http_exports, {
+  httpAddressToString: () => httpAddressToString,
+  installHttpTransport: () => installHttpTransport,
+  startHttpServer: () => startHttpServer
 });
-module.exports = __toCommonJS(transport_exports);
+module.exports = __toCommonJS(http_exports);
 var import_assert = __toESM(require("assert"));
 var import_http = __toESM(require("http"));
 var import_crypto = __toESM(require("crypto"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var mcpBundle = __toESM(require("./bundle"));
 var mcpServer = __toESM(require("./server"));
-async function start(serverBackendFactory, options) {
-  if (options.port !== void 0) {
-    const httpServer = await startHttpServer(options);
-    startHttpTransport(httpServer, serverBackendFactory);
-  } else {
-    await startStdioTransport(serverBackendFactory);
-  }
+const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+async function startHttpServer(config, abortSignal) {
+  const { host, port } = config;
+  const httpServer = import_http.default.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;
 }
-async function startStdioTransport(serverBackendFactory) {
-  await mcpServer.connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
+function httpAddressToString(address) {
+  (0, import_assert.default)(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}`;
+}
+async function installHttpTransport(httpServer, serverBackendFactory, allowedHosts) {
+  const url = httpAddressToString(httpServer.address());
+  const host = new URL(url).host;
+  allowedHosts = (allowedHosts || [host]).map((h) => h.toLowerCase());
+  const allowAnyHost = allowedHosts.includes("*");
+  const sseSessions = /* @__PURE__ */ new Map();
+  const streamableSessions = /* @__PURE__ */ new Map();
+  httpServer.on("request", async (req, res) => {
+    if (!allowAnyHost) {
+      const host2 = req.headers.host?.toLowerCase();
+      if (!host2) {
+        res.statusCode = 400;
+        return res.end("Missing host");
+      }
+      if (!allowedHosts.includes(host2)) {
+        res.statusCode = 403;
+        return res.end("Access is only allowed at " + allowedHosts.join(", "));
+      }
+    }
+    const url2 = new URL(`http://localhost${req.url}`);
+    if (url2.pathname === "/killkillkill" && req.method === "GET") {
+      res.statusCode = 200;
+      res.end("Killing process");
+      process.emit("SIGINT");
+      return;
+    }
+    if (url2.pathname.startsWith("/sse"))
+      await handleSSE(serverBackendFactory, req, res, url2, sseSessions);
+    else
+      await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+  });
 }
-const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
 async function handleSSE(serverBackendFactory, req, res, url, sessions) {
   if (req.method === "POST") {
     const sessionId = url.searchParams.get("sessionId");
@@ -108,54 +158,23 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
   res.statusCode = 400;
   res.end("Invalid request");
 }
-function startHttpTransport(httpServer, serverBackendFactory) {
-  const sseSessions = /* @__PURE__ */ new Map();
-  const streamableSessions = /* @__PURE__ */ new Map();
-  httpServer.on("request", async (req, res) => {
-    const url2 = new URL(`http://localhost${req.url}`);
-    if (url2.pathname.startsWith("/sse"))
-      await handleSSE(serverBackendFactory, req, res, url2, sseSessions);
-    else
-      await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+function decorateServer(server) {
+  const sockets = /* @__PURE__ */ new Set();
+  server.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
   });
-  const url = httpAddressToString(httpServer.address());
-  const message = [
-    `Listening on ${url}`,
-    "Put this in your client config:",
-    JSON.stringify({
-      "mcpServers": {
-        "playwright": {
-          "url": `${url}/mcp`
-        }
-      }
-    }, void 0, 2),
-    "For legacy SSE transport support, you can use the /sse endpoint instead."
-  ].join("\n");
-  console.error(message);
-}
-async function startHttpServer(config) {
-  const { host, port } = config;
-  const httpServer = import_http.default.createServer();
-  await new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, host, () => {
-      resolve();
-      httpServer.removeListener("error", reject);
-    });
-  });
-  return httpServer;
-}
-function httpAddressToString(address) {
-  (0, import_assert.default)(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}`;
+  const close = server.close;
+  server.close = (callback) => {
+    for (const socket of sockets)
+      socket.destroy();
+    sockets.clear();
+    return close.call(server, callback);
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  start
+  httpAddressToString,
+  installHttpTransport,
+  startHttpServer
 });

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());
+  const factory = {
+    ...backendFactory,
+    create: () => 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",
+    create: () => wrappedBackend
+  };
+  const httpServer = await mcpHttp.startHttpServer({ port: 0 });
+  await mcpHttp.installHttpTransport(httpServer, factory);
+  const url = mcpHttp.httpAddressToString(httpServer.address());
+  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);
+  await mcpHttp.installHttpTransport(httpServer, backendFactory);
+  return mcpHttp.httpAddressToString(httpServer.address());
+}
+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/{proxyBackend.js → sdk/proxyBackend.js}

@@ -34,20 +34,18 @@ 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(name, version, mcpProviders) {
-    this._roots = [];
-    this.name = name;
-    this.version = version;
+  constructor(mcpProviders) {
     this._mcpProviders = mcpProviders;
     this._contextSwitchTool = this._defineContextSwitchTool();
   }
-  async initialize(clientVersion, roots) {
-    this._roots = roots;
-    await this._setCurrentClient(this._mcpProviders[0]);
+  async initialize(server, clientInfo) {
+    this._clientInfo = clientInfo;
   }
   async listTools() {
-    const response = await this._currentClient.listTools();
+    const currentClient = await this._ensureCurrentClient();
+    const response = await currentClient.listTools();
     if (this._mcpProviders.length === 1)
       return response.tools;
     return [
@@ -58,7 +56,8 @@ class ProxyBackend {
   async callTool(name, args) {
     if (name === this._contextSwitchTool.name)
       return this._callContextSwitchTool(args);
-    return await this._currentClient.callTool({
+    const currentClient = await this._ensureCurrentClient();
+    return await currentClient.callTool({
       name,
       arguments: args
     });
@@ -91,8 +90,8 @@ Error: ${error}
         "Connect to a browser using one of the available methods:",
         ...this._mcpProviders.map((factory) => `- "${factory.name}": ${factory.description}`)
       ].join("\n"),
-      inputSchema: mcpBundle.zodToJsonSchema(mcpBundle.z.object({
-        name: mcpBundle.z.enum(this._mcpProviders.map((factory) => factory.name)).default(this._mcpProviders[0].name).describe("The method to use to connect to the browser")
+      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",
@@ -101,20 +100,26 @@ Error: ${error}
       }
     };
   }
+  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: this.name, version: this.version });
+    const client = new mcpBundle.Client({ name: "Playwright MCP Proxy", version: "0.0.0" });
     client.registerCapabilities({
       roots: {
         listRoots: true
       }
     });
-    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._roots }));
+    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: