chainlesschain 0.165.6 → 0.165.9

package/src/lib/cowork-workflow.js

@@ -131,6 +131,9 @@ const ADMITTED_STEP_STATUSES = new Set([
   "failed",
   "partial",
   "skipped",
+  "exhausted",
+  "upstream_failed",
+  "cancelled",
 ]);
 const MAX_ADMITTED_RUN_STEPS = 64;
 const MAX_ADMITTED_SNAPSHOT_NODES = 25_000;
@@ -948,6 +951,23 @@ export function validateWorkflow(wf) {
         errors.push(`steps[${i}].maxIterations must be a positive integer`);
       }
     }
+    // forEach expands `stepId` into concrete runtime ids such as
+    // `stepId[0]`.  A declarative step with the same id would overwrite the
+    // child result and make dependency/evidence accounting ambiguous.
+    for (const parent of wf.steps) {
+      if (parent?.forEach === undefined || typeof parent.id !== "string") {
+        continue;
+      }
+      const escapedParentId = parent.id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+      const childIdPattern = new RegExp(`^${escapedParentId}\\[\\d+\\]$`, "u");
+      for (const id of ids) {
+        if (childIdPattern.test(id)) {
+          errors.push(
+            `step id '${id}' collides with dynamic children of '${parent.id}'`,
+          );
+        }
+      }
+    }
     // Check dependsOn references exist
     for (const s of wf.steps) {
       for (const dep of s.dependsOn || []) {
@@ -1682,7 +1702,7 @@ export async function runLoopStep({
   }
   const outcome = {
     id: recordId,
-    status: last ? last.status : "skipped",
+    status: stopReason === "cap" ? "exhausted" : last ? last.status : "skipped",
     taskId: last?.taskId ?? null,
     result: {
       ...(last?.result || {}),
@@ -1694,6 +1714,35 @@ export async function runLoopStep({
   return admitted ? normalizeAdmittedOutcome(outcome) : outcome;
 }
 
+function dependencyBlock(step, resultsById) {
+  const blocked = (step.dependsOn || [])
+    .map((id) => resultsById.get(id))
+    .filter((outcome) => outcome && outcome.status !== "completed");
+  if (blocked.length === 0) return null;
+
+  const blockedRootCut = [
+    ...new Set(
+      blocked.flatMap((outcome) =>
+        Array.isArray(outcome.result?.blockedRootCut)
+          ? outcome.result.blockedRootCut
+          : [outcome.id],
+      ),
+    ),
+  ];
+  const allSkipped = blocked.every((outcome) => outcome.status === "skipped");
+  return {
+    id: step.id,
+    status: allSkipped ? "skipped" : "upstream_failed",
+    taskId: null,
+    result: {
+      summary: allSkipped
+        ? "skipped because an upstream dependency was skipped"
+        : "blocked by an unsuccessful upstream dependency",
+      blockedRootCut,
+    },
+  };
+}
+
 // ─── Step node + no-barrier pipeline ──────────────────────────────────────────
 
 /**
@@ -1726,6 +1775,12 @@ export async function runStepNode(step, ctx) {
     };
   };
 
+  const blocked = dependencyBlock(step, resultsById);
+  if (blocked) {
+    resultsById.set(recordId, blocked);
+    return { outcomes: [blocked], failed: blocked.status !== "skipped" };
+  }
+
   let runThis;
   try {
     runThis = shouldRunStep(step, resultsById);
@@ -1834,9 +1889,10 @@ export async function runStepNode(step, ctx) {
  * No-barrier pipeline scheduler: start each step the instant *its own*
  * dependencies finish, rather than waiting for the whole dependency level.
  * Up to `maxParallel` step nodes run concurrently. On failure with
- * `continueOnError` off, no new steps are scheduled (in-flight ones finish) and
- * the rest are marked skipped. Produces the same outcome set as the batch
- * executor — only the wall-clock idle between levels is removed.
+ * `continueOnError` off, no new steps are scheduled (in-flight ones finish).
+ * Unscheduled descendants receive the same dependency-derived terminal state
+ * as the batch executor; unrelated work is marked skipped. Only the wall-clock
+ * idle between levels differs.
  */
 export async function runPipeline({
   steps,
@@ -1886,9 +1942,9 @@ export async function runPipeline({
           reject(fatalError);
           return;
         }
-        for (const s of steps) {
+        for (const s of topoSort(steps)) {
           if (scheduled.has(s.id)) continue;
-          const o = {
+          const o = dependencyBlock(s, resultsById) || {
             id: s.id,
             status: "skipped",
             taskId: null,
@@ -2196,6 +2252,13 @@ export async function executeWorkflow(options = {}) {
         const runnable = []; // { step, message, recordId, parentId }
         const preOutcomes = []; // outcomes produced synchronously (skipped)
         for (const step of chunk) {
+          const blocked = dependencyBlock(step, resultsById);
+          if (blocked) {
+            if (blocked.status !== "skipped") anyFailure = true;
+            resultsById.set(step.id, blocked);
+            preOutcomes.push(blocked);
+            continue;
+          }
           if (anyFailure && !continueOnError) {
             const outcome = {
               id: step.id,

package/src/lib/execution-location-local-supervisor.mjs

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import {
+  samePathHandleFileIdentity,
+  withTrustedFileParentSync,
+} from "./secure-file-identity.js";
+
+const MEBIBYTE = 1024 * 1024;
+const MAX_CAPTURED_MARKER_BYTES = 256;
+const MAX_STDIN_BYTES = 64 * 1024 * 1024;
+const CPU_LIMIT_SIGNALS = new Set(["SIGKILL", "SIGXCPU"]);
+
+function parseArguments(argv) {
+  const separator = argv.indexOf("--");
+  assert.ok(separator >= 0, "local target supervisor requires --");
+  const control = argv.slice(0, separator);
+  const command = argv.slice(separator + 1);
+  const options = {};
+  for (let index = 0; index < control.length; index += 2) {
+    const key = control[index];
+    const value = control[index + 1];
+    assert.ok(key?.startsWith("--") && value, `invalid argument: ${key}`);
+    options[
+      key
+        .slice(2)
+        .replace(/-([a-z])/gu, (_, character) => character.toUpperCase())
+    ] = value;
+  }
+  assert.ok(options.cwd && options.entry && command.length > 0);
+  const cpuSeconds = Number(options.cpuSeconds);
+  const memoryBytes = Number(options.memoryBytes);
+  assert.ok(
+    Number.isSafeInteger(cpuSeconds) && cpuSeconds >= 1 && cpuSeconds <= 86_400,
+  );
+  assert.ok(
+    Number.isSafeInteger(memoryBytes) &&
+      memoryBytes >= 64 * MEBIBYTE &&
+      memoryBytes <= 64 * 1024 * MEBIBYTE,
+  );
+  return { ...options, cpuSeconds, memoryBytes, command };
+}
+
+function boundedHeapMebibytes(memoryBytes) {
+  // V8's old-space boundary is a real child-process limit and is intentionally
+  // allowed to be stricter than the runner's total-memory ceiling. Keeping the
+  // probe at or below 256 MiB avoids consuming a multi-GiB hosted runner merely
+  // to prove that the target-side supervisor terminates the workload.
+  return Math.max(64, Math.min(256, Math.floor(memoryBytes / MEBIBYTE)));
+}
+
+function openStagedReplicaInput(inputPath) {
+  let descriptor = null;
+  try {
+    return withTrustedFileParentSync(
+      fs,
+      inputPath,
+      ({ canonicalPath, parentDevice }) => {
+        const requested = fs.lstatSync(canonicalPath, { bigint: true });
+        assert.ok(
+          requested.isFile() &&
+            !requested.isSymbolicLink() &&
+            requested.size > 0n &&
+            requested.size <= BigInt(MAX_STDIN_BYTES),
+          "local target stdin file is invalid",
+        );
+        descriptor = fs.openSync(
+          canonicalPath,
+          fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0),
+        );
+        const opened = fs.fstatSync(descriptor, { bigint: true });
+        assert.ok(
+          opened.isFile() &&
+            opened.nlink === 1n &&
+            samePathHandleFileIdentity(requested, opened, parentDevice),
+          "local target stdin file changed while opening",
+        );
+        const stagedInput = fs.readFileSync(descriptor);
+        assert.equal(
+          BigInt(stagedInput.length),
+          requested.size,
+          "local target stdin file changed while reading",
+        );
+        return Object.freeze({ descriptor, stagedInput });
+      },
+    );
+  } catch (error) {
+    if (descriptor !== null) fs.closeSync(descriptor);
+    throw error;
+  }
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  const resourceKind =
+    options.command[0] === "session" &&
+    options.command[1] === "location" &&
+    options.command[2] === "resource-probe"
+      ? options.command[3]
+      : null;
+  const resume =
+    options.command[0] === "session" && options.command[1] === "resume";
+  const forwardsInput =
+    options.command[0] === "session" &&
+    options.command[1] === "location" &&
+    options.command[2] === "prepare";
+  if (options.stdinFile) {
+    assert.ok(
+      forwardsInput && path.isAbsolute(options.stdinFile),
+      "local target stdin file is invalid",
+    );
+  }
+  let inputDescriptor = null;
+  let stagedInput = null;
+  if (options.stdinFile) {
+    ({ descriptor: inputDescriptor, stagedInput } = openStagedReplicaInput(
+      options.stdinFile,
+    ));
+  }
+  const heapMebibytes = boundedHeapMebibytes(options.memoryBytes);
+  const childEnvironment = {
+    ...process.env,
+    CC_EXECUTION_LOCATION_OBSERVED_CPU_SECONDS: String(options.cpuSeconds),
+    CC_EXECUTION_LOCATION_OBSERVED_MEMORY_BYTES: String(
+      heapMebibytes * MEBIBYTE,
+    ),
+    CC_EXECUTION_LOCATION_RESOURCE_ENFORCEMENT: "target-supervisor",
+  };
+  let child;
+  try {
+    child = spawn(
+      process.execPath,
+      [
+        `--max-old-space-size=${heapMebibytes}`,
+        options.entry,
+        ...options.command,
+      ],
+      {
+        cwd: options.cwd,
+        env: childEnvironment,
+        shell: false,
+        stdio: [
+          resume || stagedInput !== null
+            ? "pipe"
+            : forwardsInput
+                ? "inherit"
+                : "ignore",
+          "pipe",
+          "inherit",
+        ],
+        windowsHide: true,
+      },
+    );
+  } finally {
+    if (inputDescriptor !== null) fs.closeSync(inputDescriptor);
+  }
+
+  if (resume) child.stdin.end("/exit\n", "utf8");
+  else if (stagedInput !== null) child.stdin.end(stagedInput);
+  let outputPrefix = "";
+  let cpuLimitReached = false;
+  let cpuTimer = null;
+  const armCpuLimit = () => {
+    if (cpuTimer !== null) return;
+    cpuTimer = setTimeout(() => {
+      cpuLimitReached = true;
+      child.kill("SIGKILL");
+    }, options.cpuSeconds * 1_000);
+  };
+  child.stdout.on("data", (chunk) => {
+    process.stdout.write(chunk);
+    if (outputPrefix.length < MAX_CAPTURED_MARKER_BYTES) {
+      outputPrefix += chunk
+        .toString("utf8")
+        .slice(0, MAX_CAPTURED_MARKER_BYTES - outputPrefix.length);
+    }
+    if (
+      resourceKind === "cpu" &&
+      outputPrefix.includes("CC_EXECUTION_LOCATION_RESOURCE_PROBE_ARMED:cpu")
+    ) {
+      // Startup and module loading are not the probed workload. Arm the
+      // target-side CPU boundary only after the fixed command proves that its
+      // busy loop is live; otherwise slow filesystem I/O could masquerade as
+      // CPU enforcement on hosted Windows or macOS.
+      armCpuLimit();
+    }
+  });
+
+  const forwardSignal = () => child.kill("SIGTERM");
+  process.once("SIGTERM", forwardSignal);
+  const result = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  });
+  if (cpuTimer !== null) clearTimeout(cpuTimer);
+  process.removeListener("SIGTERM", forwardSignal);
+
+  const expectedMarker = resourceKind
+    ? `CC_EXECUTION_LOCATION_RESOURCE_PROBE_ARMED:${resourceKind}`
+    : null;
+  const armed =
+    expectedMarker !== null && outputPrefix.includes(expectedMarker);
+  if (
+    resourceKind === "cpu" &&
+    armed &&
+    (cpuLimitReached || CPU_LIMIT_SIGNALS.has(result.signal))
+  ) {
+    process.exitCode = 152;
+  } else if (
+    resourceKind === "memory" &&
+    armed &&
+    (result.code !== 0 || result.signal !== null)
+  ) {
+    process.exitCode = 137;
+  } else if (result.signal !== null) {
+    process.exitCode = 128;
+  } else {
+    process.exitCode = Number(result.code || 0);
+  }
+}
+
+await main();