@evident-ai/cli 3.5.2-dev.03d3dab → 3.5.2-dev.06654ec

package/dist/index.js

@@ -703,6 +703,31 @@ async function reportResourceUsage(agentId, authHeader, usage) {
     opencode_db_bytes: usage.opencodeDbBytes
   });
 }
+async function getRunnerCredentialVault(agentId, authHeader) {
+  const empty = { prefix: null, vaultId: null, source: null };
+  try {
+    const apiUrl = getApiUrlConfig();
+    const response = await fetch(`${apiUrl}/runners/${agentId}/credential-vault`, {
+      headers: { Authorization: authHeader },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const serverMessage = await readErrorMessage(response);
+      return {
+        ...empty,
+        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
+      };
+    }
+    const data = await response.json();
+    return {
+      prefix: data.credential_vault_prefix,
+      vaultId: data.vault_id,
+      source: data.source
+    };
+  } catch (error2) {
+    return { ...empty, error: describeTimeoutError(error2, 1e4) };
+  }
+}
 async function getAgentInfo(agentId, authHeader) {
   const apiUrl = getApiUrlConfig();
   try {
@@ -877,6 +902,76 @@ async function status(options = {}) {
   process.exit(result.exitCode);
 }
 
+// src/commands/credential-vault-env.ts
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function printAssignment(prefix) {
+  console.log(`CREDENTIAL_VAULT_PREFIX=${shellQuote(prefix ?? "")}`);
+}
+function safeReason(reason, credentials2, authHeader) {
+  let safe = reason;
+  for (const secret of [
+    authHeader,
+    credentials2?.token,
+    process.env.EVIDENT_RUNNER_KEY,
+    process.env.EVIDENT_AGENT_KEY,
+    process.env.EVIDENT_TOKEN
+  ]) {
+    if (secret) safe = safe.replaceAll(secret, "[redacted]");
+  }
+  return safe.replace(/[\r\n]+/g, " ");
+}
+function printFallback(reason, credentials2, authHeader) {
+  printAssignment(null);
+  console.error(
+    `WARNING: ${safeReason(reason, credentials2, authHeader)}; using this runner's own credential prefix.`
+  );
+}
+async function credentialVaultEnv() {
+  let credentials2 = null;
+  let authHeader;
+  try {
+    credentials2 = await getAuthCredentials();
+    if (!credentials2) {
+      printFallback("no runner credentials are configured");
+      return;
+    }
+    authHeader = getAuthHeader(credentials2);
+    const runner = await resolveAgentIdFromKey(authHeader);
+    if (!runner.agent_id) {
+      printFallback(
+        runner.error ?? "the runner identity could not be resolved",
+        credentials2,
+        authHeader
+      );
+      return;
+    }
+    const lookup = await getRunnerCredentialVault(runner.agent_id, authHeader);
+    if (lookup.error) {
+      printFallback(`credential vault lookup failed: ${lookup.error}`, credentials2, authHeader);
+      return;
+    }
+    if (lookup.prefix === null) {
+      printFallback("this runner is not linked to a credential vault", credentials2, authHeader);
+      return;
+    }
+    if (/[\r\n]/.test(lookup.prefix)) {
+      printFallback("credential vault lookup returned an invalid prefix", credentials2, authHeader);
+      return;
+    }
+    printAssignment(lookup.prefix);
+    console.error(
+      `VAULT-MODE: credential stores use vault=${lookup.vaultId} source=${lookup.source} prefix=${lookup.prefix}.`
+    );
+  } catch (error2) {
+    const detail = credentials2 === null ? "credential resolution failed" : `credential vault lookup could not be completed: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    printFallback(detail, credentials2, authHeader);
+  } finally {
+    process.exitCode = 0;
+  }
+}
+
 // src/lib/claude-usage.ts
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
@@ -1227,7 +1322,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.5.2-dev.03d3dab" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.5.2-dev.06654ec" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -2621,18 +2716,16 @@ function findDispatchedUserMessageId(messages, content, excludeIds) {
   }
   return best?.id ?? null;
 }
-async function sendPromptAsync(port, sessionId, content, options, attachments, client, onKnownUserIds) {
+async function sendPromptAsync(port, sessionId, content, options, attachments, client, callbacks) {
   const before = await getSessionMessages(port, sessionId, client);
   const knownUserIds = new Set(
     (before ?? []).filter((m) => roleOf2(m) === "user").map((m) => idOf2(m)).filter((id) => typeof id === "string")
   );
-  if (onKnownUserIds) {
+  if (callbacks) {
     try {
-      onKnownUserIds(before === null ? null : knownUserIds);
+      callbacks.onKnownUserIds(before === null ? null : knownUserIds);
     } catch (error2) {
-      console.error(
-        `[sendPromptAsync] pre-dispatch snapshot callback failed: ${error2 instanceof Error ? error2.message : String(error2)}`
-      );
+      callbacks.onKnownUserIdsError(error2);
     }
   }
   const parts = [{ type: "text", text: content }];
@@ -7112,6 +7205,8 @@ var ChannelDriver = class _ChannelDriver {
    * row is `processing` or `pending`; clear it only when absent from both lists.
    */
   untrackableAck = /* @__PURE__ */ new Map();
+  /** Session binding used by the first untrackable-ack report, for retries. */
+  untrackableAckSessionIds = /* @__PURE__ */ new Map();
   /** Messages whose untrackable-ack failure signal was emitted while fenced. */
   untrackableAckSignalled = /* @__PURE__ */ new Set();
   /** Messages whose first untrackable-ack fence warning was already logged. */
@@ -7561,6 +7656,7 @@ var ChannelDriver = class _ChannelDriver {
     const dispatchDescription = source === "readopt" ? "re-dispatched message" : "message";
     const errorMessage3 = `OpenCode accepted this ${dispatchDescription} once, but its assigned id was never confirmed after ${attempts} attempts to match it up \u2014 the message was deliberately not sent again, so no duplicate turn was created; session ${sessionId.slice(0, 8)} was abandoned; a fresh one is used for further messages.`;
     this.untrackableAck.set(messageId, errorMessage3);
+    this.untrackableAckSessionIds.set(messageId, null);
     this.log({
       level: "error",
       message: errorMessage3,
@@ -7866,8 +7962,18 @@ var ChannelDriver = class _ChannelDriver {
             options,
             sendAttachments,
             this.openCodeClient,
-            (ids) => {
-              preDispatchUserIds = ids;
+            {
+              onKnownUserIds: (ids) => {
+                preDispatchUserIds = ids;
+              },
+              onKnownUserIdsError: (error2) => {
+                this.log({
+                  level: "warn",
+                  message: `Pre-dispatch snapshot callback failed for message ${message.id.slice(0, 8)}: ${error2 instanceof Error ? error2.message : String(error2)}`,
+                  conversation_id: conv.id,
+                  message_id: message.id
+                });
+              }
             }
           )
         );
@@ -7876,6 +7982,7 @@ var ChannelDriver = class _ChannelDriver {
         if (this.isV2 && err instanceof OpenCodeV2PromptAckError) {
           const errorMessage4 = err instanceof Error ? err.message : String(err);
           this.untrackableAck.set(message.id, errorMessage4);
+          this.untrackableAckSessionIds.set(message.id, null);
           this.log({
             level: "error",
             message: `V2 prompt dispatch for message ${message.id.slice(0, 8)} failed after a positive ack with no usable id: ${errorMessage4}`,
@@ -10171,6 +10278,7 @@ var ChannelDriver = class _ChannelDriver {
       for (const id of [...this.untrackableAck.keys()]) {
         if (!stillProcessing.has(id) && !this.pendingMessageIds.has(id)) {
           this.untrackableAck.delete(id);
+          this.untrackableAckSessionIds.delete(id);
           this.untrackableAckSignalled.delete(id);
           this.untrackableAckWarned.delete(id);
           this.log({
@@ -10319,8 +10427,10 @@ var ChannelDriver = class _ChannelDriver {
    * Branches on `messageRunState(messages, row.opencode_message_id)` — the
    * opencode-assigned user-message id persisted on the first `processing` PATCH
    * (#218). A row with a NULL stored id (dispatched but the read-back never landed
-   * before the restart) has no id to correlate → treated as an orphan and
-   * re-dispatched (at most once, see `forceReadoptRun`):
+   * before the restart) is first offered to an awaiting-correlation fence recorded
+   * by this process; without that fence, it has no id to correlate after restart
+   * and is treated as an orphan and re-dispatched (at most once, see
+   * `forceReadoptRun`):
    *   - `done`             → `markDone` now (guarded like the watcher's done branch);
    *   - `failed`           → `markFailed` with the surfaced error (issue #182), so an
    *                          errored turn is reported failed on restart, NOT re-dispatched —
@@ -10329,7 +10439,8 @@ var ChannelDriver = class _ChannelDriver {
    *                          re-dispatched instead (issue #1310, see the branch below);
    *   - `running`/`queued` → re-attach a watcher via `registerReadopted` (no re-dispatch),
    *                          tracking the stored id so the reply correlates by it;
-   *   - `unknown`/null id  → re-dispatch (opencode assigns a fresh id) + attach a watcher.
+   *   - `unknown`/null id  → correlate through an awaiting fence when present;
+   *                          otherwise re-dispatch (opencode assigns a fresh id) + attach a watcher.
    *
    * Only `ChannelAuthError` propagates.
    */
@@ -10410,12 +10521,48 @@ var ChannelDriver = class _ChannelDriver {
       await this.reportSubagentAuthFailures(row.conversation_id, ocId ?? "", row.id, messages);
       this.dontRedispatch.delete(row.id);
       this.untrackableAck.delete(row.id);
+      this.untrackableAckSessionIds.delete(row.id);
       this.untrackableAckSignalled.delete(row.id);
       this.untrackableAckWarned.delete(row.id);
       void this.postSignal(row.conversation_id, row.id, "readopt_failed");
       return;
     }
-    if (this.dontRedispatch.has(row.id) || this.untrackableAck.has(row.id)) {
+    if (this.untrackableAck.has(row.id)) {
+      if (this.untrackableAckSignalled.has(row.id)) {
+        const firstFenceWarning = !this.untrackableAckWarned.has(row.id);
+        this.untrackableAckWarned.add(row.id);
+        this.log({
+          level: firstFenceWarning ? "warn" : "debug",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} is fenced after an untrackable OpenCode turn \u2014 skipping re-dispatch and retrying the terminal report`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+        const errorMessage3 = this.untrackableAck.get(row.id);
+        const reportError = await this.reportUntrackableAck(
+          row.conversation_id,
+          row.id,
+          this.untrackableAckSessionIds.get(row.id) ?? null,
+          errorMessage3
+        );
+        if (reportError !== null) {
+          this.log({
+            level: "warn",
+            message: `Re-adopt: failed to report untrackable message ${row.id.slice(0, 8)} (will retry next drain): ${reportError.message}`,
+            conversation_id: row.conversation_id,
+            message_id: row.id
+          });
+        }
+      } else {
+        this.log({
+          level: "debug",
+          message: `Re-adopt: message ${row.id.slice(0, 8)} already gave up \u2014 left to the cron; skipping until it leaves processing`,
+          conversation_id: row.conversation_id,
+          message_id: row.id
+        });
+      }
+      return;
+    }
+    if (this.dontRedispatch.has(row.id)) {
       this.log({
         level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} already gave up \u2014 left to the cron; skipping until it leaves processing`,
@@ -10593,6 +10740,7 @@ var ChannelDriver = class _ChannelDriver {
     }
     this.dontRedispatch.delete(row.id);
     this.untrackableAck.delete(row.id);
+    this.untrackableAckSessionIds.delete(row.id);
     this.untrackableAckSignalled.delete(row.id);
     this.untrackableAckWarned.delete(row.id);
     void this.postSignal(row.conversation_id, row.id, "readopt_done");
@@ -10688,8 +10836,18 @@ var ChannelDriver = class _ChannelDriver {
           options,
           sendAttachments,
           this.openCodeClient,
-          (ids) => {
-            preDispatchUserIds = ids;
+          {
+            onKnownUserIds: (ids) => {
+              preDispatchUserIds = ids;
+            },
+            onKnownUserIdsError: (error2) => {
+              this.log({
+                level: "warn",
+                message: `Pre-dispatch snapshot callback failed for message ${row.id.slice(0, 8)}: ${error2 instanceof Error ? error2.message : String(error2)}`,
+                conversation_id: row.conversation_id,
+                message_id: row.id
+              });
+            }
           }
         )
       );
@@ -10723,6 +10881,7 @@ var ChannelDriver = class _ChannelDriver {
           }
         } else {
           this.untrackableAck.set(row.id, errorMessage3);
+          this.untrackableAckSessionIds.set(row.id, sessionId);
         }
         this.log({
           level: "error",
@@ -14263,6 +14422,34 @@ async function run(options) {
     } else {
       log2(state, "Not running in a MicroVM (MICROVM_ID unset) \u2014 nothing to report", "debug");
     }
+    if (options.restoreRunnerCredentials || options.credentialSyncMarker) {
+      const logCredentialVaultResolution = (message, level) => {
+        log2(state, message, level);
+        if (state.interactive && !state.json) {
+          logActivity(state, { type: "info", level, message });
+        }
+      };
+      const vaultResolution = await getRunnerCredentialVault(state.agentId, state.authHeader);
+      if (vaultResolution.error) {
+        delete process.env.CREDENTIAL_VAULT_PREFIX;
+        logCredentialVaultResolution(
+          `CREDENTIAL-VAULT-LOOKUP-FAILED: ${vaultResolution.error}; credentials will be read from and written to this runner's own prefix this boot`,
+          "warn"
+        );
+      } else if (vaultResolution.prefix !== null && vaultResolution.vaultId !== null && vaultResolution.source !== null) {
+        process.env.CREDENTIAL_VAULT_PREFIX = vaultResolution.prefix;
+        logCredentialVaultResolution(
+          `CREDENTIAL-VAULT: source=${vaultResolution.source} vault=${vaultResolution.vaultId} prefix=${vaultResolution.prefix}`,
+          "info"
+        );
+      } else {
+        delete process.env.CREDENTIAL_VAULT_PREFIX;
+        logCredentialVaultResolution(
+          "CREDENTIAL-VAULT-NONE: this runner is not linked to a credential vault; using its own prefix",
+          "debug"
+        );
+      }
+    }
     if (options.restoreRunnerCredentials) {
       log2(state, "Restoring runner credentials before starting OpenCode");
       const credentialContext = {
@@ -14660,14 +14847,14 @@ async function run(options) {
         },
         onDisconnected: (code, reason, transition) => {
           state.connected = false;
-          const safeReason = redactDiagnosticText(reason).slice(0, MAX_DISCONNECT_REASON_LENGTH);
+          const safeReason2 = redactDiagnosticText(reason).slice(0, MAX_DISCONNECT_REASON_LENGTH);
           logActivity(state, {
             type: "info",
-            message: `Tunnel disconnected (generation: ${transition.generation}, code: ${code}, reason: ${safeReason})`
+            message: `Tunnel disconnected (generation: ${transition.generation}, code: ${code}, reason: ${safeReason2})`
           });
           emitAgentDisconnected(state.agentId, {
             code,
-            reason: safeReason,
+            reason: safeReason2,
             connection_generation: transition.generation
           });
           if (state.interactive) displayStatus(state);
@@ -14830,6 +15017,7 @@ program.command("login").description("Authenticate with Evident").option("--toke
 program.command("logout").description("Remove stored credentials for the current endpoint").option("--all", "Remove stored credentials for all endpoints").action((options) => logout({ all: options.all }));
 program.command("whoami").description("Show the currently logged in user").action(whoami);
 program.command("status").description("Check whether the configured credentials can reach Evident").option("--json", "Output in JSON format").action((options) => status({ json: options.json }));
+program.command("credential-vault-env").description("Print the shell assignment a runner image evals before starting the synchroniser").action(credentialVaultEnv);
 program.command("claude-usage").description("[spike] Show Claude subscription usage (requires a local `claude login`)").action(claudeUsage);
 program.command("run").description("Connect to Evident and process messages").option("--runner [id]", "Runner ID to connect to (optional when EVIDENT_RUNNER_KEY is set)").option(
   "-a, --agent [id]",