opencroc 1.6.0 → 1.6.2

package/dist/cli/index.js

@@ -4206,12 +4206,17 @@ function registerAgentRoutes(app, office) {
       duration: result.duration
     };
   });
-  app.post("/api/run-tests", async (_req, reply) => {
+  app.post("/api/run-tests", async (req, reply) => {
     if (office.isRunning()) {
       reply.code(409).send({ error: "A task is already running" });
       return;
     }
-    office.runTests().catch(() => {
+    const mode = req.body?.mode;
+    if (mode && !["auto", "reuse", "managed"].includes(mode)) {
+      reply.code(400).send({ error: "Invalid mode. Valid values: auto, reuse, managed" });
+      return;
+    }
+    office.runTests({ mode }).catch(() => {
     });
     return { ok: true, message: "Test execution started" };
   });
@@ -4268,6 +4273,264 @@ var init_agents = __esm({
   }
 });
 
+// src/execution/coordinator.ts
+var coordinator_exports = {};
+__export(coordinator_exports, {
+  createExecutionCoordinator: () => createExecutionCoordinator
+});
+import { execSync as nodeExecSync } from "child_process";
+function parseMetrics(output) {
+  const metrics = { passed: 0, failed: 0, skipped: 0, timedOut: 0 };
+  const passedMatch = output.match(/(\d+)\s+passed/);
+  const failedMatch = output.match(/(\d+)\s+failed/);
+  const skippedMatch = output.match(/(\d+)\s+skipped/);
+  const timedOutMatch = output.match(/(\d+)\s+timed?\s*out/i);
+  if (passedMatch) metrics.passed = parseInt(passedMatch[1], 10);
+  if (failedMatch) metrics.failed = parseInt(failedMatch[1], 10);
+  if (skippedMatch) metrics.skipped = parseInt(skippedMatch[1], 10);
+  if (timedOutMatch) metrics.timedOut = parseInt(timedOutMatch[1], 10);
+  return metrics;
+}
+function getFailureLines(output) {
+  return output.split(/\r?\n/).filter((line) => /fail|error|timeout/i.test(line)).slice(0, 5);
+}
+function createExecutionCoordinator(deps = {}) {
+  const execSync = deps.execSync ?? nodeExecSync;
+  const categorizeFailure2 = deps.categorizeFailure;
+  return {
+    async run(request) {
+      const mode = request.mode ?? "auto";
+      const timeoutMs = request.timeoutMs ?? 3e5;
+      const command = `npx playwright test ${request.testFiles.map((file) => `"${file}"`).join(" ")} --reporter=line 2>&1`;
+      let output;
+      try {
+        output = String(execSync(command, {
+          cwd: request.cwd,
+          encoding: "utf-8",
+          timeout: timeoutMs,
+          stdio: "pipe"
+        }));
+      } catch (err) {
+        const execErr = err;
+        output = `${execErr.stdout || ""}
+${execErr.stderr || ""}`;
+      }
+      output = output.trim();
+      const metrics = parseMetrics(output);
+      if (metrics.passed === 0 && metrics.failed === 0 && metrics.skipped === 0 && metrics.timedOut === 0) {
+        metrics.failed = request.testFiles.length;
+      }
+      const failureHints = getFailureLines(output).map((line) => {
+        const analyzed = categorizeFailure2 ? categorizeFailure2(line) : { category: "unknown", confidence: 0.5 };
+        return {
+          line,
+          category: analyzed.category,
+          confidence: analyzed.confidence
+        };
+      });
+      return {
+        mode,
+        metrics,
+        output,
+        failureHints
+      };
+    }
+  };
+}
+var init_coordinator = __esm({
+  "src/execution/coordinator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/runtime/resilient-fetch.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function waitForBackend(baseUrl, options = {}) {
+  const { timeoutMs = 3e4, intervalMs = 1e3, healthPath = "/health" } = options;
+  const healthUrl = new URL(healthPath, baseUrl).href;
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const resp = await fetch(healthUrl, { method: "GET", signal: AbortSignal.timeout(3e3) });
+      if (resp.ok) return;
+    } catch {
+    }
+    await sleep(intervalMs);
+  }
+  throw new Error(`Backend not ready: ${healthUrl} timed out after ${timeoutMs}ms`);
+}
+var init_resilient_fetch = __esm({
+  "src/runtime/resilient-fetch.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/execution/backend-manager.ts
+var backend_manager_exports = {};
+__export(backend_manager_exports, {
+  createBackendManager: () => createBackendManager
+});
+import { resolve as resolve8 } from "path";
+import { spawn as nodeSpawn } from "child_process";
+function normalizeHealthUrl(server, baseURL) {
+  if (server?.healthUrl) return server.healthUrl;
+  if (baseURL) return new URL("/health", baseURL).href;
+  return "http://localhost:3000/health";
+}
+function splitHealthUrl(healthUrl) {
+  const parsed = new URL(healthUrl);
+  const baseUrl = `${parsed.protocol}//${parsed.host}`;
+  const healthPath = `${parsed.pathname}${parsed.search}`;
+  return { baseUrl, healthPath };
+}
+async function waitReady(waitForBackend2, healthUrl, timeoutMs, intervalMs) {
+  const { baseUrl, healthPath } = splitHealthUrl(healthUrl);
+  await waitForBackend2(baseUrl, {
+    timeoutMs,
+    intervalMs,
+    healthPath
+  });
+}
+function createBackendManager(deps = {}) {
+  const waitForBackend2 = deps.waitForBackend ?? waitForBackend;
+  const spawn = deps.spawn ?? nodeSpawn;
+  return {
+    async ensureReady(request) {
+      const server = request.server ?? {};
+      const healthUrl = normalizeHealthUrl(server, request.baseURL);
+      const quickTimeoutMs = 1500;
+      const startTimeoutMs = server.startTimeoutMs ?? 3e4;
+      const pollIntervalMs = server.pollIntervalMs ?? 800;
+      const tryReuse = request.mode !== "managed" || server.reuseExisting !== false;
+      if (tryReuse) {
+        try {
+          await waitReady(waitForBackend2, healthUrl, quickTimeoutMs, 300);
+          return {
+            mode: request.mode,
+            status: "reused",
+            healthUrl,
+            cleanup: async () => {
+            }
+          };
+        } catch (err) {
+          void err;
+        }
+      }
+      if (request.mode === "reuse") {
+        throw new Error(`HEALTH_FAIL: backend is not reachable at ${healthUrl} in reuse mode`);
+      }
+      if (!server.command) {
+        if (request.mode === "auto") {
+          return {
+            mode: request.mode,
+            status: "skipped",
+            healthUrl,
+            cleanup: async () => {
+            }
+          };
+        }
+        throw new Error("BOOT_CONFIG_MISSING: runtime.server.command is required for managed mode");
+      }
+      const child = spawn(server.command, server.args ?? [], {
+        cwd: resolve8(request.cwd, server.cwd ?? "."),
+        shell: true,
+        stdio: "pipe",
+        env: process.env
+      });
+      try {
+        await waitReady(waitForBackend2, healthUrl, startTimeoutMs, pollIntervalMs);
+      } catch {
+        if (child.exitCode === null) child.kill();
+        throw new Error(`BOOT_TIMEOUT: backend did not become healthy at ${healthUrl}`);
+      }
+      return {
+        mode: request.mode,
+        status: "started",
+        healthUrl,
+        cleanup: async () => {
+          if (child.exitCode === null) child.kill();
+        }
+      };
+    }
+  };
+}
+var init_backend_manager = __esm({
+  "src/execution/backend-manager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_resilient_fetch();
+  }
+});
+
+// src/execution/runtime-bootstrap.ts
+var runtime_bootstrap_exports = {};
+__export(runtime_bootstrap_exports, {
+  createRuntimeBootstrap: () => createRuntimeBootstrap
+});
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
+function ensureFile(filePath, content, force) {
+  if (existsSync15(filePath) && !force) {
+    return false;
+  }
+  mkdirSync10(dirname5(filePath), { recursive: true });
+  writeFileSync10(filePath, content, "utf-8");
+  return true;
+}
+function createRuntimeBootstrap(config) {
+  return {
+    async ensure(request) {
+      const force = request.force ?? false;
+      const files = [
+        {
+          name: "playwright.config.ts",
+          content: generatePlaywrightConfig(config)
+        },
+        {
+          name: "global-setup.ts",
+          content: generateGlobalSetup(config)
+        },
+        {
+          name: "global-teardown.ts",
+          content: generateGlobalTeardown(config)
+        }
+      ];
+      if (request.hasAuth) {
+        files.push({
+          name: "auth.setup.ts",
+          content: generateAuthSetup(config)
+        });
+      }
+      const writtenFiles = [];
+      const skippedFiles = [];
+      for (const file of files) {
+        const filePath = join13(request.cwd, file.name);
+        const written = ensureFile(filePath, file.content, force);
+        if (written) writtenFiles.push(file.name);
+        else skippedFiles.push(file.name);
+      }
+      return {
+        writtenFiles,
+        skippedFiles
+      };
+    }
+  };
+}
+var init_runtime_bootstrap = __esm({
+  "src/execution/runtime-bootstrap.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_playwright_config_generator();
+    init_global_setup_generator();
+    init_global_teardown_generator();
+    init_auth_setup_generator();
+  }
+});
+
 // src/server/croc-office.ts
 var DEFAULT_AGENTS, CrocOffice;
 var init_croc_office = __esm({
@@ -4408,13 +4671,13 @@ var init_croc_office = __esm({
           const fullResult = await pipeline.run(["scan", "er-diagram", "api-chain", "plan", "codegen"]);
           this.lastPipelineResult = fullResult;
           this.lastGeneratedFiles = fullResult.generatedFiles;
-          const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync10 } = await import("fs");
-          const { dirname: dirname6 } = await import("path");
+          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
+          const { dirname: dirname7 } = await import("path");
           let filesWritten = 0;
           for (const file of fullResult.generatedFiles) {
             const fullPath = resolvePath(this.cwd, file.filePath);
-            mkdirSync10(dirname6(fullPath), { recursive: true });
-            writeFileSync10(fullPath, file.content, "utf-8");
+            mkdirSync11(dirname7(fullPath), { recursive: true });
+            writeFileSync11(fullPath, file.content, "utf-8");
             filesWritten++;
           }
           this.updateNodeStatus("controller", "passed");
@@ -4483,58 +4746,66 @@ var init_croc_office = __esm({
         return this.lastReports;
       }
       /** Run generated tests with Playwright */
-      async runTests() {
+      async runTests(options = {}) {
         if (this.running) return { ok: false, task: "execute", duration: 0, error: "Another task is running" };
         if (this.lastGeneratedFiles.length === 0) {
           return { ok: false, task: "execute", duration: 0, error: "No test files \u2014 run Pipeline first" };
         }
         this.running = true;
         const start = Date.now();
+        let cleanupBackend = null;
         try {
           const { resolve: resolvePath } = await import("path");
-          const { execSync } = await import("child_process");
-          const { existsSync: existsSync16 } = await import("fs");
-          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync16(f));
+          const { existsSync: existsSync17 } = await import("fs");
+          const { createExecutionCoordinator: createExecutionCoordinator2 } = await Promise.resolve().then(() => (init_coordinator(), coordinator_exports));
+          const { createBackendManager: createBackendManager2 } = await Promise.resolve().then(() => (init_backend_manager(), backend_manager_exports));
+          const { createRuntimeBootstrap: createRuntimeBootstrap2 } = await Promise.resolve().then(() => (init_runtime_bootstrap(), runtime_bootstrap_exports));
+          const { categorizeFailure: categorizeFailure2 } = await Promise.resolve().then(() => (init_self_healing(), self_healing_exports));
+          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync17(f));
           if (testFiles.length === 0) {
             this.log("\u26A0\uFE0F No test files found on disk", "warn");
             return { ok: false, task: "execute", duration: Date.now() - start, error: "No test files found on disk" };
           }
-          this.updateAgent("tester-croc", { status: "working", currentTask: `Running ${testFiles.length} test files...`, progress: 0 });
-          this.log(`\u{1F9EA} \u6D4B\u8BD5\u9CC4 is running ${testFiles.length} Playwright tests...`);
-          this.updateAgent("healer-croc", { status: "thinking", currentTask: "Monitoring test run...", progress: 0 });
-          let stdout2 = "", stderr = "";
-          try {
-            const result = execSync(
-              `npx playwright test ${testFiles.map((f) => `"${f}"`).join(" ")} --reporter=line 2>&1`,
-              { cwd: this.cwd, encoding: "utf-8", timeout: 3e5, stdio: "pipe" }
-            );
-            stdout2 = result;
-          } catch (err) {
-            const execErr = err;
-            stdout2 = execErr.stdout || "";
-            stderr = execErr.stderr || "";
+          const mode = options.mode ?? "auto";
+          this.updateAgent("tester-croc", { status: "working", currentTask: `Running ${testFiles.length} test files (${mode})...`, progress: 0 });
+          this.log(`\u{1F9EA} \u6D4B\u8BD5\u9CC4 is running ${testFiles.length} Playwright tests (${mode})...`);
+          const runtimeBootstrap = createRuntimeBootstrap2(this.config);
+          const runtimeResult = await runtimeBootstrap.ensure({
+            cwd: this.cwd,
+            hasAuth: !!this.config.runtime?.auth?.loginUrl
+          });
+          if (runtimeResult.writtenFiles.length > 0) {
+            this.log(`\u{1F9E9} Runtime assets prepared: ${runtimeResult.writtenFiles.join(", ")}`);
+          }
+          const backendManager = createBackendManager2();
+          const backendReady = await backendManager.ensureReady({
+            mode,
+            cwd: this.cwd,
+            server: this.config.runtime?.server,
+            baseURL: this.config.playwright?.baseURL
+          });
+          cleanupBackend = backendReady.cleanup;
+          if (backendReady.status === "started") {
+            this.log(`\u{1F680} Managed backend started (${backendReady.healthUrl})`);
+          } else if (backendReady.status === "reused") {
+            this.log(`\u{1F501} Reusing backend (${backendReady.healthUrl})`);
           }
-          const output = stdout2 + "\n" + stderr;
-          const metrics = { passed: 0, failed: 0, skipped: 0, timedOut: 0 };
-          const passedMatch = output.match(/(\d+)\s+passed/);
-          const failedMatch = output.match(/(\d+)\s+failed/);
-          const skippedMatch = output.match(/(\d+)\s+skipped/);
-          const timedOutMatch = output.match(/(\d+)\s+timed?\s*out/i);
-          if (passedMatch) metrics.passed = parseInt(passedMatch[1], 10);
-          if (failedMatch) metrics.failed = parseInt(failedMatch[1], 10);
-          if (skippedMatch) metrics.skipped = parseInt(skippedMatch[1], 10);
-          if (timedOutMatch) metrics.timedOut = parseInt(timedOutMatch[1], 10);
+          this.updateAgent("healer-croc", { status: "thinking", currentTask: "Monitoring test run...", progress: 0 });
+          const coordinator = createExecutionCoordinator2({ categorizeFailure: categorizeFailure2 });
+          const execResult = await coordinator.run({
+            cwd: this.cwd,
+            testFiles,
+            mode
+          });
+          const metrics = execResult.metrics;
           this.lastExecutionMetrics = metrics;
           const total = metrics.passed + metrics.failed + metrics.skipped + metrics.timedOut;
           if (metrics.failed > 0) {
             this.updateAgent("tester-croc", { status: "error", currentTask: `${metrics.failed} tests failed`, progress: 100 });
             this.updateAgent("healer-croc", { status: "working", currentTask: `Analyzing ${metrics.failed} failures...`, progress: 50 });
             this.log(`\u274C Tests: ${metrics.passed} passed, ${metrics.failed} failed, ${metrics.skipped} skipped`, "warn");
-            const { categorizeFailure: categorizeFailure2 } = await Promise.resolve().then(() => (init_self_healing(), self_healing_exports));
-            const failLines = output.split("\n").filter((l) => /fail|error|timeout/i.test(l)).slice(0, 5);
-            for (const line of failLines) {
-              const cat = categorizeFailure2(line);
-              this.log(`  \u{1F50D} ${cat.category} (${Math.round(cat.confidence * 100)}%): ${line.substring(0, 100)}`, "warn");
+            for (const hint of execResult.failureHints) {
+              this.log(`  \u{1F50D} ${hint.category} (${Math.round(hint.confidence * 100)}%): ${hint.line.substring(0, 100)}`, "warn");
             }
             this.updateAgent("healer-croc", { status: "done", currentTask: "Failure analysis done", progress: 100 });
           } else {
@@ -4552,6 +4823,14 @@ var init_croc_office = __esm({
           this.log(`\u274C Test execution failed: ${err}`, "error");
           return { ok: false, task: "execute", duration: Date.now() - start, error: String(err) };
         } finally {
+          if (cleanupBackend) {
+            try {
+              await cleanupBackend();
+              this.log("\u{1F9F9} Managed backend stopped");
+            } catch (err) {
+              this.log(`\u26A0\uFE0F Backend cleanup failed: ${err}`, "warn");
+            }
+          }
           this.running = false;
         }
       }
@@ -4571,12 +4850,12 @@ var init_croc_office = __esm({
           const reports = generateReports2(this.lastPipelineResult, formats);
           this.lastReports = reports;
           const { resolve: resolvePath } = await import("path");
-          const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync10 } = await import("fs");
+          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
           const outDir = resolvePath(this.cwd, this.config.outDir || "./opencroc-output");
-          mkdirSync10(outDir, { recursive: true });
+          mkdirSync11(outDir, { recursive: true });
           for (const report2 of reports) {
             const fullPath = resolvePath(outDir, report2.filename);
-            writeFileSync10(fullPath, report2.content, "utf-8");
+            writeFileSync11(fullPath, report2.content, "utf-8");
             this.log(`\u{1F4C4} Generated ${report2.format} report: ${report2.filename}`);
           }
           this.updateAgent("reporter-croc", { status: "done", currentTask: `${reports.length} reports generated`, progress: 100 });
@@ -4821,13 +5100,13 @@ import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import fastifyWebsocket from "@fastify/websocket";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname5, join as join13, resolve as resolve8 } from "path";
-import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname6, join as join14, resolve as resolve9 } from "path";
+import { existsSync as existsSync16 } from "fs";
 async function startServer(opts) {
   const app = Fastify({ logger: false });
   await app.register(fastifyWebsocket);
-  const webDir = resolve8(__dirname2, "../web");
-  if (existsSync15(webDir)) {
+  const webDir = resolve9(__dirname2, "../web");
+  if (existsSync16(webDir)) {
     await app.register(fastifyStatic, {
       root: webDir,
       prefix: "/",
@@ -4848,8 +5127,8 @@ async function startServer(opts) {
       reply.code(404).send({ error: "Not found" });
       return;
     }
-    const indexPath = join13(webDir, "index.html");
-    if (existsSync15(indexPath)) {
+    const indexPath = join14(webDir, "index.html");
+    if (existsSync16(indexPath)) {
       reply.sendFile("index.html");
     } else {
       reply.code(200).header("content-type", "text/html").send(getEmbeddedHtml());
@@ -5000,7 +5279,7 @@ var init_server = __esm({
     init_agents();
     init_croc_office();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = dirname5(__filename2);
+    __dirname2 = dirname6(__filename2);
   }
 });