bosun 0.41.2 → 0.41.4

package/workflow/workflow-engine.mjs

@@ -92,6 +92,16 @@ const MAX_PERSISTED_RUNS = readBoundedEnvInt("WORKFLOW_MAX_PERSISTED_RUNS", 2000
   min: 20,
   max: 20000,
 });
+const MAX_INTERRUPTED_ORPHAN_SCAN_FILES = readBoundedEnvInt(
+  "WORKFLOW_INTERRUPTED_ORPHAN_SCAN_MAX_FILES",
+  200,
+  { min: 0, max: 5000 },
+);
+const INTERRUPTED_ORPHAN_SCAN_WINDOW_MS = readBoundedEnvInt(
+  "WORKFLOW_INTERRUPTED_ORPHAN_SCAN_WINDOW_MS",
+  7 * 24 * 60 * 60 * 1000,
+  { min: 0, max: 90 * 24 * 60 * 60 * 1000 },
+);
 const DEFAULT_RUN_STUCK_THRESHOLD_MS = readBoundedEnvInt(
   "WORKFLOW_RUN_STUCK_THRESHOLD_MS",
   5 * 60 * 1000,
@@ -312,6 +322,61 @@ export function isPortConnectionCompatible(sourcePort, targetPort) {
   };
 }
 
