@vultisig/cli 2.19.10 → 2.19.14

package/dist/index.js

@@ -4875,7 +4875,6 @@ import { descriptions } from "@vultisig/client-shared";
 import { parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
 import chalk16 from "chalk";
 import { InvalidArgumentError, program } from "commander";
-import inquirer8 from "inquirer";
 
 // src/core/command-context.ts
 var DEFAULT_PASSWORD_CACHE_TTL = 5 * 60 * 1e3;
@@ -4948,616 +4947,647 @@ var BaseCommandContext = class {
   }
 };
 
-// src/core/password-manager.ts
-import inquirer from "inquirer";
-
 // src/lib/output.ts
 import chalk from "chalk";
 import ora from "ora";
-var silentMode = false;
-var outputFormat = "table";
-var nonInteractive = false;
-var quietMode = false;
-var fieldFilter;
-function setSilentMode(silent) {
-  silentMode = silent;
-}
-function isSilent() {
-  return silentMode;
-}
-function setNonInteractive(value) {
-  nonInteractive = value;
-}
-function isNonInteractive() {
-  return nonInteractive;
-}
-function requireInteractive(hint) {
-  if (nonInteractive) {
-    throw new Error(`Interactive prompt required but --non-interactive is set. ${hint}`);
+
+// src/core/errors.ts
+import { VaultError, VaultErrorCode, VaultImportError, VaultImportErrorCode } from "@vultisig/sdk";
+var EXIT_CODE_DESCRIPTIONS = {
+  [0 /* SUCCESS */]: "Success",
+  [1 /* USAGE */]: "Usage error (bad arguments, unknown command)",
+  [2 /* AUTH_REQUIRED */]: "Authentication required",
+  [3 /* NETWORK */]: "Network error (retryable)",
+  [4 /* INVALID_INPUT */]: "Invalid input (bad chain, address, amount)",
+  [5 /* RESOURCE_NOT_FOUND */]: "Resource not found (token, route)",
+  [6 /* EXTERNAL_SERVICE */]: "External service error (retryable)",
+  [7 /* UNKNOWN */]: "Unknown/unexpected error",
+  [8 /* ACK_FAILED */]: "Broadcast succeeded but post-broadcast report failed \u2014 hash is valid, do NOT retry",
+  [9 /* DUPLICATE_BROADCAST */]: "Duplicate broadcast refused (nothing sent) \u2014 retry with --force to override",
+  [10 /* AGENT_TURN_BLOCKED */]: "agent ask: a fund-safety guardrail blocked the requested action",
+  [11 /* AGENT_TURN_REFUSAL */]: "agent ask: the model refused or asked a clarifying question (no action taken)",
+  [12 /* CONFIRMATION_REQUIRED */]: "Interactive confirmation/input required but the session is non-interactive \u2014 pass --yes/--confirm or the required flag"
+};
+var VsigError = class extends Error {
+  hint;
+  suggestions;
+  context;
+  retryable = false;
+  constructor(message, hint, suggestions, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.hint = hint;
+    this.suggestions = suggestions;
+    this.context = context;
   }
-}
-function setQuiet(value) {
-  quietMode = value;
-}
-function setFields(fields) {
-  fieldFilter = fields;
-}
-function initOutputMode(options) {
-  outputFormat = options.output ?? "table";
-  silentMode = options.silent ?? process.env.VULTISIG_SILENT === "1";
-  if (outputFormat === "json") {
-    silentMode = true;
+};
+var UsageError = class extends VsigError {
+  exitCode = 1 /* USAGE */;
+  code = "USAGE_ERROR";
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
   }
-}
-function isJsonOutput() {
-  return outputFormat === "json";
-}
-function stripEmpty(data) {
-  if (Array.isArray(data)) return data.map(stripEmpty);
-  if (data !== null && typeof data === "object") {
-    return Object.fromEntries(
-      Object.entries(data).filter(([, v]) => v != null && v !== "").map(([k, v]) => [k, stripEmpty(v)])
-    );
+};
+var AuthRequiredError = class extends VsigError {
+  exitCode = 2 /* AUTH_REQUIRED */;
+  code = "AUTH_REQUIRED";
+  constructor(message) {
+    super(message ?? "Authentication required. Set up vault credentials.", "Ensure your vault is unlocked", [
+      "vsig vaults",
+      "vsig create"
+    ]);
   }
-  return data;
-}
-function filterFields(data, fields) {
-  if (!fields.length) return data;
-  if (Array.isArray(data)) return data.map((item) => filterFields(item, fields));
-  if (data !== null && typeof data === "object") {
-    const entries = Object.entries(data);
-    const matched = entries.filter(([k]) => fields.includes(k));
-    if (matched.length > 0) return Object.fromEntries(matched);
-    const recursed = entries.map(([k, v]) => [k, filterFields(v, fields)]);
-    return Object.fromEntries(recursed);
+};
+var NetworkError = class extends VsigError {
+  exitCode = 3 /* NETWORK */;
+  code = "NETWORK_ERROR";
+  retryable = true;
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
   }
-  return data;
-}
-function collectKeys(data) {
-  const keys = /* @__PURE__ */ new Set();
-  if (Array.isArray(data)) {
-    for (const item of data) {
-      if (item !== null && typeof item === "object") {
-        for (const k of Object.keys(item)) keys.add(k);
-      }
-    }
-  } else if (data !== null && typeof data === "object") {
-    for (const [k, v] of Object.entries(data)) {
-      keys.add(k);
-      if (v !== null && typeof v === "object") {
-        for (const nested of collectKeys(v)) keys.add(nested);
-      }
-    }
+};
+var InvalidChainError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_CHAIN";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-  return keys;
-}
-function warnInvalidFields(data, fields) {
-  const available = collectKeys(data);
-  if (available.size === 0) return;
-  const invalid = fields.filter((f) => !available.has(f));
-  if (invalid.length > 0) {
-    process.stderr.write(`Warning: unknown field(s): ${invalid.join(", ")}. Available: ${[...available].join(", ")}
-`);
+};
+var InvalidAddressError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_ADDRESS";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-}
-function applyOutputTransforms(data) {
-  let out = quietMode ? stripEmpty(data) : data;
-  if (fieldFilter?.length) {
-    warnInvalidFields(out, fieldFilter);
-    out = filterFields(out, fieldFilter);
+};
+var InvalidInputError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_INPUT";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-  return out;
-}
-function bigIntReplacer(_key, value) {
-  return typeof value === "bigint" ? value.toString() : value;
-}
-function outputJson(data) {
-  const transformed = applyOutputTransforms(data);
-  process.stdout.write(JSON.stringify({ success: true, v: 1, data: transformed }, bigIntReplacer, 2) + "\n");
-}
-function outputErrorJson(errJson) {
-  const transformed = applyOutputTransforms(errJson);
-  process.stdout.write(JSON.stringify(transformed, bigIntReplacer, 2) + "\n");
-}
-function info(message) {
-  if (!silentMode) {
-    console.log(chalk.blue(message));
+};
+var InsufficientBalanceError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INSUFFICIENT_BALANCE";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-}
-function success(message) {
-  if (!silentMode) {
-    console.log(chalk.green(`
-${message}`));
+};
+var NoRouteError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "NO_ROUTE";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-}
-function warn(message) {
-  if (!silentMode) {
-    console.log(chalk.yellow(message));
+};
+var TokenNotFoundError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "TOKEN_NOT_FOUND";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-}
-function error(message) {
-  console.error(chalk.red(`
-${message}`));
-}
-function printResult(message) {
-  console.log(message);
-}
-function printTable(data) {
-  console.table(data);
-}
-function printError(message) {
-  console.error(chalk.red(message));
-}
-var activeSpinners = /* @__PURE__ */ new Set();
-function stopAllSpinners() {
-  for (const spinner of activeSpinners) {
-    spinner.stop();
+};
+var TxNotFoundError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "TX_NOT_FOUND";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
   }
-  activeSpinners.clear();
-}
-function createNoopSpinner(text) {
-  const noopSpinner = {
-    text,
-    start() {
-      return this;
-    },
-    stop() {
-      activeSpinners.delete(this);
-      return this;
-    },
-    succeed() {
-      activeSpinners.delete(this);
-      return this;
-    },
-    fail(text2) {
-      activeSpinners.delete(this);
-      if (text2) printError(text2);
-      return this;
-    },
-    warn() {
-      activeSpinners.delete(this);
-      return this;
-    },
-    info() {
-      activeSpinners.delete(this);
-      return this;
-    }
-  };
-  return noopSpinner;
-}
-function wrapOraSpinner(spinner) {
-  const originalStop = spinner.stop.bind(spinner);
-  const originalSucceed = spinner.succeed.bind(spinner);
-  const originalFail = spinner.fail.bind(spinner);
-  const originalWarn = spinner.warn.bind(spinner);
-  const originalInfo = spinner.info.bind(spinner);
-  spinner.stop = () => {
-    activeSpinners.delete(spinner);
-    return originalStop();
-  };
-  spinner.succeed = (text) => {
-    activeSpinners.delete(spinner);
-    return originalSucceed(text);
-  };
-  spinner.fail = (text) => {
-    activeSpinners.delete(spinner);
-    return originalFail(text);
-  };
-  spinner.warn = (text) => {
-    activeSpinners.delete(spinner);
-    return originalWarn(text);
-  };
-  spinner.info = (text) => {
-    activeSpinners.delete(spinner);
-    return originalInfo(text);
-  };
-  return spinner;
-}
-function createSpinner(text) {
-  if (silentMode) {
-    const spinner2 = createNoopSpinner(text);
-    activeSpinners.add(spinner2);
-    return spinner2;
-  }
-  const spinner = wrapOraSpinner(ora({ text, stream: process.stderr }).start());
-  activeSpinners.add(spinner);
-  return spinner;
-}
-
-// src/core/credential-store.ts
-import {
-  _resetAll,
-  clearCredentials,
-  getCredentialsPath,
-  getDecryptionPassword,
-  getServerPassword,
-  getStoredServerPassword,
-  isUsingFileFallback,
-  setDecryptionPassword,
-  setFilePassphrase,
-  setServerPassword
-} from "@vultisig/client-shared";
-
-// src/core/password-manager.ts
-var passwordCache = /* @__PURE__ */ new Map();
-function cachePassword(vaultIdOrName, password) {
-  passwordCache.set(vaultIdOrName, password);
-}
-function getCachedPassword(vaultId, vaultName) {
-  if (vaultName && passwordCache.has(vaultName)) return passwordCache.get(vaultName);
-  if (passwordCache.has(vaultId)) return passwordCache.get(vaultId);
-  return null;
-}
-function clearCachedPassword(vaultIdOrName) {
-  if (vaultIdOrName) {
-    passwordCache.delete(vaultIdOrName);
-  } else {
-    passwordCache.clear();
-  }
-}
-function parseVaultPasswords() {
-  const passwordMap = /* @__PURE__ */ new Map();
-  const passwordsEnv = process.env.VAULT_PASSWORDS;
-  if (passwordsEnv) {
-    const pairs = passwordsEnv.trim().split(/\s+/);
-    for (const pair of pairs) {
-      const colonIndex = pair.indexOf(":");
-      if (colonIndex > 0) {
-        const vaultKey = pair.substring(0, colonIndex);
-        const password = pair.substring(colonIndex + 1);
-        passwordMap.set(vaultKey, password);
-      }
-    }
-  }
-  return passwordMap;
-}
-function getPasswordFromEnv(vaultId, vaultName) {
-  const vaultPasswords = parseVaultPasswords();
-  if (vaultName && vaultPasswords.has(vaultName)) {
-    return vaultPasswords.get(vaultName);
-  }
-  if (vaultPasswords.has(vaultId)) {
-    return vaultPasswords.get(vaultId);
-  }
-  if (process.env.VAULT_PASSWORD || process.env.VULTISIG_PASSWORD) {
-    return process.env.VAULT_PASSWORD || process.env.VULTISIG_PASSWORD;
-  }
-  return null;
-}
-async function promptForPassword(vaultName, vaultId) {
-  requireInteractive(
-    'Use --password flag, VAULT_PASSWORD env var, or "vsig auth setup" to store credentials in keyring.'
-  );
-  const displayName = vaultName || vaultId || "vault";
-  const { password } = await inquirer.prompt([
-    {
-      type: "password",
-      name: "password",
-      message: `Enter password for vault "${displayName}":`,
-      mask: "*"
-    }
-  ]);
-  return password;
-}
-async function resolvePasswordNonInteractive(vaultId, vaultName) {
-  const cachedPassword = getCachedPassword(vaultId, vaultName);
-  if (cachedPassword) {
-    return cachedPassword;
-  }
-  try {
-    const keyringPassword = await getServerPassword(vaultId);
-    if (keyringPassword) {
-      cachePassword(vaultId, keyringPassword);
-      if (vaultName) cachePassword(vaultName, keyringPassword);
-      return keyringPassword;
-    }
-  } catch {
-  }
-  const envPassword = getPasswordFromEnv(vaultId, vaultName);
-  if (envPassword) {
-    cachePassword(vaultId, envPassword);
-    if (vaultName) cachePassword(vaultName, envPassword);
-    return envPassword;
-  }
-  return null;
-}
-async function getPassword(vaultId, vaultName) {
-  const resolved = await resolvePasswordNonInteractive(vaultId, vaultName);
-  if (resolved) {
-    return resolved;
-  }
-  if (isSilent() || isJsonOutput() || isNonInteractive()) {
-    throw new Error(
-      "Password required but not provided. Set VAULT_PASSWORD or VAULT_PASSWORDS environment variable, or use --password flag."
-    );
-  }
-  const password = await promptForPassword(vaultName, vaultId);
-  cachePassword(vaultId, password);
-  if (vaultName) cachePassword(vaultName, password);
-  return password;
-}
-function createPasswordCallback() {
-  return async (vaultId, vaultName) => {
-    return getPassword(vaultId, vaultName);
-  };
-}
-async function ensureVaultUnlocked(vault, password) {
-  if (!vault.isEncrypted || vault.isUnlocked()) {
-    return;
-  }
-  const resolvedPassword = password || await getPassword(vault.id, vault.name);
-  await vault.unlock(resolvedPassword);
-}
-
-// src/adapters/cli-context.ts
-var CLIContext = class extends BaseCommandContext {
-  get isInteractive() {
-    return false;
-  }
-  /**
-   * Get password for a vault
-   * In CLI mode, we check env vars first, then prompt
-   * No caching since each command runs independently
-   */
-  async getPassword(vaultId, vaultName) {
-    return getPassword(vaultId, vaultName);
-  }
-};
-
-// src/core/errors.ts
-import { VaultError, VaultErrorCode, VaultImportError, VaultImportErrorCode } from "@vultisig/sdk";
-var EXIT_CODE_DESCRIPTIONS = {
-  [0 /* SUCCESS */]: "Success",
-  [1 /* USAGE */]: "Usage error (bad arguments, unknown command)",
-  [2 /* AUTH_REQUIRED */]: "Authentication required",
-  [3 /* NETWORK */]: "Network error (retryable)",
-  [4 /* INVALID_INPUT */]: "Invalid input (bad chain, address, amount)",
-  [5 /* RESOURCE_NOT_FOUND */]: "Resource not found (token, route)",
-  [6 /* EXTERNAL_SERVICE */]: "External service error (retryable)",
-  [7 /* UNKNOWN */]: "Unknown/unexpected error",
-  [8 /* ACK_FAILED */]: "Broadcast succeeded but post-broadcast report failed \u2014 hash is valid, do NOT retry",
-  [9 /* DUPLICATE_BROADCAST */]: "Duplicate broadcast refused (nothing sent) \u2014 retry with --force to override",
-  [10 /* AGENT_TURN_BLOCKED */]: "agent ask: a fund-safety guardrail blocked the requested action",
-  [11 /* AGENT_TURN_REFUSAL */]: "agent ask: the model refused or asked a clarifying question (no action taken)"
 };
-var VsigError = class extends Error {
-  hint;
-  suggestions;
-  context;
-  retryable = false;
+var TxStatusTimeoutError = class extends VsigError {
+  exitCode = 3 /* NETWORK */;
+  code = "TX_STATUS_TIMEOUT";
+  retryable = true;
   constructor(message, hint, suggestions, context) {
-    super(message);
-    this.name = this.constructor.name;
-    this.hint = hint;
-    this.suggestions = suggestions;
-    this.context = context;
+    super(message, hint, suggestions, context);
   }
 };
-var UsageError = class extends VsigError {
-  exitCode = 1 /* USAGE */;
-  code = "USAGE_ERROR";
+var ExternalServiceError = class extends VsigError {
+  exitCode = 6 /* EXTERNAL_SERVICE */;
+  code = "EXTERNAL_SERVICE";
+  retryable = true;
   constructor(message, hint, suggestions) {
     super(message, hint, suggestions);
   }
 };
-var AuthRequiredError = class extends VsigError {
-  exitCode = 2 /* AUTH_REQUIRED */;
-  code = "AUTH_REQUIRED";
-  constructor(message) {
-    super(message ?? "Authentication required. Set up vault credentials.", "Ensure your vault is unlocked", [
-      "vsig vaults",
-      "vsig create"
-    ]);
+var PricingUnavailableError = class extends VsigError {
+  exitCode = 6 /* EXTERNAL_SERVICE */;
+  code = "PRICING_UNAVAILABLE";
+  retryable = true;
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
   }
 };
-var NetworkError = class extends VsigError {
-  exitCode = 3 /* NETWORK */;
-  code = "NETWORK_ERROR";
-  retryable = true;
+var ConfirmationRequiredError = class extends VsigError {
+  exitCode = 12 /* CONFIRMATION_REQUIRED */;
+  code = "CONFIRMATION_REQUIRED";
   constructor(message, hint, suggestions) {
     super(message, hint, suggestions);
   }
 };
-var InvalidChainError = class extends VsigError {
-  exitCode = 4 /* INVALID_INPUT */;
-  code = "INVALID_CHAIN";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+var UnknownError = class extends VsigError {
+  exitCode = 7 /* UNKNOWN */;
+  code = "UNKNOWN_ERROR";
+  constructor(message) {
+    super(message);
   }
 };
-var InvalidAddressError = class extends VsigError {
-  exitCode = 4 /* INVALID_INPUT */;
-  code = "INVALID_ADDRESS";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+var DuplicateBroadcastRefusedError = class extends VsigError {
+  exitCode = 9 /* DUPLICATE_BROADCAST */;
+  code = "DUPLICATE_BROADCAST";
+  constructor(message) {
+    super(message, "An identical transaction was broadcast recently and has not definitively failed", [
+      "Check its status with: vsig tx-status",
+      "Re-broadcast anyway with: --force"
+    ]);
   }
 };
-var InvalidInputError = class extends VsigError {
-  exitCode = 4 /* INVALID_INPUT */;
-  code = "INVALID_INPUT";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+function classifyError(err) {
+  if (err instanceof VsigError) return err;
+  if (err.code === "DUPLICATE_BROADCAST") {
+    return new DuplicateBroadcastRefusedError(err.message);
   }
-};
-var InsufficientBalanceError = class extends VsigError {
-  exitCode = 4 /* INVALID_INPUT */;
-  code = "INSUFFICIENT_BALANCE";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+  if (err instanceof VaultError) {
+    if (err.code === VaultErrorCode.BalanceFetchFailed && err.originalError) {
+      const inner = classifyError(err.originalError);
+      if (!(inner instanceof UnknownError)) return inner;
+    }
+    switch (err.code) {
+      case VaultErrorCode.UnsupportedChain:
+      case VaultErrorCode.ChainNotSupported:
+        return new InvalidChainError(err.message);
+      case VaultErrorCode.NetworkError:
+      case VaultErrorCode.BalanceFetchFailed:
+      case VaultErrorCode.Timeout:
+        return new NetworkError(err.message);
+      case VaultErrorCode.InvalidAmount:
+        return new InvalidInputError(err.message);
+      case VaultErrorCode.InvalidConfig: {
+        const lowerMsg = err.message.toLowerCase();
+        if (lowerMsg.includes("unknown chain") || lowerMsg.includes("unsupported chain") || lowerMsg.includes("chain not supported")) {
+          const chainMatch = err.message.match(/chain[:\s]*"([^"]+)"/i);
+          return new InvalidChainError(
+            err.message,
+            void 0,
+            void 0,
+            chainMatch ? { chain: chainMatch[1] } : void 0
+          );
+        }
+        return new UsageError(err.message);
+      }
+      case VaultErrorCode.UnsupportedToken:
+        return new TokenNotFoundError(err.message);
+      case VaultErrorCode.BroadcastFailed:
+        return new ExternalServiceError(err.message, "Broadcast failed \u2014 the node may be temporarily unavailable", [
+          "Retry the transaction"
+        ]);
+      case VaultErrorCode.GasEstimationFailed:
+        return new InvalidInputError(err.message, "Gas estimation failed \u2014 check balance and transaction params");
+      case VaultErrorCode.SigningFailed:
+        return new UnknownError(err.message);
+      default:
+        return new UnknownError(err.message);
+    }
   }
-};
-var NoRouteError = class extends VsigError {
-  exitCode = 5 /* RESOURCE_NOT_FOUND */;
-  code = "NO_ROUTE";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+  if (err instanceof VaultImportError) {
+    switch (err.code) {
+      case VaultImportErrorCode.PASSWORD_REQUIRED:
+      case VaultImportErrorCode.INVALID_PASSWORD:
+        return new AuthRequiredError(err.message);
+      default:
+        return new UsageError(err.message);
+    }
   }
-};
-var TokenNotFoundError = class extends VsigError {
-  exitCode = 5 /* RESOURCE_NOT_FOUND */;
-  code = "TOKEN_NOT_FOUND";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+  const msg = err.message.toLowerCase();
+  if (msg.includes("unsupported chain") || msg.includes("invalid chain") || msg.includes("unknown chain")) {
+    const chainMatch = err.message.match(/chain[:\s]*"([^"]+)"/i) || err.message.match(/chain[:\s]+(\S+)/i);
+    return new InvalidChainError(err.message, void 0, void 0, chainMatch ? { chain: chainMatch[1] } : void 0);
   }
-};
-var TxNotFoundError = class extends VsigError {
-  exitCode = 5 /* RESOURCE_NOT_FOUND */;
-  code = "TX_NOT_FOUND";
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+  if (msg.includes("invalid address") || msg.includes("bad address") || msg.includes("malformed address")) {
+    const addrMatch = err.message.match(/(0x[a-fA-F0-9]+|bc1[a-z0-9]+|[13][a-km-zA-HJ-NP-Z1-9]+)/i);
+    return new InvalidAddressError(err.message, void 0, void 0, addrMatch ? { address: addrMatch[1] } : void 0);
   }
-};
-var TxStatusTimeoutError = class extends VsigError {
-  exitCode = 3 /* NETWORK */;
-  code = "TX_STATUS_TIMEOUT";
-  retryable = true;
-  constructor(message, hint, suggestions, context) {
-    super(message, hint, suggestions, context);
+  if (msg.includes("insufficient") && msg.includes("balance")) {
+    return new InsufficientBalanceError(err.message);
   }
-};
-var ExternalServiceError = class extends VsigError {
-  exitCode = 6 /* EXTERNAL_SERVICE */;
-  code = "EXTERNAL_SERVICE";
-  retryable = true;
-  constructor(message, hint, suggestions) {
-    super(message, hint, suggestions);
+  if (msg.includes("no route") || msg.includes("no swap") || msg.includes("no provider")) {
+    return new NoRouteError(err.message);
   }
-};
-var PricingUnavailableError = class extends VsigError {
-  exitCode = 6 /* EXTERNAL_SERVICE */;
-  code = "PRICING_UNAVAILABLE";
-  retryable = true;
-  constructor(message, hint, suggestions) {
-    super(message, hint, suggestions);
+  if (msg.includes("token not found") || msg.includes("unknown token")) {
+    return new TokenNotFoundError(err.message);
   }
-};
-var UnknownError = class extends VsigError {
-  exitCode = 7 /* UNKNOWN */;
-  code = "UNKNOWN_ERROR";
-  constructor(message) {
-    super(message);
+  if (msg.includes("pricing") || msg.includes("price unavailable") || msg.includes("price service")) {
+    return new PricingUnavailableError(err.message);
   }
-};
-var DuplicateBroadcastRefusedError = class extends VsigError {
-  exitCode = 9 /* DUPLICATE_BROADCAST */;
-  code = "DUPLICATE_BROADCAST";
-  constructor(message) {
-    super(message, "An identical transaction was broadcast recently and has not definitively failed", [
-      "Check its status with: vsig tx-status",
-      "Re-broadcast anyway with: --force"
-    ]);
+  if (msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("econnreset") || msg.includes("fetch failed") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("dns")) {
+    return new NetworkError(err.message);
   }
-};
-function classifyError(err) {
-  if (err instanceof VsigError) return err;
-  if (err.code === "DUPLICATE_BROADCAST") {
-    return new DuplicateBroadcastRefusedError(err.message);
+  return new UnknownError(err.message);
+}
+function toErrorJson(err) {
+  if (err instanceof VsigError) {
+    const json = {
+      success: false,
+      v: 1,
+      error: {
+        code: err.code,
+        exitCode: err.exitCode,
+        message: err.message,
+        hint: err.hint,
+        retryable: err.retryable
+      }
+    };
+    if (err.suggestions?.length) json.error.suggestions = err.suggestions;
+    if (err.context) json.error.context = err.context;
+    return json;
+  }
+  return {
+    success: false,
+    v: 1,
+    error: {
+      code: "UNKNOWN_ERROR",
+      exitCode: 7 /* UNKNOWN */,
+      message: err.message,
+      retryable: false
+    }
+  };
+}
+
+// src/lib/output.ts
+var silentMode = false;
+var outputFormat = "table";
+var nonInteractive = false;
+var quietMode = false;
+var fieldFilter;
+function setSilentMode(silent) {
+  silentMode = silent;
+}
+function isSilent() {
+  return silentMode;
+}
+function setNonInteractive(value) {
+  nonInteractive = value;
+}
+function isNonInteractive() {
+  return nonInteractive;
+}
+function resolveNonInteractive(explicit, stdout = process.stdout, stdin = process.stdin) {
+  return explicit || !stdout.isTTY || !stdin.isTTY;
+}
+function requireInteractive(hint) {
+  if (nonInteractive) {
+    throw new ConfirmationRequiredError(
+      "Interactive input required but the session is non-interactive (piped/redirected stdout or stdin, or --non-interactive/--ci).",
+      hint
+    );
+  }
+}
+function setQuiet(value) {
+  quietMode = value;
+}
+function setFields(fields) {
+  fieldFilter = fields;
+}
+function initOutputMode(options) {
+  outputFormat = options.output ?? "table";
+  silentMode = options.silent ?? process.env.VULTISIG_SILENT === "1";
+  if (outputFormat === "json") {
+    silentMode = true;
+  }
+}
+function isJsonOutput() {
+  return outputFormat === "json";
+}
+function stripEmpty(data) {
+  if (Array.isArray(data)) return data.map(stripEmpty);
+  if (data !== null && typeof data === "object") {
+    return Object.fromEntries(
+      Object.entries(data).filter(([, v]) => v != null && v !== "").map(([k, v]) => [k, stripEmpty(v)])
+    );
+  }
+  return data;
+}
+function filterFields(data, fields) {
+  if (!fields.length) return data;
+  if (Array.isArray(data)) return data.map((item) => filterFields(item, fields));
+  if (data !== null && typeof data === "object") {
+    const entries = Object.entries(data);
+    const matched = entries.filter(([k]) => fields.includes(k));
+    if (matched.length > 0) return Object.fromEntries(matched);
+    const recursed = entries.map(([k, v]) => [k, filterFields(v, fields)]);
+    return Object.fromEntries(recursed);
+  }
+  return data;
+}
+function collectKeys(data) {
+  const keys = /* @__PURE__ */ new Set();
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (item !== null && typeof item === "object") {
+        for (const k of Object.keys(item)) keys.add(k);
+      }
+    }
+  } else if (data !== null && typeof data === "object") {
+    for (const [k, v] of Object.entries(data)) {
+      keys.add(k);
+      if (v !== null && typeof v === "object") {
+        for (const nested of collectKeys(v)) keys.add(nested);
+      }
+    }
+  }
+  return keys;
+}
+function warnInvalidFields(data, fields) {
+  const available = collectKeys(data);
+  if (available.size === 0) return;
+  const invalid = fields.filter((f) => !available.has(f));
+  if (invalid.length > 0) {
+    process.stderr.write(`Warning: unknown field(s): ${invalid.join(", ")}. Available: ${[...available].join(", ")}
+`);
+  }
+}
+function applyOutputTransforms(data) {
+  let out = quietMode ? stripEmpty(data) : data;
+  if (fieldFilter?.length) {
+    warnInvalidFields(out, fieldFilter);
+    out = filterFields(out, fieldFilter);
+  }
+  return out;
+}
+function bigIntReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function outputJson(data) {
+  const transformed = applyOutputTransforms(data);
+  process.stdout.write(JSON.stringify({ success: true, v: 1, data: transformed }, bigIntReplacer, 2) + "\n");
+}
+function outputErrorJson(errJson) {
+  const transformed = applyOutputTransforms(errJson);
+  process.stdout.write(JSON.stringify(transformed, bigIntReplacer, 2) + "\n");
+}
+function info(message) {
+  if (!silentMode) {
+    console.log(chalk.blue(message));
+  }
+}
+function success(message) {
+  if (!silentMode) {
+    console.log(chalk.green(`
+${message}`));
+  }
+}
+function warn(message) {
+  if (!silentMode) {
+    console.log(chalk.yellow(message));
+  }
+}
+function error(message) {
+  console.error(chalk.red(`
+${message}`));
+}
+function printResult(message) {
+  console.log(message);
+}
+function printTable(data) {
+  console.table(data);
+}
+function printError(message) {
+  console.error(chalk.red(message));
+}
+var activeSpinners = /* @__PURE__ */ new Set();
+function stopAllSpinners() {
+  for (const spinner of activeSpinners) {
+    spinner.stop();
+  }
+  activeSpinners.clear();
+}
+function createNoopSpinner(text) {
+  const noopSpinner = {
+    text,
+    start() {
+      return this;
+    },
+    stop() {
+      activeSpinners.delete(this);
+      return this;
+    },
+    succeed() {
+      activeSpinners.delete(this);
+      return this;
+    },
+    fail(text2) {
+      activeSpinners.delete(this);
+      if (text2) printError(text2);
+      return this;
+    },
+    warn() {
+      activeSpinners.delete(this);
+      return this;
+    },
+    info() {
+      activeSpinners.delete(this);
+      return this;
+    }
+  };
+  return noopSpinner;
+}
+function wrapOraSpinner(spinner) {
+  const originalStop = spinner.stop.bind(spinner);
+  const originalSucceed = spinner.succeed.bind(spinner);
+  const originalFail = spinner.fail.bind(spinner);
+  const originalWarn = spinner.warn.bind(spinner);
+  const originalInfo = spinner.info.bind(spinner);
+  spinner.stop = () => {
+    activeSpinners.delete(spinner);
+    return originalStop();
+  };
+  spinner.succeed = (text) => {
+    activeSpinners.delete(spinner);
+    return originalSucceed(text);
+  };
+  spinner.fail = (text) => {
+    activeSpinners.delete(spinner);
+    return originalFail(text);
+  };
+  spinner.warn = (text) => {
+    activeSpinners.delete(spinner);
+    return originalWarn(text);
+  };
+  spinner.info = (text) => {
+    activeSpinners.delete(spinner);
+    return originalInfo(text);
+  };
+  return spinner;
+}
+function createSpinner(text) {
+  if (silentMode) {
+    const spinner2 = createNoopSpinner(text);
+    activeSpinners.add(spinner2);
+    return spinner2;
+  }
+  const spinner = wrapOraSpinner(ora({ text, stream: process.stderr }).start());
+  activeSpinners.add(spinner);
+  return spinner;
+}
+
+// src/lib/prompt.ts
+import inquirer from "inquirer";
+var promptOutput = process.stderr;
+var promptModule = inquirer.createPromptModule({ output: promptOutput });
+function deriveHint(questions) {
+  const list = Array.isArray(questions) ? questions : [questions];
+  const needsPassword = list.some(
+    (q) => q != null && typeof q === "object" && q.type === "password"
+  );
+  return needsPassword ? 'Provide the password via --password, the VAULT_PASSWORD env var, or "vsig auth setup" (keyring).' : "Supply the required value(s) via flags (e.g. --yes/--confirm, --code, --chain/--address/--name) so no prompt is needed.";
+}
+var prompt = new Proxy(promptModule, {
+  apply(target, thisArg, argArray) {
+    requireInteractive(deriveHint(argArray[0]));
+    return Reflect.apply(target, thisArg, argArray);
+  }
+});
+
+// src/core/credential-store.ts
+import {
+  _resetAll,
+  clearCredentials,
+  getCredentialsPath,
+  getDecryptionPassword,
+  getServerPassword,
+  getStoredServerPassword,
+  isUsingFileFallback,
+  setDecryptionPassword,
+  setFilePassphrase,
+  setServerPassword
+} from "@vultisig/client-shared";
+
+// src/core/password-manager.ts
+var passwordCache = /* @__PURE__ */ new Map();
+function cachePassword(vaultIdOrName, password) {
+  passwordCache.set(vaultIdOrName, password);
+}
+function getCachedPassword(vaultId, vaultName) {
+  if (vaultName && passwordCache.has(vaultName)) return passwordCache.get(vaultName);
+  if (passwordCache.has(vaultId)) return passwordCache.get(vaultId);
+  return null;
+}
+function clearCachedPassword(vaultIdOrName) {
+  if (vaultIdOrName) {
+    passwordCache.delete(vaultIdOrName);
+  } else {
+    passwordCache.clear();
   }
-  if (err instanceof VaultError) {
-    if (err.code === VaultErrorCode.BalanceFetchFailed && err.originalError) {
-      const inner = classifyError(err.originalError);
-      if (!(inner instanceof UnknownError)) return inner;
-    }
-    switch (err.code) {
-      case VaultErrorCode.UnsupportedChain:
-      case VaultErrorCode.ChainNotSupported:
-        return new InvalidChainError(err.message);
-      case VaultErrorCode.NetworkError:
-      case VaultErrorCode.BalanceFetchFailed:
-      case VaultErrorCode.Timeout:
-        return new NetworkError(err.message);
-      case VaultErrorCode.InvalidAmount:
-        return new InvalidInputError(err.message);
-      case VaultErrorCode.InvalidConfig: {
-        const lowerMsg = err.message.toLowerCase();
-        if (lowerMsg.includes("unknown chain") || lowerMsg.includes("unsupported chain") || lowerMsg.includes("chain not supported")) {
-          const chainMatch = err.message.match(/chain[:\s]*"([^"]+)"/i);
-          return new InvalidChainError(
-            err.message,
-            void 0,
-            void 0,
-            chainMatch ? { chain: chainMatch[1] } : void 0
-          );
-        }
-        return new UsageError(err.message);
+}
+function parseVaultPasswords() {
+  const passwordMap = /* @__PURE__ */ new Map();
+  const passwordsEnv = process.env.VAULT_PASSWORDS;
+  if (passwordsEnv) {
+    const pairs = passwordsEnv.trim().split(/\s+/);
+    for (const pair of pairs) {
+      const colonIndex = pair.indexOf(":");
+      if (colonIndex > 0) {
+        const vaultKey = pair.substring(0, colonIndex);
+        const password = pair.substring(colonIndex + 1);
+        passwordMap.set(vaultKey, password);
       }
-      case VaultErrorCode.UnsupportedToken:
-        return new TokenNotFoundError(err.message);
-      case VaultErrorCode.BroadcastFailed:
-        return new ExternalServiceError(err.message, "Broadcast failed \u2014 the node may be temporarily unavailable", [
-          "Retry the transaction"
-        ]);
-      case VaultErrorCode.GasEstimationFailed:
-        return new InvalidInputError(err.message, "Gas estimation failed \u2014 check balance and transaction params");
-      case VaultErrorCode.SigningFailed:
-        return new UnknownError(err.message);
-      default:
-        return new UnknownError(err.message);
     }
   }
-  if (err instanceof VaultImportError) {
-    switch (err.code) {
-      case VaultImportErrorCode.PASSWORD_REQUIRED:
-      case VaultImportErrorCode.INVALID_PASSWORD:
-        return new AuthRequiredError(err.message);
-      default:
-        return new UsageError(err.message);
-    }
+  return passwordMap;
+}
+function getPasswordFromEnv(vaultId, vaultName) {
+  const vaultPasswords = parseVaultPasswords();
+  if (vaultName && vaultPasswords.has(vaultName)) {
+    return vaultPasswords.get(vaultName);
   }
-  const msg = err.message.toLowerCase();
-  if (msg.includes("unsupported chain") || msg.includes("invalid chain") || msg.includes("unknown chain")) {
-    const chainMatch = err.message.match(/chain[:\s]*"([^"]+)"/i) || err.message.match(/chain[:\s]+(\S+)/i);
-    return new InvalidChainError(err.message, void 0, void 0, chainMatch ? { chain: chainMatch[1] } : void 0);
+  if (vaultPasswords.has(vaultId)) {
+    return vaultPasswords.get(vaultId);
   }
-  if (msg.includes("invalid address") || msg.includes("bad address") || msg.includes("malformed address")) {
-    const addrMatch = err.message.match(/(0x[a-fA-F0-9]+|bc1[a-z0-9]+|[13][a-km-zA-HJ-NP-Z1-9]+)/i);
-    return new InvalidAddressError(err.message, void 0, void 0, addrMatch ? { address: addrMatch[1] } : void 0);
+  if (process.env.VAULT_PASSWORD || process.env.VULTISIG_PASSWORD) {
+    return process.env.VAULT_PASSWORD || process.env.VULTISIG_PASSWORD;
   }
-  if (msg.includes("insufficient") && msg.includes("balance")) {
-    return new InsufficientBalanceError(err.message);
+  return null;
+}
+async function promptForPassword(vaultName, vaultId) {
+  requireInteractive(
+    'Use --password flag, VAULT_PASSWORD env var, or "vsig auth setup" to store credentials in keyring.'
+  );
+  const displayName = vaultName || vaultId || "vault";
+  const { password } = await prompt([
+    {
+      type: "password",
+      name: "password",
+      message: `Enter password for vault "${displayName}":`,
+      mask: "*"
+    }
+  ]);
+  return password;
+}
+async function resolvePasswordNonInteractive(vaultId, vaultName) {
+  const cachedPassword = getCachedPassword(vaultId, vaultName);
+  if (cachedPassword) {
+    return cachedPassword;
   }
-  if (msg.includes("no route") || msg.includes("no swap") || msg.includes("no provider")) {
-    return new NoRouteError(err.message);
+  try {
+    const keyringPassword = await getServerPassword(vaultId);
+    if (keyringPassword) {
+      cachePassword(vaultId, keyringPassword);
+      if (vaultName) cachePassword(vaultName, keyringPassword);
+      return keyringPassword;
+    }
+  } catch {
   }
-  if (msg.includes("token not found") || msg.includes("unknown token")) {
-    return new TokenNotFoundError(err.message);
+  const envPassword = getPasswordFromEnv(vaultId, vaultName);
+  if (envPassword) {
+    cachePassword(vaultId, envPassword);
+    if (vaultName) cachePassword(vaultName, envPassword);
+    return envPassword;
   }
-  if (msg.includes("pricing") || msg.includes("price unavailable") || msg.includes("price service")) {
-    return new PricingUnavailableError(err.message);
+  return null;
+}
+async function getPassword(vaultId, vaultName) {
+  const resolved = await resolvePasswordNonInteractive(vaultId, vaultName);
+  if (resolved) {
+    return resolved;
   }
-  if (msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("econnreset") || msg.includes("fetch failed") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("dns")) {
-    return new NetworkError(err.message);
+  if (isSilent() || isJsonOutput() || isNonInteractive()) {
+    throw new Error(
+      "Password required but not provided. Set VAULT_PASSWORD or VAULT_PASSWORDS environment variable, or use --password flag."
+    );
   }
-  return new UnknownError(err.message);
+  const password = await promptForPassword(vaultName, vaultId);
+  cachePassword(vaultId, password);
+  if (vaultName) cachePassword(vaultName, password);
+  return password;
 }
-function toErrorJson(err) {
-  if (err instanceof VsigError) {
-    const json = {
-      success: false,
-      v: 1,
-      error: {
-        code: err.code,
-        exitCode: err.exitCode,
-        message: err.message,
-        hint: err.hint,
-        retryable: err.retryable
-      }
-    };
-    if (err.suggestions?.length) json.error.suggestions = err.suggestions;
-    if (err.context) json.error.context = err.context;
-    return json;
-  }
-  return {
-    success: false,
-    v: 1,
-    error: {
-      code: "UNKNOWN_ERROR",
-      exitCode: 7 /* UNKNOWN */,
-      message: err.message,
-      retryable: false
-    }
+function createPasswordCallback() {
+  return async (vaultId, vaultName) => {
+    return getPassword(vaultId, vaultName);
   };
 }
+async function ensureVaultUnlocked(vault, password) {
+  if (!vault.isEncrypted || vault.isUnlocked()) {
+    return;
+  }
+  const resolvedPassword = password || await getPassword(vault.id, vault.name);
+  await vault.unlock(resolvedPassword);
+}
+
+// src/adapters/cli-context.ts
+var CLIContext = class extends BaseCommandContext {
+  get isInteractive() {
+    return false;
+  }
+  /**
+   * Get password for a vault
+   * In CLI mode, we check env vars first, then prompt
+   * No caching since each command runs independently
+   */
+  async getPassword(vaultId, vaultName) {
+    return getPassword(vaultId, vaultName);
+  }
+};
 
 // src/adapters/cli-runner.ts
 function withExit(handler) {
@@ -5588,7 +5618,6 @@ import { fiatCurrencies, fiatCurrencyNameRecord as fiatCurrencyNameRecord2 } fro
 // src/ui.ts
 import { fiatCurrencyNameRecord, Vultisig } from "@vultisig/sdk";
 import chalk2 from "chalk";
-import inquirer2 from "inquirer";
 function displayBalance(chain, balance, _raw = false) {
   printResult(chalk2.cyan(`
 ${chain} Balance:`));
@@ -5707,7 +5736,7 @@ function displayVaultsList(vaults, activeVault) {
 }
 async function confirmTransaction() {
   requireInteractive("Use --yes to skip confirmation, or --password to provide password non-interactively.");
-  const { confirmed } = await inquirer2.prompt([
+  const { confirmed } = await prompt([
     {
       type: "confirm",
       name: "confirmed",
@@ -5827,7 +5856,7 @@ Total: ${chains.length} chains`);
 }
 async function confirmSwap() {
   requireInteractive("Use --yes to skip confirmation, or --password to provide password non-interactively.");
-  const { confirmed } = await inquirer2.prompt([
+  const { confirmed } = await prompt([
     {
       type: "confirm",
       name: "confirmed",
@@ -5839,6 +5868,10 @@ async function confirmSwap() {
 }
 
 // src/commands/balance.ts
+function conciseError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.split("\n")[0].trim() || "Unknown error";
+}
 async function executeBalance(ctx2, options = {}) {
   const vault = await ctx2.ensureActiveVault();
   const spinner = createSpinner("Loading balances...");
@@ -5876,24 +5909,50 @@ async function executePortfolio(ctx2, options = {}) {
   const spinner = createSpinner(`Loading portfolio in ${currencyName}...`);
   const totalValue = await vault.getTotalValue(currency);
   const chains = vault.chains;
-  const chainBalances = await Promise.all(
+  const results = await Promise.all(
     chains.map(async (chain) => {
-      const balance = await vault.balance(chain);
+      let balance;
+      try {
+        balance = await vault.balance(chain);
+      } catch (err) {
+        return { failure: { chain, stage: "balance", error: conciseError(err) } };
+      }
       try {
         const value = await vault.getValue(chain, void 0, currency);
-        return { chain, balance, value };
-      } catch {
-        return { chain, balance };
+        return { entry: { chain, balance, value } };
+      } catch (err) {
+        return { entry: { chain, balance }, failure: { chain, stage: "value", error: conciseError(err) } };
       }
     })
   );
+  const chainBalances = [];
+  const failures = [];
+  for (const result of results) {
+    if (result.entry) chainBalances.push(result.entry);
+    if (result.failure) failures.push(result.failure);
+  }
+  if (failures.length > 0 && chainBalances.length === 0) {
+    spinner.fail("Portfolio failed to load");
+    throw new NetworkError(
+      `Failed to load balances for all ${failures.length} chain(s): ${failures.map((f) => `${f.chain} (${f.error})`).join("; ")}`,
+      "All chain balance fetches failed \u2014 likely a network/RPC issue",
+      ["Check your internet connection", "Retry in a few moments"]
+    );
+  }
   const portfolio = { totalValue, chainBalances };
   spinner.succeed("Portfolio loaded");
   if (isJsonOutput()) {
-    outputJson({ portfolio, currency });
+    outputJson({ portfolio, currency, failures });
     return;
   }
   displayPortfolio(portfolio, currency, options.raw ?? false);
+  if (failures.length > 0) {
+    warn(`
+Warning: ${failures.length} chain(s) failed to load fully:`);
+    for (const f of failures) {
+      warn(`  - ${f.chain} (${f.stage}): ${f.error}`);
+    }
+  }
 }
 
 // src/commands/chains.ts
@@ -6577,7 +6636,6 @@ async function executeAddresses(ctx2) {
 
 // src/commands/tokens.ts
 import chalk4 from "chalk";
-import inquirer3 from "inquirer";
 async function executeTokens(ctx2, options) {
   await ctx2.ensureActiveVault();
   if (options.discover) {
@@ -6616,7 +6674,7 @@ async function executeTokens(ctx2, options) {
     }
     if (prompts.length > 0) {
       requireInteractive("Provide --symbol, --name, and --decimals flags for non-interactive token addition.");
-      const answers = await inquirer3.prompt(prompts);
+      const answers = await prompt(prompts);
       symbol = symbol || answers.symbol?.trim();
       name = name || answers.name?.trim();
       decimals = decimals ?? answers.decimals;
@@ -6750,6 +6808,12 @@ async function executeSend(ctx2, params) {
   return sendTransaction(vault, params);
 }
 async function sendTransaction(vault, params) {
+  if (!params.dryRun && !params.yes && isNonInteractive()) {
+    throw new ConfirmationRequiredError(
+      "Transaction requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview without signing."
+    );
+  }
   const prepareSpinner = createSpinner("Preparing transaction...");
   const dryResult = await vault.send({
     chain: params.chain,
@@ -6801,9 +6865,6 @@ Dry-run preview:`);
     displayTransactionPreview(address, params.to, dryResult.total, balance.symbol, params.chain, params.memo, gas);
   }
   if (!params.yes) {
-    if (isNonInteractive()) {
-      throw new Error("Transaction requires confirmation. Use --yes to skip, or --dry-run to preview.");
-    }
     const confirmed = await confirmTransaction();
     if (!confirmed) {
       warn("Transaction cancelled");
@@ -6900,6 +6961,12 @@ async function executeExecute(ctx2, params) {
   return executeContractTransaction(vault, params, chainConfig, msg, funds);
 }
 async function executeContractTransaction(vault, params, chainConfig, msg, funds) {
+  if (!params.dryRun && !params.yes && isNonInteractive()) {
+    throw new ConfirmationRequiredError(
+      "Transaction requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview without signing."
+    );
+  }
   const prepareSpinner = createSpinner("Preparing contract execution...");
   const address = await vault.address(params.chain);
   prepareSpinner.succeed("Transaction prepared");
@@ -6955,9 +7022,6 @@ async function executeContractTransaction(vault, params, chainConfig, msg, funds
     info("\u2501".repeat(50));
   }
   if (!params.yes) {
-    if (isNonInteractive()) {
-      throw new Error("Transaction requires confirmation. Use --yes to skip, or --dry-run to preview.");
-    }
     const confirmed = await confirmTransaction();
     if (!confirmed) {
       warn("Transaction cancelled");
@@ -7288,7 +7352,6 @@ var import_qrcode_terminal3 = __toESM(require_main(), 1);
 import { FastVault } from "@vultisig/sdk";
 import chalk5 from "chalk";
 import { promises as fs } from "fs";
-import inquirer4 from "inquirer";
 import path from "path";
 function withAbortSignal(promise, signal) {
   if (!signal) return promise;
@@ -7301,10 +7364,10 @@ function withAbortSignal(promise, signal) {
   ]);
 }
 async function executeCreateFast(ctx2, options) {
-  const twoStep = options.twoStep || !process.stdin.isTTY;
+  const twoStep = options.twoStep || isNonInteractive();
   const { name, password, email, signal } = options;
   if (!options.twoStep && twoStep) {
-    info("Non-interactive terminal detected. Using --two-step mode automatically.");
+    info("Non-interactive session detected. Using --two-step mode automatically.");
   }
   const spinner = createSpinner("Creating vault...");
   const vaultId = await withAbortSignal(
@@ -7347,7 +7410,7 @@ Vault ID: ${vaultId}`);
   let attempts = 0;
   while (attempts < MAX_VERIFY_ATTEMPTS) {
     attempts++;
-    const codeAnswer = await inquirer4.prompt([
+    const codeAnswer = await prompt([
       {
         type: "input",
         name: "code",
@@ -7378,7 +7441,7 @@ Vault ID: ${vaultId}`);
         err.exitCode = 1;
         throw err;
       }
-      const { action } = await inquirer4.prompt([
+      const { action } = await prompt([
         {
           type: "select",
           name: "action",
@@ -7482,7 +7545,7 @@ Important: Save your vault backup file (.vult) in a secure location.`);
 async function executeImport(ctx2, file, flagPassword) {
   let password = flagPassword || process.env.VAULT_PASSWORD || "";
   if (!password) {
-    const answers = await inquirer4.prompt([
+    const answers = await prompt([
       {
         type: "password",
         name: "password",
@@ -7507,8 +7570,9 @@ async function executeVerify(ctx2, vaultId, options = {}) {
     let email = options.email;
     let password = options.password;
     if (!email || !password) {
+      requireInteractive("Pass --email and --password to resend non-interactively.");
       info("Email and password are required to resend verification.");
-      const answers = await inquirer4.prompt([
+      const answers = await prompt([
         ...!email ? [
           {
             type: "input",
@@ -7540,10 +7604,19 @@ async function executeVerify(ctx2, vaultId, options = {}) {
       error(resendErr.message || "Could not resend email. You may need to wait a few minutes.");
       return false;
     }
+    if (!options.code && isNonInteractive()) {
+      if (isJsonOutput()) {
+        outputJson({ resent: true, vaultId });
+        return true;
+      }
+      info("\nOnce you have the code, run:");
+      printResult(chalk5.cyan(`  vultisig verify ${vaultId} --code <OTP>`));
+      return true;
+    }
   }
   let code = options.code;
   if (!code) {
-    const codeAnswer = await inquirer4.prompt([
+    const codeAnswer = await prompt([
       {
         type: "input",
         name: "code",
@@ -7621,7 +7694,7 @@ async function executeExport(ctx2, options = {}) {
     if (options.password !== void 0) {
       exportPassword = options.password;
     } else {
-      const answer = await inquirer4.prompt([
+      const answer = await prompt([
         {
           type: "password",
           name: "exportPassword",
@@ -7761,6 +7834,7 @@ async function executeInfo(ctx2) {
   displayVaultInfo(vault);
 }
 async function executeCreateFromSeedphraseFast(ctx2, options) {
+  requireInteractive("Seedphrase fast-vault import requires interactive email-OTP entry; run it in a terminal.");
   const { mnemonic, name, password, email, discoverChains, chains, signal, usePhantomSolanaPath } = options;
   const validateSpinner = createSpinner("Validating seedphrase...");
   const validation = await ctx2.sdk.validateSeedphrase(mnemonic);
@@ -7821,7 +7895,7 @@ async function executeCreateFromSeedphraseFast(ctx2, options) {
   let attempts = 0;
   while (attempts < MAX_VERIFY_ATTEMPTS) {
     attempts++;
-    const codeAnswer = await inquirer4.prompt([
+    const codeAnswer = await prompt([
       {
         type: "input",
         name: "code",
@@ -7852,7 +7926,7 @@ async function executeCreateFromSeedphraseFast(ctx2, options) {
         err.exitCode = 1;
         throw err;
       }
-      const { action } = await inquirer4.prompt([
+      const { action } = await prompt([
         {
           type: "select",
           name: "action",
@@ -8071,6 +8145,9 @@ async function executeDelete(ctx2, options = {}) {
     });
     return;
   }
+  if (!options.skipConfirmation) {
+    requireInteractive("Pass --yes to skip confirmation, or use -o json for scripting.");
+  }
   info("\n" + chalk5.bold("Vault to delete:"));
   info(`  Name:   ${chalk5.cyan(vault.name)}`);
   info(`  Type:   ${chalk5.yellow(vault.type)}`);
@@ -8081,7 +8158,7 @@ async function executeDelete(ctx2, options = {}) {
     warn(chalk5.red.bold("WARNING: This action cannot be undone!"));
     warn("Make sure you have a backup of your vault (.vult file) before proceeding.");
     info("");
-    const { confirmed } = await inquirer4.prompt([
+    const { confirmed } = await prompt([
       {
         type: "confirm",
         name: "confirmed",
@@ -8224,10 +8301,16 @@ Dry-run preview:`);
   if (result.requiresApproval) info(`  Requires approval: yes`);
   if (result.warnings?.length) result.warnings.forEach((w) => warn(`  Warning: ${w}`));
 }
+function refuseSwapWhenNonInteractive() {
+  throw new ConfirmationRequiredError(
+    "Swap requires confirmation.",
+    "Pass --yes to confirm, or --dry-run to preview without signing."
+  );
+}
 async function confirmSwapIfNeeded(options) {
   if (options.yes) return;
   if (isNonInteractive()) {
-    throw new Error("Swap requires confirmation. Use --yes to skip, or --dry-run to preview.");
+    refuseSwapWhenNonInteractive();
   }
   const confirmed = await confirmSwap();
   if (!confirmed) {
@@ -8239,6 +8322,9 @@ async function executeSwap(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
   validateSwapAmount(options.amount);
   const amountStr = getSwapAmountString(options.amount);
+  if (!options.dryRun && !options.yes && isNonInteractive()) {
+    refuseSwapWhenNonInteractive();
+  }
   const quoteSpinner = createSpinner("Getting swap quote...");
   const dryResult = await vault.swap(toSwapRequest(options, amountStr, true));
   if (!dryResult.dryRun) throw new Error("unreachable");
@@ -8310,7 +8396,6 @@ async function executeSwap(ctx2, options) {
 // src/commands/settings.ts
 import { Chain as Chain6, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
 import chalk6 from "chalk";
-import inquirer5 from "inquirer";
 async function executeCurrency(ctx2, newCurrency) {
   const vault = await ctx2.ensureActiveVault();
   if (!newCurrency) {
@@ -8396,7 +8481,7 @@ async function executeAddressBook(ctx2, options = {}) {
       });
     }
     if (prompts.length > 0) {
-      const answers = await inquirer5.prompt(prompts);
+      const answers = await prompt(prompts);
       chain = chain || answers.chain;
       address = address || answers.address?.trim();
       name = name || answers.name?.trim();
@@ -8574,7 +8659,12 @@ async function executeRujiraDeposit(ctx2, options = {}) {
 }
 async function executeRujiraSwap(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
-  await ensureVaultUnlocked(vault, options.password);
+  if (!options.dryRun && !options.yes && isNonInteractive()) {
+    throw new ConfirmationRequiredError(
+      "Swap requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
+  }
   const client = await createRujiraClient(ctx2, options);
   const destination = options.destination ?? await vault.address("THORChain");
   const quoteSpinner = createSpinner("Getting FIN swap quote...");
@@ -8614,8 +8704,12 @@ async function executeRujiraSwap(ctx2, options) {
   }
   if (!options.yes) {
     warn("This command will execute a swap. Re-run with -y/--yes to skip this warning.");
-    throw new Error("Confirmation required (use --yes)");
+    throw new ConfirmationRequiredError(
+      "Swap requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
   }
+  await ensureVaultUnlocked(vault, options.password);
   const execSpinner = createSpinner("Executing FIN swap...");
   const result = await client.swap.execute(quote, { slippageBps: options.slippageBps });
   execSpinner.succeed("Swap submitted");
@@ -8627,7 +8721,12 @@ async function executeRujiraSwap(ctx2, options) {
 }
 async function executeRujiraWithdraw(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
-  await ensureVaultUnlocked(vault, options.password);
+  if (!options.dryRun && !options.yes && isNonInteractive()) {
+    throw new ConfirmationRequiredError(
+      "Withdrawal requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
+  }
   const client = await createRujiraClient(ctx2, options);
   const prepSpinner = createSpinner("Preparing withdrawal (MsgDeposit)...");
   const prepared = await client.withdraw.prepare({
@@ -8660,8 +8759,12 @@ async function executeRujiraWithdraw(ctx2, options) {
   }
   if (!options.yes) {
     warn("This command will broadcast a THORChain MsgDeposit withdrawal. Re-run with -y/--yes to proceed.");
-    throw new Error("Confirmation required (use --yes)");
+    throw new ConfirmationRequiredError(
+      "Withdrawal requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
   }
+  await ensureVaultUnlocked(vault, options.password);
   const execSpinner = createSpinner("Broadcasting withdrawal...");
   const result = await client.withdraw.execute(prepared);
   execSpinner.succeed("Withdrawal submitted");
@@ -14251,8 +14354,8 @@ ${chalk9.gray(ts)} ${chalk9.magenta.bold("Notification")}: ${chalk9.bold(heading
   }
   showPrompt() {
     if (this.stopped) return;
-    const prompt = chalk9.gray(`${this.timestamp()} `) + chalk9.green.bold("You") + ": ";
-    this.rl.setPrompt(prompt);
+    const prompt2 = chalk9.gray(`${this.timestamp()} `) + chalk9.green.bold("You") + ": ";
+    this.rl.setPrompt(prompt2);
     this.rl.prompt();
   }
   timestamp() {
@@ -14568,7 +14671,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.19.10";
+    cachedVersion = "2.19.14";
     return cachedVersion;
   }
   try {
@@ -15194,7 +15297,6 @@ import * as readline3 from "readline";
 // src/interactive/shell-commands.ts
 import chalk13 from "chalk";
 import Table2 from "cli-table3";
-import inquirer6 from "inquirer";
 import ora2 from "ora";
 function formatTimeRemaining(ms) {
   if (!ms || ms <= 0) return "expired";
@@ -15230,7 +15332,7 @@ async function executeUnlock(ctx2) {
     console.log(chalk13.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
     return;
   }
-  const { password } = await inquirer6.prompt([
+  const { password } = await prompt([
     {
       type: "password",
       name: "password",
@@ -15375,7 +15477,6 @@ function showHelp() {
 }
 
 // src/interactive/shell-context.ts
-import inquirer7 from "inquirer";
 var ShellContext = class extends BaseCommandContext {
   vaults = /* @__PURE__ */ new Map();
   constructor(sdk, options) {
@@ -15430,7 +15531,7 @@ var ShellContext = class extends BaseCommandContext {
       return envPassword;
     }
     const displayName = vaultName || vaultId;
-    const { password } = await inquirer7.prompt([
+    const { password } = await prompt([
       {
         type: "password",
         name: "password",
@@ -15525,7 +15626,7 @@ var ShellSession = class {
   /**
    * Read a single line with tab completion, then close readline
    */
-  readLine(prompt) {
+  readLine(prompt2) {
     return new Promise((resolve) => {
       const rl = readline3.createInterface({
         input: process.stdin,
@@ -15535,7 +15636,7 @@ var ShellSession = class {
         },
         terminal: true
       });
-      rl.question(prompt, (answer) => {
+      rl.question(prompt2, (answer) => {
         rl.close();
         resolve(answer);
       });
@@ -16404,6 +16505,12 @@ function setupCompletionCommand(program2) {
       process.exit(1);
     }
     if (options.install) {
+      if (isNonInteractive()) {
+        console.error(
+          "completion --install needs an interactive terminal to pick your shell.\nRun it directly in your shell, or append the script manually, e.g.:\n  vultisig completion bash >> ~/.bashrc\n  vultisig completion zsh  >> ~/.zshrc"
+        );
+        process.exit(12 /* CONFIRMATION_REQUIRED */);
+      }
       try {
         await tt.install({
           name: "vultisig",
@@ -16622,7 +16729,7 @@ program.name("vultisig").description("Vultisig CLI - Secure multi-party crypto w
   }
   initOutputMode({ silent: opts.silent, output: opts.output });
   setQuiet(!!opts.quiet);
-  setNonInteractive(!!opts.nonInteractive);
+  setNonInteractive(resolveNonInteractive(!!opts.nonInteractive));
   const fields = opts.fields;
   setFields(
     fields ? fields.split(",").map((f) => f.trim()).filter(Boolean) : void 0
@@ -16726,7 +16833,7 @@ async function promptSeedphrase() {
   requireInteractive("Use --mnemonic flag to provide seedphrase non-interactively.");
   info("\nEnter your 12 or 24-word recovery phrase.");
   info("Words will be hidden as you type.\n");
-  const answer = await inquirer8.prompt([
+  const answer = await prompt([
     {
       type: "password",
       name: "mnemonic",
@@ -16747,7 +16854,7 @@ async function promptQrPayload() {
   requireInteractive("Use --qr or --qr-file flag to provide QR payload non-interactively.");
   info("\nEnter the QR code payload from the initiator device.");
   info('The payload starts with "vultisig://".\n');
-  const answer = await inquirer8.prompt([
+  const answer = await prompt([
     {
       type: "input",
       name: "qrPayload",
@@ -16845,6 +16952,7 @@ joinCmd.command("secure").description("Join a SecureVault creation session").opt
       const qrParams = await parseKeygenQR(qrPayload);
       let mnemonic = options.mnemonic;
       if (qrParams.libType === "KEYIMPORT" && !mnemonic) {
+        requireInteractive("Use --mnemonic flag to provide seedphrase non-interactively.");
         info("\nThis session requires a seedphrase to join.");
         mnemonic = await promptSeedphrase();
       }
@@ -17508,6 +17616,10 @@ process.on("SIGINT", () => {
   process.exit(0);
 });
 if (isInteractiveMode) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    error("Interactive mode (-i/--interactive) requires a TTY on both stdin and stdout.");
+    process.exit(12 /* CONFIRMATION_REQUIRED */);
+  }
   startInteractiveMode().catch((err) => {
     error(`Failed to start interactive mode: ${err.message}`);
     process.exit(1);