@mestreyoda/fabrica 0.1.12 → 0.1.13

package/dist/index.js

@@ -110768,7 +110768,7 @@ var init_registry = __esm({
           senior: "\u{1F9E0}"
         },
         fallbackEmoji: "\u{1F50D}",
-        completionResults: ["pass", "fail", "refine", "blocked"],
+        completionResults: ["pass", "fail", "fail_infra", "refine", "blocked"],
         sessionKeyPattern: "tester",
         notifications: { onStart: true, onComplete: true }
       },
@@ -111329,8 +111329,8 @@ import fsSync from "node:fs";
 import path5 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getCurrentVersion() {
-  if ("0.1.12") {
-    return "0.1.12";
+  if ("0.1.13") {
+    return "0.1.13";
   }
   try {
     const pkgPath = path5.join(THIS_DIR, "..", "..", "package.json");
@@ -119852,6 +119852,22 @@ PR merged \u2014 issue closed automatically (was stuck in ${event.fromState})`;
 \u{1F3C1} Done \u2014 no human action needed.`;
       return msg;
     }
+    case "infraFailure": {
+      const icon = event.infraFailCount >= 2 ? "\u{1F6A8}" : "\u26A0\uFE0F";
+      let msg = `${icon} Infrastructure failure on #${event.issueId} (attempt ${event.infraFailCount})`;
+      msg += `
+${event.summary}`;
+      msg += `
+\u{1F4CB} [Issue #${event.issueId}](${event.issueUrl})`;
+      if (event.infraFailCount >= 2) {
+        msg += `
+\u2192 Circuit breaker tripped \u2014 moved to Refining (operator intervention required)`;
+      } else {
+        msg += `
+\u2192 Returned to To Test queue \u2014 will retry after toolchain is fixed`;
+      }
+      return msg;
+    }
   }
 }
 async function sendMessage(target, message, channel, workspaceDir, runtime, accountId, runCommand, messageThreadId, auditMeta) {
@@ -120589,10 +120605,10 @@ init_audit();
 init_migrate_layout();
 init_roles();
 init_workflow();
+init_labels();
 
 // lib/tools/tasks/public-output-sanitizer.ts
 var SECRET_PATTERNS = [
-  /\b[A-Za-z_][A-Za-z0-9_]*=([^\s]+)/g,
   /\b(?:ghp_|gho_|github_pat_|sk-|xoxb-|xoxp-|AIza|AKIA|glpat-)[A-Za-z0-9._-]*/g,
   /\b(?:token|secret|api[_-]?key|password|passwd|authorization|bearer)\b\s*[:=]\s*[^\s]+/gi
 ];
@@ -120917,6 +120933,7 @@ function matchesReviewArtifact(comment, artifactId, artifactType) {
   }
   return comment.state === "COMMENTED" && !comment.path;
 }
