@cotestdev/mcp_playwright 0.0.58 → 0.0.60

package/lib/mcp/terminal/registry.js

@@ -0,0 +1,146 @@
+"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 registry_exports = {};
+__export(registry_exports, {
+  Registry: () => Registry,
+  baseDaemonDir: () => baseDaemonDir,
+  createClientInfo: () => createClientInfo
+});
+module.exports = __toCommonJS(registry_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+class Registry {
+  constructor(entries) {
+    this._entries = entries;
+  }
+  entry(clientInfo, sessionName) {
+    const key = clientInfo.workspaceDir || clientInfo.workspaceDirHash;
+    const entries = this._entries.get(key) || [];
+    return entries.find((entry) => entry.config.name === sessionName);
+  }
+  entries(clientInfo) {
+    const key = clientInfo.workspaceDir || clientInfo.workspaceDirHash;
+    return this._entries.get(key) || [];
+  }
+  entryMap() {
+    return this._entries;
+  }
+  static async loadSessionEntry(file) {
+    try {
+      const data = await import_fs.default.promises.readFile(file, "utf-8");
+      const config = JSON.parse(data);
+      if (!config.name)
+        config.name = import_path.default.basename(file, ".session");
+      if (!config.timestamp)
+        config.timestamp = 0;
+      return { file, config };
+    } catch {
+      return void 0;
+    }
+  }
+  static async load() {
+    const sessions = /* @__PURE__ */ new Map();
+    const hashDirs = await import_fs.default.promises.readdir(baseDaemonDir).catch(() => []);
+    for (const workspaceDirHash of hashDirs) {
+      const hashDir = import_path.default.join(baseDaemonDir, workspaceDirHash);
+      const stat = await import_fs.default.promises.stat(hashDir);
+      if (!stat.isDirectory())
+        continue;
+      const files = await import_fs.default.promises.readdir(hashDir).catch(() => []);
+      for (const file of files) {
+        if (!file.endsWith(".session"))
+          continue;
+        const fileName = import_path.default.join(hashDir, file);
+        const entry = await Registry.loadSessionEntry(fileName);
+        if (!entry)
+          continue;
+        const key = entry.config.workspaceDir || workspaceDirHash;
+        let list = sessions.get(key);
+        if (!list) {
+          list = [];
+          sessions.set(key, list);
+        }
+        list.push(entry);
+      }
+    }
+    return new Registry(sessions);
+  }
+}
+const baseDaemonDir = (() => {
+  if (process.env.PLAYWRIGHT_DAEMON_SESSION_DIR)
+    return process.env.PLAYWRIGHT_DAEMON_SESSION_DIR;
+  let localCacheDir;
+  if (process.platform === "linux")
+    localCacheDir = process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    localCacheDir = import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    localCacheDir = process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  if (!localCacheDir)
+    throw new Error("Unsupported platform: " + process.platform);
+  return import_path.default.join(localCacheDir, "ms-playwright", "daemon");
+})();
+function createClientInfo() {
+  const packageLocation = require.resolve("../../../package.json");
+  const packageJSON = require(packageLocation);
+  const workspaceDir = findWorkspaceDir(process.cwd());
+  const version = process.env.PLAYWRIGHT_CLI_VERSION_FOR_TEST || packageJSON.version;
+  const hash = import_crypto.default.createHash("sha1");
+  hash.update(workspaceDir || packageLocation);
+  const workspaceDirHash = hash.digest("hex").substring(0, 16);
+  return {
+    version,
+    workspaceDir,
+    workspaceDirHash,
+    daemonProfilesDir: daemonProfilesDir(workspaceDirHash)
+  };
+}
+function findWorkspaceDir(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    if (import_fs.default.existsSync(import_path.default.join(dir, ".playwright")))
+      return dir;
+    const parentDir = import_path.default.dirname(dir);
+    if (parentDir === dir)
+      break;
+    dir = parentDir;
+  }
+  return void 0;
+}
+const daemonProfilesDir = (workspaceDirHash) => {
+  return import_path.default.join(baseDaemonDir, workspaceDirHash);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Registry,
+  baseDaemonDir,
+  createClientInfo
+});

package/lib/mcp/terminal/session.js

