@evident-ai/cli 3.4.1-dev.d8ffc5f → 3.4.1-dev.f505f12

package/README.md

@@ -98,6 +98,10 @@ Options:
   healthy when the runner starts it itself (default: `180`). On expiry the runner
   warns and comes online anyway rather than failing. Env:
   `EVIDENT_OPENCODE_START_TIMEOUT` (seconds).
+- `--litestream-config <path>` — Start `litestream replicate` for the OpenCode
+  session database with this config file. Use this for runner images that persist
+  the session database; the file is produced by `runner-synchroniser litestream-config`.
+  Omit it to disable replication.
 - `--claude-usage-reporting <mode>` — Whether to report the local Claude Code
   subscription's rate-limit usage to Evident, so it shows on the runner page:
   `auto` (default) reports it when a usable Claude Code login is found on this

package/dist/index.js

@@ -1681,6 +1681,62 @@ function buildOpenCodeVersionWarning(version2) {
 
 // src/lib/opencode/process.ts
 import { execSync, spawn } from "child_process";
+
+// src/lib/process-stop.ts
+async function stopProcessAndWait(child, timeoutMs, sendTerm, sendKill) {
+  if (!child.pid) {
+    return { outcome: "not-running", code: child.exitCode, signal: child.signalCode };
+  }
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return { outcome: "exited", code: child.exitCode, signal: child.signalCode };
+  }
+  return new Promise((resolve3, reject) => {
+    let forced = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      forced = true;
+      try {
+        sendKill();
+      } catch (error2) {
+        if (error2.code === "ESRCH") {
+          finish({ outcome: "exited", code: child.exitCode, signal: child.signalCode });
+        } else {
+          fail(error2);
+        }
+      }
+    }, timeoutMs);
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
+      resolve3(result);
+    };
+    const fail = (error2) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
+      reject(error2);
+    };
+    const onExit = (code, signal) => {
+      finish({ outcome: forced ? "killed" : "exited", code, signal });
+    };
+    child.once("exit", onExit);
+    try {
+      sendTerm();
+    } catch (error2) {
+      if (error2.code === "ESRCH") {
+        finish({ outcome: "exited", code: child.exitCode, signal: child.signalCode });
+      } else {
+        fail(error2);
+      }
+      return;
+    }
+  });
+}
+
+// src/lib/opencode/process.ts
 var OPENCODE_PORT_RANGE = [4096, 4097, 4098, 4099, 4100];
 function getProcessCwd(pid) {
   const platform = process.platform;
@@ -1852,23 +1908,20 @@ async function startOpenCode(port) {
   });
   return child;
 }
