Add SPA session validation and buglist, update migration docs

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/playwright/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,24 +160,104 @@ 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
@@ -172,5 +274,6 @@ const bestPracticesMarkdown = `
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GeneratorJournal,
-  TestContext
+  TestContext,
+  createScreen
 });