@@ -0,0 +1,309 @@
+"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 session_exports = {};
+__export(session_exports, {
+  Session: () => Session,
+  renderResolvedConfig: () => renderResolvedConfig
+});
+module.exports = __toCommonJS(session_exports);
+var import_child_process = require("child_process");
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_socketConnection = require("./socketConnection");
+class Session {
+  constructor(clientInfo, options) {
+    this._nextMessageId = 1;
+    this._callbacks = /* @__PURE__ */ new Map();
+    this._clientInfo = clientInfo;
+    this.config = options;
+    this.name = options.name;
+  }
+  isCompatible() {
+    return this._clientInfo.version === this.config.version;
+  }
+  checkCompatible() {
+    if (!this.isCompatible()) {
+      throw new Error(`Client is v${this._clientInfo.version}, session '${this.name}' is v${this.config.version}. Run
+
+  playwright-cli${this.name !== "default" ? ` -s=${this.name}` : ""} open
+
+to restart the browser session.`);
+    }
+  }
+  async open() {
+    await this._startDaemonIfNeeded();
+    this.disconnect();
+  }
+  async run(args, cwd) {
+    this.checkCompatible();
+    const result = await this._send("run", { args, cwd: cwd || process.cwd() });
+    this.disconnect();
+    return result;
+  }
+  async stop(quiet = false) {
+    if (!await this.canConnect()) {
+      if (!quiet)
+        console.log(`Browser '${this.name}' is not open.`);
+      return;
+    }
+    await this._stopDaemon();
+    if (!quiet)
+      console.log(`Browser '${this.name}' closed
+`);
+  }
+  async _send(method, params = {}) {
+    const connection = await this._startDaemonIfNeeded();
+    const messageId = this._nextMessageId++;
+    const message = {
+      id: messageId,
+      method,
+      params,
+      version: this.config.version
+    };
+    const responsePromise = new Promise((resolve, reject) => {
+      this._callbacks.set(messageId, { resolve, reject, method, params });
+    });
+    const [result] = await Promise.all([responsePromise, connection.send(message)]);
+    return result;
+  }
+  disconnect() {
+    if (!this._connection)
+      return;
+    for (const callback of this._callbacks.values())
+      callback.reject(new Error("Session closed"));
+    this._callbacks.clear();
+    this._connection.close();
+    this._connection = void 0;
+  }
+  async deleteData() {
+    await this.stop();
+    const dataDirs = await import_fs.default.promises.readdir(this._clientInfo.daemonProfilesDir).catch(() => []);
+    const matchingEntries = dataDirs.filter((file) => file === `${this.name}.session` || file.startsWith(`ud-${this.name}-`));
+    if (matchingEntries.length === 0) {
+      console.log(`No user data found for browser '${this.name}'.`);
+      return;
+    }
+    for (const entry of matchingEntries) {
+      const userDataDir = import_path.default.resolve(this._clientInfo.daemonProfilesDir, entry);
+      for (let i = 0; i < 5; i++) {
+        try {
+          await import_fs.default.promises.rm(userDataDir, { recursive: true });
+          if (entry.startsWith("ud-"))
+            console.log(`Deleted user data for browser '${this.name}'.`);
+          break;
+        } catch (e) {
+          if (e.code === "ENOENT") {
+            console.log(`No user data found for browser '${this.name}'.`);
+            break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          if (i === 4)
+            throw e;
+        }
+      }
+    }
+  }
+  async _connect() {
+    return await new Promise((resolve) => {
+      const socket = import_net.default.createConnection(this.config.socketPath, () => {
+        resolve({ socket });
+      });
+      socket.on("error", (error) => {
+        if (import_os.default.platform() !== "win32")
+          void import_fs.default.promises.unlink(this.config.socketPath).catch(() => {
+          }).then(() => resolve({ error }));
+        else
+          resolve({ error });
+      });
+    });
+  }
+  async canConnect() {
+    const { socket } = await this._connect();
+    if (socket) {
+      socket.destroy();
+      return true;
+    }
+    return false;
+  }
+  async _startDaemonIfNeeded() {
+    if (this._connection)
+      return this._connection;
+    let { socket } = await this._connect();
+    if (!socket)
+      socket = await this._startDaemon();
+    this._connection = new import_socketConnection.SocketConnection(socket, this.config.version);
+    this._connection.onmessage = (message) => this._onMessage(message);
+    this._connection.onclose = () => this.disconnect();
+    return this._connection;
+  }
+  _onMessage(object) {
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.error)
+        callback.reject(new Error(object.error));
+      else
+        callback.resolve(object.result);
+    } else if (object.id) {
+      throw new Error(`Unexpected message id: ${object.id}`);
+    } else {
+      throw new Error(`Unexpected message without id: ${JSON.stringify(object)}`);
+    }
+  }
+  _sessionFile(suffix) {
+    return import_path.default.resolve(this._clientInfo.daemonProfilesDir, `${this.name}${suffix}`);
+  }
+  async _startDaemon() {
+    await import_fs.default.promises.mkdir(this._clientInfo.daemonProfilesDir, { recursive: true });
+    const cliPath = import_path.default.join(__dirname, "../../../cli.js");
+    const sessionConfigFile = this._sessionFile(".session");
+    this.config.version = this._clientInfo.version;
+    this.config.timestamp = Date.now();
+    await import_fs.default.promises.writeFile(sessionConfigFile, JSON.stringify(this.config, null, 2));
+    const errLog = this._sessionFile(".err");
+    const err = import_fs.default.openSync(errLog, "w");
+    const args = [
+      cliPath,
+      "run-mcp-server",
+      `--daemon-session=${sessionConfigFile}`
+    ];
+    const child = (0, import_child_process.spawn)(process.execPath, args, {
+      detached: true,
+      stdio: ["ignore", "pipe", err],
+      cwd: process.cwd()
+      // Will be used as root.
+    });
+    let signalled = false;
+    const sigintHandler = () => {
+      signalled = true;
+      child.kill("SIGINT");
+    };
+    const sigtermHandler = () => {
+      signalled = true;
+      child.kill("SIGTERM");
+    };
+    process.on("SIGINT", sigintHandler);
+    process.on("SIGTERM", sigtermHandler);
+    let outLog = "";
+    await new Promise((resolve, reject) => {
+      child.stdout.on("data", (data) => {
+        outLog += data.toString();
+        if (!outLog.includes("<EOF>"))
+          return;
+        const errorMatch = outLog.match(/### Error\n([\s\S]*)<EOF>/);
+        const error = errorMatch ? errorMatch[1].trim() : void 0;
+        if (error) {
+          const errLogContent = import_fs.default.readFileSync(errLog, "utf-8");
+          const message = error + (errLogContent ? "\n" + errLogContent : "");
+          reject(new Error(message));
+        }
+        const successMatch = outLog.match(/### Success\nDaemon listening on (.*)\n<EOF>/);
+        if (successMatch)
+          resolve();
+      });
+      child.on("close", (code) => {
+        if (!signalled)
+          reject(new Error(`Daemon process exited with code ${code}`));
+      });
+    });
+    process.off("SIGINT", sigintHandler);
+    process.off("SIGTERM", sigtermHandler);
+    child.stdout.destroy();
+    child.unref();
+    const { socket } = await this._connect();
+    if (socket) {
+      console.log(`### Browser \`${this.name}\` opened with pid ${child.pid}.`);
+      const resolvedConfig = await parseResolvedConfig(outLog);
+      if (resolvedConfig) {
+        this.config.resolvedConfig = resolvedConfig;
+        console.log(`- ${this.name}:`);
+        console.log(renderResolvedConfig(resolvedConfig).join("\n"));
+      }
+      console.log(`---`);
+      this.config.timestamp = Date.now();
+      await import_fs.default.promises.writeFile(sessionConfigFile, JSON.stringify(this.config, null, 2));
+      return socket;
+    }
+    console.error(`Failed to connect to daemon at ${this.config.socketPath}`);
+    process.exit(1);
+  }
+  async _stopDaemon() {
+    let error;
+    await this._send("stop").catch((e) => {
+      error = e;
+    });
+    if (import_os.default.platform() !== "win32")
+      await import_fs.default.promises.unlink(this.config.socketPath).catch(() => {
+      });
+    this.disconnect();
+    if (!this.config.cli.persistent)
+      await this.deleteSessionConfig();
+    if (error && !error?.message?.includes("Session closed"))
+      throw error;
+  }
+  async deleteSessionConfig() {
+    await import_fs.default.promises.rm(this._sessionFile(".session")).catch(() => {
+    });
+  }
+}
+function renderResolvedConfig(resolvedConfig) {
+  const channel = resolvedConfig.browser.launchOptions.channel ?? resolvedConfig.browser.browserName;
+  const lines = [];
+  if (channel)
+    lines.push(`  - browser-type: ${channel}`);
+  if (resolvedConfig.browser.isolated)
+    lines.push(`  - user-data-dir: <in-memory>`);
+  else
+    lines.push(`  - user-data-dir: ${resolvedConfig.browser.userDataDir}`);
+  lines.push(`  - headed: ${!resolvedConfig.browser.launchOptions.headless}`);
+  return lines;
+}
+async function parseResolvedConfig(errLog) {
+  const marker = "### Config\n```json\n";
+  const markerIndex = errLog.indexOf(marker);
+  if (markerIndex === -1)
+    return null;
+  const jsonStart = markerIndex + marker.length;
+  const jsonEnd = errLog.indexOf("\n```", jsonStart);
+  if (jsonEnd === -1)
+    throw null;
+  const jsonString = errLog.substring(jsonStart, jsonEnd).trim();
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Session,
+  renderResolvedConfig
+});