+var INFRA_FAIL_CIRCUIT_BREAKER_THRESHOLD = 2;
 function createWorkFinishTool(ctx) {
   return (toolCtx) => ({
     name: "work_finish",
@@ -120928,7 +120945,7 @@ function createWorkFinishTool(ctx) {
       properties: {
         channelId: { type: "string", description: "YOUR chat/group ID \u2014 the numeric ID of the chat you are in right now (e.g. '-1003844794417'). Do NOT guess; use the ID of the conversation this message came from." },
         role: { type: "string", enum: getAllRoleIds(), description: "Worker role" },
-        result: { type: "string", enum: ["done", "pass", "fail", "refine", "blocked", "approve", "reject"], description: "Completion result" },
+        result: { type: "string", enum: ["done", "pass", "fail", "fail_infra", "refine", "blocked", "approve", "reject"], description: "Completion result. Use fail_infra (tester only) when the test toolchain is missing or broken \u2014 this keeps the issue in the test queue instead of routing it to the developer." },
         summary: { type: "string", description: "Brief summary" },
         prUrl: { type: "string", description: "PR/MR URL (auto-detected if omitted)" },
         createdTasks: {
@@ -121010,6 +121027,79 @@ function createWorkFinishTool(ctx) {
         })),
         keyTransitions: resolvedConfig.workflowMeta.keyTransitions
       });
+      if (role === "tester" && result === "fail_infra") {
+        const currentInfraFails = (issueRuntime?.infraFailCount ?? 0) + 1;
+        await updateIssueRuntime(workspaceDir, project.slug, issueId, {
+          infraFailCount: currentInfraFails
+        });
+        await log(workspaceDir, "infra_failure", {
+          project: project.name,
+          issue: issueId,
+          role,
+          result,
+          summary: summary ?? null,
+          infraFailCount: currentInfraFails
+        });
+        const notifyConfig = getNotificationConfig(ctx.pluginConfig);
+        const target = resolveNotifyChannel([], project.channels);
+        const issueUrl = `https://github.com/${project.repo}/issues/${issueId}`;
+        await notify(
+          {
+            type: "infraFailure",
+            project: project.name,
+            issueId,
+            issueUrl,
+            summary: summary ?? "Infrastructure failure during testing",
+            infraFailCount: currentInfraFails
+          },
+          {
+            workspaceDir,
+            config: notifyConfig,
+            channelId: target?.channelId,
+            channel: target?.channel ?? "telegram",
+            runtime: ctx.runtime,
+            accountId: target?.accountId,
+            messageThreadId: target?.messageThreadId,
+            runCommand: ctx.runCommand
+          }
+        ).catch((err) => {
+          getRootLogger().warn(`infra_failure notification failed: ${err}`);
+        });
+        if (currentInfraFails >= INFRA_FAIL_CIRCUIT_BREAKER_THRESHOLD) {
+          await log(workspaceDir, "infra_failure_circuit_breaker", {
+            project: project.name,
+            issue: issueId,
+            infraFailCount: currentInfraFails
+          });
+          await resilientLabelTransition(provider, issueId, "Testing", "Refining");
+        } else {
+          await resilientLabelTransition(provider, issueId, "Testing", "To Test");
+        }
+        await deactivateWorker(workspaceDir, project.slug, "tester", {
+          level: slotLevel,
+          slotIndex,
+          issueId: String(issueId)
+        });
+        await recordIssueLifecycle({
+          workspaceDir,
+          slug: project.slug,
+          issueId,
+          stage: "session_completed",
+          sessionKey: toolCtx.sessionKey ?? null,
+          details: { role, result, infraFailCount: currentInfraFails }
+        }).catch(() => {
+        });
+        return jsonResult2({
+          success: true,
+          project: project.name,
+          projectSlug: project.slug,
+          issueId,
+          role,
+          result,
+          infraFailCount: currentInfraFails,
+          circuitBroken: currentInfraFails >= INFRA_FAIL_CIRCUIT_BREAKER_THRESHOLD
+        });
+      }
       if (!getRule(role, result, workflow))
         throw new Error(`Invalid completion: ${role}:${result}`);
       const repoPath = resolveRepoPath(project.repo);
@@ -121128,6 +121218,9 @@ function createWorkFinishTool(ctx) {
         details: { role, result }
       }).catch(() => {
       });
+      if (role === "tester" && issueRuntime?.infraFailCount) {
+        await updateIssueRuntime(workspaceDir, project.slug, issueId, { infraFailCount: 0 });
+      }
       return jsonResult2({
         success: true,
         project: project.name,
@@ -136063,25 +136156,39 @@ async function runHeartbeatTick(ctx, logger6, mode) {
       })
     );
     const tickFn = lifecycle ? () => lifecycle.track(mode === "repair" ? "recovery" : "heartbeat", {}, run) : run;
-    let tickPromise;
-    const wrappedTickFn = () => {
-      tickPromise = tickFn();
-      return tickPromise;
+    let resolveTick;
+    let rejectTick;
+    const tickPromise = new Promise((res, rej) => {
+      resolveTick = res;
+      rejectTick = rej;
+    });
+    tickPromise.catch(() => {
+    });
+    const wrappedTickFn = async () => {
+      try {
+        const result = await tickFn();
+        resolveTick(result);
+        return result;
+      } catch (err) {
+        rejectTick(err);
+        throw err;
+      }
     };
+    const HARD_TICK_TIMEOUT_MS = 5 * 6e4;
     const raceResult = await raceWithTimeout(wrappedTickFn, DEFAULT_TICK_TIMEOUT_MS, () => {
       _ticksTimedOut++;
       timedOut = true;
       logger6.warn(`work_heartbeat ${mode} tick timed out after ${DEFAULT_TICK_TIMEOUT_MS}ms (total timeouts: ${_ticksTimedOut})`);
-      if (tickPromise) {
-        tickPromise.finally(() => {
-          _tickRunning[mode] = false;
-          _anyTickRunning = false;
-        });
-      } else {
-        logger6.error("tick_mutex: tickPromise undefined in timeout handler \u2014 forcing mutex release");
+      const hardTimeout = setTimeout(() => {
+        logger6.error("tick_mutex: hard timeout \u2014 forcing mutex release");
         _tickRunning[mode] = false;
         _anyTickRunning = false;
-      }
+      }, HARD_TICK_TIMEOUT_MS);
+      tickPromise.finally(() => {
+        clearTimeout(hardTimeout);
+        _tickRunning[mode] = false;
+        _anyTickRunning = false;
+      });
     });
     void raceResult;
   } catch (err) {
@@ -138569,15 +138676,21 @@ Install manually: curl -LsSf ${UV_INSTALL_URL} | sh`
 var PYTHON_TOOLCHAIN_PACKAGES = ["ruff", "mypy", "pip-audit"];
 var TOOLCHAIN_DIR = ".openclaw/toolchains/python";
 var TOOLCHAIN_FINGERPRINT_FILE = "toolchain.sha256";
-function toolchainFingerprint() {
-  return createHash4("sha256").update(PYTHON_TOOLCHAIN_PACKAGES.join(",")).digest("hex");
+async function toolchainFingerprint(runCommand) {
+  let pythonVersion = "unknown";
+  try {
+    const result = await runCommand("python3", ["--version"], { timeout: 5e3 });
+    if (result.exitCode === 0) pythonVersion = result.stdout.trim();
+  } catch {
+  }
+  return createHash4("sha256").update(PYTHON_TOOLCHAIN_PACKAGES.join(",") + ":" + pythonVersion).digest("hex");
 }
 async function ensurePythonToolchain(runCommand, homeDir) {
   const home = homeDir ?? process.env.HOME ?? "/tmp";
   const toolchainPath = path34.join(home, TOOLCHAIN_DIR);
   const ruffPath = path34.join(toolchainPath, "bin", "ruff");
   const fingerprintPath = path34.join(toolchainPath, TOOLCHAIN_FINGERPRINT_FILE);
-  const expectedFp = toolchainFingerprint();
+  const expectedFp = await toolchainFingerprint(runCommand);
   if (await isValidBinary(ruffPath)) {
     try {
       const currentFp = (await fs34.readFile(fingerprintPath, "utf-8")).trim();