playwright 1.57.0-alpha-2025-11-13 → 1.57.0-alpha-2025-11-15

package/lib/mcp/sdk/tool.js

@@ -23,16 +23,12 @@ __export(tool_exports, {
 });
 module.exports = __toCommonJS(tool_exports);
 var import_bundle = require("../sdk/bundle");
-const typesWithIntent = ["action", "assertion", "input"];
-function toMcpTool(tool, options) {
-  const inputSchema = options?.addIntent && typesWithIntent.includes(tool.type) ? tool.inputSchema.extend({
-    intent: import_bundle.z.string().describe("The intent of the call, for example the test step description plan idea")
-  }) : tool.inputSchema;
+function toMcpTool(tool) {
   const readOnly = tool.type === "readOnly" || tool.type === "assertion";
   return {
     name: tool.name,
     description: tool.description,
-    inputSchema: (0, import_bundle.zodToJsonSchema)(inputSchema, { strictUnions: true }),
+    inputSchema: (0, import_bundle.zodToJsonSchema)(tool.inputSchema, { strictUnions: true }),
     annotations: {
       title: tool.title,
       readOnlyHint: readOnly,

package/lib/mcp/test/generatorTools.js

@@ -50,11 +50,11 @@ const setupPage = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params, progress) => {
+  handle: async (context, params) => {
     const seed = await context.getOrCreateSeedFile(params.seedFile, params.project);
     context.generatorJournal = new import_testContext.GeneratorJournal(context.rootPath, params.plan, seed);
-    await context.runSeedTest(seed.file, seed.projectName, progress);
-    return { content: [] };
+    const { output, status } = await context.runSeedTest(seed.file, seed.projectName);
+    return { content: [{ type: "text", text: output }], isError: status !== "paused" };
   }
 });
 const generatorReadLog = (0, import_testTool.defineTestTool)({

package/lib/mcp/test/plannerTools.js

@@ -48,10 +48,10 @@ const setupPage = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params, progress) => {
+  handle: async (context, params) => {
     const seed = await context.getOrCreateSeedFile(params.seedFile, params.project);
-    await context.runSeedTest(seed.file, seed.projectName, progress);
-    return { content: [] };
+    const { output, status } = await context.runSeedTest(seed.file, seed.projectName);
+    return { content: [{ type: "text", text: output }], isError: status !== "paused" };
   }
 });
 const planSchema = import_bundle.z.object({

package/lib/mcp/test/streams.js

@@ -24,14 +24,17 @@ module.exports = __toCommonJS(streams_exports);
 var import_stream = require("stream");
 var import_util = require("../../util");
 class StringWriteStream extends import_stream.Writable {
-  constructor(progress, stdio) {
+  constructor(output, stdio) {
     super();
-    this._progress = progress;
+    this._output = output;
     this._prefix = stdio === "stdout" ? "" : "[err] ";
   }
   _write(chunk, encoding, callback) {
-    const text = (0, import_util.stripAnsiEscapes)(chunk.toString());
-    this._progress({ message: `${this._prefix}${text.endsWith("\n") ? text.slice(0, -1) : text}` });
+    let text = (0, import_util.stripAnsiEscapes)(chunk.toString());
+    if (text.endsWith("\n"))
+      text = text.slice(0, -1);
+    if (text)
+      this._output.push(this._prefix + text);
     callback();
   }
 }

package/lib/mcp/test/testBackend.js

@@ -31,17 +31,13 @@ __export(testBackend_exports, {
   TestServerBackend: () => TestServerBackend
 });
 module.exports = __toCommonJS(testBackend_exports);
-var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var import_utils = require("playwright-core/lib/utils");
 var mcp = __toESM(require("../sdk/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");
-var import_configLoader = require("../../common/configLoader");
-var import_response = require("../browser/response");
-const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
+var import_bundle = require("../sdk/bundle");
 class TestServerBackend {
   constructor(configOption, options) {
     this.name = "Playwright";
@@ -55,86 +51,48 @@ class TestServerBackend {
       generatorTools.generatorWriteTest,
       testTools.listTests,
       testTools.runTests,
-      testTools.debugTest
+      testTools.debugTest,
+      ...import_tools.browserTools.map((tool) => wrapBrowserTool(tool))
     ];
-    this._progress = [];
-    this._context = new import_testContext.TestContext(this._pushClient.bind(this), options);
+    this._options = options || {};
     this._configOption = configOption;
-    this._progressCallback = (params) => {
-      if (params.message)
-        this._progress.push({ type: "text", text: params.message });
-    };
-  }
-  async _pushClient(sendMessage) {
-    try {
-      const initializeResponse = await sendMessage({ initialize: { clientInfo: this._clientInfo } });
-      const listToolsResponse = await sendMessage({ listTools: {} });
-      const tools = listToolsResponse.listTools;
-      this._onPauseClient = { sendMessage, tools };
-      this._interruptPromise?.resolve({
-        content: [{
-          type: "text",
-          text: initializeResponse.initialize.pausedMessage
-        }]
-      });
-      this._interruptPromise = void 0;
-    } catch {
-    }
   }
   async initialize(clientInfo) {
-    this._clientInfo = clientInfo;
-    const rootPath = mcp.firstRootPath(clientInfo);
-    if (this._configOption) {
-      this._context.initialize(rootPath, (0, import_configLoader.resolveConfigLocation)(this._configOption));
-      return;
-    }
-    if (rootPath) {
-      this._context.initialize(rootPath, (0, import_configLoader.resolveConfigLocation)(rootPath));
-      return;
-    }
-    this._context.initialize(rootPath, (0, import_configLoader.resolveConfigLocation)(void 0));
+    this._context = new import_testContext.TestContext(clientInfo, this._configOption, this._options);
   }
   async listTools() {
-    return [
-      ...this._tools.map((tool) => mcp.toMcpTool(tool.schema)),
-      ...import_tools.browserTools.map((tool) => mcp.toMcpTool(tool.schema, { addIntent: true }))
-    ];
+    return this._tools.map((tool) => mcp.toMcpTool(tool.schema));
   }
   async callTool(name, args) {
-    if (this._onPauseClient?.tools.find((tool) => tool.name === name)) {
-      const callToolRespone = await this._onPauseClient.sendMessage({ callTool: { name, arguments: args } });
-      const result2 = callToolRespone.callTool;
-      const response = (0, import_response.parseResponse)(result2);
-      if (response && !response.isError && response.code && typeof args?.["intent"] === "string")
-        this._context.generatorJournal?.logStep(args["intent"], response.code);
-      return result2;
-    }
-    await this._onPauseClient?.sendMessage({ close: {} }).catch(errorsDebug);
-    this._onPauseClient = void 0;
-    const resultPromise = new import_utils.ManualPromise();
-    const interruptPromise = new import_utils.ManualPromise();
-    this._interruptPromise = interruptPromise;
-    this._callTestTool(name, args).then((result2) => {
-      resultPromise.resolve(result2);
-    }).catch((e) => {
-      resultPromise.resolve({ content: [{ type: "text", text: String(e) }], isError: true });
-    });
-    const result = await Promise.race([interruptPromise, resultPromise]);
-    result.content.unshift(...this._progress);
-    this._progress.length = 0;
-    return result;
-  }
-  async _callTestTool(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, this._progressCallback);
+    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();
   }
 }
+const typesWithIntent = ["action", "assertion", "input"];
+function wrapBrowserTool(tool) {
+  const inputSchema = typesWithIntent.includes(tool.schema.type) ? tool.schema.inputSchema.extend({
+    intent: import_bundle.z.string().describe("The intent of the call, for example the test step description plan idea")
+  }) : tool.schema.inputSchema;
+  return {
+    schema: {
+      ...tool.schema,
+      inputSchema
+    },
+    handle: async (context, params) => {
+      const response = await context.sendMessageToPausedTest({ callTool: { name: tool.schema.name, arguments: params } });
+      return response.callTool;
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TestServerBackend

package/lib/mcp/test/testContext.js

@@ -43,6 +43,10 @@ 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;
@@ -72,40 +76,51 @@ ${step.code}
   }
 }
 class TestContext {
-  constructor(pushClient, options) {
-    this._pushClient = pushClient;
-    this.options = options;
+  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;
     if (options?.headless !== void 0)
       this.computedHeaded = !options.headless;
     else
       this.computedHeaded = !process.env.CI && !(import_os.default.platform() === "linux" && !process.env.DISPLAY);
   }
-  initialize(rootPath, configLocation) {
-    this.configLocation = configLocation;
-    this.rootPath = rootPath || configLocation.configDir;
-  }
   existingTestRunner() {
-    return this._testRunner;
+    return this._testRunnerAndScreen?.testRunner;
+  }
+  async _cleanupTestRunner() {
+    if (!this._testRunnerAndScreen)
+      return;
+    await this._testRunnerAndScreen.testRunner.stopTests();
+    this._testRunnerAndScreen.claimStdio();
+    try {
+      await this._testRunnerAndScreen.testRunner.runGlobalTeardown();
+    } finally {
+      this._testRunnerAndScreen.releaseStdio();
+      this._testRunnerAndScreen = void 0;
+    }
   }
   async createTestRunner() {
-    if (this._testRunner)
-      await this._testRunner.stopTests();
-    const testRunner = new import_testRunner.TestRunner(this.configLocation, {});
+    await this._cleanupTestRunner();
+    const testRunner = new import_testRunner.TestRunner(this._configLocation, {});
     await testRunner.initialize({});
+    const testPaused = new import_utils.ManualPromise();
+    const testRunnerAndScreen = {
+      ...createScreen(),
+      testRunner,
+      waitForTestPaused: () => testPaused
+    };
+    this._testRunnerAndScreen = testRunnerAndScreen;
     testRunner.on(import_testRunner.TestRunnerEvent.TestPaused, (params) => {
-      void this._pushClient(async (request) => {
-        const response = await params.sendMessage({ request });
-        if (response.error)
-          throw new Error(response.error.message);
-        return response.response;
-      });
+      testRunnerAndScreen.sendMessageToPausedTest = params.sendMessage;
+      testPaused.resolve();
     });
-    this._testRunner = testRunner;
-    return testRunner;
+    return testRunnerAndScreen;
   }
   async getOrCreateSeedFile(seedFile, projectName) {
-    const configDir = this.configLocation.configDir;
-    const testRunner = await this.createTestRunner();
+    const configDir = this._configLocation.configDir;
+    const { testRunner } = await this.createTestRunner();
     const config = await testRunner.loadConfig();
     const project = (0, import_seed.seedProject)(config, projectName);
     if (!seedFile) {
@@ -134,53 +149,91 @@ class TestContext {
       projectName: project.project.name
     };
   }
-  async runSeedTest(seedFile, projectName, progress) {
-    await this.runWithGlobalSetup(async (testRunner, reporter) => {
-      const result = await testRunner.runTests(reporter, {
-        headed: this.computedHeaded,
-        locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
-        projects: [projectName],
-        timeout: 0,
-        workers: 1,
-        pauseAtEnd: true,
-        disableConfigReporters: true,
-        failOnLoadErrors: true
-      });
-      if (result.status === "passed" && !reporter.suite?.allTests().length)
-        throw new Error("seed test not found.");
-      if (result.status !== "passed")
-        throw new Error("Errors while running the seed test.");
-    }, progress);
+  async runSeedTest(seedFile, projectName) {
+    const result = await this.runTestsWithGlobalSetupAndPossiblePause({
+      headed: this.computedHeaded,
+      locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
+      projects: [projectName],
+      timeout: 0,
+      workers: 1,
+      pauseAtEnd: true,
+      disableConfigReporters: true,
+      failOnLoadErrors: true
+    });
+    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 runWithGlobalSetup(callback, progress) {
-    const { screen, claimStdio, releaseStdio } = createScreen(progress);
-    const configDir = this.configLocation.configDir;
-    const testRunner = await this.createTestRunner();
+  async runTestsWithGlobalSetupAndPossiblePause(params) {
+    const configDir = this._configLocation.configDir;
+    const testRunnerAndScreen = await this.createTestRunner();
+    const { testRunner, screen, claimStdio, releaseStdio } = testRunnerAndScreen;
     claimStdio();
     try {
       const setupReporter = new import_list.default({ configDir, screen, includeTestId: true });
-      const { status } = await testRunner.runGlobalSetup([setupReporter]);
-      if (status !== "passed")
-        throw new Error("Failed to run global setup");
+      const { status: status2 } = await testRunner.runGlobalSetup([setupReporter]);
+      if (status2 !== "passed")
+        return { output: testRunnerAndScreen.output.join("\n"), status: status2 };
     } finally {
       releaseStdio();
     }
-    try {
-      const reporter = new import_list.default({ configDir, screen, includeTestId: true });
-      return await callback(testRunner, reporter);
-    } finally {
+    let status = "passed";
+    const cleanup = async () => {
       claimStdio();
-      await testRunner.runGlobalTeardown().finally(() => {
+      try {
+        const result = await testRunner.runGlobalTeardown();
+        if (status === "passed")
+          status = result.status;
+      } finally {
         releaseStdio();
-      });
+      }
+    };
+    try {
+      const reporter = new import_list.default({ configDir, screen, includeTestId: true });
+      status = await Promise.race([
+        testRunner.runTests(reporter, params).then((result) => result.status),
+        testRunnerAndScreen.waitForTestPaused().then(() => "paused")
+      ]);
+      if (status === "paused") {
+        const response = await testRunnerAndScreen.sendMessageToPausedTest({ request: { initialize: { clientInfo: this._clientInfo } } });
+        if (response.error)
+          throw new Error(response.error.message);
+        testRunnerAndScreen.output.push(response.response.initialize.pausedMessage);
+        return { output: testRunnerAndScreen.output.join("\n"), status };
+      }
+    } catch (e) {
+      status = "failed";
+      testRunnerAndScreen.output.push(String(e));
+      await cleanup();
+      return { output: testRunnerAndScreen.output.join("\n"), status };
     }
+    await cleanup();
+    return { output: testRunnerAndScreen.output.join("\n"), status };
   }
   async close() {
+    await this._cleanupTestRunner().catch(import_log.logUnhandledError);
+  }
+  async sendMessageToPausedTest(request) {
+    const sendMessage = this._testRunnerAndScreen?.sendMessageToPausedTest;
+    if (!sendMessage)
+      throw new Error("Must setup test before interacting with the page");
+    const result = await sendMessage({ request });
+    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);
+      if (response && !response.isError && response.code)
+        this.generatorJournal?.logStep(request.callTool.arguments["intent"], response.code);
+    }
+    return result.response;
   }
 }
-function createScreen(progress) {
-  const stdout = new import_streams.StringWriteStream(progress, "stdout");
-  const stderr = new import_streams.StringWriteStream(progress, "stderr");
+function createScreen() {
+  const output = [];
+  const stdout = new import_streams.StringWriteStream(output, "stdout");
+  const stderr = new import_streams.StringWriteStream(output, "stderr");
   const screen = {
     ...import_base.terminalScreen,
     isTTY: false,
@@ -204,7 +257,7 @@ function createScreen(progress) {
     process.stdout.write = originalStdoutWrite;
     process.stderr.write = originalStderrWrite;
   };
-  return { screen, claimStdio, releaseStdio };
+  return { screen, claimStdio, releaseStdio, output };
 }
 const bestPracticesMarkdown = `
 # Best practices

package/lib/mcp/test/testTools.js

@@ -36,7 +36,6 @@ module.exports = __toCommonJS(testTools_exports);
 var import_bundle = require("../sdk/bundle");
 var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
 var import_testTool = require("./testTool");
-var import_testContext = require("./testContext");
 const listTests = (0, import_testTool.defineTestTool)({
   schema: {
     name: "test_list",
@@ -45,12 +44,11 @@ const listTests = (0, import_testTool.defineTestTool)({
     inputSchema: import_bundle.z.object({}),
     type: "readOnly"
   },
-  handle: async (context, _, progress) => {
-    const { screen } = (0, import_testContext.createScreen)(progress);
+  handle: async (context) => {
+    const { testRunner, screen, output } = await context.createTestRunner();
     const reporter = new import_listModeReporter.default({ screen, includeTestId: true });
-    const testRunner = await context.createTestRunner();
     await testRunner.listTests(reporter, {});
-    return { content: [] };
+    return { content: output.map((text) => ({ type: "text", text })) };
   }
 });
 const runTests = (0, import_testTool.defineTestTool)({
@@ -64,15 +62,13 @@ const runTests = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params, progress) => {
-    await context.runWithGlobalSetup(async (testRunner, reporter) => {
-      await testRunner.runTests(reporter, {
-        locations: params.locations,
-        projects: params.projects,
-        disableConfigReporters: true
-      });
-    }, progress);
-    return { content: [] };
+  handle: async (context, params) => {
+    const { output } = await context.runTestsWithGlobalSetupAndPossiblePause({
+      locations: params.locations,
+      projects: params.projects,
+      disableConfigReporters: true
+    });
+    return { content: [{ type: "text", text: output }] };
   }
 });
 const debugTest = (0, import_testTool.defineTestTool)({
@@ -88,20 +84,18 @@ const debugTest = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params, progress) => {
-    await context.runWithGlobalSetup(async (testRunner, reporter) => {
-      await testRunner.runTests(reporter, {
-        headed: context.computedHeaded,
-        testIds: [params.test.id],
-        // For automatic recovery
-        timeout: 0,
-        workers: 1,
-        pauseOnError: true,
-        disableConfigReporters: true,
-        actionTimeout: 5e3
-      });
-    }, progress);
-    return { content: [] };
+  handle: async (context, params) => {
+    const { output, status } = await context.runTestsWithGlobalSetupAndPossiblePause({
+      headed: context.computedHeaded,
+      testIds: [params.test.id],
+      // For automatic recovery
+      timeout: 0,
+      workers: 1,
+      pauseOnError: true,
+      disableConfigReporters: true,
+      actionTimeout: 5e3
+    });
+    return { content: [{ type: "text", text: output }], isError: status !== "paused" && status !== "passed" };
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/lib/runner/dispatcher.js

@@ -483,6 +483,7 @@ class JobDispatcher {
         const result = test._appendTestResult();
         this._reporter.onTestBegin?.(test, result);
         result.status = "skipped";
+        result.annotations = [...test.annotations];
         this._reportTestEnd(test, result);
       }
       return true;

package/lib/runner/testRunner.js

@@ -253,10 +253,6 @@ class TestRunner extends import_events.default {
       ...params.updateSourceMethod ? { updateSourceMethod: params.updateSourceMethod } : {},
       ...params.workers ? { workers: params.workers } : {}
     };
-    if (params.trace === "on")
-      process.env.PW_LIVE_TRACE_STACKS = "1";
-    else
-      process.env.PW_LIVE_TRACE_STACKS = void 0;
     const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter([userReporter]), overrides);
     if (!config)
       return { status: "failed" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.57.0-alpha-2025-11-13",
+  "version": "1.57.0-alpha-2025-11-15",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.57.0-alpha-2025-11-13"
+    "playwright-core": "1.57.0-alpha-2025-11-15"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/types/test.d.ts

@@ -10198,14 +10198,14 @@ interface TestConfigWebServer {
   wait?: {
     /**
      * Regular expression to wait for in the `stdout` of the command output. Named capture groups are stored in the
-     * environment, for example /Listening on port (?<my_server_port>\\d+)/ will store the port number in
+     * environment, for example `/Listening on port (?<my_server_port>\\d+)/` will store the port number in
      * `process.env['MY_SERVER_PORT']`.
      */
     stdout?: RegExp;
 
     /**
      * Regular expression to wait for in the `stderr` of the command output. Named capture groups are stored in the
-     * environment, for example /Listening on port (?<my_server_port>\\d+)/ will store the port number in
+     * environment, for example `/Listening on port (?<my_server_port>\\d+)/` will store the port number in
      * `process.env['MY_SERVER_PORT']`.
      */
     stderr?: RegExp;