@smithers-orchestrator/driver 0.21.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/driver",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Workflow execution driver — runs tasks, acts on EngineDecisions, reports results",
   "type": "module",
   "sideEffects": false,
@@ -63,11 +63,11 @@
   "dependencies": {
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/db": "0.21.0",
-    "@smithers-orchestrator/graph": "0.21.0",
-    "@smithers-orchestrator/errors": "0.21.0",
-    "@smithers-orchestrator/observability": "0.21.0",
-    "@smithers-orchestrator/scheduler": "0.21.0"
+    "@smithers-orchestrator/errors": "0.23.0",
+    "@smithers-orchestrator/observability": "0.23.0",
+    "@smithers-orchestrator/db": "0.23.0",
+    "@smithers-orchestrator/graph": "0.23.0",
+    "@smithers-orchestrator/scheduler": "0.23.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/child-process.js

@@ -88,13 +88,24 @@ export function spawnCaptureEffect(command, args, options) {
         };
         let totalTimer;
         let idleTimer;
+        let idleGeneration = 0;
+        // Bun can deliver child stdout/stderr chunks late on macOS; avoid
+        // killing active CLI agents before observable output reaches JS.
+        const effectiveIdleTimeoutMs = typeof process.versions.bun === "string" && idleTimeoutMs >= 1000
+            ? Math.max(idleTimeoutMs, 5000)
+            : idleTimeoutMs;
         const resetIdle = () => {
             if (idleTimer)
                 clearTimeout(idleTimer);
-            if (idleTimeoutMs) {
+            if (effectiveIdleTimeoutMs) {
+                idleGeneration += 1;
+                const generation = idleGeneration;
                 idleTimer = setTimeout(() => {
+                    if (generation !== idleGeneration) {
+                        return;
+                    }
                     kill(`CLI idle timed out after ${idleTimeoutMs}ms`, "PROCESS_IDLE_TIMEOUT");
-                }, idleTimeoutMs);
+                }, effectiveIdleTimeoutMs);
             }
         };
         if (timeoutMs) {
@@ -188,6 +199,12 @@ export function spawnCaptureEffect(command, args, options) {
         child.on("close", (code) => {
             finalize({ stdout, stderr, exitCode: code ?? null });
         });
+        child.stdin?.on("error", (error) => {
+            logWarning("child process stdin error", {
+                ...logAnnotations,
+                error: error instanceof Error ? error.message : String(error),
+            }, span);
+        });
         if (input) {
             child.stdin?.write(input);
         }

package/src/withAbort.js

@@ -16,18 +16,23 @@ function throwIfAborted(signal) {
 }
 /**
  * @param {AbortSignal} [signal]
- * @returns {Promise<never> | null}
+ * @returns {{ promise: Promise<never>, cleanup: () => void } | null}
  */
 function abortPromise(signal) {
     if (!signal)
         return null;
     if (signal.aborted)
-        return Promise.reject(makeAbortError());
-    return new Promise((_, reject) => {
-        signal.addEventListener("abort", () => reject(makeAbortError()), {
-            once: true,
-        });
+        return { promise: Promise.reject(makeAbortError()), cleanup: () => {} };
+    /** @type {() => void} */
+    let cleanup = () => {};
+    const promise = new Promise((_, reject) => {
+        function onAbort() {
+            reject(makeAbortError());
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        cleanup = () => signal.removeEventListener("abort", onAbort);
     });
+    return { promise, cleanup };
 }
 /**
  * @template T
@@ -39,5 +44,12 @@ export async function withAbort(value, signal) {
     throwIfAborted(signal);
     const abort = abortPromise(signal);
     const promise = Promise.resolve(value);
-    return abort ? Promise.race([promise, abort]) : promise;
+    if (!abort)
+        return promise;
+    try {
+        return await Promise.race([promise, abort.promise]);
+    }
+    finally {
+        abort.cleanup();
+    }
 }