package/lib/mcp/test/browserBackend.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,24 +17,35 @@ 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 browserBackend_exports = {};
 __export(browserBackend_exports, {
-  createCustomMessageHandler: () => createCustomMessageHandler
+  createCustomMessageHandler: () => createCustomMessageHandler,
+  runDaemonForContext: () => runDaemonForContext
 });
 module.exports = __toCommonJS(browserBackend_exports);
-var import_config = require("../browser/config");
-var import_browserServerBackend = require("../browser/browserServerBackend");
-var import_tab = require("../browser/tab");
+var import_path = __toESM(require("path"));
+var import_utils = require("playwright-core/lib/utils");
+var mcp = __toESM(require("playwright-core/lib/mcp/exports"));
+var tools = __toESM(require("playwright-core/lib/tools/exports"));
 var import_util = require("../../util");
-var import_browserContextFactory = require("../browser/browserContextFactory");
 function createCustomMessageHandler(testInfo, context) {
   let backend;
+  const config = { capabilities: ["testing"] };
+  const toolList = tools.filteredTools(config);
   return async (data) => {
     if (data.initialize) {
       if (backend)
         throw new Error("MCP backend is already initialized");
-      backend = new import_browserServerBackend.BrowserServerBackend({ ...import_config.defaultConfig, capabilities: ["testing"] }, (0, import_browserContextFactory.identityBrowserContextFactory)(context));
+      backend = new tools.BrowserServerBackend(config, context, toolList);
       await backend.initialize(data.initialize.clientInfo);
       const pausedMessage = await generatePausedMessage(testInfo, context);
       return { initialize: { pausedMessage } };
@@ -40,7 +53,7 @@ function createCustomMessageHandler(testInfo, context) {
     if (data.listTools) {
       if (!backend)
         throw new Error("MCP backend is not initialized");
-      return { listTools: await backend.listTools() };
+      return { listTools: toolList.map((t) => mcp.toMcpTool(t.schema)) };
     }
     if (data.callTool) {
       if (!backend)
@@ -48,7 +61,7 @@ function createCustomMessageHandler(testInfo, context) {
       return { callTool: await backend.callTool(data.callTool.name, data.callTool.arguments) };
     }
     if (data.close) {
-      backend?.serverClosed();
+      await backend?.dispose();
       backend = void 0;
       return { close: {} };
     }
@@ -73,11 +86,11 @@ async function generatePausedMessage(testInfo, context) {
       `- Page URL: ${page.url()}`,
       `- Page Title: ${await page.title()}`.trim()
     );
-    let console = testInfo.errors.length ? await import_tab.Tab.collectConsoleMessages(page) : [];
-    console = console.filter((msg) => msg.type === "error");
-    if (console.length) {
+    let console2 = testInfo.errors.length ? await tools.Tab.collectConsoleMessages(page) : [];
+    console2 = console2.filter((msg) => msg.type === "error");
+    if (console2.length) {
       lines.push("- Console Messages:");
-      for (const message of console)
+      for (const message of console2)
         lines.push(`  - ${message.toString()}`);
     }
     lines.push(
@@ -92,7 +105,36 @@ async function generatePausedMessage(testInfo, context) {
     lines.push(`### Task`, `Try recovering from the error prior to continuing`);
   return lines.join("\n");
 }
+async function runDaemonForContext(testInfo, context) {
+  if (process.env.PWPAUSE !== "cli")
+    return;
+  const outputDir = import_path.default.join(testInfo.artifactsDir(), ".playwright-mcp");
+  const sessionName = `test-worker-${(0, import_utils.createGuid)().slice(0, 6)}`;
+  await mcp.startCliDaemonServer(sessionName, context, {
+    outputMode: "file",
+    snapshot: { mode: "full" },
+    outputDir
+  });
+  const lines = [""];
+  if (testInfo.errors.length) {
+    lines.push(`### Paused on test error`);
+    for (const error of testInfo.errors)
+      lines.push((0, import_util.stripAnsiEscapes)(error.message || ""));
+  } else {
+    lines.push(`### Paused at the end of the test`);
+  }
+  lines.push(
+    `### Debugging Instructions`,
+    `- Use "playwright-cli --session=${sessionName}" to explore the page and fix the problem.`,
+    `- Stop this test run when finished. Restart if needed.`,
+    ``
+  );
+  console.log(lines.join("\n"));
+  await new Promise(() => {
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createCustomMessageHandler
+  createCustomMessageHandler,
+  runDaemonForContext
 });

package/lib/mcp/test/testBackend.js

@@ -28,56 +28,55 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var testBackend_exports = {};
 __export(testBackend_exports, {
-  TestServerBackend: () => TestServerBackend
+  TestServerBackend: () => TestServerBackend,
+  testServerBackendTools: () => testServerBackendTools
 });
 module.exports = __toCommonJS(testBackend_exports);
+var import_events = __toESM(require("events"));
 var import_mcpBundle = require("../../mcpBundle");
-var mcp = __toESM(require("../sdk/exports"));
+var import_exports = require("playwright-core/lib/tools/exports");
 var import_testContext = require("./testContext");
 var testTools = __toESM(require("./testTools.js"));
 var generatorTools = __toESM(require("./generatorTools.js"));
 var plannerTools = __toESM(require("./plannerTools.js"));
-var import_tools = require("../browser/tools");
-class TestServerBackend {
+const typesWithIntent = ["action", "assertion", "input"];
+const testServerBackendTools = [
+  plannerTools.saveTestPlan,
+  plannerTools.setupPage,
+  plannerTools.submitTestPlan,
+  generatorTools.setupPage,
+  generatorTools.generatorReadLog,
+  generatorTools.generatorWriteTest,
+  testTools.listTests,
+  testTools.runTests,
+  testTools.debugTest,
+  ...import_exports.browserTools.map((tool) => wrapBrowserTool(tool))
+];
+class TestServerBackend extends import_events.default {
   constructor(configPath, options) {
+    super();
     this.name = "Playwright";
     this.version = "0.0.1";
-    this._tools = [
-      plannerTools.saveTestPlan,
-      plannerTools.setupPage,
-      plannerTools.submitTestPlan,
-      generatorTools.setupPage,
-      generatorTools.generatorReadLog,
-      generatorTools.generatorWriteTest,
-      testTools.listTests,
-      testTools.runTests,
-      testTools.debugTest,
-      ...import_tools.browserTools.map((tool) => wrapBrowserTool(tool))
-    ];
     this._options = options || {};
     this._configPath = configPath;
   }
   async initialize(clientInfo) {
     this._context = new import_testContext.TestContext(clientInfo, this._configPath, this._options);
   }
-  async listTools() {
-    return this._tools.map((tool) => mcp.toMcpTool(tool.schema));
-  }
   async callTool(name, args) {
-    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    const tool = testServerBackendTools.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(", ")}`);
+      throw new Error(`Tool not found: ${name}. Available tools: ${testServerBackendTools.map((tool2) => tool2.schema.name).join(", ")}`);
     try {
       return await tool.handle(this._context, tool.schema.inputSchema.parse(args || {}));
     } catch (e) {
       return { content: [{ type: "text", text: String(e) }], isError: true };
     }
   }
-  serverClosed() {
-    void this._context?.close();
+  async dispose() {
+    await this._context?.close();
   }
 }
-const typesWithIntent = ["action", "assertion", "input"];
 function wrapBrowserTool(tool) {
   const inputSchema = typesWithIntent.includes(tool.schema.type) ? tool.schema.inputSchema.extend({
     intent: import_mcpBundle.z.string().describe("The intent of the call, for example the test step description plan idea")
@@ -95,5 +94,6 @@ function wrapBrowserTool(tool) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TestServerBackend
+  TestServerBackend,
+  testServerBackendTools
 });