@wix/evalforge-evaluator 0.190.0 → 0.192.0

package/build/index.js

@@ -7372,6 +7372,37 @@ var import_fs = require("fs");
 var import_crypto = require("crypto");
 var import_path2 = __toESM(require("path"));
 var import_child_process = require("child_process");
+var INSTALL_TIMEOUT_MS = 9e4;
+var HEARTBEAT_INTERVAL_MS = 5e3;
+function defaultExec(cmd, args, opts) {
+  return new Promise((resolve3, reject) => {
+    const child = (0, import_child_process.spawn)(cmd, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: "inherit"
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(
+        new Error(
+          `${cmd} ${args.join(" ")} timed out after ${opts.timeoutMs}ms`
+        )
+      );
+    }, opts.timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`${cmd} exited with code ${code}`));
+      }
+    });
+  });
+}
 function detectPackageManager(workDir) {
   if ((0, import_fs.existsSync)(import_path2.default.join(workDir, "pnpm-lock.yaml"))) {
     return {
@@ -7409,7 +7440,34 @@ function cloneDirectory(src, dest) {
     (0, import_fs.cpSync)(src, dest, { recursive: true });
   }
 }
-function installWithCache(workDir, exec, cacheBase, pm) {
+async function runInstall(exec, pm, workDir, onProgress) {
+  onProgress(`[diag] npm install starting: ${pm.cmd} ${pm.args.join(" ")}`);
+  const startedAt = Date.now();
+  const heartbeat = setInterval(() => {
+    onProgress(
+      `[diag] npm install still running: ${Math.round(
+        (Date.now() - startedAt) / 1e3
+      )}s elapsed`
+    );
+  }, HEARTBEAT_INTERVAL_MS);
+  try {
+    await exec(pm.cmd, pm.args, {
+      cwd: workDir,
+      timeoutMs: INSTALL_TIMEOUT_MS,
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    onProgress(`[diag] npm install finished in ${Date.now() - startedAt}ms`);
+    return true;
+  } catch (err) {
+    onProgress(
+      `[diag] npm install FAILED after ${Date.now() - startedAt}ms: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  } finally {
+    clearInterval(heartbeat);
+  }
+}
+async function installWithCache(workDir, exec, cacheBase, pm, onProgress) {
   const sourceContent = (0, import_fs.readFileSync)(
     import_path2.default.join(workDir, pm.cacheSourceFile),
     "utf-8"
@@ -7423,29 +7481,19 @@ function installWithCache(workDir, exec, cacheBase, pm) {
     console.log(
       `[environment] Restoring node_modules from cache (key: ${cacheKey})`
     );
+    onProgress(`[diag] node_modules cache HIT (key: ${cacheKey}) \u2014 restoring`);
     if (!(0, import_fs.existsSync)(targetNodeModules)) {
       cloneDirectory(cachedNodeModules, targetNodeModules);
     }
     if ((0, import_fs.existsSync)(cachedYarnLock)) {
       (0, import_fs.copyFileSync)(cachedYarnLock, import_path2.default.join(workDir, "yarn.lock"));
     }
+    onProgress("[diag] node_modules cache restore complete");
     return;
   }
-  console.log(
-    `[environment] Running ${pm.cmd} ${pm.args.join(" ")} in ${workDir} (cache key: ${cacheKey})`
-  );
-  try {
-    exec(pm.cmd, pm.args, {
-      cwd: workDir,
-      stdio: "inherit",
-      timeout: 18e4,
-      env: { ...process.env, NODE_ENV: "development" }
-    });
-  } catch (err) {
-    console.error(
-      "[environment] Dependency installation failed:",
-      err instanceof Error ? err.message : String(err)
-    );
+  onProgress(`[diag] node_modules cache MISS (key: ${cacheKey})`);
+  const ok = await runInstall(exec, pm, workDir, onProgress);
+  if (!ok) {
     return;
   }
   console.log(
@@ -7469,31 +7517,15 @@ async function installDependencies(workDir, onProgress, options = {}) {
   if (!(0, import_fs.existsSync)(import_path2.default.join(workDir, "package.json"))) {
     return;
   }
-  const exec = options.exec ?? import_child_process.execFileSync;
+  const exec = options.exec ?? defaultExec;
   const cacheBase = options.cacheBase;
   onProgress("Installing dependencies...");
   const pm = detectPackageManager(workDir);
   if (cacheBase) {
-    installWithCache(workDir, exec, cacheBase, pm);
+    await installWithCache(workDir, exec, cacheBase, pm, onProgress);
     return;
   }
-  console.log(
-    `[environment] Running ${pm.cmd} ${pm.args.join(" ")} in ${workDir}`
-  );
-  try {
-    exec(pm.cmd, pm.args, {
-      cwd: workDir,
-      stdio: "inherit",
-      timeout: 18e4,
-      env: { ...process.env, NODE_ENV: "development" }
-    });
-    console.log("[environment] Dependency installation complete");
-  } catch (err) {
-    console.error(
-      "[environment] Dependency installation failed:",
-      err instanceof Error ? err.message : String(err)
-    );
-  }
+  await runInstall(exec, pm, workDir, onProgress);
 }
 
 // src/run-scenario/environment.ts
@@ -7569,12 +7601,39 @@ async function fetchAndWriteTemplateFiles(template, workDir, onProgress) {
       `Template "${template.name}" has no source configured, creating empty directory`
     );
   }
+  onProgress(`[diag] writing ${sourceFiles.length} source file(s) to workDir`);
   await writeFilesToDirectory(workDir, sourceFiles);
+  onProgress(`[diag] ${sourceFiles.length} source file(s) written`);
+  const extraFiles = template.extraFiles ?? [];
+  onProgress(`[diag] resolving ${extraFiles.length} extra file(s)`);
   await Promise.all(
-    (template.extraFiles ?? []).map(async (ef) => {
-      const content = ef.gitSource ? await (0, import_evalforge_github_client.fetchGitHubFile)(ef.gitSource, {
-        userAgent: "EvalForge-Evaluator"
-      }) : ef.content ?? "";
+    extraFiles.map(async (ef) => {
+      let content;
+      if (ef.gitSource) {
+        const { owner, repo, path: gitPath, ref } = ef.gitSource;
+        const startedAt = Date.now();
+        onProgress(
+          `[diag] extra fetch start: ${ef.path} <- ${owner}/${repo}/${gitPath ?? ""}@${ref ?? "default"}`
+        );
+        try {
+          content = await withTimeout(
+            (0, import_evalforge_github_client.fetchGitHubFile)(ef.gitSource, { userAgent: "EvalForge-Evaluator" }),
+            3e4,
+            `extra file fetch (${ef.path})`
+          );
+          onProgress(
+            `[diag] extra fetch done: ${ef.path} (${content.length} bytes) in ${Date.now() - startedAt}ms`
+          );
+        } catch (err) {
+          onProgress(
+            `[diag] extra fetch FAILED: ${ef.path} after ${Date.now() - startedAt}ms: ${err instanceof Error ? err.message : String(err)}`
+          );
+          throw err;
+        }
+      } else {
+        content = ef.content ?? "";
+        onProgress(`[diag] extra inline: ${ef.path} (${content.length} bytes)`);
+      }
       const dest = import_path3.default.resolve(workDir, ef.path);
       if (!dest.startsWith(workDir + import_path3.sep)) {
         throw new Error(
@@ -7585,6 +7644,7 @@ async function fetchAndWriteTemplateFiles(template, workDir, onProgress) {
       await (0, import_promises2.writeFile)(dest, content, "utf8");
     })
   );
+  onProgress("[diag] all extra files written");
 }
 function writeWixEnvFile(workDir) {
   const configPath = import_path3.default.join(workDir, "wix.config.json");
@@ -7624,10 +7684,13 @@ async function prepareWorkingDirectory(config, evalRunId2, targetId, scenarioId,
     onProgress("Fetching template files...");
     await fetchAndWriteTemplateFiles(template, workDir2, onProgress);
     console.log(`Template files written to ${workDir2}`);
+    onProgress("[diag] writing wix env file");
     writeWixEnvFile(workDir2);
+    onProgress("[diag] entering installDependencies");
     await installDependencies(workDir2, onProgress, {
       cacheBase: nodeModulesCacheDir
     });
+    onProgress("[diag] installDependencies returned");
     onProgress("Environment ready");
     return workDir2;
   }
@@ -8434,7 +8497,7 @@ async function executeWithClaudeCode(skills, scenario, options) {
   const SDK_TIMEOUT_MS = resolveTimeoutMs(maxTurns, options.maxDurationMs);
   let timeoutHandle;
   let timedOut = false;
-  const HEARTBEAT_INTERVAL_MS = 1e4;
+  const HEARTBEAT_INTERVAL_MS2 = 1e4;
   let heartbeatHandle;
   const executionStartTime = Date.now();
   try {
@@ -8486,7 +8549,7 @@ async function executeWithClaudeCode(skills, scenario, options) {
           isComplete: false
         };
         emitTraceEvent(progressEvent, traceContext.pushEvent);
-      }, HEARTBEAT_INTERVAL_MS);
+      }, HEARTBEAT_INTERVAL_MS2);
     }
     const sdkPromise = (async () => {
       const hasImages = scenario.triggerPromptImages && scenario.triggerPromptImages.length > 0;
@@ -12080,11 +12143,15 @@ async function runScenario(config, evalRunId2, scenario, evalData, template, res
   );
   let provisionedSite;
   if (apiClient && projectId2 && scenario.siteSetup && scenario.siteSetup.mode !== "none") {
+    emitSetupProgress(
+      `[diag] provisioning scenario site (mode: ${scenario.siteSetup.mode})...`
+    );
     provisionedSite = await apiClient.provisionScenarioSite(
       projectId2,
       evalRunId2,
       scenario.id
     );
+    emitSetupProgress("[diag] scenario site provisioned");
   }
   const failedStep = provisionedSite?.bootstrapResult?.steps.find((s) => !s.ok);
   if (failedStep) {
@@ -12117,6 +12184,7 @@ Site ID: ${provisionedSite.id}` : scenario.triggerPrompt;
       emitSetupProgress,
       { template }
     );
+    emitSetupProgress("[diag] starting agent run");
     const partialResult = await runAgentWithContext(
       config,
       evalRunId2,