@cotestdev/mcp_playwright 0.0.51 → 0.0.53

package/lib/mcp/sdk/bundle.js

@@ -1,75 +0,0 @@
-"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 bundle_exports = {};
-__export(bundle_exports, {
-  CallToolRequestSchema: () => CallToolRequestSchema,
-  Client: () => Client,
-  ListRootsRequestSchema: () => ListRootsRequestSchema,
-  ListToolsRequestSchema: () => ListToolsRequestSchema,
-  PingRequestSchema: () => PingRequestSchema,
-  SSEServerTransport: () => SSEServerTransport,
-  Server: () => Server,
-  StdioClientTransport: () => StdioClientTransport,
-  StdioServerTransport: () => StdioServerTransport,
-  StreamableHTTPClientTransport: () => StreamableHTTPClientTransport,
-  StreamableHTTPServerTransport: () => StreamableHTTPServerTransport,
-  z: () => z,
-  zodToJsonSchema: () => zodToJsonSchema
-});
-module.exports = __toCommonJS(bundle_exports);
-var bundle = __toESM(require("../../mcpBundle"));
-const zodToJsonSchema = bundle.zodToJsonSchema;
-const Client = bundle.Client;
-const Server = bundle.Server;
-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 ListToolsRequestSchema = bundle.ListToolsRequestSchema;
-const PingRequestSchema = bundle.PingRequestSchema;
-const z = bundle.z;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CallToolRequestSchema,
-  Client,
-  ListRootsRequestSchema,
-  ListToolsRequestSchema,
-  PingRequestSchema,
-  SSEServerTransport,
-  Server,
-  StdioClientTransport,
-  StdioServerTransport,
-  StreamableHTTPClientTransport,
-  StreamableHTTPServerTransport,
-  z,
-  zodToJsonSchema
-});

package/lib/mcp/sdk/mdb.js

@@ -1,208 +0,0 @@
-"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"));
-var import_server = require("./server");
-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(topLevelBackend) {
-    this._stack = [];
-    this._topLevelBackend = topLevelBackend;
-  }
-  async initialize(server, clientInfo) {
-    if (!this._clientInfo)
-      this._clientInfo = clientInfo;
-  }
-  async listTools() {
-    const client = await this._client();
-    const response = await client.listTools();
-    return response.tools;
-  }
-  async callTool(name, args) {
-    await this._client();
-    if (name === pushToolsSchema.name)
-      return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
-    const interruptPromise = new import_utils.ManualPromise();
-    this._interruptPromise = interruptPromise;
-    let [entry] = this._stack;
-    while (entry && !entry.toolNames.includes(name)) {
-      mdbDebug("popping client from stack for ", name);
-      this._stack.shift();
-      await entry.client.close().catch(errorsDebug);
-      entry = this._stack[0];
-    }
-    if (!entry)
-      throw new Error(`Tool ${name} not found in the tool stack`);
-    const client = await this._client();
-    const resultPromise = new import_utils.ManualPromise();
-    entry.resultPromise = resultPromise;
-    client.callTool({
-      name,
-      arguments: args
-    }).then((result2) => {
-      resultPromise.resolve(result2);
-    }).catch((e) => resultPromise.reject(e));
-    const result = await Promise.race([interruptPromise, resultPromise]);
-    if (interruptPromise.isDone())
-      mdbDebug("client call intercepted", result);
-    else
-      mdbDebug("client call result", result);
-    return result;
-  }
-  async _client() {
-    if (!this._stack.length) {
-      const transport = await (0, import_server.wrapInProcess)(this._topLevelBackend);
-      await this._pushClient(transport);
-    }
-    return this._stack[0].client;
-  }
-  async _pushTools(params) {
-    mdbDebug("pushing tools to the stack", 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) {
-    mdbDebug("pushing client to the stack");
-    const client = new mcpBundle.Client({ name: "Pushing client", version: "0.0.0" }, { capabilities: { roots: {} } });
-    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));
-    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: void 0 });
-    mdbDebug("new tools added to the stack:", tools.map((tool) => tool.name));
-    mdbDebug("interrupting current call:", !!this._interruptPromise);
-    this._interruptPromise?.resolve({
-      content: [{
-        type: "text",
-        text: introMessage || ""
-      }]
-    });
-    this._interruptPromise = void 0;
-    return { content: [{ type: "text", text: "Tools pushed" }] };
-  }
-}
-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: "On-pause 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) {
-    return this._backend.callTool(name, args);
-  }
-  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/proxyBackend.js