+function getExplicitNodeOutputs(node) {
+  return Array.isArray(node?.outputs)
+    ? Array.from(new Set(node.outputs.map((value) => String(value || "").trim()).filter(Boolean)))
+    : undefined;
+}
+
+function hydrateWorkflowNode(node, nodeMap) {
+  const ports = resolveNodePorts(node);
+  const explicitOutputs = getExplicitNodeOutputs(node);
+  const nextNode = {
+    ...node,
+    inputPorts: ports.inputs.map((port) => clonePortDescriptor(port)),
+    outputPorts: ports.outputs.map((port) => clonePortDescriptor(port)),
+    ...(explicitOutputs !== undefined ? { outputs: explicitOutputs } : {}),
+  };
+  nodeMap.set(nextNode.id, nextNode);
+  return nextNode;
+}
+
+function buildPortValidationIssue(edge, sourcePort, targetPort, compatibility) {
+  return {
+    edgeId: edge.id || `${edge.source}->${edge.target}`,
+    source: edge.source,
+    target: edge.target,
+    sourcePort: sourcePort?.name || "default",
+    targetPort: targetPort?.name || "default",
+    sourceType: sourcePort?.type || null,
+    targetType: targetPort?.type || null,
+    severity: "error",
+    message: compatibility.reason,
+  };
+}
+
+function hydrateWorkflowEdge(edge, nodeMap, issues) {
+  const sourceNode = nodeMap.get(edge.source);
+  const targetNode = nodeMap.get(edge.target);
+  const sourcePorts = resolveNodePorts(sourceNode);
+  const targetPorts = resolveNodePorts(targetNode);
+  const sourcePort = resolvePortByName(sourcePorts.outputs, edge.sourcePort || "default", "output");
+  const targetPort = resolvePortByName(targetPorts.inputs, edge.targetPort || "default", "input");
+  const compatibility = isPortConnectionCompatible(sourcePort, targetPort);
+
+  if (!compatibility.compatible) {
+    issues.push(buildPortValidationIssue(edge, sourcePort, targetPort, compatibility));
+  }
+
+  return {
+    ...edge,
+    sourcePort: sourcePort?.name || String(edge.sourcePort || "default").trim() || "default",
+    targetPort: targetPort?.name || String(edge.targetPort || "default").trim() || "default",
+    sourcePortType: sourcePort?.type || null,
+    targetPortType: targetPort?.type || null,
+  };
+}
+
 function hydrateWorkflowDefinition(def, { strict = false } = {}) {
   const normalized = {
     ...(def || {}),
@@ -321,55 +386,10 @@ function hydrateWorkflowDefinition(def, { strict = false } = {}) {
   };
 
   const nodeMap = new Map();
-  normalized.nodes = normalized.nodes.map((node) => {
-    const ports = resolveNodePorts(node);
-    const explicitOutputs = Array.isArray(node?.outputs)
-      ? Array.from(new Set(node.outputs.map((value) => String(value || "").trim()).filter(Boolean)))
-      : undefined;
-    const nextNode = {
-      ...node,
-      inputPorts: ports.inputs.map((port) => clonePortDescriptor(port)),
-      outputPorts: ports.outputs.map((port) => clonePortDescriptor(port)),
-      ...(explicitOutputs !== undefined ? { outputs: explicitOutputs } : {}),
-    };
-    nodeMap.set(nextNode.id, nextNode);
-    return nextNode;
-  });
+  normalized.nodes = normalized.nodes.map((node) => hydrateWorkflowNode(node, nodeMap));
 
   const issues = [];
-
-  normalized.edges = normalized.edges.map((edge) => {
-    const sourceNode = nodeMap.get(edge.source);
-    const targetNode = nodeMap.get(edge.target);
-    const sourcePorts = resolveNodePorts(sourceNode);
-    const targetPorts = resolveNodePorts(targetNode);
-    const sourcePort = resolvePortByName(sourcePorts.outputs, edge.sourcePort || "default", "output");
-    const targetPort = resolvePortByName(targetPorts.inputs, edge.targetPort || "default", "input");
-    const compatibility = isPortConnectionCompatible(sourcePort, targetPort);
-
-    if (!compatibility.compatible) {
-      issues.push({
-        edgeId: edge.id || `${edge.source}->${edge.target}`,
-        source: edge.source,
-        target: edge.target,
-        sourcePort: sourcePort?.name || "default",
-        targetPort: targetPort?.name || "default",
-        sourceType: sourcePort?.type || null,
-        targetType: targetPort?.type || null,
-        severity: "error",
-        message: compatibility.reason,
-      });
-    }
-
-    return {
-      ...edge,
-      sourcePort: sourcePort?.name || String(edge.sourcePort || "default").trim() || "default",
-      targetPort: targetPort?.name || String(edge.targetPort || "default").trim() || "default",
-      sourcePortType: sourcePort?.type || null,
-      targetPortType: targetPort?.type || null,
-    };
-  });
-
+  normalized.edges = normalized.edges.map((edge) => hydrateWorkflowEdge(edge, nodeMap, issues));
   normalized.metadata.validationIssues = issues;
 
   if (strict && issues.length > 0) {
@@ -378,7 +398,6 @@ function hydrateWorkflowDefinition(def, { strict = false } = {}) {
 
   return normalized;
 }
-
 /**
  * Register a node type handler.
  * @param {string} type - Node type identifier (e.g., "trigger.task_low", "action.run_agent")
@@ -982,7 +1001,16 @@ export class WorkflowEngine extends EventEmitter {
   /** Get a single workflow definition */
   get(id) {
     if (!this._loaded) this.load();
-    return this._workflows.get(id) || null;
+    const workflowId = String(id || "").trim();
+    if (!workflowId) return null;
+    const exact = this._workflows.get(workflowId);
+    if (exact) return exact;
+    for (const workflow of this._workflows.values()) {
+      if (workflow?.metadata?.installedFrom === workflowId) {
+        return workflow;
+      }
+    }
+    return null;
   }
 
   /** Save (create or update) a workflow definition */
@@ -2421,6 +2449,24 @@ export class WorkflowEngine extends EventEmitter {
           }
         }
 
+        const countForwardIncomingEdges = (targetNodeId) =>
+          (def.edges || []).filter((edge) => edge.target === targetNodeId && !edge.backEdge).length;
+
+        const propagateSkippedDependencies = (skippedNodeId) => {
+          if (countForwardIncomingEdges(skippedNodeId) > 1) return;
+          const skippedEdges = adjacency.get(skippedNodeId) || [];
+          for (const skippedEdge of skippedEdges) {
+            if (skippedEdge.backEdge) continue;
+            consumeEdgeDependency(skippedEdge.target, false, {
+              reason: "upstream-skipped",
+              payload: {
+                sourceNodeId: skippedNodeId,
+                edgeId: skippedEdge.id || `${skippedEdge.source}->${skippedEdge.target}`,
+              },
+            });
+          }
+        };
+
         const consumeEdgeDependency = (targetNodeId, matched, skipInfo = null) => {
           const nextDegree = (inDegree.get(targetNodeId) || 1) - 1;
           inDegree.set(targetNodeId, nextDegree);
@@ -2438,6 +2484,7 @@ export class WorkflowEngine extends EventEmitter {
               executed.add(targetNodeId);
               const skippedNode = nodeMap.get(targetNodeId);
               console.log(`${TAG} node:SKIPPED ${targetNodeId} (${skippedNode?.type || "?"}) [${skippedNode?.label || ""}] — no satisfied edges`);
+              propagateSkippedDependencies(targetNodeId);
             }
           }
         };
@@ -2710,6 +2757,51 @@ export class WorkflowEngine extends EventEmitter {
     }
   }
 
