playwright 1.56.0-alpha-2025-10-01 → 1.56.0-beta-1759412259000

package/lib/mcp/test/generatorTools.js

@@ -28,7 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var generatorTools_exports = {};
 __export(generatorTools_exports, {
-  generatorLogStep: () => generatorLogStep,
   generatorReadLog: () => generatorReadLog,
   generatorWriteTest: () => generatorWriteTest,
   setupPage: () => setupPage
@@ -52,27 +51,9 @@ const setupPage = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, params, progress) => {
-    const seed = await context.getOrCreateSeedFile(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, params.project, progress);
-    return { content: [] };
-  }
-});
-const generatorLogStep = (0, import_testTool.defineTestTool)({
-  schema: {
-    name: "generator_log_step",
-    title: "Log a test step",
-    description: "Log a successful test step.",
-    inputSchema: import_bundle.z.object({
-      title: import_bundle.z.string().describe("Title of the test step"),
-      code: import_bundle.z.string().describe("The code for the last step only, as a markdown code block")
-    }),
-    type: "readOnly"
-  },
-  handle: async (context, params) => {
-    if (!context.generatorJournal)
-      throw new Error(`Please setup page using "${setupPage.schema.name}" first.`);
-    context.generatorJournal.logStep(params.title, params.code);
+    await context.runSeedTest(seed.file, seed.projectName, progress);
     return { content: [] };
   }
 });
@@ -103,7 +84,7 @@ const generatorWriteTest = (0, import_testTool.defineTestTool)({
       fileName: import_bundle.z.string().describe("The file to write the test to"),
       code: import_bundle.z.string().describe("The generated test code")
     }),
