playwright 1.56.1 → 1.57.0

package/lib/mcp/test/testContext.js

@@ -29,10 +29,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var testContext_exports = {};
 __export(testContext_exports, {
   GeneratorJournal: () => GeneratorJournal,
-  TestContext: () => TestContext
+  TestContext: () => TestContext,
+  createScreen: () => createScreen
 });
 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");
@@ -41,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;
@@ -70,35 +76,55 @@ ${step.code}
   }
 }
 class TestContext {
-  constructor(options) {
-    this.options = options;
-  }
-  initialize(rootPath, configLocation) {
-    this.configLocation = configLocation;
-    this.rootPath = rootPath || configLocation.configDir;
+  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);
   }
   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({});
-    this._testRunner = testRunner;
-    testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => {
-      this._testRunner?.emit(import_testRunner.TestRunnerEvent.TestFilesChanged, testFiles);
+    const testPaused = new import_utils.ManualPromise();
+    const testRunnerAndScreen = {
+      ...createScreen(),
+      testRunner,
+      waitForTestPaused: () => testPaused
+    };
+    this._testRunnerAndScreen = testRunnerAndScreen;
+    testRunner.on(import_testRunner.TestRunnerEvent.TestPaused, (params) => {
+      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) {
-      seedFile = await (0, import_seed.ensureSeedTest)(project, false);
+      seedFile = await (0, import_seed.ensureSeedFile)(project);
     } else {
       const candidateFiles = [];
       const testDir = project.project.testDir;
@@ -123,13 +149,9 @@ class TestContext {
       projectName: project.project.name
     };
   }
-  async runSeedTest(seedFile, projectName, progress) {
-    const { screen } = this.createScreen(progress);
-    const configDir = this.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen });
-    const testRunner = await this.createTestRunner();
-    const result = await testRunner.runTests(reporter, {
-      headed: !this.options?.headless,
+  async runSeedTest(seedFile, projectName) {
+    const result = await this.runTestsWithGlobalSetupAndPossiblePause({
+      headed: this.computedHeaded,
       locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
       projects: [projectName],
       timeout: 0,
@@ -138,25 +160,105 @@ class TestContext {
       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.");
+    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;
   }
-  createScreen(progress) {
-    const stream = new import_streams.StringWriteStream(progress);
-    const screen = {
-      ...import_base.terminalScreen,
-      isTTY: false,
-      colors: import_utils.noColors,
-      stdout: stream,
-      stderr: stream
+  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: status2 } = await testRunner.runGlobalSetup([setupReporter]);
+      if (status2 !== "passed")
+        return { output: testRunnerAndScreen.output.join("\n"), status: status2 };
+    } finally {
+      releaseStdio();
+    }
+    let status = "passed";
+    const cleanup = async () => {
+      claimStdio();
+      try {
+        const result = await testRunner.runGlobalTeardown();
+        if (status === "passed")
+          status = result.status;
+      } finally {
+        releaseStdio();
+      }
     };
-    return { screen, stream };
+    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() {
+  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,
+    colors: import_utils.noColors,
+    stdout,
+    stderr
+  };
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+  const claimStdio = () => {
+    process.stdout.write = (chunk) => {
+      stdout.write(chunk);
+      return true;
+    };
+    process.stderr.write = (chunk) => {
+      stderr.write(chunk);
+      return true;
+    };
+  };
+  const releaseStdio = () => {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  };
+  return { screen, claimStdio, releaseStdio, output };
+}
 const bestPracticesMarkdown = `
 # Best practices
 - Do not improvise, do not add directives that were not asked for
@@ -172,5 +274,6 @@ const bestPracticesMarkdown = `
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GeneratorJournal,
-  TestContext
+  TestContext,
+  createScreen
 });

package/lib/mcp/test/testTools.js

@@ -34,7 +34,6 @@ __export(testTools_exports, {
 });
 module.exports = __toCommonJS(testTools_exports);
 var import_bundle = require("../sdk/bundle");
-var import_list = __toESM(require("../../reporters/list"));
 var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
 var import_testTool = require("./testTool");
 const listTests = (0, import_testTool.defineTestTool)({
@@ -45,12 +44,11 @@ const listTests = (0, import_testTool.defineTestTool)({
     inputSchema: import_bundle.z.object({}),
     type: "readOnly"
   },
-  handle: async (context, _, progress) => {
-    const { screen } = context.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,17 +62,13 @@ const runTests = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params, progress) => {
-    const { screen } = context.createScreen(progress);
-    const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
-    const testRunner = await context.createTestRunner();
-    await testRunner.runTests(reporter, {
+  handle: async (context, params) => {
+    const { output } = await context.runTestsWithGlobalSetupAndPossiblePause({
       locations: params.locations,
       projects: params.projects,
       disableConfigReporters: true
     });
-    return { content: [] };
+    return { content: [{ type: "text", text: output }] };
   }
 });
 const debugTest = (0, import_testTool.defineTestTool)({
@@ -90,21 +84,18 @@ const debugTest = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params, progress) => {
-    const { screen } = context.createScreen(progress);
-    const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
-    const testRunner = await context.createTestRunner();
-    await testRunner.runTests(reporter, {
-      headed: !context.options?.headless,
+  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
+      disableConfigReporters: true,
+      actionTimeout: 5e3
     });
-    return { content: [] };
+    return { content: [{ type: "text", text: output }], isError: status !== "paused" && status !== "passed" };
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/lib/plugins/webServerPlugin.js

@@ -115,17 +115,42 @@ class WebServerPlugin {
     });
     this._killProcess = gracefullyClose;
     debugWebServer(`Process started`);
-    launchedProcess.stderr.on("data", (data) => {
-      if (debugWebServer.enabled || (this._options.stderr === "pipe" || !this._options.stderr))
-        this._reporter.onStdErr?.(prefixOutputLines(data.toString(), this._options.name));
-    });
+    if (this._options.wait?.stdout || this._options.wait?.stderr)
+      this._waitForStdioPromise = new import_utils.ManualPromise();
+    const stdioWaitCollectors = {
+      stdout: this._options.wait?.stdout ? "" : void 0,
+      stderr: this._options.wait?.stderr ? "" : void 0
+    };
     launchedProcess.stdout.on("data", (data) => {
       if (debugWebServer.enabled || this._options.stdout === "pipe")
         this._reporter.onStdOut?.(prefixOutputLines(data.toString(), this._options.name));
     });
+    launchedProcess.stderr.on("data", (data) => {
+      if (debugWebServer.enabled || (this._options.stderr === "pipe" || !this._options.stderr))
+        this._reporter.onStdErr?.(prefixOutputLines(data.toString(), this._options.name));
+    });
+    const resolveStdioPromise = () => {
+      stdioWaitCollectors.stdout = void 0;
+      stdioWaitCollectors.stderr = void 0;
+      this._waitForStdioPromise?.resolve();
+    };
+    for (const stdio of ["stdout", "stderr"]) {
+      launchedProcess[stdio].on("data", (data) => {
+        if (!this._options.wait?.[stdio] || stdioWaitCollectors[stdio] === void 0)
+          return;
+        stdioWaitCollectors[stdio] += data.toString();
+        this._options.wait[stdio].lastIndex = 0;
+        const result = this._options.wait[stdio].exec(stdioWaitCollectors[stdio]);
+        if (result) {
+          for (const [key, value] of Object.entries(result.groups || {}))
+            process.env[key.toUpperCase()] = value;
+          resolveStdioPromise();
+        }
+      });
+    }
   }
   async _waitForProcess() {
-    if (!this._isAvailableCallback) {
+    if (!this._isAvailableCallback && !this._waitForStdioPromise) {
       this._processExitedPromise.catch(() => {
       });
       return;
@@ -133,10 +158,13 @@ class WebServerPlugin {
     debugWebServer(`Waiting for availability...`);
     const launchTimeout = this._options.timeout || 60 * 1e3;
     const cancellationToken = { canceled: false };
-    const { timedOut } = await Promise.race([
-      (0, import_utils.raceAgainstDeadline)(() => waitFor(this._isAvailableCallback, cancellationToken), (0, import_utils.monotonicTime)() + launchTimeout),
-      this._processExitedPromise
-    ]);
+    const deadline = (0, import_utils.monotonicTime)() + launchTimeout;
+    const racingPromises = [this._processExitedPromise];
+    if (this._isAvailableCallback)
+      racingPromises.push((0, import_utils.raceAgainstDeadline)(() => waitFor(this._isAvailableCallback, cancellationToken), deadline));
+    if (this._waitForStdioPromise)
+      racingPromises.push((0, import_utils.raceAgainstDeadline)(() => this._waitForStdioPromise, deadline));
+    const { timedOut } = await Promise.race(racingPromises);
     cancellationToken.canceled = true;
     if (timedOut)
       throw new Error(`Timed out waiting ${launchTimeout}ms from config.webServer.`);

package/lib/program.js

@@ -46,9 +46,8 @@ var testServer = __toESM(require("./runner/testServer"));
 var import_watchMode = require("./runner/watchMode");
 var import_testRunner = require("./runner/testRunner");
 var import_reporters = require("./runner/reporters");
-var import_exports = require("./mcp/sdk/exports");
+var mcp = __toESM(require("./mcp/sdk/exports"));
 var import_testBackend = require("./mcp/test/testBackend");
-var import_seed = require("./mcp/test/seed");
 var import_program3 = require("./mcp/program");
 var import_watchdog = require("./mcp/browser/watchdog");
 var import_generateAgents = require("./agents/generateAgents");
@@ -160,44 +159,36 @@ function addTestMCPServerCommand(program3) {
   command.option("--port <port>", "port to listen on for SSE transport.");
   command.action(async (options) => {
     (0, import_watchdog.setupExitWatchdog)();
-    const backendFactory = {
+    const factory = {
       name: "Playwright Test Runner",
       nameInConfig: "playwright-test-runner",
       version: packageJSON.version,
       create: () => new import_testBackend.TestServerBackend(options.config, { muteConsole: options.port === void 0, headless: options.headless })
     };
-    const mdbUrl = await (0, import_exports.runMainBackend)(
-      backendFactory,
-      {
-        port: options.port === void 0 ? void 0 : +options.port
-      }
-    );
-    if (mdbUrl)
-      console.error("MCP Listening on: ", mdbUrl);
+    await mcp.start(factory, { port: options.port === void 0 ? void 0 : +options.port, host: options.host });
   });
 }
 function addInitAgentsCommand(program3) {
   const command = program3.command("init-agents");
   command.description("Initialize repository agents");
   const option = command.createOption("--loop <loop>", "Agentic loop provider");
-  option.choices(["vscode", "claude", "opencode"]);
+  option.choices(["claude", "copilot", "opencode", "vscode", "vscode-legacy"]);
   command.addOption(option);
   command.option("-c, --config <file>", `Configuration file to find a project to use for seed test`);
   command.option("--project <project>", "Project to use for seed test");
+  command.option("--prompts", "Whether to include prompts in the agent initialization");
   command.action(async (opts) => {
+    const config = await (0, import_configLoader.loadConfigFromFile)(opts.config);
     if (opts.loop === "opencode") {
-      await (0, import_generateAgents.initOpencodeRepo)();
-    } else if (opts.loop === "vscode") {
-      await (0, import_generateAgents.initVSCodeRepo)();
+      await import_generateAgents.OpencodeGenerator.init(config, opts.project, opts.prompts);
+    } else if (opts.loop === "vscode-legacy") {
+      await import_generateAgents.VSCodeGenerator.init(config, opts.project);
     } else if (opts.loop === "claude") {
-      await (0, import_generateAgents.initClaudeCodeRepo)();
+      await import_generateAgents.ClaudeGenerator.init(config, opts.project, opts.prompts);
     } else {
-      command.help();
+      await import_generateAgents.CopilotGenerator.init(config, opts.project, opts.prompts);
       return;
     }
-    const config = await (0, import_configLoader.loadConfigFromFile)(opts.config);
-    const project = (0, import_seed.seedProject)(config, opts.project);
-    await (0, import_seed.ensureSeedTest)(project, true);
   });
 }
 async function runTests(args, opts) {

package/lib/reporters/html.js

@@ -130,10 +130,10 @@ class HtmlReporter {
     if (process.env.CI || !this._buildResult)
       return;
     const { ok, singleTestId } = this._buildResult;
-    const shouldOpen = !this._options._isTestServer && (this._open === "always" || !ok && this._open === "on-failure");
+    const shouldOpen = !!process.stdin.isTTY && (this._open === "always" || !ok && this._open === "on-failure");
     if (shouldOpen) {
       await showHTMLReport(this._outputFolder, this._host, this._port, singleTestId);
-    } else if (this._options._mode === "test" && !this._options._isTestServer) {
+    } else if (this._options._mode === "test" && !!process.stdin.isTTY) {
       const packageManagerCommand = (0, import_utils.getPackageManagerExecCommand)();
       const relativeReportPath = this._outputFolder === standaloneDefaultFolder() ? "" : " " + import_path.default.relative(process.cwd(), this._outputFolder);
       const hostArg = this._host ? ` --host ${this._host}` : "";
@@ -197,8 +197,6 @@ function startHtmlReportServer(folder) {
         return false;
       }
     }
-    if (relativePath.endsWith("/stall.js"))
-      return true;
     if (relativePath === "/")
       relativePath = "/index.html";
     const absolutePath = import_path.default.join(folder, ...relativePath.split("/"));
@@ -274,25 +272,6 @@ class HtmlBuilder {
       const testFile = data.values().next().value.testFile;
       singleTestId = testFile.tests[0].testId;
     }
-    if (process.env.PW_HMR === "1") {
-      const redirectFile = import_path.default.join(this._reportFolder, "index.html");
-      await this._writeReportData(redirectFile);
-      async function redirect() {
-        const hmrURL = new URL("http://localhost:44224");
-        const popup = window.open(hmrURL);
-        const listener = (evt) => {
-          if (evt.source === popup && evt.data === "ready") {
-            const element = document.getElementById("playwrightReportBase64");
-            popup.postMessage(element?.textContent ?? "", hmrURL.origin);
-            window.removeEventListener("message", listener);
-            window.close();
-          }
-        };
-        window.addEventListener("message", listener);
-      }
-      import_fs.default.appendFileSync(redirectFile, `<script>(${redirect.toString()})()</script>`);
-      return { ok, singleTestId };
-    }
     const appFolder = import_path.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "htmlReport");
     await (0, import_utils.copyFileAndMakeWritable)(import_path.default.join(appFolder, "index.html"), import_path.default.join(this._reportFolder, "index.html"));
     if (this._hasTraces) {

package/lib/reporters/internalReporter.js

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var internalReporter_exports = {};
 __export(internalReporter_exports, {
-  InternalReporter: () => InternalReporter
+  InternalReporter: () => InternalReporter,
+  addLocationAndSnippetToError: () => addLocationAndSnippetToError
 });
 module.exports = __toCommonJS(internalReporter_exports);
 var import_fs = __toESM(require("fs"));
@@ -126,5 +127,6 @@ function addLocationAndSnippetToError(config, error, file) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  InternalReporter
+  InternalReporter,
+  addLocationAndSnippetToError
 });

package/lib/reporters/junit.js

@@ -173,8 +173,10 @@ class JUnitReporter {
     const systemOut = [];
     const systemErr = [];
     for (const result of test.results) {
-      systemOut.push(...result.stdout.map((item) => item.toString()));
-      systemErr.push(...result.stderr.map((item) => item.toString()));
+      for (const item of result.stdout)
+        systemOut.push(item.toString());
+      for (const item of result.stderr)
+        systemErr.push(item.toString());
       for (const attachment of result.attachments) {
         if (!attachment.path)
           continue;

package/lib/reporters/list.js

@@ -39,7 +39,6 @@ class ListReporter extends import_base.TerminalReporter {
     this._stepIndex = /* @__PURE__ */ new Map();
     this._needNewLine = false;
     this._printSteps = (0, import_utils.getAsBooleanFromENV)("PLAYWRIGHT_LIST_PRINT_STEPS", options?.printSteps);
-    this._prefixStdio = options?.prefixStdio;
   }
   onBegin(suite) {
     super.onBegin(suite);
@@ -143,10 +142,7 @@ class ListReporter extends import_base.TerminalReporter {
       return;
     const text = chunk.toString("utf-8");
     this._updateLineCountAndNewLineFlagForOutput(text);
-    if (this._prefixStdio)
-      stream.write(`[${stdio}] ${chunk}`);
-    else
-      stream.write(chunk);
+    stream.write(chunk);
   }
   onTestEnd(test, result) {
     super.onTestEnd(test, result);

package/lib/reporters/merge.js

@@ -41,7 +41,7 @@ var import_teleReceiver = require("../isomorphic/teleReceiver");
 var import_reporters = require("../runner/reporters");
 var import_util = require("../util");
 async function createMergedReport(config, dir, reporterDescriptions, rootDirOverride) {
-  const reporters = await (0, import_reporters.createReporters)(config, "merge", false, reporterDescriptions);
+  const reporters = await (0, import_reporters.createReporters)(config, "merge", reporterDescriptions);
   const multiplexer = new import_multiplexer.Multiplexer(reporters);
   const stringPool = new import_stringInternPool.StringInternPool();
   let printStatus = () => {
@@ -72,13 +72,15 @@ async function createMergedReport(config, dir, reporterDescriptions, rootDirOver
     }
   };
   await dispatchEvents(eventData.prologue);
-  for (const { reportFile, eventPatchers, metadata } of eventData.reports) {
+  for (const { reportFile, eventPatchers, metadata, tags } of eventData.reports) {
     const reportJsonl = await import_fs.default.promises.readFile(reportFile);
     const events = parseTestEvents(reportJsonl);
     new import_stringInternPool.JsonStringInternalizer(stringPool).traverse(events);
     eventPatchers.patchers.push(new AttachmentPathPatcher(dir));
     if (metadata.name)
       eventPatchers.patchers.push(new GlobalErrorPatcher(metadata.name));
+    if (tags.length)
+      eventPatchers.patchers.push(new GlobalErrorPatcher(tags.join(" ")));
     eventPatchers.patchEvents(events);
     await dispatchEvents(events);
   }
@@ -178,18 +180,22 @@ async function mergeEvents(dir, shardReportFiles, stringPool, printStatus, rootD
     if (rootDirOverride)
       eventPatchers.patchers.push(new PathSeparatorPatcher(metadata.pathSeparator));
     eventPatchers.patchEvents(parsedEvents);
+    let tags = [];
     for (const event of parsedEvents) {
-      if (event.method === "onConfigure")
+      if (event.method === "onConfigure") {
         configureEvents.push(event);
-      else if (event.method === "onProject")
+        tags = event.params.config.tags || [];
+      } else if (event.method === "onProject") {
         projectEvents.push(event);
-      else if (event.method === "onEnd")
+      } else if (event.method === "onEnd") {
         endEvents.push(event);
+      }
     }
     reports.push({
       eventPatchers,
       reportFile: localPath,
-      metadata
+      metadata,
+      tags
     });
   }
   return {

package/lib/reporters/teleEmitter.js

@@ -154,7 +154,9 @@ class TeleReporterEmitter {
       version: config.version,
       workers: config.workers,
       globalSetup: config.globalSetup,
-      globalTeardown: config.globalTeardown
+      globalTeardown: config.globalTeardown,
+      tags: config.tags,
+      webServer: config.webServer
     };
   }
   _serializeProject(suite) {