opencode-swarm 7.139.2 → 7.139.4

package/dist/cli/{index-wrt6m5ze.js → index-sd657fkp.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-s608d3hw.js";
+} from "./index-nrx08gcr.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,
@@ -18,13 +18,13 @@ import {
   computeTaskSetContentHash,
   resolveContainedExistingPath
 } from "./index-y8552snf.js";
+import {
+  bunSpawn
+} from "./index-4nt52yr9.js";
 import {
   exports_external,
   init_zod
 } from "./index-bpmtbmy9.js";
-import {
-  bunSpawn
-} from "./index-y111zefa.js";
 
 // src/evaluation/runner.ts
 import * as fs3 from "fs";
@@ -193,6 +193,17 @@ init_zod();
 import * as fs from "fs";
 import * as path from "path";
 var DEFAULT_WINDOWS_EXTENSIONS = [".exe", ".cmd", ".bat"];
+var TERMINATION_GRACE_MS = 20;
+var TERMINATION_FORCE_MS = 20;
+var TERMINATION_CONFIRM_MS = 20;
+var TREE_TERMINATION_CONFIRM_MS = 5100;
+var TERMINATION_FALLBACK_BUFFER_MS = 1;
+var STREAM_DRAIN_MS = 50;
+var STREAM_CANCEL_MS = 50;
+var MAX_TIMEOUT_MS = 2147483647;
+var TERMINATION_WINDOWS_MS = TERMINATION_GRACE_MS + TERMINATION_FORCE_MS + TERMINATION_CONFIRM_MS + TREE_TERMINATION_CONFIRM_MS + TERMINATION_FALLBACK_BUFFER_MS;
+var MAX_RUNNER_TIMEOUT_MS = MAX_TIMEOUT_MS - TERMINATION_WINDOWS_MS;
+var UNCONFIRMED_TERMINATION_MESSAGE = "external tool process termination could not be confirmed";
 function isExecutableFile(candidate) {
   try {
     const stats = fs.statSync(candidate);
@@ -222,9 +233,35 @@ function resolveExecutableFromPath(names, envPath = process.env.PATH ?? "", plat
   }
   return null;
 }
-async function readBoundedStream(stream, maxBytes) {
+function clampTimeoutMs(timeoutMs) {
+  if (!Number.isFinite(timeoutMs)) {
+    return MAX_RUNNER_TIMEOUT_MS;
+  }
+  return Math.min(Math.max(1, Math.floor(timeoutMs)), MAX_RUNNER_TIMEOUT_MS);
+}
+function addTimeoutMs(baseMs, deltaMs) {
+  if (baseMs >= MAX_TIMEOUT_MS) {
+    return MAX_TIMEOUT_MS;
+  }
+  return Math.min(MAX_TIMEOUT_MS, baseMs + deltaMs);
+}
+function computeSpawnTimeoutMs(timeoutMs) {
+  let total = clampTimeoutMs(timeoutMs);
+  for (const windowMs of [
+    TERMINATION_GRACE_MS,
+    TERMINATION_FORCE_MS,
+    TERMINATION_CONFIRM_MS,
+    TREE_TERMINATION_CONFIRM_MS,
+    TERMINATION_FALLBACK_BUFFER_MS
+  ]) {
+    total = addTimeoutMs(total, windowMs);
+  }
+  return total;
+}
+function startBoundedStreamRead(stream, maxBytes, onLimitExceeded) {
   const reader = stream.getReader();
   let lockReleased = false;
+  let cancelPromise;
   const releaseLock = () => {
     if (lockReleased)
       return;
@@ -233,53 +270,66 @@ async function readBoundedStream(stream, maxBytes) {
       reader.releaseLock();
     } catch {}
   };
-  const cancelAndRelease = async () => {
-    try {
-      await reader.cancel();
-    } catch {} finally {
-      releaseLock();
-    }
+  const cancel = async () => {
+    cancelPromise ??= (async () => {
+      try {
+        await reader.cancel();
+      } catch {} finally {
+        releaseLock();
+      }
+    })();
+    return cancelPromise;
   };
   if (maxBytes <= 0) {
-    await cancelAndRelease();
-    return { text: "", truncated: true };
+    onLimitExceeded?.();
+    return {
+      cancel,
+      promise: (async () => {
+        await cancel();
+        return { text: "", truncated: true };
+      })()
+    };
   }
-  const chunks = [];
-  let total = 0;
-  let truncated = false;
-  try {
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      if (!value)
-        continue;
-      const remaining = maxBytes - total;
-      if (value.byteLength > remaining) {
-        if (remaining > 0) {
-          chunks.push(value.slice(0, remaining));
-          total += remaining;
+  const promise = (async () => {
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    try {
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (!value)
+          continue;
+        const remaining = maxBytes - total;
+        if (value.byteLength > remaining) {
+          if (remaining > 0) {
+            chunks.push(value.slice(0, remaining));
+            total += remaining;
+          }
+          truncated = true;
+          onLimitExceeded?.();
+          cancel();
+          break;
         }
-        truncated = true;
-        await cancelAndRelease();
-        break;
+        chunks.push(value);
+        total += value.byteLength;
       }
-      chunks.push(value);
-      total += value.byteLength;
+    } finally {
+      releaseLock();
     }
-  } finally {
-    releaseLock();
-  }
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return {
-    text: new TextDecoder().decode(out),
-    truncated
-  };
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return {
+      text: new TextDecoder().decode(out),
+      truncated
+    };
+  })();
+  return { promise, cancel };
 }
 function timeoutKillSignal(platform) {
   return platform === "win32" ? "SIGTERM" : "SIGKILL";
@@ -289,6 +339,71 @@ function killProcess(proc) {
     proc?.kill(timeoutKillSignal(_internals.platform()));
   } catch {}
 }
+function requestTermination(proc, signal) {
+  try {
+    if (proc?.killTree) {
+      return proc.killTree(signal).then(() => true, () => false);
+    } else {
+      proc?.kill(signal);
+      return Promise.resolve(proc !== undefined);
+    }
+  } catch {
+    return Promise.resolve(false);
+  }
+}
+async function waitForExitWithin(exitPromise, waitMs) {
+  if (waitMs <= 0) {
+    return Promise.resolve(null);
+  }
+  let timeoutHandle;
+  try {
+    return await Promise.race([
+      exitPromise,
+      new Promise((resolve) => {
+        timeoutHandle = _internals.setTimeout(() => resolve(null), waitMs);
+      })
+    ]);
+  } finally {
+    if (timeoutHandle !== undefined) {
+      _internals.clearTimeout(timeoutHandle);
+    }
+  }
+}
+async function waitForValueWithin(promise, waitMs) {
+  let timeoutHandle;
+  try {
+    return await Promise.race([
+      promise.then((value) => ({ completed: true, value })),
+      new Promise((resolve) => {
+        timeoutHandle = _internals.setTimeout(() => resolve({ completed: false }), waitMs);
+      })
+    ]);
+  } finally {
+    if (timeoutHandle !== undefined) {
+      _internals.clearTimeout(timeoutHandle);
+    }
+  }
+}
+async function collectBoundedStreams(stdoutRead, stderrRead, proc, treeAlreadyConfirmed = false) {
+  const reads = Promise.all([stdoutRead.promise, stderrRead.promise]);
+  let collected = await waitForValueWithin(reads, STREAM_DRAIN_MS);
+  if (!collected.completed) {
+    const treeTermination = waitForValueWithin(requestTermination(proc, "SIGKILL"), TREE_TERMINATION_CONFIRM_MS);
+    Promise.allSettled([stdoutRead.cancel(), stderrRead.cancel()]);
+    collected = await waitForValueWithin(reads, STREAM_CANCEL_MS);
+    const terminationResult = await treeTermination;
+    if (!treeAlreadyConfirmed && (!terminationResult.completed || !terminationResult.value)) {
+      return { kind: "unconfirmed-termination" };
+    }
+  }
+  if (!collected.completed)
+    return { kind: "cleanup-failed" };
+  return {
+    kind: "collected",
+    stdout: collected.value[0],
+    stderr: collected.value[1]
+  };
+}
 async function runExternalTool(options) {
   if (!path.isAbsolute(options.cwd)) {
     return {
@@ -315,8 +430,11 @@ async function runExternalTool(options) {
   let proc;
   let timeoutHandle;
   let abortListener;
+  let overflowTreeTermination;
   let exitSettled = false;
   let settledExitCode = null;
+  const runnerTimeoutMs = clampTimeoutMs(options.timeoutMs);
+  const spawnTimeoutMs = computeSpawnTimeoutMs(runnerTimeoutMs);
   try {
     proc = _internals.bunSpawn([options.executable, ...options.args], {
       cwd: options.cwd,
@@ -324,15 +442,18 @@ async function runExternalTool(options) {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
-      timeout: options.timeoutMs
+      timeout: spawnTimeoutMs,
+      killProcessTree: true,
+      windowsVerbatimArguments: options.windowsVerbatimArguments
     });
     const exitPromise = proc.exited.then((exitCode) => {
       exitSettled = true;
       settledExitCode = exitCode;
-      return { kind: "exit", exitCode };
+      return exitCode;
     });
+    const exitRacePromise = exitPromise.then((exitCode) => ({ kind: "exit", exitCode }));
     const timeout = new Promise((resolve) => {
-      timeoutHandle = setTimeout(() => {
+      timeoutHandle = _internals.setTimeout(() => {
         if (exitSettled) {
           resolve({
             kind: "exit",
@@ -340,9 +461,8 @@ async function runExternalTool(options) {
           });
           return;
         }
-        killProcess(proc);
         resolve({ kind: "timeout" });
-      }, options.timeoutMs);
+      }, runnerTimeoutMs);
     });
     const cancelled = new Promise((resolve) => {
       if (!options.abortSignal)
@@ -352,7 +472,6 @@ async function runExternalTool(options) {
         if (handled)
           return;
         handled = true;
-        killProcess(proc);
         resolve({ kind: "cancelled" });
       };
       options.abortSignal.addEventListener("abort", abortListener, {
@@ -361,31 +480,126 @@ async function runExternalTool(options) {
       if (options.abortSignal.aborted)
         abortListener();
     });
-    const stdoutPromise = readBoundedStream(proc.stdout, options.maxStdoutBytes);
-    const stderrPromise = readBoundedStream(proc.stderr, options.maxStderrBytes);
-    const exitResult = await Promise.race([exitPromise, timeout, cancelled]);
-    if (exitResult.kind === "timeout") {
+    const terminateOnOverflow = () => {
+      overflowTreeTermination ??= requestTermination(proc, "SIGKILL");
+    };
+    const stdoutRead = startBoundedStreamRead(proc.stdout, options.maxStdoutBytes, terminateOnOverflow);
+    const stderrRead = startBoundedStreamRead(proc.stderr, options.maxStderrBytes, terminateOnOverflow);
+    const exitResult = await Promise.race([
+      exitRacePromise,
+      timeout,
+      cancelled
+    ]);
+    if (exitResult.kind === "timeout" || exitResult.kind === "cancelled") {
+      const gracefulTreeTermination = requestTermination(proc, "SIGTERM");
+      let confirmedExitCode = await waitForExitWithin(exitPromise, TERMINATION_GRACE_MS);
+      if (!overflowTreeTermination) {
+        overflowTreeTermination = requestTermination(proc, "SIGKILL");
+      }
+      const forcedTreeTermination = overflowTreeTermination;
+      const treeTerminationResult = waitForValueWithin(Promise.all([gracefulTreeTermination, forcedTreeTermination]), TREE_TERMINATION_CONFIRM_MS);
+      if (confirmedExitCode === null) {
+        confirmedExitCode = await waitForExitWithin(exitPromise, TERMINATION_FORCE_MS);
+      }
+      if (confirmedExitCode === null) {
+        confirmedExitCode = await waitForExitWithin(exitPromise, TERMINATION_CONFIRM_MS);
+      }
+      const treeTermination = await treeTerminationResult;
+      const treeTerminationConfirmed = treeTermination.completed && treeTermination.value.some(Boolean);
+      Promise.allSettled([stdoutRead.cancel(), stderrRead.cancel()]);
+      const streams2 = await collectBoundedStreams(stdoutRead, stderrRead, proc, treeTerminationConfirmed);
+      if (streams2.kind !== "collected") {
+        return {
+          status: "spawn-error",
+          exitCode: confirmedExitCode ?? proc.exitCode,
+          stdout: "",
+          stderr: "",
+          stdoutTruncated: true,
+          stderrTruncated: true,
+          message: streams2.kind === "unconfirmed-termination" ? UNCONFIRMED_TERMINATION_MESSAGE : "external tool output cleanup did not complete"
+        };
+      }
+      const { stdout: stdout2, stderr: stderr2 } = streams2;
+      if (confirmedExitCode === null || !treeTerminationConfirmed) {
+        return {
+          status: "spawn-error",
+          exitCode: proc.exitCode,
+          stdout: stdout2.text,
+          stderr: stderr2.text,
+          stdoutTruncated: stdout2.truncated,
+          stderrTruncated: stderr2.truncated,
+          message: UNCONFIRMED_TERMINATION_MESSAGE
+        };
+      }
+      if (exitResult.kind === "timeout") {
+        return {
+          status: "timeout",
+          exitCode: confirmedExitCode,
+          stdout: stdout2.text,
+          stderr: stderr2.text,
+          stdoutTruncated: stdout2.truncated,
+          stderrTruncated: stderr2.truncated
+        };
+      }
       return {
-        status: "timeout",
-        exitCode: proc.exitCode,
+        status: "cancelled",
+        exitCode: confirmedExitCode,
+        stdout: stdout2.text,
+        stderr: stderr2.text,
+        stdoutTruncated: stdout2.truncated,
+        stderrTruncated: stderr2.truncated,
+        message: "external tool execution cancelled"
+      };
+    }
+    const streams = await collectBoundedStreams(stdoutRead, stderrRead, proc);
+    if (streams.kind !== "collected") {
+      return {
+        status: "spawn-error",
+        exitCode: exitResult.exitCode,
         stdout: "",
         stderr: "",
-        stdoutTruncated: false,
-        stderrTruncated: false
+        stdoutTruncated: true,
+        stderrTruncated: true,
+        message: streams.kind === "unconfirmed-termination" ? UNCONFIRMED_TERMINATION_MESSAGE : "external tool output cleanup did not complete"
       };
     }
-    if (exitResult.kind === "cancelled") {
+    const { stdout, stderr } = streams;
+    if (overflowTreeTermination) {
+      const overflowTermination = await waitForValueWithin(overflowTreeTermination, TREE_TERMINATION_CONFIRM_MS);
+      if (!overflowTermination.completed || !overflowTermination.value) {
+        return {
+          status: "spawn-error",
+          exitCode: exitResult.exitCode,
+          stdout: stdout.text,
+          stderr: stderr.text,
+          stdoutTruncated: stdout.truncated,
+          stderrTruncated: stderr.truncated,
+          message: UNCONFIRMED_TERMINATION_MESSAGE
+        };
+      }
+    }
+    if (proc.spawnError) {
       return {
-        status: "cancelled",
+        status: "spawn-error",
         exitCode: proc.exitCode,
-        stdout: "",
-        stderr: "",
-        stdoutTruncated: false,
-        stderrTruncated: false,
-        message: "external tool execution cancelled"
+        stdout: stdout.text,
+        stderr: stderr.text,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated,
+        message: proc.spawnError.message
+      };
+    }
+    if (proc.signalCode) {
+      return {
+        status: "spawn-error",
+        exitCode: exitResult.exitCode,
+        stdout: stdout.text,
+        stderr: stderr.text,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated,
+        message: `external tool terminated by signal ${proc.signalCode}`
       };
     }
-    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
     return {
       status: "completed",
       exitCode: exitResult.exitCode,
@@ -406,20 +620,22 @@ async function runExternalTool(options) {
     };
   } finally {
     if (timeoutHandle !== undefined)
-      clearTimeout(timeoutHandle);
+      _internals.clearTimeout(timeoutHandle);
     if (abortListener && options.abortSignal) {
       options.abortSignal.removeEventListener("abort", abortListener);
     }
-    if (proc) {
-      try {
-        proc.kill();
-      } catch {}
-    }
+    if (!exitSettled)
+      killProcess(proc);
   }
 }
 var _internals = {
   bunSpawn,
-  platform: () => process.platform
+  platform: () => process.platform,
+  now: () => Date.now(),
+  setTimeout,
+  clearTimeout,
+  clampTimeoutMs,
+  computeSpawnTimeoutMs
 };
 
 // src/evaluation/disposable-worktree.ts

package/dist/cli/{index-yr6x707c.js → index-vfsqpcz6.js}

@@ -7,7 +7,7 @@ import {
   loadPluginConfigWithMeta,
   loadPluginConfigWithMetaAsync,
   resolveWorktreeIsolationConfig
-} from "./index-q11t5erh.js";
+} from "./index-s58vghgj.js";
 import {
   ApprovalEvidenceSchema,
   BaseEvidenceSchema,
@@ -33,6 +33,17 @@ import {
   SwarmSpecSchema,
   validateSpecContent
 } from "./index-n832052r.js";
+import {
+  MigrationStatusSchema,
+  PhaseSchema,
+  PhaseStatusSchema,
+  PlanSchema,
+  TaskSchema,
+  TaskSizeSchema,
+  TaskStatusSchema
+} from "./index-1kz6da87.js";
+import"./index-4rhhvd1a.js";
+import"./index-zgwm4ryv.js";
 import {
   AUTO_REVIEW_V8_BURN_IN_DECISION,
   AgentOverrideConfigSchema,
@@ -54,18 +65,7 @@ import {
   TurboConfigSchema,
   WorktreeIsolationConfigSchema,
   resolveAutoReviewConfig
-} from "./index-8p9pasnp.js";
-import"./index-bk5tah7q.js";
-import {
-  MigrationStatusSchema,
-  PhaseSchema,
-  PhaseStatusSchema,
-  PlanSchema,
-  TaskSchema,
-  TaskSizeSchema,
-  TaskStatusSchema
-} from "./index-1kz6da87.js";
-import"./index-4rhhvd1a.js";
+} from "./index-5s23pfsy.js";
 import {
   ALL_AGENT_NAMES,
   ALL_SUBAGENT_NAMES,
@@ -75,10 +75,10 @@ import {
   QA_AGENTS,
   isQAAgent,
   isSubagent
-} from "./index-3jcyn8g6.js";
-import"./index-bpmtbmy9.js";
+} from "./index-4wjk296r.js";
 import"./index-zjygnfay.js";
-import"./index-zgwm4ryv.js";
+import"./index-bk5tah7q.js";
+import"./index-bpmtbmy9.js";
 import"./index-a76rekgs.js";
 export {
   validateSpecContent,