-function stopOpenCode(opencodeProcess) {
-  if (!opencodeProcess || !opencodeProcess.pid) {
-    return;
-  }
-  try {
+function stopOpenCodeAndWait(opencodeProcess, timeoutMs) {
+  const sendSignal = (signal) => {
     if (process.platform === "win32") {
-      opencodeProcess.kill("SIGTERM");
+      opencodeProcess.kill(signal);
     } else {
-      process.kill(-opencodeProcess.pid, "SIGTERM");
+      process.kill(-opencodeProcess.pid, signal);
     }
-  } catch (err) {
-    if (err.code !== "ESRCH") {
-      console.warn(
-        `stopOpenCode: kill failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
+  };
+  return stopProcessAndWait(
+    opencodeProcess,
+    timeoutMs,
+    () => sendSignal("SIGTERM"),
+    () => sendSignal("SIGKILL")
+  );
 }
 
 // src/lib/opencode/install.ts
@@ -2155,6 +2208,7 @@ async function createOpenCodeSession(port, directory) {
   return data.id;
 }
 async function getModelAttachmentCapability(port, model) {
+  const { model: baseModel } = splitModelVariant(model);
   try {
     const res = await timedFetch(`${opencodeBase(port)}/config/providers`);
     if (!res.ok) {
@@ -2171,9 +2225,9 @@ async function getModelAttachmentCapability(port, model) {
       );
       return null;
     }
-    const slash = model ? model.indexOf("/") : -1;
-    const providerId = slash > 0 ? model.slice(0, slash) : void 0;
-    let modelId = slash > 0 ? model.slice(slash + 1) : void 0;
+    const slash = baseModel ? baseModel.indexOf("/") : -1;
+    const providerId = slash > 0 ? baseModel.slice(0, slash) : void 0;
+    let modelId = slash > 0 ? baseModel.slice(slash + 1) : void 0;
     const defaults2 = body?.default && typeof body.default === "object" ? body.default : void 0;
     let provider = providerId ? providers.find((p) => p?.id === providerId) : void 0;
     if (!provider && !providerId) {
@@ -2253,6 +2307,29 @@ async function buildFileParts(attachments, capable) {
   }
   return { parts, outcomes, capabilityUnknown };
 }
+function splitModelVariant(raw) {
+  const value = raw?.trim();
+  if (!value) return {};
+  const hashIndex = value.indexOf("#");
+  if (hashIndex === -1) return { model: value };
+  const model = value.slice(0, hashIndex).trim() || void 0;
+  const variant = value.slice(hashIndex + 1).trim() || void 0;
+  return { model, variant };
+}
+function applyModelOptions(body, options) {
+  if (options?.agent) body.agent = options.agent;
+  const { model, variant } = splitModelVariant(options?.model);
+  if (model) {
+    const slashIndex = model.indexOf("/");
+    if (slashIndex !== -1) {
+      body.model = {
+        providerID: model.substring(0, slashIndex),
+        modelID: model.substring(slashIndex + 1)
+      };
+    }
+  }
+  if (variant) body.variant = variant;
+}
 function messageText(m) {
   if (!m || !Array.isArray(m.parts)) return "";
   return m.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
@@ -2277,18 +2354,7 @@ async function sendPromptAsync(port, sessionId, content, options, attachments) {
   const body = {
     parts
   };
-  if (options?.agent) {
-    body.agent = options.agent;
-  }
-  if (options?.model) {
-    const slashIndex = options.model.indexOf("/");
-    if (slashIndex !== -1) {
-      body.model = {
-        providerID: options.model.substring(0, slashIndex),
-        modelID: options.model.substring(slashIndex + 1)
-      };
-    }
-  }
+  applyModelOptions(body, options);
   const res = await timedFetch(`${opencodeBase(port)}/session/${sessionId}/prompt_async`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -2296,7 +2362,10 @@ async function sendPromptAsync(port, sessionId, content, options, attachments) {
   });
   if (res.status < 200 || res.status >= 300) {
     const text = await res.text().catch(() => "");
-    throw new Error(`OpenCode prompt_async failed: HTTP ${res.status}${text ? `: ${text}` : ""}`);
+    const { variant } = splitModelVariant(options?.model);
+    throw new Error(
+      `OpenCode prompt_async failed: HTTP ${res.status}${text ? `: ${text}` : ""}${variant ? ` (variant: ${variant})` : ""}`
+    );
   }
   const READ_BACK_ATTEMPTS = 5;
   const READ_BACK_DELAY_MS = 150;
@@ -3246,6 +3315,22 @@ function writeTunnelReadyMarker(path, agentId) {
   }
 }
 
+// src/lib/replication.ts
+import { spawn as spawn2 } from "child_process";
+function startSessionDbReplication(configPath) {
+  return spawn2("litestream", ["replicate", "-config", configPath], {
+    stdio: "inherit"
+  });
+}
+async function stopSessionDbReplication(child, timeoutMs) {
+  return stopProcessAndWait(
+    child,
+    timeoutMs,
+    () => child.kill("SIGTERM"),
+    () => child.kill("SIGKILL")
+  );
+}
+
 // src/lib/openai-usage.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -7980,6 +8065,7 @@ var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_
 var CHANNEL_STUCK_QUEUED_MS = Number(process.env.EVIDENT_STUCK_QUEUED_MS) || void 0;
 var SHUTDOWN_DRAIN_TIMEOUT_MS = Number(process.env.EVIDENT_SHUTDOWN_DRAIN_MS) || 25e3;
 var TELEMETRY_SHUTDOWN_TIMEOUT_MS = 5e3;
+var CHILD_STOP_TIMEOUT_MS = 1e4;
 function resolveLogLevel(options) {
   const accepted = Object.keys(LOG_LEVELS);
   const validate = (value, source) => {
@@ -8767,15 +8853,31 @@ async function cleanup(state, opts = {}) {
   }
   if (state.opencodeProcess) {
     const opencodeProcess = state.opencodeProcess;
-    await timeShutdownPhase(state, durations, "opencode_stop", () => stopOpenCode(opencodeProcess));
+    const result = await timeShutdownPhase(
+      state,
+      durations,
+      "opencode_stop",
+      () => stopOpenCodeAndWait(opencodeProcess, CHILD_STOP_TIMEOUT_MS)
+    );
     if (state.interactive) {
-      logActivity(state, { type: "info", message: "Stopped OpenCode process" });
+      logActivity(state, { type: "info", message: `Stopped OpenCode process (${result.outcome})` });
       displayStatus(state);
     } else {
-      log2(state, "Stopped OpenCode process");
+      log2(state, `Stopped OpenCode process (${result.outcome})`);
     }
     state.opencodeProcess = null;
   }
+  if (state.litestreamProcess) {
+    const litestreamProcess = state.litestreamProcess;
+    const result = await timeShutdownPhase(
+      state,
+      durations,
+      "litestream_stop",
+      () => stopSessionDbReplication(litestreamProcess, CHILD_STOP_TIMEOUT_MS)
+    );
+    log2(state, `Stopped litestream replication (${result.outcome})`);
+    state.litestreamProcess = null;
+  }
   return durations;
 }
 async function run(options) {
@@ -8809,6 +8911,7 @@ async function run(options) {
     opencodeConnected: false,
     opencodeVersion: null,
     opencodeProcess: null,
+    litestreamProcess: null,
     connection: null,
     channelDriver: null,
     running: true,
@@ -9073,6 +9176,40 @@ async function run(options) {
       ocSpinner?.fail(error2.message);
       throw error2;
     }
+    if (options.litestreamConfig) {
+      const litestreamProcess = startSessionDbReplication(options.litestreamConfig);
+      state.litestreamProcess = litestreamProcess;
+      let failureHandled = false;
+      const failRunForReplication = (message) => {
+        if (failureHandled || state.shuttingDown || !state.running) return;
+        failureHandled = true;
+        state.shuttingDown = true;
+        logActivity(state, { type: "error", error: message });
+        if (state.interactive) displayStatus(state);
+        void (async () => {
+          try {
+            await cleanup(state);
+            await shutdownTelemetry();
+          } catch (error2) {
+            console.error(
+              `[run] replication failure cleanup failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+            );
+          }
+          process.exit(1);
+        })();
+      };
+      litestreamProcess.on("exit", (code, signal) => {
+        failRunForReplication(
+          `Litestream replication stopped unexpectedly (code: ${code ?? "null"}, signal: ${signal ?? "none"})`
+        );
+      });
+      litestreamProcess.on("error", (error2) => {
+        failRunForReplication(
+          `Litestream replication failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+        );
+      });
+      log2(state, `Started litestream replication with config ${options.litestreamConfig}`);
+    }
     const tunnelSpinner = interactive && !state.json ? ora3("Connecting tunnel...").start() : null;
     const channelDriver = new ChannelDriver({
       agentId: state.agentId,
@@ -9333,6 +9470,9 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option(
   "--tunnel-ready-file <path>",
   "Path to write once the tunnel is connected (opt-in; unused unless an operator/image sets it)"
+).option(
+  "--litestream-config <path>",
+  "Replicate the OpenCode session database with `litestream replicate` using this config file (written by the runner image). Omit to disable replication."
 ).action(
   (options) => {
     run({
@@ -9364,7 +9504,8 @@ program.command("run").description("Connect to Evident and process messages").op
       // Raw values — expansion/validation is single-sourced in run.ts's
       // resolveFileSyncDirectories.
       enableFileSyncTo: options.enableFileSyncTo,
-      tunnelReadyFile: options.tunnelReadyFile
+      tunnelReadyFile: options.tunnelReadyFile,
+      litestreamConfig: options.litestreamConfig
     });
   }
 );