@vultisig/cli 2.7.0 → 2.8.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @vultisig/cli
 
+## 2.8.1
+
+### Patch Changes
+
+- [#867](https://github.com/vultisig/vultisig-sdk/pull/867) [`ddd08af`](https://github.com/vultisig/vultisig-sdk/commit/ddd08af883a1b2ee2f72dac4d406782de9090672) Thanks [@neavra](https://github.com/neavra)! - Agent: poll for final on-chain confirmation after broadcasting a signed tx
+  (audit F1). A `pending` `tx_status` only means "broadcast accepted" — the tx can
+  still revert, expire, or be dropped. After broadcast the session now polls
+  `vault.getTxStatus` until the tx reaches a final state and emits `confirmed` /
+  `failed`, or `timeout` when the bounded poll budget (~120s) is exhausted. The
+  `ask` result records the latest per-tx `status` (deduped by hash), and the pipe
+  `tx_status` event gains a `timeout` status. Best-effort and non-fatal: when the
+  chain can't be resolved or the vault can't poll status, the existing `pending`
+  status stands. The blocking confirmation wait is scoped to the top of the
+  message loop (depth 0 — the single-tx ask/pipe case); inside a multi-turn tool
+  loop a leg keeps its honest `pending` instead of stacking the poll budget per
+  tx. The shared `pending | confirmed | failed | timeout` union is now threaded
+  through the ask result, pipe event, and UI callback without unchecked casts.
+
+## 2.8.0
+
+### Patch Changes
+
+- [#868](https://github.com/vultisig/vultisig-sdk/pull/868) [`6f84f19`](https://github.com/vultisig/vultisig-sdk/commit/6f84f19444752976a6677d3ee4054701b0904eae) Thanks [@neavra](https://github.com/neavra)! - `agent ask --json` now emits one stable v1 envelope on stdout for both success and error. Previously the success envelope was written through a redirected `console.log` and landed on stderr (stdout empty), and the error path wrote a different flat `{error,code}` shape. The envelope now carries `conversation_id` (success + error) and per-tool-call `id`s, and a mid-stream backend/SSE `error` frame makes the command exit non-zero instead of reporting false success.
+
+- Updated dependencies [[`c9a235b`](https://github.com/vultisig/vultisig-sdk/commit/c9a235b959c7c82cd189482fab86ce3d27ddb4ff), [`9585b6f`](https://github.com/vultisig/vultisig-sdk/commit/9585b6f246de3ce537eae201f0d660fc89ff1012), [`f82caf5`](https://github.com/vultisig/vultisig-sdk/commit/f82caf58532f58af9d62b0143c7466cabcd88b06), [`361ba58`](https://github.com/vultisig/vultisig-sdk/commit/361ba58f79f241c4c00e33785a66ec6987628d26), [`7625e0b`](https://github.com/vultisig/vultisig-sdk/commit/7625e0bf325c8957bc3e28270454fd54c5589e2f), [`2024a92`](https://github.com/vultisig/vultisig-sdk/commit/2024a92b44760e1ff2043b0e45b083edc131b16c)]:
+  - @vultisig/sdk@2.8.0
+  - @vultisig/rujira@41.0.0
+
 ## 2.7.0
 
 ### Patch Changes

package/dist/index.js

@@ -5053,11 +5053,11 @@ function bigIntReplacer(_key, value) {
 }
 function outputJson(data) {
   const transformed = applyOutputTransforms(data);
-  console.log(JSON.stringify({ success: true, v: 1, data: transformed }, bigIntReplacer, 2));
+  process.stdout.write(JSON.stringify({ success: true, v: 1, data: transformed }, bigIntReplacer, 2) + "\n");
 }
 function outputErrorJson(errJson) {
   const transformed = applyOutputTransforms(errJson);
-  console.log(JSON.stringify(transformed, bigIntReplacer, 2));
+  process.stdout.write(JSON.stringify(transformed, bigIntReplacer, 2) + "\n");
 }
 function info(message) {
   if (!silentMode) {
@@ -8184,6 +8184,7 @@ var AskInterface = class {
   toolCalls = [];
   transactions = [];
   cards = [];
+  error;
   constructor(session, verbose = false, autoApprove = false) {
     this.session = session;
     this.verbose = verbose;
@@ -8204,8 +8205,8 @@ var AskInterface = class {
 `);
         }
       },
-      onToolResult: (_id, action, success2, data, error2, code) => {
-        this.toolCalls.push({ action, success: success2, data, error: error2, code });
+      onToolResult: (id, action, success2, data, error2, code) => {
+        this.toolCalls.push({ id, action, success: success2, data, error: error2, code });
         if (this.verbose) {
           const status = success2 ? "ok" : `error: ${error2}${code ? ` [${code}]` : ""}`;
           process.stderr.write(`[tool] ${action}: ${status}
@@ -8222,14 +8223,23 @@ var AskInterface = class {
       },
       onSuggestions: (_suggestions) => {
       },
-      onTxStatus: (txHash, chain, _status, explorerUrl) => {
-        this.transactions.push({ hash: txHash, chain, explorerUrl });
+      onTxStatus: (txHash, chain, status, explorerUrl) => {
+        const existing = this.transactions.find((t) => t.hash === txHash);
+        if (existing) {
+          existing.status = status;
+          if (explorerUrl) existing.explorerUrl = explorerUrl;
+        } else {
+          this.transactions.push({ hash: txHash, chain, explorerUrl, status });
+        }
         if (this.verbose) {
-          process.stderr.write(`[tx] ${chain}: ${txHash}
+          process.stderr.write(`[tx] ${chain}: ${txHash} (${status})
 `);
         }
       },
       onError: (message, code) => {
+        if (!this.error) {
+          this.error = { message, code };
+        }
         process.stderr.write(`[error] ${message} [${code}]
 `);
       },
@@ -8259,14 +8269,27 @@ var AskInterface = class {
     this.toolCalls = [];
     this.transactions = [];
     this.cards = [];
+    this.error = void 0;
     const callbacks = this.getCallbacks();
     await this.session.sendMessage(message, callbacks);
+    return this.partialResult();
+  }
+  /**
+   * Snapshot of everything collected so far this turn. Identical to a normal
+   * `ask()` return, but callable from a catch block when `ask()` THREW mid-turn
+   * — e.g. the follow-up request that reports recent_actions back to the backend
+   * fails (timeout/5xx/auth) AFTER a tx has already broadcast and `onTxStatus`
+   * fired. Lets the caller still surface the already-broadcast tx hash in the
+   * error envelope instead of stranding funds the turn just moved.
+   */
+  partialResult() {
     return {
       sessionId: this.session.getConversationId() || "",
       response: this.responseParts[this.responseParts.length - 1] || "",
       toolCalls: this.toolCalls,
       transactions: this.transactions,
-      cards: this.cards
+      cards: this.cards,
+      error: this.error
     };
   }
 };
@@ -12063,6 +12086,8 @@ var CLIENT_SIDE_TOOL_DISPATCH = {
 var MAX_MESSAGE_LOOP_DEPTH = 16;
 var RECOVERY_POLL_INTERVAL_MS = 2e3;
 var RECOVERY_MAX_POLLS = 90;
+var TX_CONFIRM_POLL_INTERVAL_MS = 3e3;
+var TX_CONFIRM_MAX_POLLS = 40;
 var AgentSession = class {
   client;
   vault;
@@ -12080,6 +12105,10 @@ var AgentSession = class {
   // poll loop without real 2s waits.
   recoveryPollIntervalMs = RECOVERY_POLL_INTERVAL_MS;
   recoveryMaxPolls = RECOVERY_MAX_POLLS;
+  // Post-broadcast confirmation poll cadence — instance fields so tests can
+  // drive the loop without real waits.
+  txConfirmPollIntervalMs = TX_CONFIRM_POLL_INTERVAL_MS;
+  txConfirmMaxPolls = TX_CONFIRM_MAX_POLLS;
   constructor(vault, config) {
     this.vault = vault;
     this.config = config;
@@ -12358,7 +12387,9 @@ var AgentSession = class {
         const txHash = recent.data.tx_hash;
         const chain = recent.data.chain;
         const explorerUrl = recent.data.explorer_url;
-        if (txHash) ui.onTxStatus(txHash, chain || "", "pending", explorerUrl);
+        if (txHash) {
+          await this.emitAndConfirmTx(txHash, chain, explorerUrl, depth, ui);
+        }
       }
       await this.processMessageLoop(null, ui, depth + 1);
       return;
@@ -12417,6 +12448,75 @@ var AgentSession = class {
   recoverySleep() {
     return new Promise((resolve) => setTimeout(resolve, this.recoveryPollIntervalMs));
   }
+  /**
+   * Post-broadcast confirmation polling (audit F1). A bare `pending` status only
+   * means "broadcast accepted"; the tx can still revert, expire, or be dropped,
+   * so a headless caller that stops at `pending` may mark a later-reverted
+   * operation complete. Poll vault.getTxStatus until the tx reaches a final
+   * state and emit the matching lifecycle status (`confirmed`/`failed`), or
+   * `timeout` when the bounded poll budget is exhausted (the tx may still
+   * confirm later — callers can re-check with `vultisig tx-status`).
+   *
+   * Transient RPC/network errors are treated as "not final yet" and retried
+   * until the budget is spent. Best-effort and non-fatal: if the chain can't be
+   * resolved or the vault doesn't expose getTxStatus, the caller's already-
+   * emitted `pending` status stands and this returns quietly.
+   *
+   * Scoped to headless callers (ask/pipe) that need machine-readable finality.
+   * The interactive TUI already shows `pending` + an explorer link immediately
+   * and has the dedicated `vultisig tx-status` command, so blocking its prompt
+   * for the full poll budget would be a UX regression the audit didn't scope.
+   * The poll also bails on cancel (Ctrl-C aborts the controller) so a long wait
+   * is interruptible.
+   *
+   * The caller only invokes this at message-loop depth 0 (see the call site):
+   * inside a multi-turn tool loop the broadcast result already drives the next
+   * turn, so blocking here would stack the poll budget per leg without feeding
+   * the server any extra signal. Those deeper legs keep their honest `pending`.
+   */
+  async emitAndConfirmTx(txHash, chain, explorerUrl, depth, ui) {
+    ui.onTxStatus(txHash, chain || "", "pending", explorerUrl);
+    if (depth === 0) {
+      await this.confirmBroadcastedTx(txHash, chain, explorerUrl, ui);
+    }
+  }
+  async confirmBroadcastedTx(txHash, chainName, explorerUrl, ui) {
+    if (!this.config.askMode && !this.config.viaAgent) return;
+    const chain = resolveChain(chainName ?? "");
+    if (!chain || typeof this.vault?.getTxStatus !== "function") return;
+    for (let attempt = 0; attempt < this.txConfirmMaxPolls; attempt++) {
+      if (this.abortController?.signal?.aborted) return;
+      try {
+        const result = await this.vault.getTxStatus({ chain, txHash });
+        if (result.status === "success") {
+          ui.onTxStatus(txHash, chainName ?? "", "confirmed", explorerUrl);
+          return;
+        }
+        if (result.status === "error") {
+          ui.onTxStatus(txHash, chainName ?? "", "failed", explorerUrl);
+          return;
+        }
+      } catch (err) {
+        if (this.config.verbose) {
+          process.stderr.write(`[session] tx confirm poll ${attempt + 1} failed: ${err?.message ?? err}
+`);
+        }
+      }
+      if (attempt < this.txConfirmMaxPolls - 1) await this.txConfirmSleep();
+    }
+    if (this.abortController?.signal?.aborted) return;
+    if (this.config.verbose) {
+      process.stderr.write(
+        `[session] tx ${txHash} not confirmed within ${this.txConfirmMaxPolls} polls; emitting timeout
+`
+      );
+    }
+    ui.onTxStatus(txHash, chainName ?? "", "timeout", explorerUrl);
+  }
+  /** Sleep between confirmation polls. Separate method so tests can stub it out. */
+  txConfirmSleep() {
+    return new Promise((resolve) => setTimeout(resolve, this.txConfirmPollIntervalMs));
+  }
   /**
    * Fold a recovered assistant message back into the live stream result: the
    * authoritative message wins over any partial deltas, and any persisted
@@ -13068,12 +13168,85 @@ async function executeAgent(ctx2, options) {
     }
   }
 }
+function outputAskError(wantsJson, message, code, conversationId, result) {
+  if (wantsJson) {
+    const data = {};
+    if (result?.transactions.length) data.transactions = result.transactions;
+    if (result?.toolCalls.length) data.tool_calls = result.toolCalls;
+    if (result?.response) data.response = result.response;
+    outputErrorJson({
+      success: false,
+      v: 1,
+      error: { message, code, conversation_id: conversationId },
+      ...Object.keys(data).length > 0 ? { data } : {}
+    });
+  } else {
+    process.stderr.write(`Error: ${message} [${code}]
+`);
+  }
+}
+function outputAskHuman(result, confirmationRequired, proposed) {
+  process.stdout.write(`session:${result.sessionId}
+`);
+  if (confirmationRequired) {
+    process.stdout.write(`confirmation-required:pass --yes to authorize signing
+`);
+    if (proposed) {
+      process.stdout.write(`proposed:${proposed}
+`);
+    }
+  }
+  for (const card of result.cards) {
+    process.stdout.write(`
+${renderBalanceSummaryCard(card)}
+`);
+  }
+  if (result.response) {
+    process.stdout.write(`
+${result.response}
+`);
+  }
+  for (const tx of result.transactions) {
+    process.stdout.write(`
+tx:${tx.chain}:${tx.hash}
+`);
+    if (tx.explorerUrl) {
+      process.stdout.write(`explorer:${tx.explorerUrl}
+`);
+    }
+  }
+}
+function outputAskSuccess(wantsJson, result, conversationId) {
+  const confirmationRequired = result.toolCalls.some((tc) => tc.code === "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */);
+  const proposedCall = result.toolCalls.find(
+    (tc) => tc.code === "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */ && typeof tc.data?.proposed === "string"
+  );
+  const proposed = proposedCall?.data?.proposed;
+  if (wantsJson) {
+    outputJson({
+      conversation_id: conversationId,
+      session_id: result.sessionId,
+      response: result.response,
+      tool_calls: result.toolCalls,
+      transactions: result.transactions,
+      ...result.cards.length > 0 ? { cards: result.cards } : {},
+      ...confirmationRequired ? { confirmation_required: true } : {},
+      ...proposed ? { proposed } : {}
+    });
+    return;
+  }
+  outputAskHuman(result, confirmationRequired, proposed);
+}
 async function executeAgentAsk(ctx2, message, options) {
   setSilentMode(true);
   const originalConsoleLog = console.log;
   console.log = (...args) => {
     process.stderr.write(args.map(String).join(" ") + "\n");
   };
+  const wantsJson = !!options.json || isJsonOutput();
+  let conversationId = "";
+  let exitCode = 0;
+  let ask;
   try {
     const vault = await ctx2.ensureActiveVault();
     const config = {
@@ -13087,70 +13260,28 @@ async function executeAgentAsk(ctx2, message, options) {
       profile: options.profile ?? process.env.VULTISIG_AGENT_PROFILE ?? ""
     };
     const session = new AgentSession(vault, config);
-    const ask = new AskInterface(session, !!config.verbose, !!options.autoApprove);
+    ask = new AskInterface(session, !!config.verbose, !!options.autoApprove);
     const callbacks = ask.getCallbacks();
     await session.initialize(callbacks);
     const result = await ask.ask(message);
-    const confirmationRequired = result.toolCalls.some((tc) => tc.code === "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */);
-    const proposedCall = result.toolCalls.find(
-      (tc) => tc.code === "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */ && typeof tc.data?.proposed === "string"
-    );
-    const proposed = proposedCall?.data?.proposed;
-    if (options.json || isJsonOutput()) {
-      outputJson({
-        session_id: result.sessionId,
-        response: result.response,
-        tool_calls: result.toolCalls,
-        transactions: result.transactions,
-        ...result.cards.length > 0 ? { cards: result.cards } : {},
-        ...confirmationRequired ? { confirmation_required: true } : {},
-        ...proposed ? { proposed } : {}
-      });
+    conversationId = result.sessionId;
+    if (result.error) {
+      exitCode = 1;
+      outputAskError(wantsJson, result.error.message, result.error.code, conversationId, result);
     } else {
-      process.stdout.write(`session:${result.sessionId}
-`);
-      if (confirmationRequired) {
-        process.stdout.write(`confirmation-required:pass --yes to authorize signing
-`);
-        if (proposed) {
-          process.stdout.write(`proposed:${proposed}
-`);
-        }
-      }
-      for (const card of result.cards) {
-        process.stdout.write(`
-${renderBalanceSummaryCard(card)}
-`);
-      }
-      if (result.response) {
-        process.stdout.write(`
-${result.response}
-`);
-      }
-      for (const tx of result.transactions) {
-        process.stdout.write(`
-tx:${tx.chain}:${tx.hash}
-`);
-        if (tx.explorerUrl) {
-          process.stdout.write(`explorer:${tx.explorerUrl}
-`);
-        }
-      }
+      outputAskSuccess(wantsJson, result, conversationId);
     }
   } catch (err) {
     const { code, message: message2 } = normalizeAgentError(err);
-    if (options.json) {
-      process.stdout.write(JSON.stringify({ error: message2, code }) + "\n");
-    } else {
-      process.stderr.write(`Error: ${message2} [${code}]
-`);
-    }
-    process.exit(1);
+    exitCode = 1;
+    const partial = ask?.partialResult();
+    if (partial && !conversationId) conversationId = partial.sessionId;
+    outputAskError(wantsJson, message2, code, conversationId, partial);
   } finally {
     console.log = originalConsoleLog;
     setSilentMode(false);
   }
-  process.exit(0);
+  process.exit(exitCode);
 }
 async function executeAgentSessionsList(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
@@ -13235,7 +13366,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.7.0";
+    cachedVersion = "2.8.1";
     return cachedVersion;
   }
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/cli",
-  "version": "2.7.0",
+  "version": "2.8.1",
   "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": {
@@ -75,8 +75,8 @@
     "@noble/hashes": "^2.2.0",
     "@vultisig/client-shared": "^0.2.16",
     "@vultisig/core-chain": "^2.17.8",
-    "@vultisig/rujira": "^40.0.0",
-    "@vultisig/sdk": "^2.7.0",
+    "@vultisig/rujira": "^41.0.0",
+    "@vultisig/sdk": "^2.8.0",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",