@vultisig/cli 2.8.1 → 2.8.4

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # @vultisig/cli
 
+## 2.8.4
+
+### Patch Changes
+
+- [#879](https://github.com/vultisig/vultisig-sdk/pull/879) [`f34ef93`](https://github.com/vultisig/vultisig-sdk/commit/f34ef932ba18c19accccc716098c3c16b83da625) Thanks [@neavra](https://github.com/neavra)! - Fix `agent ask` error reporting so a real first-turn backend/stream error is no
+  longer masked by the initialize-time `SESSION_NOT_FOUND` signal. The
+  stale-`--session` fallback signal is now kept separately and used only as a
+  lowest-priority fallback when the turn produced no error of its own, so a
+  genuine turn error wins while a clean turn after a stale-session fallback still
+  reports `SESSION_NOT_FOUND` (non-zero exit).
+
+- [#875](https://github.com/vultisig/vultisig-sdk/pull/875) [`a1d711b`](https://github.com/vultisig/vultisig-sdk/commit/a1d711beaf1694883688cd8e430c8b38162975b6) Thanks [@neavra](https://github.com/neavra)! - agent: surface a loop-depth overrun as a typed `LOOP_DEPTH_EXCEEDED` error instead of a success-shaped `done`.
+
+  When the agent message loop exceeds `MAX_MESSAGE_LOOP_DEPTH` (16), `processMessageLoop` previously cleared the queued tool results and called `ui.onDone()` — the same callback used on a clean finish — so a headless caller (`agent ask --json` / `--via-agent` pipe) could not distinguish a depth-capped truncation from a completed turn. It now emits `AgentErrorCode.LOOP_DEPTH_EXCEEDED` via `ui.onError` first (ask exits non-zero with an error envelope; pipe gets a typed `error` frame), then `onDone()` as the turn terminator.
+
+- Updated dependencies [[`26dd218`](https://github.com/vultisig/vultisig-sdk/commit/26dd218282b198fdea9c1118e7fe5bc800c071fb), [`69bb830`](https://github.com/vultisig/vultisig-sdk/commit/69bb8307de72883f0c7693871a6ca040b7a0756c)]:
+  - @vultisig/client-shared@0.2.17
+  - @vultisig/core-chain@2.17.10
+  - @vultisig/sdk@2.8.4
+
+## 2.8.2
+
+### Patch Changes
+
+- [#869](https://github.com/vultisig/vultisig-sdk/pull/869) [`2623ca0`](https://github.com/vultisig/vultisig-sdk/commit/2623ca0dd04c5ca3c65126b6008a93c1d7559793) Thanks [@neavra](https://github.com/neavra)! - Harden agent conversation auth across every path. A revoked-but-unexpired
+  cached token now recovers uniformly: a new `withAuthRetry` helper does
+  clear→reauth→retry-once and wraps the fresh-conversation `createConversation`
+  (previously unguarded — it hard-threw `Authentication failed`), the resume
+  `getConversation`, the send-message stream, and the `agent sessions
+list`/`delete` commands.
+
+  A `--session-id` resume whose 401 survives the single retry — or that fails for
+  any other reason — now falls back to a fresh conversation instead of throwing
+  uncaught, and emits a typed, non-fatal `SESSION_NOT_FOUND` signal carrying the
+  new conversation id so a headless caller knows prior context was dropped. In
+  `agent ask`, that initialize-time signal is now preserved into the first turn's
+  result envelope (it was previously cleared at turn start, so a stale-session
+  `ask --json` returned a false-success envelope instead of the promised non-zero
+  `SESSION_NOT_FOUND`).
+
+  Models the backend's `refresh_token`/`access_token` in `AuthTokenResponse` and
+  persists the refresh token in the token cache (0o600) for a future
+  `POST /auth/refresh` exchange; the retry path re-auths via MPC re-sign today.
+  The retry preserves a previously cached refresh token when the re-auth response
+  omits one, and the cache directory is chmod'd to 0o700 on every write (not only
+  on create) so a pre-existing `~/.vultisig` can't retain looser perms on upgrade.
+
+  Adds the first `auth.ts` unit tests (EIP-191 hash cross-checked against viem,
+  DER→65-byte formatting, signing-retry classification) plus session
+  auth-retry/fallback coverage.
+
+- Updated dependencies [[`0dc1620`](https://github.com/vultisig/vultisig-sdk/commit/0dc16206bedcdde8832a068b15383565a6b98896)]:
+  - @vultisig/sdk@2.8.2
+
 ## 2.8.1
 
 ### Patch Changes

package/dist/index.js

@@ -8074,6 +8074,8 @@ var AgentErrorCode = /* @__PURE__ */ ((AgentErrorCode3) => {
   AgentErrorCode3["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
   AgentErrorCode3["SIGNING_FAILED"] = "SIGNING_FAILED";
   AgentErrorCode3["SESSION_NOT_INITIALIZED"] = "SESSION_NOT_INITIALIZED";
+  AgentErrorCode3["LOOP_DEPTH_EXCEEDED"] = "LOOP_DEPTH_EXCEEDED";
+  AgentErrorCode3["SESSION_NOT_FOUND"] = "SESSION_NOT_FOUND";
   AgentErrorCode3["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
   return AgentErrorCode3;
 })(AgentErrorCode || {});
@@ -8081,6 +8083,10 @@ var AGENT_ERROR_CODE_VALUES = new Set(Object.values(AgentErrorCode));
 function isAgentErrorCode(value) {
   return AGENT_ERROR_CODE_VALUES.has(value);
 }
+var TERMINAL_AGENT_ERROR_CODES = /* @__PURE__ */ new Set(["LOOP_DEPTH_EXCEEDED" /* LOOP_DEPTH_EXCEEDED */]);
+function isTerminalAgentErrorCode(code) {
+  return TERMINAL_AGENT_ERROR_CODES.has(code);
+}
 function mapVaultError(err) {
   if (err.code === VaultErrorCode2.InvalidConfig && /failed to unlock vault/i.test(err.message)) {
     return "AUTH_FAILED" /* AUTH_FAILED */;
@@ -8185,6 +8191,22 @@ var AskInterface = class {
   transactions = [];
   cards = [];
   error;
+  // Initialize-time error, kept SEPARATE from the turn error so it stays the
+  // LOWEST-priority signal. initialize() drives getCallbacks() BEFORE the first
+  // ask() — a stale --session fallback fires onError(SESSION_NOT_FOUND) there.
+  // A real first-turn error must override it, so we never pre-set `this.error`
+  // with the init signal; instead partialResult() falls back to `initError` only
+  // when the turn produced no error of its own. Cleared after the first turn so
+  // later turns don't carry the init signal.
+  initError;
+  // Tracks whether the currently-latched `error` is a terminal one (e.g. the
+  // depth cap). A terminal error may overwrite a prior non-terminal one; once a
+  // terminal error is recorded, later frames cannot replace it. See onError.
+  errorIsTerminal = false;
+  // Whether ask() has run at least once. Distinguishes init-time onError (sets
+  // initError) from turn onError (sets error), and gates clearing initError so
+  // the init signal only carries into the FIRST turn.
+  hasAsked = false;
   constructor(session, verbose = false, autoApprove = false) {
     this.session = session;
     this.verbose = verbose;
@@ -8237,8 +8259,12 @@ var AskInterface = class {
         }
       },
       onError: (message, code) => {
-        if (!this.error) {
+        const isTerminal = isTerminalAgentErrorCode(code);
+        if (!this.hasAsked) {
+          this.initError = { message, code };
+        } else if (!this.error || isTerminal && !this.errorIsTerminal) {
           this.error = { message, code };
+          this.errorIsTerminal = isTerminal;
         }
         process.stderr.write(`[error] ${message} [${code}]
 `);
@@ -8270,6 +8296,11 @@ var AskInterface = class {
     this.transactions = [];
     this.cards = [];
     this.error = void 0;
+    if (this.hasAsked) {
+      this.initError = void 0;
+      this.errorIsTerminal = false;
+    }
+    this.hasAsked = true;
     const callbacks = this.getCallbacks();
     await this.session.sendMessage(message, callbacks);
     return this.partialResult();
@@ -8289,7 +8320,9 @@ var AskInterface = class {
       toolCalls: this.toolCalls,
       transactions: this.transactions,
       cards: this.cards,
-      error: this.error
+      // A real turn error wins; fall back to the init-time signal (e.g. stale
+      // --session SESSION_NOT_FOUND) only when the turn produced no error.
+      error: this.error ?? this.initError
     };
   }
 };
@@ -8624,7 +8657,13 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
       });
       return {
         token: authResponse.token,
-        expiresAt: authResponse.expires_at
+        expiresAt: authResponse.expires_at,
+        // Captured + persisted by the session token cache. The backend exposes
+        // POST /auth/refresh to exchange it for a fresh access token without a
+        // new MPC round; wiring that exchange is a future enhancement — today
+        // the CLI re-auths via a full MPC re-sign (authenticateVault), which is
+        // always available and avoids depending on refresh-token rotation.
+        refreshToken: authResponse.refresh_token
       };
     } catch (err) {
       lastError = err;
@@ -12072,7 +12111,7 @@ var PipeInterface = class {
 };
 
 // src/agent/session.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmodSync, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 import { MemoryStorage, PushNotificationService } from "@vultisig/sdk";
@@ -12144,7 +12183,7 @@ var AgentSession = class {
       } else {
         const auth = await authenticateVault(this.client, this.vault, this.config.password);
         this.client.setAuthToken(auth.token);
-        saveCachedToken(this.publicKey, auth.token, auth.expiresAt);
+        saveCachedToken(this.publicKey, auth.token, auth.expiresAt, auth.refreshToken);
       }
     } catch (err) {
       throw new Error(`Authentication failed: ${err.message}`);
@@ -12152,25 +12191,20 @@ var AgentSession = class {
     if (this.config.sessionId) {
       this.conversationId = this.config.sessionId;
       try {
-        const conv = await this.client.getConversation(this.conversationId, this.publicKey);
+        const conv = await this.withAuthRetry(() => this.client.getConversation(this.conversationId, this.publicKey));
         this.historyMessages = conv.messages || [];
       } catch (err) {
-        if (err.message?.includes("401") || err.message?.includes("403")) {
-          clearCachedToken(this.publicKey);
-          const auth = await authenticateVault(this.client, this.vault, this.config.password);
-          this.client.setAuthToken(auth.token);
-          saveCachedToken(this.publicKey, auth.token, auth.expiresAt);
-          const conv = await this.client.getConversation(this.conversationId, this.publicKey);
-          this.historyMessages = conv.messages || [];
-        } else {
-          this.conversationId = null;
-          this.historyMessages = [];
-          const conv = await this.client.createConversation(this.publicKey);
-          this.conversationId = conv.id;
-        }
+        this.conversationId = null;
+        this.historyMessages = [];
+        const conv = await this.withAuthRetry(() => this.client.createConversation(this.publicKey));
+        this.conversationId = conv.id;
+        ui.onError(
+          `Session ${this.config.sessionId} could not be resumed (${err?.message ?? "unknown error"}); started a new conversation ${conv.id}`,
+          "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */
+        );
       }
     } else {
-      const conv = await this.client.createConversation(this.publicKey);
+      const conv = await this.withAuthRetry(() => this.client.createConversation(this.publicKey));
       this.conversationId = conv.id;
     }
     this.cachedContext = this.config.viaAgent || this.config.askMode ? await buildMinimalContext(this.vault) : await buildMessageContext(this.vault);
@@ -12204,6 +12238,40 @@ var AgentSession = class {
       }
     }
   }
+  /**
+   * Run an authenticated backend request and, on a 401/403, do a single
+   * clear → re-auth → retry. This is the ONE chokepoint every conversation
+   * request shares (resume fetch, fresh-convo create, error-fallback create,
+   * and the send-message stream) so a revoked-but-unexpired cached token
+   * recovers identically everywhere instead of throwing on some paths.
+   *
+   * The retry replays the EXACT same `request` closure, which matters for the
+   * send-message path: the replayed body must carry the same content +
+   * recent_actions or the LLM re-emits tool calls (runaway loop). Re-auth is a
+   * full MPC re-sign via authenticateVault — the backend also exposes
+   * POST /auth/refresh, but exchanging the refresh token is a future
+   * enhancement (see auth.ts); the re-sign is always available.
+   *
+   * `onReauth` (optional) fires the instant a re-auth is committed to — BEFORE
+   * authenticateVault runs — so a caller in a retry loop (recoverDisconnectedTurn)
+   * can record that its single re-auth has been spent even if the MPC re-sign
+   * itself then throws. Without this hook a re-auth that fails with a non-auth
+   * error would let the caller re-enter and re-sign on every iteration.
+   */
+  async withAuthRetry(request, onReauth) {
+    try {
+      return await request();
+    } catch (err) {
+      if (!isAuthError(err)) throw err;
+      onReauth?.();
+      const previousRefreshToken = readTokenStore()[this.publicKey]?.refreshToken;
+      clearCachedToken(this.publicKey);
+      const auth = await authenticateVault(this.client, this.vault, this.config.password);
+      this.client.setAuthToken(auth.token);
+      saveCachedToken(this.publicKey, auth.token, auth.expiresAt, auth.refreshToken ?? previousRefreshToken);
+      return await request();
+    }
+  }
   getConversationId() {
     return this.conversationId;
   }
@@ -12253,6 +12321,10 @@ var AgentSession = class {
 `
       );
       this.pendingToolResults = [];
+      ui.onError(
+        `agent message loop exceeded ${MAX_MESSAGE_LOOP_DEPTH} turns; conversation truncated`,
+        "LOOP_DEPTH_EXCEEDED" /* LOOP_DEPTH_EXCEEDED */
+      );
       ui.onDone();
       return;
     }
@@ -12328,31 +12400,15 @@ var AgentSession = class {
       }
     };
     let streamResult;
-    let authRetried = false;
-    while (true) {
-      try {
-        streamResult = await this.client.sendMessageStream(
-          this.conversationId,
-          request,
-          callbacks,
-          this.abortController?.signal
-        );
-        break;
-      } catch (err) {
-        const isAuthErr = err.message?.includes("401") || err.message?.includes("403");
-        if (isAuthErr && !authRetried) {
-          authRetried = true;
-          clearCachedToken(this.publicKey);
-          const auth = await authenticateVault(this.client, this.vault, this.config.password);
-          this.client.setAuthToken(auth.token);
-          saveCachedToken(this.publicKey, auth.token, auth.expiresAt);
-          continue;
-        }
-        if (flushedThisCall.length > 0) {
-          this.pendingToolResults = [...flushedThisCall, ...this.pendingToolResults];
-        }
-        throw err;
+    try {
+      streamResult = await this.withAuthRetry(
+        () => this.client.sendMessageStream(this.conversationId, request, callbacks, this.abortController?.signal)
+      );
+    } catch (err) {
+      if (flushedThisCall.length > 0) {
+        this.pendingToolResults = [...flushedThisCall, ...this.pendingToolResults];
       }
+      throw err;
     }
     if (pendingDispatches.length > 0) {
       await Promise.all(pendingDispatches);
@@ -12415,10 +12471,16 @@ var AgentSession = class {
     const since = serverAnchor ?? new Date(Date.now() - 2e3).toISOString();
     const replaySignableCards = serverAnchor !== null;
     let cursor;
+    let authRecovered = false;
     for (let attempt = 0; attempt < this.recoveryMaxPolls; attempt++) {
       let resp;
       try {
-        resp = await this.client.messagesSince(this.conversationId, cursor ? { cursor } : { since });
+        resp = authRecovered ? await this.client.messagesSince(this.conversationId, cursor ? { cursor } : { since }) : await this.withAuthRetry(
+          () => this.client.messagesSince(this.conversationId, cursor ? { cursor } : { since }),
+          () => {
+            authRecovered = true;
+          }
+        );
       } catch (err) {
         if (this.config.verbose) {
           process.stderr.write(`[session] recovery poll ${attempt + 1} failed: ${err?.message ?? err}
@@ -12708,6 +12770,10 @@ function serverNowToIso(serverNow) {
 function hasTxReadyPart(parts) {
   return !!parts?.some((p) => p.type === "data-tx_ready" && !!p.data);
 }
+function isAuthError(err) {
+  const msg = err instanceof Error ? err.message : String(err ?? "");
+  return /\b(401|403)\b/.test(msg);
+}
 function getTokenCachePath() {
   const dir = process.env.VULTISIG_CONFIG_DIR ?? join2(homedir2(), ".vultisig");
   return join2(dir, "agent-tokens.json");
@@ -12724,8 +12790,16 @@ function readTokenStore() {
 function writeTokenStore(store) {
   const path4 = getTokenCachePath();
   const dir = join2(path4, "..");
-  if (!existsSync(dir)) mkdirSync2(dir, { recursive: true });
+  if (!existsSync(dir)) mkdirSync2(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
   writeFileSync2(path4, JSON.stringify(store, null, 2), { mode: 384 });
+  try {
+    chmodSync(path4, 384);
+  } catch {
+  }
 }
 function loadCachedToken(publicKey) {
   const store = readTokenStore();
@@ -12743,9 +12817,13 @@ function loadCachedToken(publicKey) {
   }
   return entry.token;
 }
-function saveCachedToken(publicKey, token, expiresAt) {
+function saveCachedToken(publicKey, token, expiresAt, refreshToken) {
   const store = readTokenStore();
-  store[publicKey] = { token, expiresAt };
+  store[publicKey] = {
+    token,
+    expiresAt,
+    refreshToken: refreshToken ?? store[publicKey]?.refreshToken
+  };
   try {
     writeTokenStore(store);
   } catch {
@@ -13293,7 +13371,12 @@ async function executeAgentSessionsList(ctx2, options) {
   let totalCount = 0;
   let skip = 0;
   while (true) {
-    const page = await client.listConversations(publicKey, skip, PAGE_SIZE);
+    const page = await withClientAuthRetry(
+      client,
+      vault,
+      options.password,
+      () => client.listConversations(publicKey, skip, PAGE_SIZE)
+    );
     totalCount = page.total_count;
     allConversations.push(...page.conversations);
     if (allConversations.length >= totalCount || page.conversations.length < PAGE_SIZE) break;
@@ -13335,7 +13418,7 @@ async function executeAgentSessionsDelete(ctx2, sessionId, options) {
   const backendUrl = options.backendUrl || process.env.VULTISIG_AGENT_URL || "https://abe.vultisig.com";
   const client = await createAuthenticatedClient(backendUrl, vault, options.password);
   const publicKey = vault.publicKeys.ecdsa;
-  await client.deleteConversation(sessionId, publicKey);
+  await withClientAuthRetry(client, vault, options.password, () => client.deleteConversation(sessionId, publicKey));
   if (isJsonOutput()) {
     outputJson({ deleted: sessionId });
     return;
@@ -13348,6 +13431,16 @@ async function createAuthenticatedClient(backendUrl, vault, password) {
   client.setAuthToken(auth.token);
   return client;
 }
+async function withClientAuthRetry(client, vault, password, request) {
+  try {
+    return await request();
+  } catch (err) {
+    if (!isAuthError(err)) throw err;
+    const auth = await authenticateVault(client, vault, password);
+    client.setAuthToken(auth.token);
+    return await request();
+  }
+}
 function formatDate(iso) {
   try {
     const d = new Date(iso);
@@ -13366,7 +13459,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.8.1";
+    cachedVersion = "2.8.4";
     return cachedVersion;
   }
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/cli",
-  "version": "2.8.1",
+  "version": "2.8.4",
   "description": "The self-custody MPC wallet CLI for AI coding agents (Claude Code, Cursor, OpenCode). Natural-language agent mode, 36+ chains, DKLS23 threshold signatures. Seedless.",
   "type": "module",
   "bin": {
@@ -73,10 +73,10 @@
     "@cosmjs/stargate": "^0.39.0",
     "@napi-rs/keyring": "^1.3.0",
     "@noble/hashes": "^2.2.0",
-    "@vultisig/client-shared": "^0.2.16",
-    "@vultisig/core-chain": "^2.17.8",
+    "@vultisig/client-shared": "^0.2.17",
+    "@vultisig/core-chain": "^2.17.10",
     "@vultisig/rujira": "^41.0.0",
-    "@vultisig/sdk": "^2.8.0",
+    "@vultisig/sdk": "^2.8.4",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",