@smoothdeploy/playwright 1.58.4 → 1.61.0

package/lib/mcp/test/testContext.js

@@ -36,17 +36,17 @@ module.exports = __toCommonJS(testContext_exports);
 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_base = require("../../reporters/base");
-var import_list = __toESM(require("../../reporters/list"));
+var import_coreBundle = require("playwright-core/lib/coreBundle");
+var import_runner = require("../../runner");
 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");
+var import_common = require("../../common");
+const debug = require("playwright-core/lib/utilsBundle").debug;
+const { noColors } = require("playwright-core/lib/coreBundle").iso;
+const { ManualPromise, signalToPromise } = require("playwright-core/lib/coreBundle").iso;
+const { escapeRegExp } = require("playwright-core/lib/coreBundle").iso;
+const { toPosixPath } = require("playwright-core/lib/coreBundle").utils;
 class GeneratorJournal {
   constructor(rootPath, plan, seed) {
     this._rootPath = rootPath;
@@ -62,7 +62,7 @@ class GeneratorJournal {
     const result = [];
     result.push(`# Plan`);
     result.push(this._plan);
-    result.push(`# Seed file: ${(0, import_utils.toPosixPath)(import_path.default.relative(this._rootPath, this._seed.file))}`);
+    result.push(`# Seed file: ${toPosixPath(import_path.default.relative(this._rootPath, this._seed.file))}`);
     result.push("```ts");
     result.push(this._seed.content);
     result.push("```");
@@ -77,15 +77,22 @@ ${step.code}
 }
 class TestContext {
   constructor(clientInfo, configPath, options) {
+    this._testOpQueue = Promise.resolve();
     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 = import_common.configLoader.resolveConfigLocation(configPath || clientInfo.cwd);
+    this.rootPath = clientInfo.cwd || this._configLocation.configDir;
     if (options?.headless !== void 0)
       this.computedHeaded = !options.headless;
     else
       this.computedHeaded = !process.env.CI && !(import_os.default.platform() === "linux" && !process.env.DISPLAY);
   }
+  async _enqueue(fn) {
+    const next = this._testOpQueue.then(fn);
+    this._testOpQueue = next.then(() => {
+    }, () => {
+    });
+    return await next;
+  }
   existingTestRunner() {
     return this._testRunnerAndScreen?.testRunner;
   }
@@ -103,16 +110,16 @@ class TestContext {
   }
   async createTestRunner() {
     await this._cleanupTestRunner();
-    const testRunner = new import_testRunner.TestRunner(this._configLocation, {});
-    await testRunner.initialize({});
-    const testPaused = new import_utils.ManualPromise();
+    const runner = new import_runner.testRunner.TestRunner(this._configLocation, {});
+    await runner.initialize({});
+    const testPaused = new ManualPromise();
     const testRunnerAndScreen = {
       ...createScreen(),
-      testRunner,
+      testRunner: runner,
       waitForTestPaused: () => testPaused
     };
     this._testRunnerAndScreen = testRunnerAndScreen;
-    testRunner.on(import_testRunner.TestRunnerEvent.TestPaused, (params) => {
+    runner.on(import_runner.testRunner.TestRunnerEvent.TestPaused, (params) => {
       testRunnerAndScreen.sendMessageToPausedTest = params.sendMessage;
       testPaused.resolve();
     });
@@ -120,8 +127,8 @@ class TestContext {
   }
   async getOrCreateSeedFile(seedFile, projectName) {
     const configDir = this._configLocation.configDir;
-    const { testRunner } = await this.createTestRunner();
-    const config = await testRunner.loadConfig();
+    const { testRunner: runner } = await this.createTestRunner();
+    const config = await runner.loadConfig();
     const project = (0, import_seed.seedProject)(config, projectName);
     if (!seedFile) {
       seedFile = await (0, import_seed.ensureSeedFile)(project);
@@ -149,31 +156,34 @@ class TestContext {
       projectName: project.project.name
     };
   }
-  async runSeedTest(seedFile, projectName) {
+  async runSeedTest(seedFile, projectName, signal) {
     const result = await this.runTestsWithGlobalSetupAndPossiblePause({
       headed: this.computedHeaded,
-      locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
+      locations: ["/" + escapeRegExp(seedFile) + "/"],
       projects: [projectName],
       timeout: 0,
       workers: 1,
       pauseAtEnd: true,
       disableConfigReporters: true,
       failOnLoadErrors: true
-    });
+    }, signal);
     if (result.status === "passed")
       result.output += "\nError: seed test not found.";
     else if (result.status !== "paused")
       result.output += "\nError while running the seed test.";
     return result;
   }
-  async runTestsWithGlobalSetupAndPossiblePause(params) {
+  async runTestsWithGlobalSetupAndPossiblePause(params, signal) {
+    return this._enqueue(() => this._runTestsImpl(params, signal));
+  }
+  async _runTestsImpl(params, signal) {
     const configDir = this._configLocation.configDir;
     const testRunnerAndScreen = await this.createTestRunner();
-    const { testRunner, screen, claimStdio, releaseStdio } = testRunnerAndScreen;
+    const { testRunner: runner, screen, claimStdio, releaseStdio } = testRunnerAndScreen;
     claimStdio();
     try {
       const setupReporter = new MCPListReporter({ configDir, screen, includeTestId: true });
-      const { status: status2 } = await testRunner.runGlobalSetup([setupReporter]);
+      const { status: status2 } = await runner.runGlobalSetup([setupReporter]);
       if (status2 !== "passed")
         return { output: testRunnerAndScreen.output.join("\n"), status: status2 };
     } finally {
@@ -183,19 +193,28 @@ class TestContext {
     const cleanup = async () => {
       claimStdio();
       try {
-        const result = await testRunner.runGlobalTeardown();
+        const result = await runner.runGlobalTeardown();
         if (status === "passed")
           status = result.status;
       } finally {
         releaseStdio();
       }
     };
+    const abort = signal ? signalToPromise(signal) : void 0;
+    const abortPromise = abort ? abort.promise.then(() => "interrupted") : new Promise(() => {
+    });
     try {
       const reporter = new MCPListReporter({ configDir, screen, includeTestId: true });
       status = await Promise.race([
-        testRunner.runTests(reporter, params).then((result) => result.status),
-        testRunnerAndScreen.waitForTestPaused().then(() => "paused")
+        runner.runTests(reporter, params).then((result) => result.status),
+        testRunnerAndScreen.waitForTestPaused().then(() => "paused"),
+        abortPromise
       ]);
+      if (status === "interrupted") {
+        await runner.stopTests();
+        await cleanup();
+        return { output: testRunnerAndScreen.output.join("\n"), status };
+      }
       if (status === "paused") {
         const response = await testRunnerAndScreen.sendMessageToPausedTest({ request: { initialize: { clientInfo: this._clientInfo } } });
         if (response.error)
@@ -208,12 +227,14 @@ class TestContext {
       testRunnerAndScreen.output.push(String(e));
       await cleanup();
       return { output: testRunnerAndScreen.output.join("\n"), status };
+    } finally {
+      abort?.dispose();
     }
     await cleanup();
     return { output: testRunnerAndScreen.output.join("\n"), status };
   }
   async close() {
-    await this._cleanupTestRunner().catch(import_log.logUnhandledError);
+    await this._enqueue(() => this._cleanupTestRunner()).catch((e) => debug("pw:mcp:error")(e));
   }
   async sendMessageToPausedTest(request) {
     const sendMessage = this._testRunnerAndScreen?.sendMessageToPausedTest;
@@ -223,7 +244,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 = import_coreBundle.tools.parseResponse(result.response.callTool);
       if (response && !response.isError && response.code)
         this.generatorJournal?.logStep(request.callTool.arguments["intent"], response.code);
     }
@@ -235,9 +256,9 @@ function createScreen() {
   const stdout = new import_streams.StringWriteStream(output, "stdout");
   const stderr = new import_streams.StringWriteStream(output, "stderr");
   const screen = {
-    ...import_base.terminalScreen,
+    ...import_runner.base.terminalScreen,
     isTTY: false,
-    colors: import_utils.noColors,
+    colors: noColors,
     stdout,
     stderr
   };
@@ -271,7 +292,7 @@ const bestPracticesMarkdown = `
 - NEVER! use page.waitForTimeout()
 - NEVER! use page.evaluate()
 `;
-class MCPListReporter extends import_list.default {
+class MCPListReporter extends import_runner.ListReporter {
   async onTestPaused() {
     await new Promise(() => {
     });

package/lib/mcp/test/testTools.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ 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 testTools_exports = {};
 __export(testTools_exports, {
@@ -33,20 +23,20 @@ __export(testTools_exports, {
   runTests: () => runTests
 });
 module.exports = __toCommonJS(testTools_exports);
-var import_mcpBundle = require("playwright-core/lib/mcpBundle");
-var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
+var import_runner = require("../../runner");
 var import_testTool = require("./testTool");
+const z = require("playwright-core/lib/utilsBundle").z;
 const listTests = (0, import_testTool.defineTestTool)({
   schema: {
     name: "test_list",
     title: "List tests",
     description: "List tests",
-    inputSchema: import_mcpBundle.z.object({}),
+    inputSchema: z.object({}),
     type: "readOnly"
   },
   handle: async (context) => {
     const { testRunner, screen, output } = await context.createTestRunner();
-    const reporter = new import_listModeReporter.default({ screen, includeTestId: true });
+    const reporter = new import_runner.ListModeReporter({ screen, includeTestId: true });
     await testRunner.listTests(reporter, {});
     return { content: output.map((text) => ({ type: "text", text })) };
   }
@@ -56,18 +46,18 @@ const runTests = (0, import_testTool.defineTestTool)({
     name: "test_run",
     title: "Run tests",
     description: "Run tests",
-    inputSchema: import_mcpBundle.z.object({
-      locations: import_mcpBundle.z.array(import_mcpBundle.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_mcpBundle.z.array(import_mcpBundle.z.string()).optional().describe('Projects to run, projects from playwright.config.ts, by default runs all projects. Running with "chromium" is a good start')
+    inputSchema: z.object({
+      locations: z.array(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: z.array(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) => {
+  handle: async (context, params, signal) => {
     const { output } = await context.runTestsWithGlobalSetupAndPossiblePause({
       locations: params.locations ?? [],
       projects: params.projects,
       disableConfigReporters: true
-    });
+    }, signal);
     return { content: [{ type: "text", text: output }] };
   }
 });
@@ -76,15 +66,15 @@ const debugTest = (0, import_testTool.defineTestTool)({
     name: "test_debug",
     title: "Debug single test",
     description: "Debug single test",
-    inputSchema: import_mcpBundle.z.object({
-      test: import_mcpBundle.z.object({
-        id: import_mcpBundle.z.string().describe("Test ID to debug."),
-        title: import_mcpBundle.z.string().describe("Human readable test title for granting permission to debug the test.")
+    inputSchema: z.object({
+      test: z.object({
+        id: z.string().describe("Test ID to debug."),
+        title: z.string().describe("Human readable test title for granting permission to debug the test.")
       })
     }),
     type: "readOnly"
   },
-  handle: async (context, params) => {
+  handle: async (context, params, signal) => {
     const { output, status } = await context.runTestsWithGlobalSetupAndPossiblePause({
       headed: context.computedHeaded,
       locations: [],
@@ -96,7 +86,7 @@ const debugTest = (0, import_testTool.defineTestTool)({
       pauseOnError: true,
       disableConfigReporters: true,
       actionTimeout: 5e3
-    });
+    }, signal);
     return { content: [{ type: "text", text: output }], isError: status !== "paused" && status !== "passed" };
   }
 });

package/lib/{internalsForTest.js → package.js}

@@ -26,17 +26,22 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var internalsForTest_exports = {};
-__export(internalsForTest_exports, {
-  fileDependencies: () => fileDependencies
+var package_exports = {};
+__export(package_exports, {
+  libPath: () => libPath,
+  packageJSON: () => packageJSON,
+  packageRoot: () => packageRoot
 });
-module.exports = __toCommonJS(internalsForTest_exports);
+module.exports = __toCommonJS(package_exports);
 var import_path = __toESM(require("path"));
-var import_compilationCache = require("./transform/compilationCache");
-function fileDependencies() {
-  return Object.fromEntries([...(0, import_compilationCache.fileDependenciesForTest)().entries()].map((entry) => [import_path.default.basename(entry[0]), [...entry[1]].map((f) => import_path.default.basename(f)).sort()]));
+const packageRoot = import_path.default.join(__dirname, "..");
+const packageJSON = require(import_path.default.join(packageRoot, "package.json"));
+function libPath(...parts) {
+  return import_path.default.join(packageRoot, "lib", ...parts);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  fileDependencies
+  libPath,
+  packageJSON,
+  packageRoot
 });