@@ -1,128 +0,0 @@
-"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/vscode/host.js

@@ -1,187 +0,0 @@
-"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 host_exports = {};
-__export(host_exports, {
-  runVSCodeTools: () => runVSCodeTools
-});
-module.exports = __toCommonJS(host_exports);
-var import_path = __toESM(require("path"));
-var mcpBundle = __toESM(require("../sdk/bundle"));
-var mcpServer = __toESM(require("../sdk/server"));
-var import_log = require("../log");
-var import_browserServerBackend = require("../browser/browserServerBackend");
-var import_browserContextFactory = require("../browser/browserContextFactory");
-const packageJSON = require("../../../package.json");
-const { z, zodToJsonSchema } = mcpBundle;
-const contextSwitchOptions = z.object({
-  connectionString: z.string().optional().describe("The connection string to use to connect to the browser"),
-  lib: z.string().optional().describe("The library to use for the connection"),
-  debugController: z.boolean().optional().describe("Enable the debug controller")
-});
-class VSCodeProxyBackend {
-  constructor(_config, _defaultTransportFactory) {
-    this._config = _config;
-    this._defaultTransportFactory = _defaultTransportFactory;
-    this.name = "Playwright MCP Client Switcher";
-    this.version = packageJSON.version;
-    this._contextSwitchTool = this._defineContextSwitchTool();
-  }
-  async initialize(server, clientInfo) {
-    this._clientInfo = clientInfo;
-    const transport = await this._defaultTransportFactory(this);
-    await this._setCurrentClient(transport);
-  }
-  async listTools() {
-    const response = await this._currentClient.listTools();
-    return [
-      ...response.tools,
-      this._contextSwitchTool
-    ];
-  }
-  async callTool(name, args) {
-    if (name === this._contextSwitchTool.name)
-      return this._callContextSwitchTool(args);
-    return await this._currentClient.callTool({
-      name,
-      arguments: args
-    });
-  }
-  serverClosed(server) {
-    void this._currentClient?.close().catch(import_log.logUnhandledError);
-  }
-  onContext(context) {
-    this._context = context;
-    context.on("close", () => {
-      this._context = void 0;
-    });
-  }
-  async _getDebugControllerURL() {
-    if (!this._context)
-      return;
-    const browser = this._context.browser();
-    if (!browser || !browser._launchServer)
-      return;
-    if (this._browser !== browser)
-      this._browserServer = void 0;
-    if (!this._browserServer)
-      this._browserServer = await browser._launchServer({ _debugController: true });
-    const url = new URL(this._browserServer.wsEndpoint());
-    url.searchParams.set("debug-controller", "1");
-    return url.toString();
-  }
-  async _callContextSwitchTool(params) {
-    if (params.debugController) {
-      const url = await this._getDebugControllerURL();
-      const lines = [`### Result`];
-      if (url) {
-        lines.push(`URL: ${url}`);
-        lines.push(`Version: ${packageJSON.version}`);
-      } else {
-        lines.push(`No open browsers.`);
-      }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-    if (!params.connectionString || !params.lib) {
-      const transport = await this._defaultTransportFactory(this);
-      await this._setCurrentClient(transport);
-      return {
-        content: [{ type: "text", text: "### Result\nSuccessfully disconnected.\n" }]
-      };
-    }
-    await this._setCurrentClient(
-      new mcpBundle.StdioClientTransport({
-        command: process.execPath,
-        cwd: process.cwd(),
-        args: [
-          import_path.default.join(__dirname, "main.js"),
-          JSON.stringify(this._config),
-          params.connectionString,
-          params.lib
-        ]
-      })
-    );
-    return {
-      content: [{ type: "text", text: "### Result\nSuccessfully connected.\n" }]
-    };
-  }
-  _defineContextSwitchTool() {
-    return {
-      name: "browser_connect",
-      description: "Do not call, this tool is used in the integration with the Playwright VS Code Extension and meant for programmatic usage only.",
-      inputSchema: zodToJsonSchema(contextSwitchOptions, { strictUnions: true }),
-      annotations: {
-        title: "Connect to a browser running in VS Code.",
-        readOnlyHint: true,
-        openWorldHint: false
-      }
-    };
-  }
-  async _setCurrentClient(transport) {
-    await this._currentClient?.close();
-    this._currentClient = void 0;
-    const client = new mcpBundle.Client({ name: this._clientInfo.name, version: this._clientInfo.version });
-    client.registerCapabilities({
-      roots: {
-        listRoots: true
-      }
-    });
-    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo.roots }));
-    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
-    await client.connect(transport);
-    this._currentClient = client;
-  }
-}
-async function runVSCodeTools(config) {
-  const serverBackendFactory = {
-    name: "Playwright w/ vscode",
-    nameInConfig: "playwright-vscode",
-    version: packageJSON.version,
-    create: () => new VSCodeProxyBackend(
-      config,
-      (delegate) => mcpServer.wrapInProcess(
-        new import_browserServerBackend.BrowserServerBackend(
-          config,
-          {
-            async createContext(clientInfo, abortSignal, toolName) {
-              const context = await (0, import_browserContextFactory.contextFactory)(config).createContext(clientInfo, abortSignal, toolName);
-              delegate.onContext(context.browserContext);
-              return context;
-            }
-          }
-        )
-      )
-    )
-  };
-  await mcpServer.start(serverBackendFactory, config.server);
-  return;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  runVSCodeTools
-});

