rechrome 1.18.1 → 1.20.0

package/vendor/playwright-cli/node_modules/playwright-core/lib/tools/mcp/browserFactory.js

@@ -0,0 +1,233 @@
+"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 browserFactory_exports = {};
+__export(browserFactory_exports, {
+  createBrowser: () => createBrowser,
+  createBrowserWithInfo: () => createBrowserWithInfo,
+  isProfileLocked: () => isProfileLocked
+});
+module.exports = __toCommonJS(browserFactory_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var playwright = __toESM(require("../../.."));
+var import_registry = require("../../server/registry/index");
+var import_log = require("./log");
+var import_context = require("../backend/context");
+var import_extensionContextFactory = require("./extensionContextFactory");
+var import_connect = require("../utils/connect");
+var import_serverRegistry = require("../../serverRegistry");
+var import_connect2 = require("../../client/connect");
+async function createBrowser(config, clientInfo) {
+  const { browser } = await createBrowserWithInfo(config, clientInfo);
+  return browser;
+}
+async function createBrowserWithInfo(config, clientInfo) {
+  if (config.browser.remoteEndpoint)
+    return await createRemoteBrowser(config);
+  let browser;
+  if (config.browser.cdpEndpoint)
+    browser = await createCDPBrowser(config, clientInfo);
+  else if (config.browser.isolated)
+    browser = await createIsolatedBrowser(config, clientInfo);
+  else if (config.extension)
+    browser = await (0, import_extensionContextFactory.createExtensionBrowser)(config, clientInfo);
+  else
+    browser = await createPersistentBrowser(config, clientInfo);
+  return { browser, browserInfo: browserInfo(browser, config) };
+}
+function browserInfo(browser, config) {
+  return {
+    // eslint-disable-next-line no-restricted-syntax
+    guid: browser._guid,
+    browserName: config.browser.browserName,
+    launchOptions: config.browser.launchOptions,
+    userDataDir: config.browser.userDataDir
+  };
+}
+async function createIsolatedBrowser(config, clientInfo) {
+  (0, import_log.testDebug)("create browser (isolated)");
+  await injectCdpPort(config.browser);
+  const browserType = playwright[config.browser.browserName];
+  const tracesDir = await computeTracesDir(config, clientInfo);
+  const browser = await browserType.launch({
+    tracesDir,
+    ...config.browser.launchOptions,
+    handleSIGINT: false,
+    handleSIGTERM: false
+  }).catch((error) => {
+    if (error.message.includes("Executable doesn't exist"))
+      throwBrowserIsNotInstalledError(config);
+    throw error;
+  });
+  await startServer(browser, clientInfo);
+  return browser;
+}
+async function createCDPBrowser(config, clientInfo) {
+  (0, import_log.testDebug)("create browser (cdp)");
+  const browser = await playwright.chromium.connectOverCDP(config.browser.cdpEndpoint, {
+    headers: config.browser.cdpHeaders,
+    timeout: config.browser.cdpTimeout
+  });
+  await startServer(browser, clientInfo);
+  return browser;
+}
+async function createRemoteBrowser(config) {
+  (0, import_log.testDebug)("create browser (remote)");
+  const descriptor = await import_serverRegistry.serverRegistry.find(config.browser.remoteEndpoint);
+  if (descriptor) {
+    const browser2 = await (0, import_connect.connectToBrowserAcrossVersions)(descriptor);
+    return {
+      browser: browser2,
+      browserInfo: {
+        guid: descriptor.browser.guid,
+        browserName: descriptor.browser.browserName,
+        launchOptions: descriptor.browser.launchOptions,
+        userDataDir: descriptor.browser.userDataDir
+      }
+    };
+  }
+  const endpoint = config.browser.remoteEndpoint;
+  const playwrightObject = playwright;
+  const browser = await (0, import_connect2.connectToBrowser)(playwrightObject, { endpoint });
+  browser._connectToBrowserType(playwrightObject[browser._browserName], {}, void 0);
+  return { browser, browserInfo: browserInfo(browser, config) };
+}
+async function createPersistentBrowser(config, clientInfo) {
+  (0, import_log.testDebug)("create browser (persistent)");
+  await injectCdpPort(config.browser);
+  const userDataDir = config.browser.userDataDir ?? await createUserDataDir(config, clientInfo);
+  const tracesDir = await computeTracesDir(config, clientInfo);
+  if (await isProfileLocked5Times(userDataDir))
+    throw new Error(`Browser is already in use for ${userDataDir}, use --isolated to run multiple instances of the same browser`);
+  const browserType = playwright[config.browser.browserName];
+  const launchOptions = {
+    tracesDir,
+    ...config.browser.launchOptions,
+    ...config.browser.contextOptions,
+    handleSIGINT: false,
+    handleSIGTERM: false,
+    ignoreDefaultArgs: [
+      "--disable-extensions"
+    ]
+  };
+  try {
+    const browserContext = await browserType.launchPersistentContext(userDataDir, launchOptions);
+    const browser = browserContext.browser();
+    await startServer(browser, clientInfo);
+    return browser;
+  } catch (error) {
+    if (error.message.includes("Executable doesn't exist"))
+      throwBrowserIsNotInstalledError(config);
+    if (error.message.includes("cannot open shared object file: No such file or directory")) {
+      const browserName = launchOptions.channel ?? config.browser.browserName;
+      throw new Error(`Missing system dependencies required to run browser ${browserName}. Install them with: sudo npx playwright install-deps ${browserName}`);
+    }
+    if (error.message.includes("ProcessSingleton") || error.message.includes("exitCode=21"))
+      throw new Error(`Browser is already in use for ${userDataDir}, use --isolated to run multiple instances of the same browser`);
+    throw error;
+  }
+}
+async function createUserDataDir(config, clientInfo) {
+  const dir = process.env.PWMCP_PROFILES_DIR_FOR_TEST ?? import_registry.registryDirectory;
+  const browserToken = config.browser.launchOptions?.channel ?? config.browser?.browserName;
+  const rootPathToken = createHash(clientInfo.cwd);
+  const result = import_path.default.join(dir, `mcp-${browserToken}-${rootPathToken}`);
+  await import_fs.default.promises.mkdir(result, { recursive: true });
+  return result;
+}
+async function injectCdpPort(browserConfig) {
+  if (browserConfig.browserName === "chromium")
+    browserConfig.launchOptions.cdpPort = await findFreePort();
+}
+async function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = import_net.default.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+function createHash(data) {
+  return import_crypto.default.createHash("sha256").update(data).digest("hex").slice(0, 7);
+}
+async function computeTracesDir(config, clientInfo) {
+  return import_path.default.resolve((0, import_context.outputDir)({ config, cwd: clientInfo.cwd }), "traces");
+}
+async function isProfileLocked5Times(userDataDir) {
+  for (let i = 0; i < 5; i++) {
+    if (!isProfileLocked(userDataDir))
+      return false;
+    await new Promise((f) => setTimeout(f, 1e3));
+  }
+  return true;
+}
+function isProfileLocked(userDataDir) {
+  const lockFile = process.platform === "win32" ? "lockfile" : "SingletonLock";
+  const lockPath = import_path.default.join(userDataDir, lockFile);
+  if (process.platform === "win32") {
+    try {
+      const fd = import_fs.default.openSync(lockPath, "r+");
+      import_fs.default.closeSync(fd);
+      return false;
+    } catch (e) {
+      return e.code !== "ENOENT";
+    }
+  }
+  try {
+    const target = import_fs.default.readlinkSync(lockPath);
+    const pid = parseInt(target.split("-").pop() || "", 10);
+    if (isNaN(pid))
+      return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function throwBrowserIsNotInstalledError(config) {
+  const channel = config.browser.launchOptions?.channel ?? config.browser.browserName;
+  if (config.skillMode)
+    throw new Error(`Browser "${channel}" is not installed. Run \`playwright-cli install-browser ${channel}\` to install`);
+  else
+    throw new Error(`Browser "${channel}" is not installed. Run \`npx @playwright/mcp install-browser ${channel}\` to install`);
+}
+async function startServer(browser, clientInfo) {
+  if (clientInfo.sessionName)
+    await browser._register(clientInfo.sessionName, { workspaceDir: clientInfo.workspaceDir });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrowser,
+  createBrowserWithInfo,
+  isProfileLocked
+});

package/vendor/playwright-cli/node_modules/playwright-core/lib/tools/mcp/cdpRelay.js

@@ -0,0 +1,356 @@
+"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 cdpRelay_exports = {};
+__export(cdpRelay_exports, {
+  CDPRelayServer: () => CDPRelayServer
+});
+module.exports = __toCommonJS(cdpRelay_exports);
+var import_child_process = require("child_process");
+var import_os = __toESM(require("os"));
+var import_utilsBundle = require("../../utilsBundle");
+var import_registry = require("../../server/registry/index");
+var import_manualPromise = require("../../utils/isomorphic/manualPromise");
+var import_http2 = require("../utils/mcp/http");
+var import_log = require("./log");
+var protocol = __toESM(require("./protocol"));
+const debugLogger = (0, import_utilsBundle.debug)("pw:mcp:relay");
+class CDPRelayServer {
+  constructor(server, browserChannel, userDataDir, executablePath) {
+    this._playwrightConnection = null;
+    this._extensionConnection = null;
+    this._nextSessionId = 1;
+    this._wsHost = (0, import_http2.addressToString)(server.address(), { protocol: "ws" });
+    this._browserChannel = browserChannel;
+    this._userDataDir = userDataDir;
+    this._executablePath = executablePath;
+    const uuid = crypto.randomUUID();
+    this._cdpPath = `/cdp/${uuid}`;
+    this._extensionPath = `/extension/${uuid}`;
+    this._resetExtensionConnection();
+    this._wss = new import_utilsBundle.wsServer({ server });
+    this._wss.on("connection", this._onConnection.bind(this));
+  }
+  cdpEndpoint() {
+    return `${this._wsHost}${this._cdpPath}`;
+  }
+  extensionEndpoint() {
+    return `${this._wsHost}${this._extensionPath}`;
+  }
+  async ensureExtensionConnectionForMCPContext(clientInfo, forceNewTab) {
+    debugLogger("Ensuring extension connection for MCP context");
+    if (this._extensionConnection)
+      return;
+    this._connectBrowser(clientInfo, forceNewTab);
+    debugLogger("Waiting for incoming extension connection");
+    await Promise.race([
+      this._extensionConnectionPromise,
+      new Promise((_, reject) => setTimeout(() => {
+        reject(new Error(`Extension connection timeout. Make sure the "Playwright MCP Bridge" extension is installed. See https://github.com/microsoft/playwright-mcp/blob/main/packages/extension/README.md for installation instructions.`));
+      }, process.env.PWMCP_TEST_CONNECTION_TIMEOUT ? parseInt(process.env.PWMCP_TEST_CONNECTION_TIMEOUT, 10) : 5e3))
+    ]);
+    debugLogger("Extension connection established");
+  }
+  _connectBrowser(clientInfo, forceNewTab) {
+    const mcpRelayEndpoint = `${this._wsHost}${this._extensionPath}`;
+    const extensionId = process.env.PLAYWRIGHT_MCP_EXTENSION_ID ?? "mmlmfjhmonkocbjadbfplnigmagldckm";
+    const url = new URL(`chrome-extension://${extensionId}/connect.html`);
+    url.searchParams.set("mcpRelayUrl", mcpRelayEndpoint);
+    const client = {
+      name: "Playwright Agent",
+      version: require("../../../package.json").version
+    };
+    url.searchParams.set("client", JSON.stringify(client));
+    url.searchParams.set("protocolVersion", process.env.PWMCP_TEST_PROTOCOL_VERSION ?? protocol.VERSION.toString());
+    if (forceNewTab)
+      url.searchParams.set("newTab", "true");
+    const token = process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
+    if (token)
+      url.searchParams.set("token", token);
+    const href = url.toString();
+    let executablePath = this._executablePath;
+    if (!executablePath) {
+      const executableInfo = import_registry.registry.findExecutable(this._browserChannel);
+      if (!executableInfo)
+        throw new Error(`Unsupported channel: "${this._browserChannel}"`);
+      executablePath = executableInfo.executablePath();
+      if (!executablePath)
+        throw new Error(`"${this._browserChannel}" executable not found. Make sure it is installed at a standard location.`);
+    }
+    const args = [];
+    if (this._userDataDir)
+      args.push(`--user-data-dir=${this._userDataDir}`);
+    if (process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY)
+      args.push(`--profile-directory=${process.env.PLAYWRIGHT_MCP_PROFILE_DIRECTORY}`);
+    if (import_os.default.platform() === "linux" && this._browserChannel === "chromium")
+      args.push("--no-sandbox");
+    args.push(href);
+    (0, import_child_process.spawn)(executablePath, args, {
+      windowsHide: true,
+      detached: true,
+      shell: false,
+      stdio: "ignore"
+    });
+  }
+  stop() {
+    this.closeConnections("Server stopped");
+    this._wss.close();
+  }
+  closeConnections(reason) {
+    this._closePlaywrightConnection(reason);
+    this._closeExtensionConnection(reason);
+  }
+  _onConnection(ws2, request) {
+    const url = new URL(`http://localhost${request.url}`);
+    debugLogger(`New connection to ${url.pathname}`);
+    if (url.pathname === this._cdpPath) {
+      this._handlePlaywrightConnection(ws2);
+    } else if (url.pathname === this._extensionPath) {
+      this._handleExtensionConnection(ws2);
+    } else {
+      debugLogger(`Invalid path: ${url.pathname}`);
+      ws2.close(4004, "Invalid path");
+    }
+  }
+  _handlePlaywrightConnection(ws2) {
+    if (this._playwrightConnection) {
+      debugLogger("Rejecting second Playwright connection");
+      ws2.close(1e3, "Another CDP client already connected");
+      return;
+    }
+    this._playwrightConnection = ws2;
+    ws2.on("message", async (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        await this._handlePlaywrightMessage(message);
+      } catch (error) {
+        debugLogger(`Error while handling Playwright message
+${data.toString()}
+`, error);
+      }
+    });
+    ws2.on("close", () => {
+      if (this._playwrightConnection !== ws2)
+        return;
+      this._playwrightConnection = null;
+      this._closeExtensionConnection("Playwright client disconnected");
+      debugLogger("Playwright WebSocket closed");
+    });
+    ws2.on("error", (error) => {
+      debugLogger("Playwright WebSocket error:", error);
+    });
+    debugLogger("Playwright MCP connected");
+  }
+  _closeExtensionConnection(reason) {
+    this._extensionConnection?.close(reason);
+    this._extensionConnectionPromise.reject(new Error(reason));
+    this._resetExtensionConnection();
+  }
+  _resetExtensionConnection() {
+    this._connectedTabInfo = void 0;
+    this._extensionConnection = null;
+    this._extensionConnectionPromise = new import_manualPromise.ManualPromise();
+    void this._extensionConnectionPromise.catch(import_log.logUnhandledError);
+  }
+  _closePlaywrightConnection(reason) {
+    if (this._playwrightConnection?.readyState === import_utilsBundle.ws.OPEN)
+      this._playwrightConnection.close(1e3, reason);
+    this._playwrightConnection = null;
+  }
+  _handleExtensionConnection(ws2) {
+    if (this._extensionConnection) {
+      ws2.close(1e3, "Another extension connection already established");
+      return;
+    }
+    this._extensionConnection = new ExtensionConnection(ws2);
+    this._extensionConnection.onclose = (c, reason) => {
+      debugLogger("Extension WebSocket closed:", reason, c === this._extensionConnection);
+      if (this._extensionConnection !== c)
+        return;
+      this._resetExtensionConnection();
+      this._closePlaywrightConnection(`Extension disconnected: ${reason}`);
+    };
+    this._extensionConnection.onmessage = this._handleExtensionMessage.bind(this);
+    this._extensionConnectionPromise.resolve();
+  }
+  _handleExtensionMessage(method, params) {
+    switch (method) {
+      case "forwardCDPEvent":
+        const sessionId = params.sessionId || this._connectedTabInfo?.sessionId;
+        this._sendToPlaywright({
+          sessionId,
+          method: params.method,
+          params: params.params
+        });
+        break;
+    }
+  }
+  async _handlePlaywrightMessage(message) {
+    debugLogger("\u2190 Playwright:", `${message.method} (id=${message.id})`);
+    const { id, sessionId, method, params } = message;
+    try {
+      const result = await this._handleCDPCommand(method, params, sessionId);
+      this._sendToPlaywright({ id, sessionId, result });
+    } catch (e) {
+      debugLogger("Error in the extension:", e);
+      this._sendToPlaywright({
+        id,
+        sessionId,
+        error: { message: e.message }
+      });
+    }
+  }
+  async _handleCDPCommand(method, params, sessionId) {
+    switch (method) {
+      case "Browser.getVersion": {
+        return {
+          protocolVersion: "1.3",
+          product: "Chrome/Extension-Bridge",
+          userAgent: "CDP-Bridge-Server/1.0.0"
+        };
+      }
+      case "Browser.setDownloadBehavior": {
+        return {};
+      }
+      case "Target.setAutoAttach": {
+        if (sessionId)
+          break;
+        const { targetInfo } = await this._extensionConnection.send("attachToTab", {});
+        this._connectedTabInfo = {
+          targetInfo,
+          sessionId: `pw-tab-${this._nextSessionId++}`
+        };
+        debugLogger("Simulating auto-attach");
+        this._sendToPlaywright({
+          method: "Target.attachedToTarget",
+          params: {
+            sessionId: this._connectedTabInfo.sessionId,
+            targetInfo: {
+              ...this._connectedTabInfo.targetInfo,
+              attached: true
+            },
+            waitingForDebugger: false
+          }
+        });
+        return {};
+      }
+      case "Target.getTargetInfo": {
+        return this._connectedTabInfo?.targetInfo;
+      }
+    }
+    return await this._forwardToExtension(method, params, sessionId);
+  }
+  async _forwardToExtension(method, params, sessionId) {
+    if (!this._extensionConnection)
+      throw new Error("Extension not connected");
+    if (this._connectedTabInfo?.sessionId === sessionId)
+      sessionId = void 0;
+    return await this._extensionConnection.send("forwardCDPCommand", { sessionId, method, params });
+  }
+  _sendToPlaywright(message) {
+    debugLogger("\u2192 Playwright:", `${message.method ?? `response(id=${message.id})`}`);
+    this._playwrightConnection?.send(JSON.stringify(message));
+  }
+}
+class ExtensionConnection {
+  constructor(ws2) {
+    this._callbacks = /* @__PURE__ */ new Map();
+    this._lastId = 0;
+    this._ws = ws2;
+    this._ws.on("message", this._onMessage.bind(this));
+    this._ws.on("close", this._onClose.bind(this));
+    this._ws.on("error", this._onError.bind(this));
+  }
+  async send(method, params) {
+    if (this._ws.readyState !== import_utilsBundle.ws.OPEN)
+      throw new Error(`Unexpected WebSocket state: ${this._ws.readyState}`);
+    const id = ++this._lastId;
+    this._ws.send(JSON.stringify({ id, method, params }));
+    const error = new Error(`Protocol error: ${method}`);
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(id, { resolve, reject, error });
+    });
+  }
+  close(message) {
+    debugLogger("closing extension connection:", message);
+    if (this._ws.readyState === import_utilsBundle.ws.OPEN)
+      this._ws.close(1e3, message);
+  }
+  _onMessage(event) {
+    const eventData = event.toString();
+    let parsedJson;
+    try {
+      parsedJson = JSON.parse(eventData);
+    } catch (e) {
+      debugLogger(`<closing ws> Closing websocket due to malformed JSON. eventData=${eventData} e=${e?.message}`);
+      this._ws.close();
+      return;
+    }
+    try {
+      this._handleParsedMessage(parsedJson);
+    } catch (e) {
+      debugLogger(`<closing ws> Closing websocket due to failed onmessage callback. eventData=${eventData} e=${e?.message}`);
+      this._ws.close();
+    }
+  }
+  _handleParsedMessage(object) {
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.error) {
+        const error = callback.error;
+        error.message = object.error;
+        callback.reject(error);
+      } else {
+        callback.resolve(object.result);
+      }
+    } else if (object.id) {
+      debugLogger("\u2190 Extension: unexpected response", object);
+    } else {
+      this.onmessage?.(object.method, object.params);
+    }
+  }
+  _onClose(event) {
+    debugLogger(`<ws closed> code=${event.code} reason=${event.reason}`);
+    this._dispose();
+    this.onclose?.(this, event.reason);
+  }
+  _onError(event) {
+    debugLogger(`<ws error> message=${event.message} type=${event.type} target=${event.target}`);
+    this._dispose();
+  }
+  _dispose() {
+    for (const callback of this._callbacks.values())
+      callback.reject(new Error("WebSocket closed"));
+    this._callbacks.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CDPRelayServer
+});

package/vendor/playwright-cli/node_modules/playwright-core/lib/tools/mcp/cli-stub.js

@@ -0,0 +1,7 @@
+"use strict";
+var import_utilsBundle = require("../../utilsBundle");
+var import_program = require("./program");
+const packageJSON = require("../../../package.json");
+const p = import_utilsBundle.program.version("Version " + packageJSON.version).name("Playwright MCP");
+(0, import_program.decorateMCPCommand)(p);
+void import_utilsBundle.program.parseAsync(process.argv);

package/vendor/playwright-cli/node_modules/playwright-core/lib/tools/mcp/config.d.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 config_d_exports = {};
+module.exports = __toCommonJS(config_d_exports);