@cotestdev/mcp_playwright 0.0.59 → 0.0.60

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
 });

package/lib/mcp/test/testContext.js

@@ -37,16 +37,15 @@ var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
 var import_utils = require("playwright-core/lib/utils");
+var import_exports = require("playwright-core/lib/tools/exports");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_base = require("../../reporters/base");
 var import_list = __toESM(require("../../reporters/list"));
 var import_streams = require("./streams");
 var import_util = require("../../util");
 var import_testRunner = require("../../runner/testRunner");
 var import_seed = require("./seed");
-var import_exports = require("../sdk/exports");
 var import_configLoader = require("../../common/configLoader");
-var import_response = require("../browser/response");
-var import_log = require("../log");
 class GeneratorJournal {
   constructor(rootPath, plan, seed) {
     this._rootPath = rootPath;
@@ -78,9 +77,8 @@ ${step.code}
 class TestContext {
   constructor(clientInfo, configPath, options) {
     this._clientInfo = clientInfo;
-    const rootPath = (0, import_exports.firstRootPath)(clientInfo);
-    this._configLocation = (0, import_configLoader.resolveConfigLocation)(configPath || rootPath);
-    this.rootPath = rootPath || this._configLocation.configDir;
+    this._configLocation = (0, import_configLoader.resolveConfigLocation)(configPath || clientInfo.cwd);
+    this.rootPath = clientInfo.cwd || this._configLocation.configDir;
     if (options?.headless !== void 0)
       this.computedHeaded = !options.headless;
     else
@@ -213,7 +211,7 @@ class TestContext {
     return { output: testRunnerAndScreen.output.join("\n"), status };
   }
   async close() {
-    await this._cleanupTestRunner().catch(import_log.logUnhandledError);
+    await this._cleanupTestRunner().catch((e) => (0, import_utilsBundle.debug)("pw:mcp:error")(e));
   }
   async sendMessageToPausedTest(request) {
     const sendMessage = this._testRunnerAndScreen?.sendMessageToPausedTest;
@@ -223,7 +221,7 @@ class TestContext {
     if (result.error)
       throw new Error(result.error.message);
     if (typeof request?.callTool?.arguments?.["intent"] === "string") {
-      const response = (0, import_response.parseResponse)(result.response.callTool);
+      const response = (0, import_exports.parseResponse)(result.response.callTool);
       if (response && !response.isError && response.code)
         this.generatorJournal?.logStep(request.callTool.arguments["intent"], response.code);
     }