package/lib/mcp/vscode/main.js

@@ -1,77 +0,0 @@
-"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 __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 mcpBundle = __toESM(require("../sdk/bundle"));
-var mcpServer = __toESM(require("../sdk/server"));
-var import_browserServerBackend = require("../browser/browserServerBackend");
-class VSCodeBrowserContextFactory {
-  constructor(_config, _playwright, _connectionString) {
-    this._config = _config;
-    this._playwright = _playwright;
-    this._connectionString = _connectionString;
-    this.name = "vscode";
-    this.description = "Connect to a browser running in the Playwright VS Code extension";
-  }
-  async createContext(clientInfo, abortSignal) {
-    let launchOptions = this._config.browser.launchOptions;
-    if (this._config.browser.userDataDir) {
-      launchOptions = {
-        ...launchOptions,
-        ...this._config.browser.contextOptions,
-        userDataDir: this._config.browser.userDataDir
-      };
-    }
-    const connectionString = new URL(this._connectionString);
-    connectionString.searchParams.set("launch-options", JSON.stringify(launchOptions));
-    const browserType = this._playwright.chromium;
-    const browser = await browserType.connect(connectionString.toString());
-    const context = browser.contexts()[0] ?? await browser.newContext(this._config.browser.contextOptions);
-    return {
-      browserContext: context,
-      close: async () => {
-        await browser.close();
-      }
-    };
-  }
-}
-async function main(config, connectionString, lib) {
-  const playwright = await import(lib).then((mod) => mod.default ?? mod);
-  const factory = new VSCodeBrowserContextFactory(config, playwright, connectionString);
-  await mcpServer.connect(
-    {
-      name: "Playwright MCP",
-      nameInConfig: "playwright-vscode",
-      create: () => new import_browserServerBackend.BrowserServerBackend(config, factory),
-      version: "unused"
-    },
-    new mcpBundle.StdioServerTransport(),
-    false
-  );
-}
-void (async () => {
-  await main(
-    JSON.parse(process.argv[2]),
-    process.argv[3],
-    process.argv[4]
-  );
-})();