@mutagent/cli 0.2.207 → 0.2.209

package/dist/bin/cli.js

@@ -28444,10 +28444,8 @@ async function* readSseEvents(body) {
   }
 }
 
-// src/lib/sandbox-stream.ts
-init_errors();
-
 // src/lib/stream-reconnect.ts
+init_errors();
 var QUICK_CLOSE_MS = 1000;
 var CLEAN_BACKOFF_BASE_MS = 1000;
 var CLEAN_BACKOFF_CAP_MS = 5000;
@@ -28465,13 +28463,62 @@ class CleanClosePacer {
     return Math.min(CLEAN_BACKOFF_BASE_MS * 2 ** (this.streak - 2), CLEAN_BACKOFF_CAP_MS);
   }
 }
-function retryFailedNotice(failedRetries, max, lastSeq) {
-  return `Reconnect failed (${String(failedRetries)}/${String(max)}). Retrying from seq ${String(lastSeq)}...`;
+function retryFailedNotice(failedRetries, _max, lastSeq) {
+  return `Reconnect failed (attempt ${String(failedRetries)}). Retrying from seq ${String(lastSeq)}...`;
+}
+var OUTAGE_WINDOW_MS = 300000;
+var OUTAGE_BACKOFF_CAP_MS = 15000;
+var CHECK_TIMEOUT_MS = 1e4;
+function outageBackoffMs(baseMs, attempt, capMs = Infinity) {
+  return Math.min(baseMs * 2 ** (attempt - 1), capMs);
+}
+async function askBounded(check, timeoutMs = CHECK_TIMEOUT_MS) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      resolve({ state: "unknown", detail: `no answer within ${String(timeoutMs / 1000)} s` });
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      check().catch((error) => ({
+        state: "unknown",
+        detail: error instanceof Error ? error.message : String(error)
+      })),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function lostStreamGuidance(lastSeq, checked, resume) {
+  const at = `Resume from seq ${String(lastSeq)} with: ${resume}`;
+  if (checked === undefined) {
+    return `Could not check whether the sandbox is still running. ${at}`;
+  }
+  if (checked.state === "running") {
+    return `The server reports the sandbox still running${checked.detail === undefined ? "" : ` (${checked.detail})`}. ${at}`;
+  }
+  if (checked.state === "not-running") {
+    return `The sandbox is not running: ${checked.detail}. Its output up to seq ${String(lastSeq)} is recorded. ${at}`;
+  }
+  return `Could not check whether the sandbox is still running (${checked.detail}). ${at}`;
+}
+async function lostStreamError(input) {
+  const { lastSeq } = input;
+  const detail = input.cause instanceof Error ? ` (${input.cause.message})` : "";
+  const guidance = input.released ? "This was a single-command run: the server deletes the sandbox when the connection drops, so nothing is left running and there is nothing to re-attach to. Run the turn again, or use --no-stream to wait for the whole result in one reply." : lostStreamGuidance(lastSeq, input.check === undefined ? undefined : await askBounded(input.check), input.resume?.(lastSeq) ?? `mutagent sandbox attach <id> --since ${String(lastSeq)}`);
+  return new MutagentError("STREAM_DISCONNECTED", `Lost the sandbox stream at seq ${String(lastSeq)} and could not reconnect${detail}.`, guidance);
 }
 
 // src/lib/sandbox-stream.ts
-var DEFAULT_RETRY = { attempts: 3, baseDelayMs: 500 };
-var MAX_TOTAL_RECONNECTS = 12;
+var DEFAULT_RETRY = {
+  attempts: 40,
+  baseDelayMs: 500,
+  maxDelayMs: OUTAGE_BACKOFF_CAP_MS,
+  windowMs: OUTAGE_WINDOW_MS
+};
+var MAX_TOTAL_RECONNECTS = 40;
 async function runStreamSession(options) {
   const retry = options.retry ?? DEFAULT_RETRY;
   const sleep = options.sleep ?? delay;
@@ -28484,6 +28531,7 @@ async function runStreamSession(options) {
   let exitCode = null;
   let reconnects = 0;
   let errorReconnects = 0;
+  let outageStartedAt = 0;
   let gaps = 0;
   let attempt = 0;
   let sandbox;
@@ -28505,18 +28553,29 @@ async function runStreamSession(options) {
   const detached = () => outcome("detached");
   const isAborted = () => signal.aborted;
   const withinTotalBudget = () => errorReconnects < MAX_TOTAL_RECONNECTS;
-  const retryAfterError = async (error) => {
+  const retryAfterError = async (error, progressed) => {
+    if (progressed)
+      errorReconnects = 0;
     attempt += 1;
-    if (attempt > retry.attempts || !withinTotalBudget()) {
+    if (attempt === 1)
+      outageStartedAt = now();
+    const outageOver = retry.windowMs !== undefined && attempt > 1 && now() - outageStartedAt >= retry.windowMs;
+    if (attempt > retry.attempts || outageOver || !withinTotalBudget()) {
       if (live !== undefined && !live.live)
         sink.notice(unfollowableNotice(live.reason));
-      throw exhausted(lastSeq, error, onDisconnect);
+      throw await lostStreamError({
+        lastSeq,
+        cause: error,
+        released: onDisconnect === "released",
+        ...options.checkSandbox === undefined ? {} : { check: options.checkSandbox },
+        ...options.resumeCommand === undefined ? {} : { resume: options.resumeCommand }
+      });
     }
     reconnects += 1;
     errorReconnects += 1;
     if (attempt > 1)
       sink.notice(retryFailedNotice(attempt - 1, retry.attempts, lastSeq));
-    await sleep(backoffMs(retry.baseDelayMs, attempt), signal);
+    await sleep(outageBackoffMs(retry.baseDelayMs, attempt, retry.maxDelayMs), signal);
   };
   const alreadyDelivered = (seq) => seq <= floor;
   const noteSeq = (seq) => {
@@ -28539,7 +28598,7 @@ async function runStreamSession(options) {
         return detached();
       if (reconnects === 0 && attempt === 0)
         throw error;
-      await retryAfterError(error);
+      await retryAfterError(error, false);
       continue;
     }
     let exited = false;
@@ -28671,7 +28730,7 @@ async function runStreamSession(options) {
     } catch (error) {
       if (isAborted())
         return detached();
-      await retryAfterError(error);
+      await retryAfterError(error, lastSeq > seqAtOpen);
       continue;
     }
     if (exited)
@@ -28690,9 +28749,6 @@ async function runStreamSession(options) {
       await sleep(wait, signal);
   }
 }
-function backoffMs(base, attempt) {
-  return base * 2 ** (attempt - 1);
-}
 function unfollowableNotice(reason) {
   const why = reason === "" ? "" : ` (${reason})`;
   return `The backend cannot follow this sandbox from the instance that answered${why}. ` + "Everything already recorded has been replayed above, and this stream will end there rather " + "than continuing live — the sandbox itself is unaffected and may still be running. " + "Retry later, or attach from the instance that owns it.";
@@ -28701,11 +28757,6 @@ function gapNotice(lastSeq, nextSeq) {
   const missing = nextSeq - lastSeq - 1;
   return `Output gap: ${String(missing)} event(s) between seq ${String(lastSeq)} and ` + `${String(nextSeq)} are unavailable — the server buffer rolled past the resume point. ` + "What follows is not continuous with what came before.";
 }
-function exhausted(lastSeq, cause, onDisconnect) {
-  const detail = cause instanceof Error ? ` (${cause.message})` : "";
-  const guidance = onDisconnect === "released" ? "This was a single-command run: the server deletes the sandbox when the connection drops, so nothing is left running and there is nothing to re-attach to. Run the turn again, or use --no-stream to wait for the whole result in one reply." : `The sandbox is still running — nothing was destroyed. Resume with: mutagent sandbox attach <id> --since ${String(lastSeq)}`;
-  return new MutagentError("STREAM_DISCONNECTED", `Lost the sandbox stream and could not reconnect${detail}.`, guidance);
-}
 function isGapError(payload) {
   return payload.code === "gap";
 }
@@ -28900,6 +28951,8 @@ async function runNativeSession(options) {
         notice
       },
       filtered: true,
+      resumeCommand: (seq) => activeProduct().cli + " session attach " + options.reference + " --since " + String(seq),
+      ...options.check === undefined ? {} : { checkSandbox: options.check },
       ...options.sessionId === undefined ? {} : { sessionId: options.sessionId },
       ...options.since === undefined ? {} : { since: options.since },
       signal: controller.signal
@@ -28942,6 +28995,36 @@ async function runNativeSession(options) {
   }
 }
 
+// src/lib/session-durability.ts
+async function checkSession(reference, findRow) {
+  let row;
+  try {
+    row = await findRow(reference);
+  } catch (error) {
+    return { state: "unknown", detail: error instanceof Error ? error.message : String(error) };
+  }
+  if (row === undefined)
+    return { state: "unknown", detail: "the session list does not show it" };
+  switch (row.status) {
+    case "live":
+    case "restored":
+      return row.idleStopHeld === undefined ? { state: "running" } : { state: "running", detail: `kept by the idle stop: ${row.idleStopHeld.reason}` };
+    case "stopped-for-idling":
+      return {
+        state: "not-running",
+        detail: "the session stopped for idling; a send wakes it from its checkpoint"
+      };
+    case "ended":
+      return {
+        state: "not-running",
+        detail: `the session ended${row.exitCode === undefined || row.exitCode === null ? "" : ` (exit code ${String(row.exitCode)})`}`
+      };
+  }
+}
+function listedRow(routes) {
+  return async (reference) => (await listHarnessSessions(routes)).sessions.find((row) => row.reference === reference);
+}
+
 // src/commands/cloud-session/run-cloud.ts
 function repositoryFields(flags) {
   return {
@@ -29055,7 +29138,8 @@ async function attachLaunched(session, rpc, interruptRequested) {
     send: (line, signal) => sendSessionInput(routes, reference, line, signal),
     closeInput: (signal) => closeSessionInput(routes, reference, signal),
     interrupt: (signal) => signalSession(routes, reference, "SIGINT", signal),
-    interruptRequested
+    interruptRequested,
+    check: () => checkSession(reference, listedRow(routes))
   }).catch((error) => {
     throw markStreamStarted(error);
   });
@@ -30015,6 +30099,23 @@ function formatDuration(ms) {
 }
 
 // src/lib/sandbox-session.ts
+async function sandboxCheck(id) {
+  let status;
+  try {
+    ({ status } = await inspectSandbox(id));
+  } catch (error) {
+    if (error instanceof MutagentError && error.code === "NOT_FOUND") {
+      return { state: "not-running", detail: "it no longer exists" };
+    }
+    throw error;
+  }
+  if (status === undefined)
+    return { state: "unknown", detail: "the server reported no status" };
+  if (status === "running" || status === "starting" || status === "pending" || status === "paused") {
+    return { state: "running", detail: status };
+  }
+  return { state: "not-running", detail: `it is ${status}` };
+}
 function dim(text) {
   return isPlainOutput() ? text : chalk24.dim(text);
 }
@@ -30122,7 +30223,11 @@ async function attachToSandbox(options) {
       signal: controller.signal,
       ...options.retry === undefined ? {} : { retry: options.retry },
       ...options.onDisconnect === undefined ? {} : { onDisconnect: options.onDisconnect },
-      ...options.onSandbox === undefined ? {} : { onSandbox: options.onSandbox }
+      ...options.onSandbox === undefined ? {} : { onSandbox: options.onSandbox },
+      ...options.id === "" ? {} : {
+        checkSandbox: () => sandboxCheck(options.id),
+        resumeCommand: (seq) => reattachHint(options.id, seq)
+      }
     });
     reportOutcome(options.id, result, sink, options.onDisconnect ?? "survives");
     return result;
@@ -30148,7 +30253,7 @@ function reportOutcome(id, result, sink, onDisconnect) {
       sink.notice("Run the turn again to retry, or add --keep next time to hold the sandbox open.");
       return;
     }
-    sink.notice(`Detached. Sandbox ${sandboxId} is still running — nothing was destroyed.`);
+    sink.notice(`Detached at seq ${String(result.lastSeq)}: this CLI stopped watching and did not stop sandbox ${sandboxId}.`);
     sink.notice(`Re-attach with: ${reattachHint(sandboxId, result.lastSeq)}`);
     sink.notice(`Destroy it with: mutagent sandbox delete ${sandboxId} --force`);
     return;
@@ -30973,6 +31078,7 @@ function registerSessionAttach(session, p) {
     "AI Agent Directive:",
     "  Output is Helix's own text or JSON lines on stdout; CLI messages go to stderr. --json does not change it.",
     "  Ctrl-C stops watching without signalling the session.",
+    "  A dropped stream reconnects at its cursor for up to 5 minutes; if it gives up, it prints the seq to resume from.",
     "  A reference names one session; after a restore, take the new reference from session list.",
     '  When a send wakes the session, stderr carries [mutagent] {"event":"woken","reference":"hs1_..."}:',
     "  this stream ends there; attach to that reference with --since 0."
@@ -30980,9 +31086,11 @@ function registerSessionAttach(session, p) {
 `))).action(async (reference, options) => {
     try {
       const since = parseSince(options.since);
+      const findRow = listedRow(p);
       await runNativeSession({
         reference,
         rpc: false,
+        check: () => checkSession(reference, findRow),
         ...since === undefined ? {} : { since },
         open: (request) => openSessionStream(p, reference, request),
         send: (line, signal) => sendSessionInput(p, reference, line, signal)
@@ -44673,4 +44781,4 @@ if (process.env.CLI_VERSION) {
 }
 runCli(process.argv.slice(2), cliVersion);
 
-//# debugId=B287580A222D152F64756E2164756E21
+//# debugId=E0552D781753FD4964756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutagent/cli",
-  "version": "0.2.207",
+  "version": "0.2.209",
   "description": "Bun-native CLI for the MutagenT AI platform - auth, provider config, and lifecycle-tool installer for AI-native workflows",
   "type": "module",
   "bin": {
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.7.2",
-    "@mutagent/sdk": "0.12.20",
+    "@mutagent/sdk": "0.12.21",
     "@sinclair/typebox": "^0.34.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
@@ -94,5 +94,5 @@
   "bugs": {
     "url": "https://docs.mutagent.io/support"
   },
-  "gitHead": "8ed68aa4195126d5a414d4b326883a8433ee06cb"
+  "gitHead": "14b9f48b84e32ae4f13253bad2d4a365cb03107d"
 }