@cotestdev/mcp_playwright 0.0.9 → 0.0.11

package/lib/mcp/test/streams.js

@@ -0,0 +1,41 @@
+"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 streams_exports = {};
+__export(streams_exports, {
+  StringWriteStream: () => StringWriteStream
+});
+module.exports = __toCommonJS(streams_exports);
+var import_stream = require("stream");
+class StringWriteStream extends import_stream.Writable {
+  constructor() {
+    super(...arguments);
+    this._chunks = [];
+  }
+  _write(chunk, encoding, callback) {
+    this._chunks.push(chunk.toString());
+    callback();
+  }
+  content() {
+    return this._chunks.join("");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringWriteStream
+});

package/lib/mcp/test/testBackend.js

@@ -0,0 +1,79 @@
+"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 testBackend_exports = {};
+__export(testBackend_exports, {
+  TestServerBackend: () => TestServerBackend
+});
+module.exports = __toCommonJS(testBackend_exports);
+var mcp = __toESM(require("../sdk/exports"));
+var import_testContext = require("./testContext");
+var import_testTools = require("./testTools.js");
+var import_tools = require("../browser/tools");
+var import_configLoader = require("../../common/configLoader");
+class TestServerBackend {
+  constructor(configOption, options) {
+    this.name = "Playwright";
+    this.version = "0.0.1";
+    this._tools = [import_testTools.listTests, import_testTools.runTests, import_testTools.debugTest, import_testTools.setupPage];
+    this._context = new import_testContext.TestContext(options);
+    this._configOption = configOption;
+  }
+  async initialize(server, clientInfo) {
+    if (this._configOption) {
+      this._context.setConfigLocation((0, import_configLoader.resolveConfigLocation)(this._configOption));
+      return;
+    }
+    const rootPath = mcp.firstRootPath(clientInfo);
+    if (rootPath) {
+      this._context.setConfigLocation((0, import_configLoader.resolveConfigLocation)(rootPath));
+      return;
+    }
+    throw new Error("No config option or MCP root path provided");
+  }
+  async listTools() {
+    return [
+      ...this._tools.map((tool) => mcp.toMcpTool(tool.schema)),
+      ...import_tools.browserTools.map((tool) => mcp.toMcpTool(tool.schema))
+    ];
+  }
+  async callTool(name, args) {
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool)
+      throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map((tool2) => tool2.schema.name).join(", ")}`);
+    const parsedArguments = tool.schema.inputSchema.parse(args || {});
+    return await tool.handle(this._context, parsedArguments);
+  }
+  serverClosed() {
+    void this._context.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestServerBackend
+});

package/lib/mcp/test/testContext.js

@@ -0,0 +1,50 @@
+"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 testContext_exports = {};
+__export(testContext_exports, {
+  TestContext: () => TestContext
+});
+module.exports = __toCommonJS(testContext_exports);
+var import_testRunner = require("../../runner/testRunner");
+class TestContext {
+  constructor(options) {
+    this.options = options;
+  }
+  setConfigLocation(configLocation) {
+    this.configLocation = configLocation;
+  }
+  async createTestRunner() {
+    if (this._testRunner)
+      await this._testRunner.stopTests();
+    const testRunner = new import_testRunner.TestRunner(this.configLocation, {});
+    await testRunner.initialize({});
+    this._testRunner = testRunner;
+    testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => {
+      this._testRunner?.emit(import_testRunner.TestRunnerEvent.TestFilesChanged, testFiles);
+    });
+    this._testRunner = testRunner;
+    return testRunner;
+  }
+  async close() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestContext
+});

package/lib/mcp/test/testTool.js

@@ -0,0 +1,30 @@
+"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 testTool_exports = {};
+__export(testTool_exports, {
+  defineTestTool: () => defineTestTool
+});
+module.exports = __toCommonJS(testTool_exports);
+function defineTestTool(tool) {
+  return tool;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineTestTool
+});

package/lib/mcp/test/testTools.js

@@ -0,0 +1,194 @@
+"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 testTools_exports = {};
+__export(testTools_exports, {
+  debugTest: () => debugTest,
+  listTests: () => listTests,
+  runTests: () => runTests,
+  setupPage: () => setupPage
+});
+module.exports = __toCommonJS(testTools_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("playwright-core/lib/utils");
+var import_bundle = require("../sdk/bundle");
+var import_base = require("../../reporters/base");
+var import_list = __toESM(require("../../reporters/list"));
+var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
+var import_projectUtils = require("../../runner/projectUtils");
+var import_testTool = require("./testTool");
+var import_streams = require("./streams");
+const listTests = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "test_list",
+    title: "List tests",
+    description: "List tests",
+    inputSchema: import_bundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context) => {
+    const { screen, stream } = createScreen();
+    const reporter = new import_listModeReporter.default({ screen, includeTestId: true });
+    const testRunner = await context.createTestRunner();
+    await testRunner.listTests(reporter, {});
+    return {
+      content: [{ type: "text", text: stream.content() }]
+    };
+  }
+});
+const runTests = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "test_run",
+    title: "Run tests",
+    description: "Run tests",
+    inputSchema: import_bundle.z.object({
+      locations: import_bundle.z.array(import_bundle.z.string()).optional().describe('Folder, file or location to run: "test/e2e" or "test/e2e/file.spec.ts" or "test/e2e/file.spec.ts:20"'),
+      projects: import_bundle.z.array(import_bundle.z.string()).optional().describe('Projects to run, projects from playwright.config.ts, by default runs all projects. Running with "chromium" is a good start')
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params) => {
+    const { screen, stream } = createScreen();
+    const configDir = context.configLocation.configDir;
+    const reporter = new import_list.default({ configDir, screen, includeTestId: true });
+    const testRunner = await context.createTestRunner();
+    await testRunner.runTests(reporter, {
+      locations: params.locations,
+      projects: params.projects,
+      disableConfigReporters: true
+    });
+    const text = stream.content();
+    return {
+      content: [
+        { type: "text", text }
+      ]
+    };
+  }
+});
+const debugTest = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "test_debug",
+    title: "Debug single test",
+    description: "Debug single test",
+    inputSchema: import_bundle.z.object({
+      test: import_bundle.z.object({
+        id: import_bundle.z.string().describe("Test ID to debug."),
+        title: import_bundle.z.string().describe("Human readable test title for granting permission to debug the test.")
+      })
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params) => {
+    const { screen, stream } = createScreen();
+    const configDir = context.configLocation.configDir;
+    const reporter = new import_list.default({ configDir, screen });
+    const testRunner = await context.createTestRunner();
+    const result = await testRunner.runTests(reporter, {
+      headed: !context.options?.headless,
+      testIds: [params.test.id],
+      // For automatic recovery
+      timeout: 0,
+      workers: 1,
+      pauseOnError: true,
+      disableConfigReporters: true
+    });
+    const text = stream.content();
+    return {
+      content: [
+        { type: "text", text }
+      ],
+      isError: result.status !== "passed"
+    };
+  }
+});
+const setupPage = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "test_setup_page",
+    title: "Setup page",
+    description: "Setup the page for test",
+    inputSchema: import_bundle.z.object({
+      project: import_bundle.z.string().optional().describe('Project to use for setup. For example: "chromium", if no project is provided uses the first project in the config.'),
+      testLocation: import_bundle.z.string().optional().describe('Location of the seed test to use for setup. For example: "test/seed/default.spec.ts:20".')
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params) => {
+    const { screen, stream } = createScreen();
+    const configDir = context.configLocation.configDir;
+    const reporter = new import_list.default({ configDir, screen });
+    const testRunner = await context.createTestRunner();
+    let testLocation = params.testLocation;
+    if (!testLocation) {
+      testLocation = "default.seed.spec.ts";
+      const config = await testRunner.loadConfig();
+      const project = params.project ? config.projects.find((p) => p.project.name === params.project) : (0, import_projectUtils.findTopLevelProjects)(config)[0];
+      const testDir = project?.project.testDir || configDir;
+      const seedFile = import_path.default.join(testDir, testLocation);
+      if (!import_fs.default.existsSync(seedFile)) {
+        await import_fs.default.promises.mkdir(import_path.default.dirname(seedFile), { recursive: true });
+        await import_fs.default.promises.writeFile(seedFile, `import { test, expect } from '@playwright/test';
+
+test('seed', async ({ page }) => {});
+`);
+      }
+    }
+    const result = await testRunner.runTests(reporter, {
+      headed: !context.options?.headless,
+      locations: [testLocation],
+      projects: params.project ? [params.project] : void 0,
+      timeout: 0,
+      workers: 1,
+      pauseAtEnd: true,
+      disableConfigReporters: true
+    });
+    const text = stream.content();
+    return {
+      content: [{ type: "text", text }],
+      isError: result.status !== "passed"
+    };
+  }
+});
+function createScreen() {
+  const stream = new import_streams.StringWriteStream();
+  const screen = {
+    ...import_base.terminalScreen,
+    isTTY: false,
+    colors: import_utils.noColors,
+    stdout: stream,
+    stderr: stream
+  };
+  return { screen, stream };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debugTest,
+  listTests,
+  runTests,
+  setupPage
+});

package/lib/mcp/vscode/host.js

@@ -0,0 +1,187 @@
+"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

@@ -0,0 +1,77 @@
+"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]
+  );
+})();