@integrity-labs/agt-cli 0.28.762 → 0.28.764

package/dist/{chunk-EU6RSU5V.js → chunk-LVBINNTQ.js}

@@ -18,13 +18,122 @@ import {
   rotateDailySession,
   sessionFileExists,
   todayLocalIso
-} from "./chunk-L4KDOGHB.js";
+} from "./chunk-23KTLVYX.js";
 import {
   reapOrphanChannelMcps
 } from "./chunk-XWVM4KPK.js";
 
 // src/lib/persistent-session.ts
-import { spawn as spawn2, execSync as execSync2, execFileSync as execFileSync3 } from "child_process";
+import { spawn as spawn2, execSync as execSync2, execFileSync as execFileSync4 } from "child_process";
+
+// src/lib/bounded-exec.ts
+import { execFileSync } from "child_process";
+var TIMEOUT_EXIT_DEADLINE = 124;
+var TIMEOUT_EXIT_KILLED = 137;
+var TIMEOUT_EXIT_CANNOT_RUN = 126;
+var TIMEOUT_EXIT_NOT_FOUND = 127;
+var DEFAULT_KILL_AFTER_MS = 2e3;
+var MIN_DURATION_MS = 1;
+var timeoutBinaryProbe = null;
+var warnedNoTimeoutBinary = false;
+var warnedInvalidDuration = false;
+function hasTimeoutBinary(exec) {
+  if (timeoutBinaryProbe !== null) return timeoutBinaryProbe;
+  try {
+    exec("timeout", ["--version"], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] });
+    timeoutBinaryProbe = true;
+  } catch {
+    timeoutBinaryProbe = false;
+  }
+  return timeoutBinaryProbe;
+}
+function toTimeoutArg(ms) {
+  return `${(ms / 1e3).toFixed(3)}s`;
+}
+function invalidDuration(name, ms) {
+  if (Number.isFinite(ms) && ms >= MIN_DURATION_MS) return null;
+  return `[bounded-exec] refusing to run: ${name}=${String(ms)} is not a usable deadline (needs a finite value >= ${MIN_DURATION_MS}ms). A zero or sub-millisecond duration DISABLES the deadline or the SIGKILL escalation, which would leave this call unbounded while reporting that it was bounded (ENG-9781).`;
+}
+function hardBoundedExecFile(file, args, opts) {
+  const exec = opts.exec ?? execFileSync;
+  const killAfterMs = opts.killAfterMs ?? DEFAULT_KILL_AFTER_MS;
+  const log2 = opts.log;
+  const badDuration = invalidDuration("timeoutMs", opts.timeoutMs) ?? invalidDuration("killAfterMs", killAfterMs);
+  if (badDuration) {
+    if (!warnedInvalidDuration) {
+      warnedInvalidDuration = true;
+      (log2 ?? ((m) => console.warn(m)))(badDuration);
+    }
+    return { kind: "failed", status: null, message: badDuration, bounded: false };
+  }
+  const available = opts.timeoutBinaryAvailable ? opts.timeoutBinaryAvailable() : hasTimeoutBinary(exec);
+  if (!available && !warnedNoTimeoutBinary) {
+    warnedNoTimeoutBinary = true;
+    (log2 ?? ((m) => console.warn(m)))(
+      `[bounded-exec] coreutils 'timeout' not found \u2014 subprocess calls on the manager's critical path are running UNBOUNDED. A wedged '${file}' can block the event loop for every agent on this host (ENG-9781).`
+    );
+  }
+  const nodeTimeoutMs = available ? opts.timeoutMs + killAfterMs + 5e3 : opts.timeoutMs;
+  const execFile = available ? "timeout" : file;
+  const execArgs = available ? [
+    "--signal=TERM",
+    `--kill-after=${toTimeoutArg(killAfterMs)}`,
+    toTimeoutArg(opts.timeoutMs),
+    file,
+    ...args
+  ] : [...args];
+  const now = opts.now ?? (() => performance.now());
+  const startedAt = now();
+  try {
+    const stdout = exec(execFile, execArgs, {
+      encoding: "utf-8",
+      timeout: nodeTimeoutMs,
+      maxBuffer: opts.maxBuffer,
+      // stderr is CAPTURED rather than discarded: it is the only place the
+      // command says why it failed, and a reaper that logs "docker exec failed"
+      // with no reason is the kind of line that costs an hour at 3am.
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { kind: "ok", stdout: String(stdout ?? ""), bounded: available };
+  } catch (err) {
+    const e = err;
+    const status = e?.status ?? null;
+    const elapsedMs = now() - startedAt;
+    if (available && status === TIMEOUT_EXIT_KILLED) {
+      return { kind: "timed-out", bounded: true };
+    }
+    if (available && status === TIMEOUT_EXIT_DEADLINE && elapsedMs >= opts.timeoutMs) {
+      return { kind: "timed-out", bounded: true };
+    }
+    if (e?.code === "ETIMEDOUT" || e?.signal === "SIGTERM" || e?.signal === "SIGKILL") {
+      return { kind: "timed-out", bounded: available };
+    }
+    const stderr = String(e?.stderr ?? "").trim();
+    if (available && (status === TIMEOUT_EXIT_CANNOT_RUN || status === TIMEOUT_EXIT_NOT_FOUND) && /^timeout:/m.test(stderr)) {
+      return {
+        kind: "failed",
+        status: null,
+        message: `timeout could not run '${file}' (wrapper exit ${status}): ${stderr}`,
+        bounded: true,
+        notFound: status === TIMEOUT_EXIT_NOT_FOUND
+      };
+    }
+    const base = e?.message ?? String(err);
+    return {
+      kind: "failed",
+      status,
+      message: stderr ? `${base}: ${stderr}` : base,
+      bounded: available,
+      notFound: e?.code === "ENOENT"
+    };
+  }
+}
+function hardBoundedCapture(file, args, opts) {
+  const r = hardBoundedExecFile(file, args, opts);
+  return r.kind === "ok" ? r.stdout : null;
+}
+
+// src/lib/persistent-session.ts
 import { join as join6, dirname as dirname5 } from "path";
 import { homedir as homedir5, platform, userInfo as userInfo2 } from "os";
 import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync4, appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, chmodSync as chmodSync3, copyFileSync, rmSync as rmSync3, lstatSync as lstatSync3, realpathSync as realpathSync2, renameSync as renameSync2, statSync } from "fs";
@@ -2501,7 +2610,7 @@ function readAgentIntegrationsEnv(codeName, dir) {
 import { randomUUID } from "crypto";
 
 // ../../packages/core/dist/runtime/session-probe.js
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function escapePgrepRegex(value) {
   return value.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&");
 }
@@ -2509,7 +2618,7 @@ function probeClaudeProcessInTmux(tmuxSession) {
   const escapedSession = escapePgrepRegex(tmuxSession);
   const pattern = `(^|[[:space:]])--name ${escapedSession}([[:space:]]|$)`;
   try {
-    const out = execFileSync("pgrep", ["-f", "--", pattern], {
+    const out = execFileSync2("pgrep", ["-f", "--", pattern], {
       encoding: "utf-8",
       timeout: 3e3
     }).trim();
@@ -2616,7 +2725,7 @@ function describeError(err) {
 }
 
 // src/lib/claude-dialogs.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 function isLoginPickerVisible(screen) {
   return screen.includes("Select login method") || screen.includes("Claude account with subscription") && screen.includes("Anthropic Console account");
 }
@@ -2857,7 +2966,7 @@ async function sendDialogKeys(tmuxSession, action) {
     if (i > 0 && action.interKeyDelayMs > 0) {
       await new Promise((r) => setTimeout(r, action.interKeyDelayMs));
     }
-    execFileSync2("tmux", ["send-keys", "-t", tmuxSession, action.keys[i]], {
+    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, action.keys[i]], {
       stdio: "ignore"
     });
   }
@@ -3365,20 +3474,20 @@ function isolationMode(codeName) {
 var dockerReadinessCache = null;
 var isolationDegradationLogged = false;
 function probeDockerRuntime(image) {
-  try {
-    execFileSync3("docker", ["info"], { stdio: "ignore", timeout: 15e3 });
-  } catch (err) {
-    const code = err?.code;
+  const info = hardBoundedExecFile("docker", ["info"], { timeoutMs: 15e3 });
+  if (info.kind !== "ok") {
     return {
       ok: false,
-      reason: code === "ENOENT" ? "docker-not-installed" : "docker-daemon-unavailable"
+      // A wedged daemon and a missing binary are different operational
+      // problems with different fixes, and the readiness reason is what an
+      // operator reads. `notFound` carries the distinction across the wrapper
+      // (unwrapped ENOENT vs `timeout` exiting 127) so neither is mistaken for
+      // the other.
+      reason: info.kind === "failed" && info.notFound ? "docker-not-installed" : "docker-daemon-unavailable"
     };
   }
-  try {
-    execFileSync3("docker", ["image", "inspect", image], { stdio: "ignore", timeout: 15e3 });
-  } catch {
-    return { ok: false, reason: `image-missing:${image}` };
-  }
+  const img = hardBoundedExecFile("docker", ["image", "inspect", image], { timeoutMs: 15e3 });
+  if (img.kind !== "ok") return { ok: false, reason: `image-missing:${image}` };
   return { ok: true };
 }
 function dockerRuntimeReadiness() {
@@ -3456,7 +3565,7 @@ function isNoSuchContainer(err) {
 }
 function reloadEgressSidecar(codeName) {
   try {
-    execFileSync3("docker", ["kill", "--signal=HUP", `agt-squid-${codeName}`], {
+    execFileSync4("docker", ["kill", "--signal=HUP", `agt-squid-${codeName}`], {
       stdio: "pipe",
       timeout: EGRESS_DOCKER_TIMEOUT_MS
     });
@@ -3468,7 +3577,7 @@ function reloadEgressSidecar(codeName) {
 }
 function restartEgressSidecar(codeName) {
   try {
-    execFileSync3("docker", ["restart", `agt-squid-${codeName}`], {
+    execFileSync4("docker", ["restart", `agt-squid-${codeName}`], {
       stdio: "pipe",
       timeout: EGRESS_DOCKER_TIMEOUT_MS
     });
@@ -4379,7 +4488,7 @@ async function waitForPromptReady(tmuxSession) {
   const deadline = Date.now() + 1e4;
   while (Date.now() < deadline) {
     try {
-      const screen = execFileSync3(
+      const screen = execFileSync4(
         "tmux",
         ["capture-pane", "-t", tmuxSession, "-p"],
         { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
@@ -4398,11 +4507,11 @@ function sleepBlockingMs(ms) {
 }
 function defaultArmSender(tmuxSession, command) {
   try {
-    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, "-l", command], {
+    execFileSync4("tmux", ["send-keys", "-t", tmuxSession, "-l", command], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     sleepBlockingMs(SEND_KEYS_ENTER_DELAY_MS);
-    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, "Enter"], {
+    execFileSync4("tmux", ["send-keys", "-t", tmuxSession, "Enter"], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     return true;
@@ -4413,7 +4522,7 @@ function defaultArmSender(tmuxSession, command) {
 var armSender = defaultArmSender;
 function defaultPaneCapture(tmuxSession) {
   try {
-    return execFileSync3("tmux", ["capture-pane", "-t", tmuxSession, "-p"], {
+    return execFileSync4("tmux", ["capture-pane", "-t", tmuxSession, "-p"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 2e3
@@ -4428,7 +4537,7 @@ var defaultHygieneKeySender = async (tmuxSession, keys, interKeyDelayMs) => {
     if (i > 0 && interKeyDelayMs > 0) {
       await new Promise((r) => setTimeout(r, interKeyDelayMs));
     }
-    execFileSync3("tmux", ["send-keys", "-t", tmuxSession, keys[i]], {
+    execFileSync4("tmux", ["send-keys", "-t", tmuxSession, keys[i]], {
       stdio: "ignore"
     });
   }
@@ -4437,7 +4546,7 @@ var hygieneKeySender = defaultHygieneKeySender;
 var SESSION_CREATED_TIMEOUT_MS = 3e3;
 function defaultSessionCreatedProbe(tmuxSession) {
   try {
-    const created = execFileSync3("tmux", ["display", "-p", "-t", tmuxSession, "#{session_created}"], {
+    const created = execFileSync4("tmux", ["display", "-p", "-t", tmuxSession, "#{session_created}"], {
       encoding: "utf-8",
       timeout: SESSION_CREATED_TIMEOUT_MS
     }).trim();
@@ -4564,7 +4673,7 @@ function stopPersistentSession(codeName, log2) {
   log2(`[persistent-session] Stopping session for '${codeName}'`);
   session.status = "stopped";
   try {
-    execFileSync3("tmux", ["kill-session", "-t", `agt-${codeName}`], { stdio: ["ignore", "ignore", "pipe"] });
+    execFileSync4("tmux", ["kill-session", "-t", `agt-${codeName}`], { stdio: ["ignore", "ignore", "pipe"] });
   } catch (err) {
     const stderr = (err.stderr ?? "").toString().trim();
     const alreadyGone = /can't find session|no server running/i.test(stderr);
@@ -4589,17 +4698,23 @@ var pendingZombieDetections = /* @__PURE__ */ new Map();
 function isClaudeProcessAliveInTmux(tmuxSession) {
   const codeName = tmuxSession.replace(/^agt-/, "");
   if (effectiveIsolationMode(codeName) === "docker") {
-    try {
-      const out = execFileSync3("docker", ["exec", `agt-${codeName}`, "pgrep", "-f", "claude"], {
-        encoding: "utf-8",
-        timeout: 8e3
-      }).trim();
-      return out.length > 0;
-    } catch (err) {
-      const e = err;
-      if (e?.status === 1 || e?.status === 125 || e?.status === 126) return false;
-      return true;
+    const r = hardBoundedExecFile(
+      "docker",
+      ["exec", `agt-${codeName}`, "pgrep", "-f", "claude"],
+      // No logger threaded through this helper, and it is not worth widening
+      // its signature for one line: bounded-exec falls back to `console.warn`
+      // when a call site passes none, so the one-shot "unbounded" warning fires
+      // from whichever call is first whether or not that call carries a logger.
+      // It did NOT before ENG-9781's review — the latch was consumed without
+      // emitting — and this comment asserted the outcome it wanted rather than
+      // the one the code produced.
+      { timeoutMs: 8e3 }
+    );
+    if (r.kind === "ok") return r.stdout.trim().length > 0;
+    if (r.kind === "failed" && (r.status === 1 || r.status === 125 || r.status === 126)) {
+      return false;
     }
+    return true;
   }
   return probeClaudeProcessInTmux(tmuxSession) === "alive";
 }
@@ -4657,7 +4772,7 @@ function isSessionHealthy(codeName) {
     if (!claudeAlive) {
       const paneTail = readPaneLogTail(codeName);
       try {
-        execFileSync3("tmux", ["kill-session", "-t", tmuxSession], { stdio: "ignore" });
+        execFileSync4("tmux", ["kill-session", "-t", tmuxSession], { stdio: "ignore" });
       } catch {
       }
       session.status = "crashed";
@@ -4753,13 +4868,13 @@ function collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, sp
     let launchArgs = null;
     let channelStatus = null;
     try {
-      execFileSync3("tmux", ["has-session", "-t", tmuxSession], { stdio: "ignore" });
+      execFileSync4("tmux", ["has-session", "-t", tmuxSession], { stdio: "ignore" });
       tmuxAlive = true;
     } catch {
     }
     if (tmuxAlive) {
       try {
-        screenCapture = execFileSync3("tmux", ["capture-pane", "-t", tmuxSession, "-p", "-S", "-30"], {
+        screenCapture = execFileSync4("tmux", ["capture-pane", "-t", tmuxSession, "-p", "-S", "-30"], {
           encoding: "utf-8",
           timeout: 3e3
         }).trim();
@@ -4767,7 +4882,7 @@ function collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, sp
       }
     }
     try {
-      const psOutput = execFileSync3("ps", ["aux"], { encoding: "utf-8", timeout: 3e3 });
+      const psOutput = execFileSync4("ps", ["aux"], { encoding: "utf-8", timeout: 3e3 });
       const line2 = psOutput.split("\n").find((l) => l.includes(`agt-${codeName}`) && !l.includes("grep"));
       if (line2) {
         const match = line2.match(/claude\s+.*/);
@@ -4858,6 +4973,8 @@ export {
   toOpencodeModel,
   mergeOpencodeConfigArtifact,
   readChannelServerEnv,
+  hardBoundedExecFile,
+  hardBoundedCapture,
   LATE_BOUND_VARS,
   expandTemplateVars,
   parseEnvIntegrations,
@@ -4934,4 +5051,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-EU6RSU5V.js.map
+//# sourceMappingURL=chunk-LVBINNTQ.js.map