+  _getInterruptedOrphanRunCandidates() {
+    if (!existsSync(this.runsDir)) return [];
+    if (MAX_INTERRUPTED_ORPHAN_SCAN_FILES <= 0) return [];
+
+    const cutoffMs = INTERRUPTED_ORPHAN_SCAN_WINDOW_MS > 0
+      ? Date.now() - INTERRUPTED_ORPHAN_SCAN_WINDOW_MS
+      : 0;
+    const candidates = [];
+    let totalCandidates = 0;
+
+    try {
+      for (const file of readdirSync(this.runsDir)) {
+        if (
+          extname(file) !== ".json" ||
+          file === "index.json" ||
+          file === ACTIVE_RUNS_INDEX
+        ) {
+          continue;
+        }
+        const detailPath = resolve(this.runsDir, file);
+        let mtimeMs = 0;
+        try {
+          mtimeMs = statSync(detailPath).mtimeMs || 0;
+        } catch {
+          continue;
+        }
+        if (cutoffMs > 0 && mtimeMs < cutoffMs) continue;
+        totalCandidates += 1;
+        candidates.push({ file, detailPath, mtimeMs });
+      }
+    } catch {
+      return [];
+    }
+
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (candidates.length > MAX_INTERRUPTED_ORPHAN_SCAN_FILES) {
+      console.warn(
+        `${TAG} Orphan interrupted-run scan limited to ${MAX_INTERRUPTED_ORPHAN_SCAN_FILES} recent files ` +
+          `(${totalCandidates} candidate files in retention window)`,
+      );
+      candidates.length = MAX_INTERRUPTED_ORPHAN_SCAN_FILES;
+    }
+    return candidates;
+  }
+
   _getRunStuckThresholdMs() {
     const raw = Number(process.env.WORKFLOW_RUN_STUCK_THRESHOLD_MS);
     if (Number.isFinite(raw) && raw > 0) return raw;
@@ -3074,17 +3166,14 @@ export class WorkflowEngine extends EventEmitter {
       }
 
       // Tertiary source: orphan detail files with no index entry and no end marker.
-      const detailFiles = readdirSync(this.runsDir).filter((file) =>
-        extname(file) === ".json" &&
-        file !== "index.json" &&
-        file !== ACTIVE_RUNS_INDEX,
-      );
-      for (const file of detailFiles) {
-        const runId = basename(file, ".json");
+      // This is bounded to a recent subset so old archived run details cannot
+      // stall startup when workflow-runs contains thousands of historical files.
+      const orphanCandidates = this._getInterruptedOrphanRunCandidates();
+      for (const candidate of orphanCandidates) {
+        const runId = basename(candidate.file, ".json");
         if (!runId || this._activeRuns.has(runId) || runsById.has(runId)) continue;
-        const detailPath = resolve(this.runsDir, file);
         try {
-          const detail = JSON.parse(readFileSync(detailPath, "utf8"));
+          const detail = JSON.parse(readFileSync(candidate.detailPath, "utf8"));
           const hasRunningNode = Object.values(detail?.nodeStatuses || {}).some(
             (status) => status === NodeStatus.RUNNING || status === NodeStatus.WAITING,
           );