-    type: "destructive"
+    type: "readOnly"
   },
   handle: async (context, params) => {
     if (!context.generatorJournal)
@@ -117,7 +98,9 @@ const generatorWriteTest = (0, import_testTool.defineTestTool)({
       const testDir = import_path.default.relative(context.rootPath, project.project.testDir).replace(/\\/g, "/");
       const fileName = params.fileName.replace(/\\/g, "/");
       if (fileName.startsWith(testDir)) {
-        await import_fs.default.promises.writeFile(import_path.default.resolve(context.rootPath, fileName), params.code);
+        const resolvedFile = import_path.default.resolve(context.rootPath, fileName);
+        await import_fs.default.promises.mkdir(import_path.default.dirname(resolvedFile), { recursive: true });
+        await import_fs.default.promises.writeFile(resolvedFile, params.code);
         return {
           content: [{
             type: "text",
@@ -133,7 +116,6 @@ Test written to ${params.fileName}`
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  generatorLogStep,
   generatorReadLog,
   generatorWriteTest,
   setupPage

package/lib/mcp/test/plannerTools.js

@@ -35,8 +35,8 @@ const setupPage = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, params, progress) => {
-    const seed = await context.getOrCreateSeedFile(params);
-    await context.runSeedTest(seed.file, params.project, progress);
+    const seed = await context.getOrCreateSeedFile(params.seedFile, params.project);
+    await context.runSeedTest(seed.file, seed.projectName, progress);
     return { content: [] };
   }
 });

package/lib/mcp/test/seed.js

@@ -44,8 +44,7 @@ function seedProject(config, projectName) {
     throw new Error(`Project ${projectName} not found`);
   return project;
 }
-async function ensureSeedTest(config, projectName, logNew) {
-  const project = seedProject(config, projectName);
+async function ensureSeedTest(project, logNew) {
   const files = await (0, import_projectUtils.collectFilesForProject)(project);
   const seed = files.find((file) => import_path.default.basename(file).includes("seed"));
   if (seed)

package/lib/mcp/test/testBackend.js

@@ -38,6 +38,7 @@ 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");
 class TestServerBackend {
   constructor(configOption, options) {
     this.name = "Playwright";
@@ -45,7 +46,6 @@ class TestServerBackend {
     this._tools = [
       plannerTools.setupPage,
       generatorTools.setupPage,
-      generatorTools.generatorLogStep,
       generatorTools.generatorReadLog,
       generatorTools.generatorWriteTest,
       testTools.listTests,
@@ -55,11 +55,6 @@ class TestServerBackend {
     this._context = new import_testContext.TestContext(options);
     this._configOption = configOption;
   }
-  static {
-    this.allowedOnPause = [
-      generatorTools.generatorLogStep.schema.name
-    ];
-  }
   async initialize(server, clientInfo) {
     const rootPath = mcp.firstRootPath(clientInfo);
     if (this._configOption) {
@@ -75,9 +70,16 @@ class TestServerBackend {
   async listTools() {
     return [
       ...this._tools.map((tool) => mcp.toMcpTool(tool.schema)),
-      ...import_tools.browserTools.map((tool) => mcp.toMcpTool(tool.schema))
+      ...import_tools.browserTools.map((tool) => mcp.toMcpTool(tool.schema, { addIntent: true }))
     ];
   }
+  async afterCallTool(name, args, result) {
+    if (!import_tools.browserTools.find((tool) => tool.schema.name === name))
+      return;
+    const response = (0, import_response.parseResponse)(result);
+    if (response && !response.isError && response.code && typeof args?.["intent"] === "string")
+      this._context.generatorJournal?.logStep(args["intent"], response.code);
+  }
   async callTool(name, args, progress) {
     const tool = this._tools.find((tool2) => tool2.schema.name === name);
     if (!tool)

package/lib/mcp/test/testContext.js

@@ -49,7 +49,8 @@ class GeneratorJournal {
     this._steps = [];
   }
   logStep(title, code) {
-    this._steps.push({ title, code });
+    if (title)
+      this._steps.push({ title, code });
   }
   journal() {
     const result = [];
@@ -61,7 +62,9 @@ class GeneratorJournal {
     result.push("```");
     result.push(`# Steps`);
     result.push(this._steps.map((step) => `### ${step.title}
-${step.code}`).join("\n\n"));
+\`\`\`ts
+${step.code}
+\`\`\``).join("\n\n"));
     return result.join("\n\n");
   }
 }
@@ -88,30 +91,36 @@ class TestContext {
     this._testRunner = testRunner;
     return testRunner;
   }
-  async getOrCreateSeedFile(params) {
+  async getOrCreateSeedFile(seedFile, projectName) {
     const configDir = this.configLocation.configDir;
     const testRunner = await this.createTestRunner();
     const config = await testRunner.loadConfig();
-    let seedFile;
-    if (!params.seedFile) {
-      seedFile = await (0, import_seed.ensureSeedTest)(config, params.project, false);
+    const project = (0, import_seed.seedProject)(config, projectName);
+    if (!seedFile) {
+      seedFile = await (0, import_seed.ensureSeedTest)(project, false);
     } else {
       const candidateFiles = [];
-      const testDir = (0, import_seed.seedProject)(config, params.project).project.testDir;
-      candidateFiles.push(import_path.default.resolve(testDir, params.seedFile));
-      candidateFiles.push(import_path.default.resolve(configDir, params.seedFile));
-      candidateFiles.push(import_path.default.resolve(this.rootPath, params.seedFile));
+      const testDir = project.project.testDir;
+      candidateFiles.push(import_path.default.resolve(testDir, seedFile));
+      candidateFiles.push(import_path.default.resolve(configDir, seedFile));
+      candidateFiles.push(import_path.default.resolve(this.rootPath, seedFile));
+      let resolvedSeedFile;
       for (const candidateFile of candidateFiles) {
         if (await (0, import_util.fileExistsAsync)(candidateFile)) {
-          seedFile = candidateFile;
+          resolvedSeedFile = candidateFile;
           break;
         }
       }
-      if (!seedFile)
+      if (!resolvedSeedFile)
         throw new Error("seed test not found.");
+      seedFile = resolvedSeedFile;
     }
     const seedFileContent = await import_fs.default.promises.readFile(seedFile, "utf8");
-    return { file: seedFile, content: seedFileContent };
+    return {
+      file: seedFile,
+      content: seedFileContent,
+      projectName: project.project.name
+    };
   }
   async runSeedTest(seedFile, projectName, progress) {
     const { screen } = this.createScreen(progress);
@@ -121,7 +130,7 @@ class TestContext {
     const result = await testRunner.runTests(reporter, {
       headed: !this.options?.headless,
       locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
-      projects: projectName ? [projectName] : void 0,
+      projects: [projectName],
       timeout: 0,
       workers: 1,
       pauseAtEnd: true,