playwright 1.57.0-alpha-2025-10-15 → 1.57.0-alpha-2025-10-17

package/lib/agents/generateAgents.js

@@ -28,20 +28,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var generateAgents_exports = {};
 __export(generateAgents_exports, {
-  initClaudeCodeRepo: () => initClaudeCodeRepo,
-  initOpencodeRepo: () => initOpencodeRepo,
-  initVSCodeRepo: () => initVSCodeRepo
+  AgentGenerator: () => AgentGenerator,
+  ClaudeGenerator: () => ClaudeGenerator,
+  OpencodeGenerator: () => OpencodeGenerator,
+  VSCodeGenerator: () => VSCodeGenerator
 });
 module.exports = __toCommonJS(generateAgents_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_seed = require("../mcp/test/seed");
 class AgentParser {
+  static async loadAgents() {
+    const files = await import_fs.default.promises.readdir(__dirname);
+    return Promise.all(files.filter((file) => file.endsWith(".md")).map((file) => AgentParser.parseFile(import_path.default.join(__dirname, file))));
+  }
   static async parseFile(filePath) {
-    const rawMarkdown = await import_fs.default.promises.readFile(filePath, "utf-8");
-    const { header, content } = this.extractYamlAndContent(rawMarkdown);
+    const source = await import_fs.default.promises.readFile(filePath, "utf-8");
+    const { header, content } = this.extractYamlAndContent(source);
     const { instructions, examples } = this.extractInstructionsAndExamples(content);
-    return { header, instructions, examples };
+    return { source, header, instructions, examples };
   }
   static extractYamlAndContent(markdown) {
     const lines = markdown.split("\n");
@@ -84,182 +91,275 @@ class AgentParser {
     return { instructions, examples };
   }
 }
-const claudeToolMap = /* @__PURE__ */ new Map([
-  ["ls", ["Glob"]],
-  ["grep", ["Grep"]],
-  ["read", ["Read"]],
-  ["edit", ["Edit", "MultiEdit"]],
-  ["write", ["Write"]]
-]);
-const commonMcpServers = {
-  playwrightTest: {
-    type: "local",
-    command: "npx",
-    args: ["playwright", "run-test-mcp-server"]
+class ClaudeGenerator {
+  static async init(config, projectName) {
+    await initRepo(config, projectName);
+    const agents = await AgentParser.loadAgents();
+    await import_fs.default.promises.mkdir(".claude/agents", { recursive: true });
+    for (const agent of agents)
+      await writeFile(`.claude/agents/${agent.header.name}.md`, ClaudeGenerator.agentSpec(agent), "\u{1F916}", "agent definition");
+    await writeFile(".mcp.json", JSON.stringify({
+      mcpServers: {
+        "playwright-test": {
+          command: "npx",
+          args: ["playwright", "run-test-mcp-server"]
+        }
+      }
+    }, null, 2), "\u{1F527}", "mcp configuration");
+    initRepoDone();
   }
-};
-function saveAsClaudeCode(agent) {
-  function asClaudeTool(tool) {
-    const [first, second] = tool.split("/");
-    if (!second)
-      return (claudeToolMap.get(first) || [first]).join(", ");
-    return `mcp__${first}__${second}`;
+  static agentSpec(agent) {
+    const claudeToolMap = /* @__PURE__ */ new Map([
+      ["search", ["Glob", "Grep"]],
+      ["read", ["Read"]],
+      ["edit", ["Edit", "MultiEdit"]],
+      ["write", ["Write"]]
+    ]);
+    function asClaudeTool(tool) {
+      const [first, second] = tool.split("/");
+      if (!second)
+        return (claudeToolMap.get(first) || [first]).join(", ");
+      return `mcp__${first}__${second}`;
+    }
+    const lines = [];
+    lines.push(`---`);
+    lines.push(`name: ${agent.header.name}`);
+    lines.push(`description: ${agent.header.description}. Examples: ${agent.examples.map((example) => `<example>${example}</example>`).join("")}`);
+    lines.push(`tools: ${agent.header.tools.map((tool) => asClaudeTool(tool)).join(", ")}`);
+    lines.push(`model: ${agent.header.model}`);
+    lines.push(`color: ${agent.header.color}`);
+    lines.push(`---`);
+    lines.push("");
+    lines.push(agent.instructions);
+    return lines.join("\n");
   }
-  const lines = [];
-  lines.push(`---`);
-  lines.push(`name: playwright-test-${agent.header.name}`);
-  lines.push(`description: ${agent.header.description}. Examples: ${agent.examples.map((example) => `<example>${example}</example>`).join("")}`);
-  lines.push(`tools: ${agent.header.tools.map((tool) => asClaudeTool(tool)).join(", ")}`);
-  lines.push(`model: ${agent.header.model}`);
-  lines.push(`color: ${agent.header.color}`);
-  lines.push(`---`);
-  lines.push("");
-  lines.push(agent.instructions);
-  return lines.join("\n");
 }
-const opencodeToolMap = /* @__PURE__ */ new Map([
-  ["ls", ["ls", "glob"]],
-  ["grep", ["grep"]],
-  ["read", ["read"]],
-  ["edit", ["edit"]],
-  ["write", ["write"]]
-]);
-function saveAsOpencodeJson(agents) {
-  function asOpencodeTool(tools, tool) {
-    const [first, second] = tool.split("/");
-    if (!second) {
-      for (const tool2 of opencodeToolMap.get(first) || [first])
-        tools[tool2] = true;
-    } else {
-      tools[`${first}*${second}`] = true;
+class OpencodeGenerator {
+  static async init(config, projectName) {
+    await initRepo(config, projectName);
+    const agents = await AgentParser.loadAgents();
+    await import_fs.default.promises.mkdir(".opencode/prompts", { recursive: true });
+    for (const agent of agents) {
+      const prompt = [agent.instructions];
+      prompt.push("");
+      prompt.push(...agent.examples.map((example) => `<example>${example}</example>`));
+      await writeFile(`.opencode/prompts/${agent.header.name}.md`, prompt.join("\n"), "\u{1F916}", "agent definition");
     }
+    await writeFile("opencode.json", OpencodeGenerator.configuration(agents), "\u{1F527}", "opencode configuration");
+    initRepoDone();
   }
-  const result = {};
-  result["$schema"] = "https://opencode.ai/config.json";
-  result["mcp"] = {};
-  result["tools"] = {
-    "playwright*": false
-  };
-  result["agent"] = {};
-  for (const agent of agents) {
-    const tools = {};
-    result["agent"]["playwright-test-" + agent.header.name] = {
-      description: agent.header.description,
-      mode: "subagent",
-      prompt: `{file:.opencode/prompts/playwright-test-${agent.header.name}.md}`,
-      tools
+  static configuration(agents) {
+    const opencodeToolMap = /* @__PURE__ */ new Map([
+      ["search", ["ls", "glob", "grep"]],
+      ["read", ["read"]],
+      ["edit", ["edit"]],
+      ["write", ["write"]]
+    ]);
+    const asOpencodeTool = (tools, tool) => {
+      const [first, second] = tool.split("/");
+      if (!second) {
+        for (const tool2 of opencodeToolMap.get(first) || [first])
+          tools[tool2] = true;
+      } else {
+        tools[`${first}*${second}`] = true;
+      }
+    };
+    const result = {};
+    result["$schema"] = "https://opencode.ai/config.json";
+    result["mcp"] = {};
+    result["tools"] = {
+      "playwright*": false
     };
-    for (const tool of agent.header.tools)
-      asOpencodeTool(tools, tool);
+    result["agent"] = {};
+    for (const agent of agents) {
+      const tools = {};
+      result["agent"][agent.header.name] = {
+        description: agent.header.description,
+        mode: "subagent",
+        prompt: `{file:.opencode/prompts/${agent.header.name}.md}`,
+        tools
+      };
+      for (const tool of agent.header.tools)
+        asOpencodeTool(tools, tool);
+    }
+    result["mcp"]["playwright-test"] = {
+      type: "local",
+      command: ["npx", "playwright", "run-test-mcp-server"],
+      enabled: true
+    };
+    return JSON.stringify(result, null, 2);
   }
-  const server = commonMcpServers.playwrightTest;
-  result["mcp"]["playwright-test"] = {
-    type: server.type,
-    command: [server.command, ...server.args],
-    enabled: true
-  };
-  return JSON.stringify(result, null, 2);
-}
-async function loadAgents() {
-  const files = await import_fs.default.promises.readdir(__dirname);
-  return Promise.all(files.filter((file) => file.endsWith(".md")).map((file) => AgentParser.parseFile(import_path.default.join(__dirname, file))));
-}
-async function writeFile(filePath, content) {
-  console.log(`Writing file: ${filePath}`);
-  await import_fs.default.promises.writeFile(filePath, content, "utf-8");
 }
-async function initClaudeCodeRepo() {
-  const agents = await loadAgents();
-  await import_fs.default.promises.mkdir(".claude/agents", { recursive: true });
-  for (const agent of agents)
-    await writeFile(`.claude/agents/playwright-test-${agent.header.name}.md`, saveAsClaudeCode(agent));
-  await writeFile(".mcp.json", JSON.stringify({
-    mcpServers: {
-      "playwright-test": {
-        command: commonMcpServers.playwrightTest.command,
-        args: commonMcpServers.playwrightTest.args
-      }
+class AgentGenerator {
+  static async init(config, projectName) {
+    const agentsFolder = process.env.AGENTS_FOLDER;
+    if (!agentsFolder) {
+      console.error("AGENTS_FOLDER environment variable is not set");
+      return;
     }
-  }, null, 2));
-}
-const vscodeToolMap = /* @__PURE__ */ new Map([
-  ["ls", ["search/listDirectory", "search/fileSearch"]],
-  ["grep", ["search/textSearch"]],
-  ["read", ["search/readFile"]],
-  ["edit", ["edit/editFiles"]],
-  ["write", ["edit/createFile", "edit/createDirectory"]]
-]);
-const vscodeToolsOrder = ["edit/createFile", "edit/createDirectory", "edit/editFiles", "search/fileSearch", "search/textSearch", "search/listDirectory", "search/readFile"];
-const vscodeMcpName = "playwright-test";
-function saveAsVSCodeChatmode(agent) {
-  function asVscodeTool(tool) {
-    const [first, second] = tool.split("/");
-    if (second)
-      return `${vscodeMcpName}/${second}`;
-    return vscodeToolMap.get(first) || first;
+    await initRepo(config, projectName);
+    const agents = await AgentParser.loadAgents();
+    await import_fs.default.promises.mkdir(agentsFolder, { recursive: true });
+    for (const agent of agents)
+      await writeFile(`${agentsFolder}/${agent.header.name}.md`, agent.source, "\u{1F916}", "agent definition");
+    console.log("\u{1F527} MCP configuration");
+    console.log(JSON.stringify({
+      mcpServers: {
+        "playwright-test": {
+          type: "stdio",
+          command: "npx",
+          args: [
+            `--prefix=${import_path.default.resolve(process.cwd())}`,
+            "playwright",
+            "run-test-mcp-server",
+            `--headless`,
+            `--config=${import_path.default.resolve(process.cwd())}`
+          ],
+          tools: ["*"]
+        }
+      }
+    }, null, 2));
+    initRepoDone();
   }
-  const tools = agent.header.tools.map(asVscodeTool).flat().sort((a, b) => {
-    const indexA = vscodeToolsOrder.indexOf(a);
-    const indexB = vscodeToolsOrder.indexOf(b);
-    if (indexA === -1 && indexB === -1)
-      return a.localeCompare(b);
-    if (indexA === -1)
-      return 1;
-    if (indexB === -1)
-      return -1;
-    return indexA - indexB;
-  }).map((tool) => `'${tool}'`).join(", ");
-  const lines = [];
-  lines.push(`---`);
-  lines.push(`description: ${agent.header.description}.`);
-  lines.push(`tools: [${tools}]`);
-  lines.push(`---`);
-  lines.push("");
-  lines.push(agent.instructions);
-  for (const example of agent.examples)
-    lines.push(`<example>${example}</example>`);
-  return lines.join("\n");
 }
-async function initVSCodeRepo() {
-  const agents = await loadAgents();
-  await import_fs.default.promises.mkdir(".github/chatmodes", { recursive: true });
-  for (const agent of agents)
-    await writeFile(`.github/chatmodes/${agent.header.name === "planner" ? " " : ""}\u{1F3AD} ${agent.header.name}.chatmode.md`, saveAsVSCodeChatmode(agent));
-  await import_fs.default.promises.mkdir(".vscode", { recursive: true });
-  const mcpJsonPath = ".vscode/mcp.json";
-  let mcpJson = {
-    servers: {},
-    inputs: []
-  };
-  try {
-    mcpJson = JSON.parse(import_fs.default.readFileSync(mcpJsonPath, "utf8"));
-  } catch {
+class VSCodeGenerator {
+  static async init(config, projectName) {
+    await initRepo(config, projectName);
+    const agents = await AgentParser.loadAgents();
+    const nameMap = /* @__PURE__ */ new Map([
+      ["playwright-test-planner", " \u{1F3AD} planner"],
+      ["playwright-test-generator", "\u{1F3AD} generator"],
+      ["playwright-test-healer", "\u{1F3AD} healer"]
+    ]);
+    await import_fs.default.promises.mkdir(".github/chatmodes", { recursive: true });
+    for (const agent of agents)
+      await writeFile(`.github/chatmodes/${nameMap.get(agent.header.name)}.chatmode.md`, VSCodeGenerator.agentSpec(agent), "\u{1F916}", "chatmode definition");
+    await import_fs.default.promises.mkdir(".vscode", { recursive: true });
+    const mcpJsonPath = ".vscode/mcp.json";
+    let mcpJson = {
+      servers: {},
+      inputs: []
+    };
+    try {
+      mcpJson = JSON.parse(import_fs.default.readFileSync(mcpJsonPath, "utf8"));
+    } catch {
+    }
+    if (!mcpJson.servers)
+      mcpJson.servers = {};
+    mcpJson.servers["playwright-test"] = {
+      type: "stdio",
+      command: "npx",
+      args: ["playwright", "run-test-mcp-server"]
+    };
+    await writeFile(mcpJsonPath, JSON.stringify(mcpJson, null, 2), "\u{1F527}", "mcp configuration");
+    initRepoDone();
+  }
+  static agentSpec(agent) {
+    const vscodeToolMap = /* @__PURE__ */ new Map([
+      ["search", ["search/listDirectory", "search/fileSearch", "search/textSearch"]],
+      ["read", ["search/readFile"]],
+      ["edit", ["edit/editFiles"]],
+      ["write", ["edit/createFile", "edit/createDirectory"]]
+    ]);
+    const vscodeToolsOrder = ["edit/createFile", "edit/createDirectory", "edit/editFiles", "search/fileSearch", "search/textSearch", "search/listDirectory", "search/readFile"];
+    const vscodeMcpName = "playwright-test";
+    function asVscodeTool(tool) {
+      const [first, second] = tool.split("/");
+      if (second)
+        return `${vscodeMcpName}/${second}`;
+      return vscodeToolMap.get(first) || first;
+    }
+    const tools = agent.header.tools.map(asVscodeTool).flat().sort((a, b) => {
+      const indexA = vscodeToolsOrder.indexOf(a);
+      const indexB = vscodeToolsOrder.indexOf(b);
+      if (indexA === -1 && indexB === -1)
+        return a.localeCompare(b);
+      if (indexA === -1)
+        return 1;
+      if (indexB === -1)
+        return -1;
+      return indexA - indexB;
+    }).map((tool) => `'${tool}'`).join(", ");
+    const lines = [];
+    lines.push(`---`);
+    lines.push(`description: ${agent.header.description}.`);
+    lines.push(`tools: [${tools}]`);
+    lines.push(`---`);
+    lines.push("");
+    lines.push(agent.instructions);
+    for (const example of agent.examples)
+      lines.push(`<example>${example}</example>`);
+    return lines.join("\n");
   }
-  if (!mcpJson.servers)
-    mcpJson.servers = {};
-  mcpJson.servers["playwright-test"] = {
-    type: "stdio",
-    command: commonMcpServers.playwrightTest.command,
-    args: commonMcpServers.playwrightTest.args,
-    cwd: "${workspaceFolder}"
-  };
-  await writeFile(mcpJsonPath, JSON.stringify(mcpJson, null, 2));
-  console.log(import_utilsBundle.colors.yellow(`${import_utilsBundle.colors.bold("Note:")} Playwright Test Agents require VSCode version 1.105+ or VSCode Insiders`));
 }
-async function initOpencodeRepo() {
-  const agents = await loadAgents();
-  await import_fs.default.promises.mkdir(".opencode/prompts", { recursive: true });
-  for (const agent of agents) {
-    const prompt = [agent.instructions];
-    prompt.push("");
-    prompt.push(...agent.examples.map((example) => `<example>${example}</example>`));
-    await writeFile(`.opencode/prompts/playwright-test-${agent.header.name}.md`, prompt.join("\n"));
+async function writeFile(filePath, content, icon, description) {
+  console.log(`- ${icon} ${import_path.default.relative(process.cwd(), filePath)} ${import_utilsBundle.colors.dim("- " + description)}`);
+  await (0, import_utils.mkdirIfNeeded)(filePath);
+  await import_fs.default.promises.writeFile(filePath, content, "utf-8");
+}
+async function initRepo(config, projectName) {
+  const project = (0, import_seed.seedProject)(config, projectName);
+  console.log(`\u{1F3AD} Using project "${project.project.name}" as a primary project`);
+  if (!import_fs.default.existsSync("specs")) {
+    await import_fs.default.promises.mkdir("specs");
+    await writeFile(import_path.default.join("specs", "README.md"), `# Specs
+
+This is a directory for test plans.
+`, "\u{1F4DD}", "directory for test plans");
   }
-  await writeFile("opencode.json", saveAsOpencodeJson(agents));
+  if (!import_fs.default.existsSync("prompts")) {
+    await import_fs.default.promises.mkdir("prompts");
+    await writeFile(import_path.default.join("prompts", "README.md"), `# Prompts
+
+This is a directory for useful prompts.
+`, "\u{1F4DD}", "useful prompts");
+  }
+  let seedFile = await (0, import_seed.findSeedFile)(project);
+  if (!seedFile) {
+    seedFile = (0, import_seed.defaultSeedFile)(project);
+    await writeFile(seedFile, import_seed.seedFileContent, "\u{1F331}", "default environment seed file");
+  }
+  const coveragePromptFile = import_path.default.join("prompts", "test-coverage.md");
+  if (!import_fs.default.existsSync(coveragePromptFile))
+    await writeFile(coveragePromptFile, coveragePrompt(seedFile), "\u{1F4DD}", "test coverage prompt");
+}
+function initRepoDone() {
+  console.log("\u2705 Done.");
 }
+const coveragePrompt = (seedFile) => `
+# Produce test coverage
+
+Parameters:
+- Task: the task to perform
+- Seed file (optional): the seed file to use, defaults to ${import_path.default.relative(process.cwd(), seedFile)}
+- Test plan file (optional): the test plan file to write, under specs/ folder.
+
+1. Call #playwright-test-planner subagent with prompt:
+
+<plan>
+  <task><!-- the task --></task>
+  <seed-file><!-- seed file param --></seed-file>
+  <plan-file><!-- test plan file --></plan-file>
+</plan>
+
+2. For each test case from the test plan file (1.1, 1.2, ...), Call #playwright-test-generator subagent with prompt:
+
+<generate>
+  <test-file><!-- Name of the file to save the test into, should be unique for test --></test-file>
+  <test-suite><!-- Name of the top level test spec w/o ordinal--></test-suite>
+  <test-name><!--Name of the test case without the ordinal --></test-name>
+  <seed-file><!-- Seed file from test plan --></seed-file>
+  <body><!-- Test case content including steps and expectations --></body>
+</generate>
+
+3. Call #playwright-test-healer subagent with prompt:
+
+<heal>Run all tests and fix the failing ones one after another.</heal>
+`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  initClaudeCodeRepo,
-  initOpencodeRepo,
-  initVSCodeRepo
+  AgentGenerator,
+  ClaudeGenerator,
+  OpencodeGenerator,
+  VSCodeGenerator
 });

package/lib/agents/generator.md

@@ -1,12 +1,11 @@
 ---
-name: generator
+name: playwright-test-generator
 description: Use this agent when you need to create automated browser tests using Playwright
 model: sonnet
 color: blue
 tools:
-  - ls
-  - grep
   - read
+  - search
   - playwright-test/browser_click
   - playwright-test/browser_drag
   - playwright-test/browser_evaluate

package/lib/agents/healer.md

@@ -1,12 +1,11 @@
 ---
-name: healer
+name: playwright-test-healer
 description: Use this agent when you need to debug and fix failing Playwright tests
-color: red
 model: sonnet
+color: red
 tools:
-  - ls
-  - grep
   - read
+  - search
   - write
   - edit
   - playwright-test/browser_console_messages
@@ -24,8 +23,8 @@ resolving Playwright test failures. Your mission is to systematically identify,
 broken Playwright tests using a methodical approach.
 
 Your workflow:
-1. **Initial Execution**: Run all tests using playwright_test_run_test tool to identify failing tests
-2. **Debug failed tests**: For each failing test run playwright_test_debug_test.
+1. **Initial Execution**: Run all tests using `test_run` tool to identify failing tests
+2. **Debug failed tests**: For each failing test run `test_debug`.
 3. **Error Investigation**: When the test pauses on errors, use available Playwright MCP tools to:
    - Examine the error details
    - Capture page snapshot to understand the context

package/lib/agents/planner.md

@@ -1,12 +1,11 @@
 ---
-name: planner
+name: playwright-test-planner
 description: Use this agent when you need to create comprehensive test plan for a web application or website
 model: sonnet
 color: green
 tools:
-  - ls
-  - grep
   - read
+  - search
   - write
   - playwright-test/browser_click
   - playwright-test/browser_close
@@ -38,7 +37,7 @@ You will:
    - Invoke the `planner_setup_page` tool once to set up page before using any other tools
    - Explore the browser snapshot
    - Do not take screenshots unless absolutely necessary
-   - Use browser_* tools to navigate and discover interface
+   - Use `browser_*` tools to navigate and discover interface
    - Thoroughly explore the interface, identifying all interactive elements, forms, navigation paths, and functionality
 
 2. **Analyze User Flows**

package/lib/mcp/browser/tools/screenshot.js

@@ -61,7 +61,7 @@ const screenshot = (0, import_tool.defineTabTool)({
     if (params.fullPage && params.ref)
       throw new Error("fullPage cannot be used with element screenshots.");
     const fileType = params.type || "png";
-    const fileName = await tab.context.outputFile(params.filename ?? (0, import_utils2.dateAsFileName)(fileType), { origin: "llm", reason: "Saving screenshot" });
+    const fileName = await tab.context.outputFile(params.filename || (0, import_utils2.dateAsFileName)(fileType), { origin: "llm", reason: "Saving screenshot" });
     const options = {
       type: fileType,
       quality: fileType === "png" ? void 0 : 90,

package/lib/mcp/test/seed.js

@@ -28,7 +28,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var seed_exports = {};
 __export(seed_exports, {
-  ensureSeedTest: () => ensureSeedTest,
+  defaultSeedFile: () => defaultSeedFile,
+  ensureSeedFile: () => ensureSeedFile,
+  findSeedFile: () => findSeedFile,
+  seedFileContent: () => seedFileContent,
   seedProject: () => seedProject
 });
 module.exports = __toCommonJS(seed_exports);
@@ -44,29 +47,36 @@ function seedProject(config, projectName) {
     throw new Error(`Project ${projectName} not found`);
   return project;
 }
-async function ensureSeedTest(project, logNew) {
+async function findSeedFile(project) {
   const files = await (0, import_projectUtils.collectFilesForProject)(project);
-  const seed = files.find((file) => import_path.default.basename(file).includes("seed"));
-  if (seed)
-    return seed;
+  return files.find((file) => import_path.default.basename(file).includes("seed"));
+}
+function defaultSeedFile(project) {
   const testDir = project.project.testDir;
-  const seedFile = import_path.default.resolve(testDir, "seed.spec.ts");
-  if (logNew) {
-    console.log(`Writing file: ${import_path.default.relative(process.cwd(), seedFile)}`);
-  }
-  await (0, import_utils.mkdirIfNeeded)(seedFile);
-  await import_fs.default.promises.writeFile(seedFile, `import { test, expect } from '@playwright/test';
+  return import_path.default.resolve(testDir, "seed.spec.ts");
+}
+async function ensureSeedFile(project) {
+  const seedFile = await findSeedFile(project);
+  if (seedFile)
+    return seedFile;
+  const seedFilePath = defaultSeedFile(project);
+  await (0, import_utils.mkdirIfNeeded)(seedFilePath);
+  await import_fs.default.promises.writeFile(seedFilePath, seedFileContent);
+  return seedFilePath;
+}
+const seedFileContent = `import { test, expect } from '@playwright/test';
 
 test.describe('Test group', () => {
   test('seed', async ({ page }) => {
     // generate code here.
   });
 });
-`);
-  return seedFile;
-}
+`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ensureSeedTest,
+  defaultSeedFile,
+  ensureSeedFile,
+  findSeedFile,
+  seedFileContent,
   seedProject
 });

package/lib/mcp/test/testContext.js

@@ -98,7 +98,7 @@ class TestContext {
     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;

package/lib/program.js

@@ -48,7 +48,6 @@ var import_testRunner = require("./runner/testRunner");
 var import_reporters = require("./runner/reporters");
 var import_exports = 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");
@@ -180,24 +179,24 @@ 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(["vscode", "claude", "opencode", "generic"]);
   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.action(async (opts) => {
+    const config = await (0, import_configLoader.loadConfigFromFile)(opts.config);
     if (opts.loop === "opencode") {
-      await (0, import_generateAgents.initOpencodeRepo)();
+      await import_generateAgents.OpencodeGenerator.init(config, opts.project);
     } else if (opts.loop === "vscode") {
-      await (0, import_generateAgents.initVSCodeRepo)();
+      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);
+    } else if (opts.loop === "generic") {
+      await import_generateAgents.AgentGenerator.init(config, opts.project);
     } else {
       command.help();
       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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.57.0-alpha-2025-10-15",
+  "version": "1.57.0-alpha-2025-10-17",
   "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-10-15"
+    "playwright-core": "1.57.0-alpha-2025-10-17"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"