@vultisig/cli 0.1.0-alpha.1 → 0.1.0

package/dist/index.js

@@ -1,440 +1,3264 @@
 #!/usr/bin/env node
-import 'dotenv/config';
-import { Vultisig } from '@vultisig/sdk';
-import chalk from 'chalk';
-import { program } from 'commander';
-import { CLIContext, withExit } from './adapters';
-import { executeAddressBook, executeAddresses, executeBalance, executeChains, executeCreate, executeCurrency, executeExport, executeImport, executeInfo, executePortfolio, executeRename, executeSend, executeServer, executeSwap, executeSwapChains, executeSwapQuote, executeSwitch, executeTokens, executeVaults, executeVerify, } from './commands';
-import { createPasswordCallback } from './core';
-import { findChainByName } from './interactive';
-import { ShellSession } from './interactive';
-import { checkForUpdates, error, formatVersionDetailed, formatVersionShort, getUpdateCommand, handleCompletion, info, initOutputMode, printResult, setupCompletionCommand, warn, } from './lib';
-import { setupVaultEvents } from './ui';
-(async () => {
-    const handled = await handleCompletion();
-    if (handled)
-        process.exit(0);
-})();
-// ============================================================================
-// Global State
-// ============================================================================
-let ctx;
-// ============================================================================
-// Program Configuration
-// ============================================================================
-program
-    .name('vultisig')
-    .description('Vultisig CLI - Secure multi-party crypto wallet')
-    .version(formatVersionShort(), '-v, --version', 'Show version')
-    .option('--debug', 'Enable debug output')
-    .option('--silent', 'Suppress informational output, show only results')
-    .option('-o, --output <format>', 'Output format: table, json (default: table)', 'table')
-    .option('-i, --interactive', 'Start interactive shell mode')
-    .option('--vault <nameOrId>', 'Specify vault by name or ID')
-    .hook('preAction', thisCommand => {
-    const opts = thisCommand.opts();
-    initOutputMode({ silent: opts.silent, output: opts.output });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
 });
-// ============================================================================
-// SDK Initialization
-// ============================================================================
-/**
- * Find a vault by name or ID
- * Tries exact ID match, then case-insensitive name match, then partial ID prefix match
- */
-async function findVaultByNameOrId(sdk, nameOrId) {
-    const vaults = await sdk.listVaults();
-    // Try exact ID match first
-    const byId = vaults.find(v => v.id === nameOrId);
-    if (byId)
-        return byId;
-    // Try name match (case-insensitive)
-    const byName = vaults.find(v => v.name.toLowerCase() === nameOrId.toLowerCase());
-    if (byName)
-        return byName;
-    // Try partial ID match (prefix)
-    const byPartialId = vaults.find(v => v.id.startsWith(nameOrId));
-    if (byPartialId)
-        return byPartialId;
+
+// src/index.ts
+import "dotenv/config";
+import { Vultisig as Vultisig3 } from "@vultisig/sdk";
+import chalk12 from "chalk";
+import { program } from "commander";
+
+// src/core/command-context.ts
+var DEFAULT_PASSWORD_CACHE_TTL = 5 * 60 * 1e3;
+var BaseCommandContext = class {
+  _sdk;
+  _activeVault = null;
+  passwordCache = /* @__PURE__ */ new Map();
+  defaultPasswordTtl;
+  constructor(sdk, options) {
+    this._sdk = sdk;
+    this.defaultPasswordTtl = options?.passwordTtlMs ?? DEFAULT_PASSWORD_CACHE_TTL;
+  }
+  get sdk() {
+    return this._sdk;
+  }
+  getActiveVault() {
+    return this._activeVault;
+  }
+  async setActiveVault(vault) {
+    this._activeVault = vault;
+    await this._sdk.setActiveVault(vault);
+  }
+  async ensureActiveVault() {
+    if (!this._activeVault) {
+      const vault = await this._sdk.getActiveVault();
+      if (vault) {
+        this._activeVault = vault;
+      }
+    }
+    if (!this._activeVault) {
+      throw new Error("No active vault. Create or import a vault first.");
+    }
+    return this._activeVault;
+  }
+  cachePassword(vaultId, password, ttlMs) {
+    const ttl = ttlMs ?? this.defaultPasswordTtl;
+    this.passwordCache.set(vaultId, {
+      password,
+      expiresAt: Date.now() + ttl
+    });
+  }
+  clearPasswordCache(vaultId) {
+    if (vaultId) {
+      this.passwordCache.delete(vaultId);
+    } else {
+      this.passwordCache.clear();
+    }
+  }
+  isPasswordCached(vaultId) {
+    const entry = this.passwordCache.get(vaultId);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.passwordCache.delete(vaultId);
+      return false;
+    }
+    return true;
+  }
+  getCachedPassword(vaultId) {
+    const entry = this.passwordCache.get(vaultId);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.passwordCache.delete(vaultId);
+      return null;
+    }
+    return entry.password;
+  }
+  dispose() {
+    this.passwordCache.clear();
+    this._sdk.dispose();
+  }
+};
+
+// 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";
+function isSilent() {
+  return silentMode;
+}
+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 bigIntReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function outputJson(data) {
+  console.log(JSON.stringify({ success: true, data }, bigIntReplacer, 2));
+}
+function outputJsonError(message, code) {
+  console.log(JSON.stringify({ success: false, error: { message, code } }, bigIntReplacer, 2));
+}
+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));
+}
+function createNoopSpinner(text) {
+  const noopSpinner = {
+    text,
+    start() {
+      return this;
+    },
+    stop() {
+      return this;
+    },
+    succeed() {
+      return this;
+    },
+    fail(text2) {
+      if (text2) printError(text2);
+      return this;
+    },
+    warn() {
+      return this;
+    },
+    info() {
+      return this;
+    }
+  };
+  return noopSpinner;
+}
+function createSpinner(text) {
+  if (silentMode) {
+    return createNoopSpinner(text);
+  }
+  return ora(text).start();
+}
+
+// src/core/password-manager.ts
+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) {
+    return process.env.VAULT_PASSWORD;
+  }
+  return null;
+}
+async function promptForPassword(vaultName, vaultId) {
+  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 getPassword(vaultId, vaultName) {
+  const envPassword = getPasswordFromEnv(vaultId, vaultName);
+  if (envPassword) {
+    return envPassword;
+  }
+  if (isSilent() || isJsonOutput()) {
+    throw new Error("Password required but not provided. Set VAULT_PASSWORD or VAULT_PASSWORDS environment variable.");
+  }
+  return promptForPassword(vaultName, vaultId);
+}
+function createPasswordCallback() {
+  return async (vaultId, vaultName) => {
+    return getPassword(vaultId, vaultName);
+  };
+}
+
+// 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) {
+  return async (...args) => {
+    try {
+      await handler(...args);
+      process.exit(0);
+    } catch (err) {
+      const exitCode = err.exitCode ?? 1;
+      if (isJsonOutput()) {
+        outputJsonError(err.message, err.code ?? "GENERAL_ERROR");
+        process.exit(exitCode);
+      }
+      if (err.exitCode !== void 0) {
+        process.exit(err.exitCode);
+      }
+      printError(`
+x ${err.message}`);
+      process.exit(1);
+    }
+  };
+}
+
+// src/commands/balance.ts
+import { fiatCurrencies, fiatCurrencyNameRecord as fiatCurrencyNameRecord2 } from "@vultisig/sdk";
+
+// src/ui.ts
+import { fiatCurrencyNameRecord, Vultisig } from "@vultisig/sdk";
+import chalk2 from "chalk";
+import inquirer2 from "inquirer";
+function displayBalance(chain, balance) {
+  printResult(chalk2.cyan(`
+${chain} Balance:`));
+  printResult(`  Amount: ${balance.amount} ${balance.symbol}`);
+  if (balance.fiatValue && balance.fiatCurrency) {
+    printResult(`  Value:  ${balance.fiatValue.toFixed(2)} ${balance.fiatCurrency}`);
+  }
+}
+function displayBalancesTable(balances) {
+  printResult(chalk2.cyan("\nPortfolio Balances:\n"));
+  const tableData = Object.entries(balances).map(([chain, balance]) => ({
+    Chain: chain,
+    Amount: balance.amount,
+    Symbol: balance.symbol,
+    Value: balance.fiatValue && balance.fiatCurrency ? `${balance.fiatValue.toFixed(2)} ${balance.fiatCurrency}` : "N/A"
+  }));
+  printTable(tableData);
+}
+function displayPortfolio(portfolio, currency) {
+  const currencyName = fiatCurrencyNameRecord[currency];
+  printResult(chalk2.cyan("\n+----------------------------------------+"));
+  printResult(chalk2.cyan(`|       Portfolio Total Value (${currencyName})       |`));
+  printResult(chalk2.cyan("+----------------------------------------+"));
+  const totalDisplay = portfolio.totalValue.amount.padEnd(20) + portfolio.totalValue.currency.toUpperCase().padStart(16);
+  printResult(chalk2.cyan("|  ") + chalk2.bold.green(totalDisplay) + chalk2.cyan("  |"));
+  printResult(chalk2.cyan("+----------------------------------------+\n"));
+  printResult(chalk2.bold("Chain Breakdown:\n"));
+  const table = portfolio.chainBalances.map(({ chain, balance, value }) => ({
+    Chain: chain,
+    Amount: balance.amount,
+    Symbol: balance.symbol,
+    Value: value ? `${value.amount} ${value.currency.toUpperCase()}` : "N/A"
+  }));
+  printTable(table);
+}
+function displayAddresses(addresses) {
+  printResult(chalk2.cyan("\nVault Addresses:\n"));
+  const table = Object.entries(addresses).map(([chain, address]) => ({
+    Chain: chain,
+    Address: address
+  }));
+  printTable(table);
+}
+function displayVaultInfo(vault) {
+  printResult(chalk2.cyan("\n+----------------------------------------+"));
+  printResult(chalk2.cyan("|           Vault Information            |"));
+  printResult(chalk2.cyan("+----------------------------------------+\n"));
+  printResult(chalk2.bold("Basic Information:"));
+  printResult(`  Name:          ${chalk2.green(vault.name)}`);
+  printResult(`  ID:            ${vault.id}`);
+  printResult(`  Type:          ${chalk2.yellow(vault.type)}`);
+  printResult(`  Created:       ${new Date(vault.createdAt).toLocaleString()}`);
+  printResult(`  Last Modified: ${new Date(vault.lastModified).toLocaleString()}`);
+  printResult(chalk2.bold("\nSecurity:"));
+  printResult(`  Encrypted:     ${vault.isEncrypted ? chalk2.green("Yes") : chalk2.gray("No")}`);
+  printResult(`  Backed Up:     ${vault.isBackedUp ? chalk2.green("Yes") : chalk2.yellow("No")}`);
+  printResult(chalk2.bold("\nMPC Configuration:"));
+  printResult(`  Library Type:  ${vault.libType}`);
+  printResult(`  Threshold:     ${chalk2.cyan(vault.threshold)} of ${chalk2.cyan(vault.totalSigners)}`);
+  printResult(`  Local Party:   ${vault.localPartyId}`);
+  printResult(`  Total Signers: ${vault.totalSigners}`);
+  const modes = vault.availableSigningModes;
+  printResult(chalk2.bold("\nSigning Modes:"));
+  modes.forEach((mode) => {
+    printResult(`  - ${mode}`);
+  });
+  const chains = vault.chains;
+  printResult(chalk2.bold("\nChains:"));
+  printResult(`  Total: ${chains.length}`);
+  chains.forEach((chain) => {
+    printResult(`  - ${chain}`);
+  });
+  printResult(chalk2.bold("\nPreferences:"));
+  printResult(`  Currency:      ${vault.currency.toUpperCase()}`);
+  printResult(chalk2.bold("\nPublic Keys:"));
+  printResult(`  ECDSA:         ${vault.publicKeys.ecdsa.substring(0, 20)}...`);
+  printResult(`  EdDSA:         ${vault.publicKeys.eddsa.substring(0, 20)}...`);
+  printResult(`  Chain Code:    ${vault.hexChainCode.substring(0, 20)}...
+`);
+}
+function displayTransactionPreview(fromAddress, toAddress, amount, symbol, chain, memo, gas) {
+  if (gas) {
+    const bigIntReplacer2 = (_k, v) => typeof v === "bigint" ? v.toString() : v;
+    info(chalk2.blue(`
+Estimated gas: ${JSON.stringify(gas, bigIntReplacer2, 2)}`));
+  }
+  printResult(chalk2.cyan("\nTransaction Preview:"));
+  printResult(`  From:   ${fromAddress}`);
+  printResult(`  To:     ${toAddress}`);
+  printResult(`  Amount: ${amount} ${symbol}`);
+  printResult(`  Chain:  ${chain}`);
+  if (memo) {
+    printResult(`  Memo:   ${memo}`);
+  }
+}
+function displayTransactionResult(chain, txHash) {
+  const explorerUrl = Vultisig.getTxExplorerUrl(chain, txHash);
+  printResult(txHash);
+  printResult(explorerUrl);
+}
+function displayVaultsList(vaults, activeVault) {
+  printResult(chalk2.cyan("\nStored Vaults:\n"));
+  const table = vaults.map((vault) => ({
+    ID: vault.id,
+    Name: vault.name === activeVault?.name ? chalk2.green(`${vault.name} (active)`) : vault.name,
+    Type: vault.type,
+    Chains: vault.chains.length,
+    Created: new Date(vault.createdAt).toLocaleDateString()
+  }));
+  printTable(table);
+}
+async function confirmTransaction() {
+  const { confirmed } = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: "Proceed with this transaction?",
+      default: false
+    }
+  ]);
+  return confirmed;
+}
+function setupVaultEvents(vault) {
+  vault.on("balanceUpdated", ({ chain, balance, tokenId }) => {
+    const asset = tokenId ? `${balance.symbol} token` : balance.symbol;
+    info(chalk2.blue(`i Balance updated for ${chain} (${asset}): ${balance.amount}`));
+  });
+  vault.on("transactionBroadcast", ({ chain, txHash }) => {
+    info(chalk2.green(`+ Transaction broadcast on ${chain}`));
+    info(chalk2.blue(`  TX Hash: ${txHash}`));
+  });
+  vault.on("chainAdded", ({ chain }) => {
+    info(chalk2.green(`+ Chain added: ${chain}`));
+  });
+  vault.on("chainRemoved", ({ chain }) => {
+    warn(chalk2.yellow(`i Chain removed: ${chain}`));
+  });
+  vault.on("tokenAdded", ({ chain, token }) => {
+    info(chalk2.green(`+ Token added: ${token.symbol} on ${chain}`));
+  });
+  vault.on("valuesUpdated", ({ chain }) => {
+    if (chain === "all") {
+      info(chalk2.blue("i Portfolio values updated"));
+    } else {
+      info(chalk2.blue(`i Values updated for ${chain}`));
+    }
+  });
+  if (!isJsonOutput()) {
+    vault.on("error", (err) => {
+      printError(chalk2.red(`x Vault error: ${err.message}`));
+    });
+  }
+}
+function formatBigintAmount(amount, decimals) {
+  if (amount === 0n) return "0";
+  const divisor = BigInt(10 ** decimals);
+  const whole = amount / divisor;
+  const fraction = amount % divisor;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionStr = fraction.toString().padStart(decimals, "0");
+  const trimmed = fractionStr.replace(/0+$/, "");
+  return `${whole}.${trimmed}`;
+}
+function displaySwapPreview(quote, fromAmount, fromSymbol, toSymbol, options) {
+  const estimatedOutputFormatted = formatBigintAmount(quote.estimatedOutput, options.toDecimals);
+  printResult(chalk2.cyan("\nSwap Preview:"));
+  printResult(`  From:     ${fromAmount} ${fromSymbol}`);
+  printResult(`  To:       ${estimatedOutputFormatted} ${toSymbol}`);
+  if (quote.estimatedOutputFiat !== void 0) {
+    printResult(`            (~$${quote.estimatedOutputFiat.toFixed(2)})`);
+  }
+  printResult(`  Provider: ${quote.provider}`);
+  if (quote.fees) {
+    const networkFeeFormatted = formatBigintAmount(quote.fees.network, options.feeDecimals);
+    const totalFeeFormatted = formatBigintAmount(quote.fees.total, options.feeDecimals);
+    printResult(chalk2.bold("\n  Fees:"));
+    printResult(`    Network:  ${networkFeeFormatted} ${options.feeSymbol}`);
+    if (quote.feesFiat) {
+      printResult(`              (~$${quote.feesFiat.network.toFixed(2)})`);
+    }
+    if (quote.fees.affiliate && quote.fees.affiliate > 0n) {
+      const affiliateFeeFormatted = formatBigintAmount(quote.fees.affiliate, options.feeDecimals);
+      printResult(`    Affiliate: ${affiliateFeeFormatted} ${options.feeSymbol}`);
+      if (quote.feesFiat?.affiliate) {
+        printResult(`               (~$${quote.feesFiat.affiliate.toFixed(2)})`);
+      }
+    }
+    printResult(`    Total:    ${totalFeeFormatted} ${options.feeSymbol}`);
+    if (quote.feesFiat) {
+      printResult(`              (~$${quote.feesFiat.total.toFixed(2)})`);
+    }
+  }
+  if (quote.warnings && quote.warnings.length > 0) {
+    printResult(chalk2.yellow("\n  Warnings:"));
+    quote.warnings.forEach((warning) => {
+      printResult(chalk2.yellow(`    - ${warning}`));
+    });
+  }
+  if (quote.requiresApproval) {
+    printResult(chalk2.yellow("\n  Token approval required before swap"));
+    if (quote.approvalInfo) {
+      printResult(`    Spender: ${quote.approvalInfo.spender}`);
+    }
+  }
+  const expiresIn = Math.max(0, Math.floor((quote.expiresAt - Date.now()) / 1e3));
+  info(chalk2.gray(`
+  Quote expires in ${expiresIn}s`));
+}
+function displaySwapResult(fromChain, _toChain, txHash, quote, toDecimals) {
+  const explorerUrl = Vultisig.getTxExplorerUrl(fromChain, txHash);
+  const estimatedOutputFormatted = formatBigintAmount(quote.estimatedOutput, toDecimals);
+  printResult(txHash);
+  printResult(explorerUrl);
+  printResult(estimatedOutputFormatted);
+}
+function displaySwapChains(chains) {
+  printResult(chalk2.cyan("\nSupported Swap Chains:\n"));
+  const table = chains.map((chain) => ({
+    Chain: chain
+  }));
+  printTable(table);
+  printResult(`
+Total: ${chains.length} chains`);
+}
+async function confirmSwap() {
+  const { confirmed } = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: "Proceed with this swap?",
+      default: false
+    }
+  ]);
+  return confirmed;
+}
+
+// src/commands/balance.ts
+async function executeBalance(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner("Loading balances...");
+  if (options.chain) {
+    const balance = await vault.balance(options.chain);
+    spinner.succeed("Balance loaded");
+    if (isJsonOutput()) {
+      outputJson({ chain: options.chain, balance });
+      return;
+    }
+    displayBalance(options.chain, balance);
+  } else {
+    const balances = await vault.balances(void 0, options.includeTokens);
+    spinner.succeed("Balances loaded");
+    if (isJsonOutput()) {
+      outputJson({ balances });
+      return;
+    }
+    displayBalancesTable(balances);
+  }
+}
+async function executePortfolio(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  const currency = options.currency || "usd";
+  if (!fiatCurrencies.includes(currency)) {
+    error(`x Invalid currency: ${currency}`);
+    warn(`Supported currencies: ${fiatCurrencies.join(", ")}`);
+    throw new Error("Invalid currency");
+  }
+  if (vault.currency !== currency) {
+    await vault.setCurrency(currency);
+  }
+  const currencyName = fiatCurrencyNameRecord2[currency];
+  const spinner = createSpinner(`Loading portfolio in ${currencyName}...`);
+  const totalValue = await vault.getTotalValue(currency);
+  const chains = vault.chains;
+  const chainBalances = await Promise.all(
+    chains.map(async (chain) => {
+      const balance = await vault.balance(chain);
+      try {
+        const value = await vault.getValue(chain, void 0, currency);
+        return { chain, balance, value };
+      } catch {
+        return { chain, balance };
+      }
+    })
+  );
+  const portfolio = { totalValue, chainBalances };
+  spinner.succeed("Portfolio loaded");
+  if (isJsonOutput()) {
+    outputJson({ portfolio, currency });
+    return;
+  }
+  displayPortfolio(portfolio, currency);
+}
+
+// src/commands/chains.ts
+import chalk3 from "chalk";
+async function executeChains(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  if (options.add) {
+    await vault.addChain(options.add);
+    success(`
++ Added chain: ${options.add}`);
+    const address = await vault.address(options.add);
+    info(`Address: ${address}`);
+  } else if (options.remove) {
+    await vault.removeChain(options.remove);
+    success(`
++ Removed chain: ${options.remove}`);
+  } else {
+    const chains = vault.chains;
+    if (isJsonOutput()) {
+      outputJson({ chains: [...chains] });
+      return;
+    }
+    printResult(chalk3.cyan("\nActive Chains:\n"));
+    chains.forEach((chain) => {
+      printResult(`  - ${chain}`);
+    });
+    info(chalk3.gray("\nUse --add <chain> to add a chain or --remove <chain> to remove one"));
+  }
+}
+async function executeAddresses(ctx2) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner("Loading addresses...");
+  const addresses = await vault.addresses();
+  spinner.succeed("Addresses loaded");
+  if (isJsonOutput()) {
+    outputJson({ addresses });
+    return;
+  }
+  displayAddresses(addresses);
+}
+
+// src/commands/tokens.ts
+import chalk4 from "chalk";
+import inquirer3 from "inquirer";
+async function executeTokens(ctx2, options) {
+  await ctx2.ensureActiveVault();
+  if (options.add) {
+    let symbol = options.symbol;
+    let name = options.name;
+    let decimals = options.decimals;
+    const prompts = [];
+    if (!symbol) {
+      prompts.push({
+        type: "input",
+        name: "symbol",
+        message: "Enter token symbol (e.g., USDT):",
+        validate: (input) => input.trim() !== "" || "Symbol is required"
+      });
+    }
+    if (!name) {
+      prompts.push({
+        type: "input",
+        name: "name",
+        message: "Enter token name (e.g., Tether USD):",
+        validate: (input) => input.trim() !== "" || "Name is required"
+      });
+    }
+    if (decimals === void 0) {
+      prompts.push({
+        type: "number",
+        name: "decimals",
+        message: "Enter token decimals:",
+        default: 18,
+        validate: (input) => input >= 0 || "Decimals must be non-negative"
+      });
+    }
+    if (prompts.length > 0) {
+      const answers = await inquirer3.prompt(prompts);
+      symbol = symbol || answers.symbol?.trim();
+      name = name || answers.name?.trim();
+      decimals = decimals ?? answers.decimals;
+    }
+    await addToken(ctx2, {
+      chain: options.chain,
+      contractAddress: options.add,
+      symbol,
+      name,
+      decimals
+    });
+  } else if (options.remove) {
+    await removeToken(ctx2, options.chain, options.remove);
+  } else {
+    await listTokens(ctx2, options.chain);
+  }
+}
+async function addToken(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  await vault.addToken(options.chain, {
+    id: `${options.chain}-${options.contractAddress}`,
+    contractAddress: options.contractAddress,
+    symbol: options.symbol,
+    name: options.name,
+    decimals: options.decimals,
+    chainId: options.chain,
+    isNative: false
+  });
+  success(`
++ Added token ${options.symbol} on ${options.chain}`);
+}
+async function removeToken(ctx2, chain, tokenId) {
+  const vault = await ctx2.ensureActiveVault();
+  await vault.removeToken(chain, tokenId);
+  success(`
++ Removed token ${tokenId} from ${chain}`);
+}
+async function listTokens(ctx2, chain) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner(`Loading tokens for ${chain}...`);
+  const tokens = vault.getTokens(chain);
+  spinner.succeed(`Tokens loaded for ${chain}`);
+  if (isJsonOutput()) {
+    outputJson({ chain, tokens: tokens || [] });
+    return;
+  }
+  if (!tokens || tokens.length === 0) {
+    warn(`
+No tokens configured for ${chain}`);
+    info(chalk4.gray(`
+Use --add <contractAddress> to add a token`));
+  } else {
+    printResult(chalk4.cyan(`
+Tokens for ${chain}:
+`));
+    const table = tokens.map((token) => ({
+      Symbol: token.symbol,
+      Name: token.name,
+      Contract: token.contractAddress || "N/A",
+      Decimals: token.decimals,
+      Native: token.isNative ? "Yes" : "No"
+    }));
+    printTable(table);
+    info(chalk4.gray(`
+Use --add <contractAddress> to add or --remove <tokenId> to remove`));
+  }
+}
+
+// src/commands/transaction.ts
+import { Chain, Vultisig as Vultisig2 } from "@vultisig/sdk";
+async function executeSend(ctx2, params) {
+  const vault = await ctx2.ensureActiveVault();
+  if (!Object.values(Chain).includes(params.chain)) {
+    throw new Error(`Invalid chain: ${params.chain}`);
+  }
+  if (isNaN(parseFloat(params.amount)) || parseFloat(params.amount) <= 0) {
+    throw new Error("Invalid amount");
+  }
+  return sendTransaction(vault, params);
+}
+async function sendTransaction(vault, params) {
+  const prepareSpinner = createSpinner("Preparing transaction...");
+  const address = await vault.address(params.chain);
+  const balance = await vault.balance(params.chain, params.tokenId);
+  const coin = {
+    chain: params.chain,
+    address,
+    decimals: balance.decimals,
+    ticker: balance.symbol,
+    id: params.tokenId
+  };
+  const amount = BigInt(Math.floor(parseFloat(params.amount) * Math.pow(10, balance.decimals)));
+  const payload = await vault.prepareSendTx({
+    coin,
+    receiver: params.to,
+    amount,
+    memo: params.memo
+  });
+  prepareSpinner.succeed("Transaction prepared");
+  let gas;
+  try {
+    gas = await vault.gas(params.chain);
+  } catch {
+    warn("\nGas estimation unavailable");
+  }
+  if (!isJsonOutput()) {
+    displayTransactionPreview(
+      payload.coin.address,
+      params.to,
+      params.amount,
+      payload.coin.ticker,
+      params.chain,
+      params.memo,
+      gas
+    );
+  }
+  if (!params.yes && !isJsonOutput()) {
+    const confirmed = await confirmTransaction();
+    if (!confirmed) {
+      warn("Transaction cancelled");
+      throw new Error("Transaction cancelled by user");
+    }
+  }
+  const signSpinner = createSpinner("Signing transaction...");
+  vault.on("signingProgress", ({ step }) => {
+    signSpinner.text = `${step.message} (${step.progress}%)`;
+  });
+  try {
+    const messageHashes = await vault.extractMessageHashes(payload);
+    const signature = await vault.sign({
+      transaction: payload,
+      chain: payload.coin.chain,
+      messageHashes
+    });
+    signSpinner.succeed("Transaction signed");
+    const broadcastSpinner = createSpinner("Broadcasting transaction...");
+    const txHash = await vault.broadcastTx({
+      chain: params.chain,
+      keysignPayload: payload,
+      signature
+    });
+    broadcastSpinner.succeed(`Transaction broadcast: ${txHash}`);
+    const result = {
+      txHash,
+      chain: params.chain,
+      explorerUrl: Vultisig2.getTxExplorerUrl(params.chain, txHash)
+    };
+    if (isJsonOutput()) {
+      outputJson(result);
+    } else {
+      displayTransactionResult(params.chain, txHash);
+    }
+    return result;
+  } finally {
+    vault.removeAllListeners("signingProgress");
+  }
+}
+
+// src/commands/vault-management.ts
+import chalk5 from "chalk";
+import { promises as fs } from "fs";
+import inquirer4 from "inquirer";
+async function executeCreate(ctx2, options = { type: "fast" }) {
+  const vaultType = options.type.toLowerCase();
+  if (vaultType !== "fast" && vaultType !== "secure") {
+    throw new Error('Invalid vault type. Must be "fast" or "secure"');
+  }
+  let name = options.name;
+  let password = options.password;
+  const prompts = [];
+  if (!name) {
+    prompts.push({
+      type: "input",
+      name: "name",
+      message: "Enter vault name:",
+      validate: (input) => input.trim() !== "" || "Name is required"
+    });
+  }
+  if (!password) {
+    prompts.push({
+      type: "password",
+      name: "password",
+      message: "Enter password:",
+      mask: "*",
+      validate: (input) => input.length >= 8 || "Password must be at least 8 characters"
+    });
+    prompts.push({
+      type: "password",
+      name: "confirmPassword",
+      message: "Confirm password:",
+      mask: "*",
+      validate: (input, ans) => input === ans.password || "Passwords do not match"
+    });
+  }
+  if (prompts.length > 0) {
+    const answers = await inquirer4.prompt(prompts);
+    name = name || answers.name;
+    password = password || answers.password;
+  }
+  if (vaultType === "fast") {
+    let email = options.email;
+    if (!email) {
+      const emailAnswer = await inquirer4.prompt([
+        {
+          type: "input",
+          name: "email",
+          message: "Enter email for verification:",
+          validate: (input) => /\S+@\S+\.\S+/.test(input) || "Invalid email format"
+        }
+      ]);
+      email = emailAnswer.email;
+    }
+    const spinner = createSpinner("Creating vault...");
+    const result = await ctx2.sdk.createFastVault({
+      name,
+      password,
+      email,
+      onProgress: (step) => {
+        spinner.text = `${step.message} (${step.progress}%)`;
+      }
+    });
+    setupVaultEvents(result.vault);
+    await ctx2.setActiveVault(result.vault);
+    spinner.succeed(`Vault created: ${name}`);
+    if (result.verificationRequired) {
+      let code = options.code;
+      if (!code) {
+        warn("\nA verification code has been sent to your email.");
+        info("Please check your inbox and enter the code.");
+        const codeAnswer = await inquirer4.prompt([
+          {
+            type: "input",
+            name: "code",
+            message: `Verification code sent to ${email}. Enter code:`,
+            validate: (input) => /^\d{4,6}$/.test(input) || "Code must be 4-6 digits"
+          }
+        ]);
+        code = codeAnswer.code;
+      }
+      const verifySpinner = createSpinner("Verifying email code...");
+      const verified = await ctx2.sdk.verifyVault(result.vaultId, code);
+      if (verified) {
+        verifySpinner.succeed("Email verified successfully!");
+      } else {
+        verifySpinner.fail("Invalid verification code");
+        error("\nx Verification failed. Please check the code and try again.");
+        warn("\nTo retry verification, use:");
+        info(`  npm run wallet verify ${result.vaultId}`);
+        warn("\nTo resend the verification email:");
+        info(`  npm run wallet verify ${result.vaultId} --resend`);
+        const err = new Error("Verification failed");
+        err.exitCode = 1;
+        throw err;
+      }
+    }
+    success("\n+ Vault created!");
+    info("\nYour vault is ready. Run the following commands:");
+    printResult(chalk5.cyan("  npm run wallet balance     ") + "- View balances");
+    printResult(chalk5.cyan("  npm run wallet addresses   ") + "- View addresses");
+    printResult(chalk5.cyan("  npm run wallet portfolio   ") + "- View portfolio value");
+    return result.vault;
+  } else {
+    let threshold = options.threshold;
+    let totalShares = options.shares;
+    const securePrompts = [];
+    if (threshold === void 0) {
+      securePrompts.push({
+        type: "number",
+        name: "threshold",
+        message: "Signing threshold (m):",
+        default: 2,
+        validate: (input) => input > 0 || "Threshold must be greater than 0"
+      });
+    }
+    if (totalShares === void 0) {
+      securePrompts.push({
+        type: "number",
+        name: "totalShares",
+        message: "Total shares (n):",
+        default: 3,
+        validate: (input, ans) => {
+          const t = threshold ?? ans.threshold;
+          return input >= t || `Total shares must be >= threshold (${t})`;
+        }
+      });
+    }
+    if (securePrompts.length > 0) {
+      const secureAnswers = await inquirer4.prompt(securePrompts);
+      threshold = threshold ?? secureAnswers.threshold;
+      totalShares = totalShares ?? secureAnswers.totalShares;
+    }
+    const spinner = createSpinner("Creating secure vault...");
+    try {
+      const result = await ctx2.sdk.createSecureVault({
+        name,
+        password,
+        devices: totalShares,
+        threshold,
+        onProgress: (step) => {
+          spinner.text = `${step.message} (${step.progress}%)`;
+        }
+      });
+      setupVaultEvents(result.vault);
+      await ctx2.setActiveVault(result.vault);
+      spinner.succeed(`Secure vault created: ${name} (${threshold}-of-${totalShares})`);
+      warn(`
+Important: Save your vault backup file (.vult) in a secure location.`);
+      warn(`This is a ${threshold}-of-${totalShares} vault. You'll need ${threshold} devices to sign transactions.`);
+      success("\n+ Vault created!");
+      return result.vault;
+    } catch (err) {
+      spinner.fail("Secure vault creation failed");
+      if (err.message?.includes("not implemented")) {
+        warn("\nSecure vault creation is not yet implemented in the SDK");
+      }
+      throw err;
+    }
+  }
+}
+async function executeImport(ctx2, file) {
+  const { password } = await inquirer4.prompt([
+    {
+      type: "password",
+      name: "password",
+      message: "Enter vault password (if encrypted):",
+      mask: "*"
+    }
+  ]);
+  const spinner = createSpinner("Importing vault...");
+  const vultContent = await fs.readFile(file, "utf-8");
+  const vault = await ctx2.sdk.importVault(vultContent, password || void 0);
+  setupVaultEvents(vault);
+  await ctx2.setActiveVault(vault);
+  spinner.succeed(`Vault imported: ${vault.name}`);
+  success("\n+ Vault imported successfully!");
+  info('\nRun "npm run wallet balance" to view balances');
+  return vault;
+}
+async function executeVerify(ctx2, vaultId, options = {}) {
+  if (options.resend) {
+    const spinner2 = createSpinner("Resending verification email...");
+    await ctx2.sdk.resendVaultVerification(vaultId);
+    spinner2.succeed("Verification email sent!");
+    info("Check your inbox for the new verification code.");
+  }
+  let code = options.code;
+  if (!code) {
+    const codeAnswer = await inquirer4.prompt([
+      {
+        type: "input",
+        name: "code",
+        message: "Enter verification code:",
+        validate: (input) => /^\d{4,6}$/.test(input) || "Code must be 4-6 digits"
+      }
+    ]);
+    code = codeAnswer.code;
+  }
+  const spinner = createSpinner("Verifying email code...");
+  const verified = await ctx2.sdk.verifyVault(vaultId, code);
+  if (verified) {
+    spinner.succeed("Vault verified successfully!");
+    return true;
+  } else {
+    spinner.fail("Invalid verification code");
+    error("\nx Verification failed. Please check the code and try again.");
+    warn("\nTip: Use --resend to get a new verification code:");
+    info(`  npm run wallet verify ${vaultId} --resend`);
+    return false;
+  }
+}
+async function executeExport(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  let encrypt = options.encrypt;
+  let password = options.password;
+  if (encrypt === void 0) {
+    const encryptAnswer = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "encrypt",
+        message: "Encrypt export with password?",
+        default: true
+      }
+    ]);
+    encrypt = encryptAnswer.encrypt;
+  }
+  if (encrypt && !password) {
+    const passwordAnswer = await inquirer4.prompt([
+      {
+        type: "password",
+        name: "password",
+        message: "Enter password:",
+        mask: "*"
+      }
+    ]);
+    password = passwordAnswer.password;
+  }
+  const spinner = createSpinner("Exporting vault...");
+  const { data: vultContent } = await vault.export(encrypt ? password : void 0);
+  const fileName = options.outputPath || `${vault.name}-${vault.localPartyId}-vault.vult`;
+  await fs.writeFile(fileName, vultContent, "utf-8");
+  spinner.succeed(`Vault exported: ${fileName}`);
+  success("\n+ Vault exported successfully!");
+  info(`File: ${fileName}`);
+  return fileName;
+}
+async function executeVaults(ctx2) {
+  const spinner = createSpinner("Loading vaults...");
+  const vaults = await ctx2.sdk.listVaults();
+  spinner.succeed("Vaults loaded");
+  if (isJsonOutput()) {
+    const activeVault2 = ctx2.getActiveVault();
+    outputJson({
+      vaults: vaults.map((v) => ({
+        id: v.id,
+        name: v.name,
+        type: v.type,
+        chains: v.chains.length,
+        createdAt: v.createdAt,
+        isActive: activeVault2?.id === v.id
+      }))
+    });
+    return vaults;
+  }
+  if (vaults.length === 0) {
+    warn("\nNo vaults found. Create or import a vault first.");
+    return [];
+  }
+  const activeVault = ctx2.getActiveVault();
+  displayVaultsList(vaults, activeVault);
+  info(chalk5.gray('\nUse "npm run wallet switch <id>" to switch active vault'));
+  return vaults;
+}
+async function executeSwitch(ctx2, vaultId) {
+  const spinner = createSpinner("Loading vault...");
+  const vault = await ctx2.sdk.getVaultById(vaultId);
+  if (!vault) {
+    spinner.fail("Vault not found");
+    throw new Error(`No vault found with ID: ${vaultId}`);
+  }
+  await ctx2.setActiveVault(vault);
+  setupVaultEvents(vault);
+  spinner.succeed("Vault switched");
+  success(`
++ Switched to vault: ${vault.name}`);
+  info(`  Type: ${vault.type}`);
+  info(`  Chains: ${vault.chains.length}`);
+  return vault;
+}
+async function executeRename(ctx2, newName) {
+  const vault = await ctx2.ensureActiveVault();
+  const oldName = vault.name;
+  const spinner = createSpinner("Renaming vault...");
+  await vault.rename(newName);
+  spinner.succeed("Vault renamed");
+  success(`
++ Vault renamed from "${oldName}" to "${newName}"`);
+}
+async function executeInfo(ctx2) {
+  const vault = await ctx2.ensureActiveVault();
+  if (isJsonOutput()) {
+    outputJson({
+      vault: {
+        id: vault.id,
+        name: vault.name,
+        type: vault.type,
+        createdAt: vault.createdAt,
+        lastModified: vault.lastModified,
+        isEncrypted: vault.isEncrypted,
+        isBackedUp: vault.isBackedUp,
+        libType: vault.libType,
+        threshold: vault.threshold,
+        totalSigners: vault.totalSigners,
+        localPartyId: vault.localPartyId,
+        availableSigningModes: [...vault.availableSigningModes],
+        chains: [...vault.chains],
+        currency: vault.currency,
+        publicKeys: {
+          ecdsa: vault.publicKeys.ecdsa,
+          eddsa: vault.publicKeys.eddsa,
+          chainCode: vault.hexChainCode
+        }
+      }
+    });
+    return;
+  }
+  displayVaultInfo(vault);
+}
+
+// src/commands/swap.ts
+async function executeSwapChains(ctx2) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner("Loading supported swap chains...");
+  const chains = await vault.getSupportedSwapChains();
+  spinner.succeed("Swap chains loaded");
+  if (isJsonOutput()) {
+    outputJson({ swapChains: [...chains] });
+    return chains;
+  }
+  displaySwapChains(chains);
+  return chains;
+}
+async function executeSwapQuote(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  if (isNaN(options.amount) || options.amount <= 0) {
+    throw new Error("Invalid amount");
+  }
+  const isSupported = await vault.isSwapSupported(options.fromChain, options.toChain);
+  if (!isSupported) {
+    throw new Error(`Swaps from ${options.fromChain} to ${options.toChain} are not supported`);
+  }
+  const spinner = createSpinner("Getting swap quote...");
+  const quote = await vault.getSwapQuote({
+    fromCoin: { chain: options.fromChain, token: options.fromToken },
+    toCoin: { chain: options.toChain, token: options.toToken },
+    amount: options.amount,
+    fiatCurrency: "usd"
+    // Request fiat conversion
+  });
+  spinner.succeed("Quote received");
+  if (isJsonOutput()) {
+    outputJson({
+      fromChain: options.fromChain,
+      toChain: options.toChain,
+      amount: options.amount,
+      quote
+    });
+    return quote;
+  }
+  const feeBalance = await vault.balance(options.fromChain);
+  displaySwapPreview(quote, String(options.amount), quote.fromCoin.ticker, quote.toCoin.ticker, {
+    fromDecimals: quote.fromCoin.decimals,
+    toDecimals: quote.toCoin.decimals,
+    feeDecimals: feeBalance.decimals,
+    feeSymbol: feeBalance.symbol
+  });
+  info('\nTo execute this swap, use the "swap" command');
+  return quote;
+}
+async function executeSwap(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  if (isNaN(options.amount) || options.amount <= 0) {
+    throw new Error("Invalid amount");
+  }
+  const isSupported = await vault.isSwapSupported(options.fromChain, options.toChain);
+  if (!isSupported) {
+    throw new Error(`Swaps from ${options.fromChain} to ${options.toChain} are not supported`);
+  }
+  const quoteSpinner = createSpinner("Getting swap quote...");
+  const quote = await vault.getSwapQuote({
+    fromCoin: { chain: options.fromChain, token: options.fromToken },
+    toCoin: { chain: options.toChain, token: options.toToken },
+    amount: options.amount,
+    fiatCurrency: "usd"
+    // Request fiat conversion
+  });
+  quoteSpinner.succeed("Quote received");
+  const feeBalance = await vault.balance(options.fromChain);
+  if (!isJsonOutput()) {
+    displaySwapPreview(quote, String(options.amount), quote.fromCoin.ticker, quote.toCoin.ticker, {
+      fromDecimals: quote.fromCoin.decimals,
+      toDecimals: quote.toCoin.decimals,
+      feeDecimals: feeBalance.decimals,
+      feeSymbol: feeBalance.symbol
+    });
+  }
+  if (!options.yes && !isJsonOutput()) {
+    const confirmed = await confirmSwap();
+    if (!confirmed) {
+      warn("Swap cancelled");
+      throw new Error("Swap cancelled by user");
+    }
+  }
+  const prepSpinner = createSpinner("Preparing swap transaction...");
+  const { keysignPayload, approvalPayload } = await vault.prepareSwapTx({
+    fromCoin: { chain: options.fromChain, token: options.fromToken },
+    toCoin: { chain: options.toChain, token: options.toToken },
+    amount: options.amount,
+    swapQuote: quote,
+    autoApprove: false
+  });
+  prepSpinner.succeed("Swap prepared");
+  if (approvalPayload) {
+    info("\nToken approval required before swap...");
+    const approvalSpinner = createSpinner("Signing approval transaction...");
+    vault.on("signingProgress", ({ step }) => {
+      approvalSpinner.text = `Approval: ${step.message} (${step.progress}%)`;
+    });
+    try {
+      const approvalHashes = await vault.extractMessageHashes(approvalPayload);
+      const approvalSig = await vault.sign({
+        transaction: approvalPayload,
+        chain: options.fromChain,
+        messageHashes: approvalHashes
+      });
+      approvalSpinner.succeed("Approval signed");
+      const broadcastApprovalSpinner = createSpinner("Broadcasting approval...");
+      const approvalTxHash = await vault.broadcastTx({
+        chain: options.fromChain,
+        keysignPayload: approvalPayload,
+        signature: approvalSig
+      });
+      broadcastApprovalSpinner.succeed(`Approval broadcast: ${approvalTxHash}`);
+      info("Waiting for approval to confirm...");
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+    } finally {
+      vault.removeAllListeners("signingProgress");
+    }
+  }
+  const signSpinner = createSpinner("Signing swap transaction...");
+  vault.on("signingProgress", ({ step }) => {
+    signSpinner.text = `${step.message} (${step.progress}%)`;
+  });
+  try {
+    const messageHashes = await vault.extractMessageHashes(keysignPayload);
+    const signature = await vault.sign({
+      transaction: keysignPayload,
+      chain: options.fromChain,
+      messageHashes
+    });
+    signSpinner.succeed("Swap transaction signed");
+    const broadcastSpinner = createSpinner("Broadcasting swap transaction...");
+    const txHash = await vault.broadcastTx({
+      chain: options.fromChain,
+      keysignPayload,
+      signature
+    });
+    broadcastSpinner.succeed(`Swap broadcast: ${txHash}`);
+    if (isJsonOutput()) {
+      outputJson({
+        txHash,
+        fromChain: options.fromChain,
+        toChain: options.toChain,
+        quote
+      });
+    } else {
+      displaySwapResult(options.fromChain, options.toChain, txHash, quote, quote.toCoin.decimals);
+    }
+    return { txHash, quote };
+  } finally {
+    vault.removeAllListeners("signingProgress");
+  }
+}
+
+// src/commands/settings.ts
+import { Chain as Chain2, 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) {
+    const currentCurrency = vault.currency;
+    const currencyName2 = fiatCurrencyNameRecord3[currentCurrency];
+    printResult(chalk6.cyan("\nCurrent Currency Preference:"));
+    printResult(`  ${chalk6.green(currentCurrency.toUpperCase())} - ${currencyName2}`);
+    info(chalk6.gray(`
+Supported currencies: ${fiatCurrencies2.join(", ")}`));
+    info(chalk6.gray('Use "npm run wallet currency <code>" to change'));
+    return currentCurrency;
+  }
+  const currency = newCurrency.toLowerCase();
+  if (!fiatCurrencies2.includes(currency)) {
+    error(`x Invalid currency: ${newCurrency}`);
+    warn(`Supported currencies: ${fiatCurrencies2.join(", ")}`);
+    throw new Error("Invalid currency");
+  }
+  const spinner = createSpinner("Updating currency preference...");
+  await vault.setCurrency(currency);
+  spinner.succeed("Currency updated");
+  const currencyName = fiatCurrencyNameRecord3[currency];
+  success(`
++ Currency preference set to ${currency.toUpperCase()} (${currencyName})`);
+  return currency;
+}
+async function executeServer(ctx2) {
+  const spinner = createSpinner("Checking server status...");
+  try {
+    const status = await ctx2.sdk.getServerStatus();
+    spinner.succeed("Server status retrieved");
+    if (isJsonOutput()) {
+      outputJson({ server: status });
+      return status;
+    }
+    printResult(chalk6.cyan("\nServer Status:\n"));
+    printResult(chalk6.bold("Fast Vault Server:"));
+    printResult(`  Online:   ${status.fastVault.online ? chalk6.green("Yes") : chalk6.red("No")}`);
+    if (status.fastVault.latency) {
+      printResult(`  Latency:  ${status.fastVault.latency}ms`);
+    }
+    printResult(chalk6.bold("\nMessage Relay:"));
+    printResult(`  Online:   ${status.messageRelay.online ? chalk6.green("Yes") : chalk6.red("No")}`);
+    if (status.messageRelay.latency) {
+      printResult(`  Latency:  ${status.messageRelay.latency}ms`);
+    }
+    return status;
+  } catch (err) {
+    spinner.fail("Failed to check server status");
+    error(`
+x ${err.message}`);
+    throw err;
+  }
+}
+async function executeAddressBook(ctx2, options = {}) {
+  if (options.add) {
+    let chain = options.chain;
+    let address = options.address;
+    let name = options.name;
+    const prompts = [];
+    if (!chain) {
+      prompts.push({
+        type: "list",
+        name: "chain",
+        message: "Select chain:",
+        choices: Object.values(Chain2)
+      });
+    }
+    if (!address) {
+      prompts.push({
+        type: "input",
+        name: "address",
+        message: "Enter address:",
+        validate: (input) => input.trim() !== "" || "Address is required"
+      });
+    }
+    if (!name) {
+      prompts.push({
+        type: "input",
+        name: "name",
+        message: "Enter name/label:",
+        validate: (input) => input.trim() !== "" || "Name is required"
+      });
+    }
+    if (prompts.length > 0) {
+      const answers = await inquirer5.prompt(prompts);
+      chain = chain || answers.chain;
+      address = address || answers.address?.trim();
+      name = name || answers.name?.trim();
+    }
+    const spinner2 = createSpinner("Adding address to address book...");
+    await ctx2.sdk.addAddressBookEntry([
+      {
+        chain,
+        address,
+        name,
+        source: "saved",
+        dateAdded: Date.now()
+      }
+    ]);
+    spinner2.succeed("Address added");
+    success(`
++ Added ${name} (${chain}: ${address})`);
+    return [];
+  }
+  if (options.remove) {
+    const spinner2 = createSpinner("Removing address from address book...");
+    await ctx2.sdk.removeAddressBookEntry([{ address: options.remove, chain: options.chain }]);
+    spinner2.succeed("Address removed");
+    success(`
++ Removed ${options.remove}`);
+    return [];
+  }
+  const spinner = createSpinner("Loading address book...");
+  const addressBook = await ctx2.sdk.getAddressBook(options.chain);
+  spinner.succeed("Address book loaded");
+  const allEntries = [...addressBook.saved, ...addressBook.vaults];
+  if (isJsonOutput()) {
+    outputJson({ addressBook: allEntries, chain: options.chain });
+    return allEntries;
+  }
+  if (allEntries.length === 0) {
+    warn(`
+No addresses in address book${options.chain ? ` for ${options.chain}` : ""}`);
+    info(chalk6.gray("\nUse --add to add an address to the address book"));
+  } else {
+    printResult(chalk6.cyan(`
+Address Book${options.chain ? ` (${options.chain})` : ""}:
+`));
+    const table = allEntries.map((entry) => ({
+      Name: entry.name,
+      Chain: entry.chain,
+      Address: entry.address,
+      Source: entry.source
+    }));
+    printTable(table);
+    info(chalk6.gray("\nUse --add to add or --remove <address> to remove an address"));
+  }
+  return allEntries;
+}
+
+// src/interactive/completer.ts
+import { Chain as Chain3 } from "@vultisig/sdk";
+import fs2 from "fs";
+import path from "path";
+var COMMANDS = [
+  // Vault management
+  "vaults",
+  "vault",
+  "import",
+  "create",
+  "info",
+  "export",
+  // Wallet operations
+  "balance",
+  "bal",
+  "send",
+  "portfolio",
+  "addresses",
+  "chains",
+  "tokens",
+  // Swap operations
+  "swap-chains",
+  "swap-quote",
+  "swap",
+  // Session commands (shell-only)
+  "lock",
+  "unlock",
+  "status",
+  // Settings
+  "currency",
+  "server",
+  "address-book",
+  // Help
+  "help",
+  "?",
+  // REPL commands
+  ".help",
+  ".clear",
+  ".exit"
+];
+function createCompleter(ctx2) {
+  return function completer(line) {
+    try {
+      const parts = line.split(/\s+/);
+      const command = parts[0]?.toLowerCase();
+      if ((command === "import" || command === "export") && parts.length > 1) {
+        const partial = parts.slice(1).join(" ");
+        return completeFilePath(partial, command === "import");
+      }
+      if (command === "vault" && parts.length > 1) {
+        const partial = parts.slice(1).join(" ");
+        return completeVaultName(ctx2, partial);
+      }
+      if (command === "chains" && parts.length >= 2) {
+        const flag = parts[parts.length - 2]?.toLowerCase();
+        if (flag === "--add" || flag === "--remove") {
+          const partial = parts[parts.length - 1] || "";
+          return completeChainName(partial);
+        }
+        if (parts[parts.length - 1]?.toLowerCase() === "--add" || parts[parts.length - 1]?.toLowerCase() === "--remove") {
+          return completeChainName("");
+        }
+      }
+      if (["balance", "bal", "tokens", "send", "swap", "swap-quote"].includes(command) && parts.length === 2) {
+        const partial = parts[1] || "";
+        return completeChainName(partial);
+      }
+      const hits = COMMANDS.filter((c) => c.startsWith(line));
+      const show = hits.length ? hits : COMMANDS;
+      return [show, line];
+    } catch {
+      return [[], line];
+    }
+  };
+}
+function completeFilePath(partial, filterVult) {
+  try {
+    const endsWithSeparator = partial.endsWith("/") || partial.endsWith(path.sep);
+    let dir;
+    let basename;
+    if (endsWithSeparator) {
+      dir = partial;
+      basename = "";
+    } else {
+      dir = path.dirname(partial);
+      basename = path.basename(partial);
+      if (fs2.existsSync(partial) && fs2.statSync(partial).isDirectory()) {
+        dir = partial;
+        basename = "";
+      }
+    }
+    const resolvedDir = path.resolve(dir);
+    if (!fs2.existsSync(resolvedDir) || !fs2.statSync(resolvedDir).isDirectory()) {
+      return [[], partial];
+    }
+    const files = fs2.readdirSync(resolvedDir);
+    const matches = files.filter((file) => file.startsWith(basename)).map((file) => {
+      const fullPath = path.join(dir, file);
+      const stats = fs2.statSync(path.join(resolvedDir, file));
+      if (stats.isDirectory()) {
+        return fullPath + "/";
+      }
+      if (filterVult) {
+        if (file.endsWith(".vult") || stats.isDirectory()) {
+          return fullPath;
+        }
+        return null;
+      }
+      return fullPath;
+    }).filter((item) => item !== null);
+    return [matches, partial];
+  } catch {
+    return [[], partial];
+  }
+}
+function completeVaultName(ctx2, partial) {
+  const vaultNames = Array.from(ctx2.getVaults().values()).map((vault) => vault.name);
+  const partialLower = partial.toLowerCase();
+  const matches = vaultNames.filter((name) => name.toLowerCase().startsWith(partialLower));
+  matches.sort();
+  const show = matches.length > 0 ? matches : vaultNames.sort();
+  return [show, partial];
+}
+function completeChainName(partial) {
+  const allChains = Object.values(Chain3);
+  const partialLower = partial.toLowerCase();
+  const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
+  matches.sort();
+  const show = matches.length > 0 ? matches : allChains.sort();
+  return [show, partial];
+}
+function findChainByName(name) {
+  const allChains = Object.values(Chain3);
+  const nameLower = name.toLowerCase();
+  const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
+  return found ? found : null;
+}
+
+// src/interactive/event-buffer.ts
+import chalk7 from "chalk";
+var EventBuffer = class {
+  eventBuffer = [];
+  isCommandRunning = false;
+  /**
+   * Mark the start of a command execution.
+   * Events will be buffered until endCommand() is called.
+   */
+  startCommand() {
+    this.isCommandRunning = true;
+    this.eventBuffer = [];
+  }
+  /**
+   * Mark the end of a command execution.
+   * Flushes any buffered events to the console.
+   */
+  endCommand() {
+    this.isCommandRunning = false;
+    this.flushBuffer();
+  }
+  /**
+   * Handle an event - buffer if command is running, display immediately if idle.
+   */
+  handleEvent(message, type = "info") {
+    if (this.isCommandRunning) {
+      this.eventBuffer.push({
+        timestamp: /* @__PURE__ */ new Date(),
+        message,
+        type
+      });
+    } else {
+      this.displayEvent(message, type);
+    }
+  }
+  /**
+   * Display a single event to the console with appropriate formatting.
+   */
+  displayEvent(message, type) {
+    switch (type) {
+      case "success":
+        console.log(chalk7.green(message));
+        break;
+      case "warning":
+        console.log(chalk7.yellow(message));
+        break;
+      case "error":
+        console.error(chalk7.red(message));
+        break;
+      case "info":
+      default:
+        console.log(chalk7.blue(message));
+        break;
+    }
+  }
+  /**
+   * Flush all buffered events to the console.
+   */
+  flushBuffer() {
+    if (this.eventBuffer.length === 0) {
+      return;
+    }
+    console.log(chalk7.gray("\n--- Background Events ---"));
+    this.eventBuffer.forEach((event) => {
+      const timeStr = event.timestamp.toLocaleTimeString();
+      const message = `[${timeStr}] ${event.message}`;
+      this.displayEvent(message, event.type);
+    });
+    console.log(chalk7.gray("--- End Events ---\n"));
+  }
+  /**
+   * Setup all vault event listeners
+   */
+  setupVaultListeners(vault) {
+    vault.on("balanceUpdated", ({ chain, balance, tokenId }) => {
+      const asset = tokenId ? `${balance.symbol} token` : balance.symbol;
+      this.handleEvent(`i Balance updated for ${chain} (${asset}): ${balance.amount}`, "info");
+    });
+    vault.on("transactionSigned", () => {
+      this.handleEvent(`+ Transaction signed successfully`, "success");
+    });
+    vault.on("transactionBroadcast", ({ chain, txHash }) => {
+      this.handleEvent(`+ Transaction broadcast on ${chain}`, "success");
+      this.handleEvent(`  TX Hash: ${txHash}`, "info");
+    });
+    vault.on("signingProgress", ({ step }) => {
+      this.handleEvent(`i Signing: ${step}`, "info");
+    });
+    vault.on("chainAdded", ({ chain }) => {
+      this.handleEvent(`+ Chain added: ${chain}`, "success");
+    });
+    vault.on("chainRemoved", ({ chain }) => {
+      this.handleEvent(`i Chain removed: ${chain}`, "warning");
+    });
+    vault.on("tokenAdded", ({ chain, token }) => {
+      this.handleEvent(`+ Token added: ${token.symbol} on ${chain}`, "success");
+    });
+    vault.on("tokenRemoved", ({ chain, tokenId }) => {
+      this.handleEvent(`i Token removed: ${tokenId} from ${chain}`, "warning");
+    });
+    vault.on("renamed", ({ oldName, newName }) => {
+      this.handleEvent(`i Vault renamed: ${oldName} -> ${newName}`, "info");
+    });
+    vault.on("valuesUpdated", ({ chain }) => {
+      if (chain === "all") {
+        this.handleEvent("i Portfolio values updated", "info");
+      } else {
+        this.handleEvent(`i Values updated for ${chain}`, "info");
+      }
+    });
+    vault.on("totalValueUpdated", ({ value }) => {
+      this.handleEvent(`i Portfolio total: ${value.formatted}`, "info");
+    });
+    vault.on("saved", () => {
+      this.handleEvent(`+ Vault saved`, "success");
+    });
+    vault.on("loaded", () => {
+      this.handleEvent(`i Vault loaded`, "info");
+    });
+    vault.on("unlocked", () => {
+      this.handleEvent(`+ Vault unlocked`, "success");
+    });
+    vault.on("locked", () => {
+      this.handleEvent(`i Vault locked`, "info");
+    });
+    vault.on("swapQuoteReceived", ({ quote }) => {
+      this.handleEvent(`i Swap quote received: ${quote.fromAmount} -> ${quote.toAmount}`, "info");
+    });
+    vault.on("swapApprovalRequired", ({ token, amount }) => {
+      this.handleEvent(`! Approval required for ${token}: ${amount}`, "warning");
+    });
+    vault.on("swapApprovalGranted", ({ token }) => {
+      this.handleEvent(`+ Approval granted for ${token}`, "success");
+    });
+    vault.on("swapPrepared", ({ provider, fromAmount, toAmountExpected }) => {
+      this.handleEvent(`i Swap prepared via ${provider}: ${fromAmount} -> ${toAmountExpected}`, "info");
+    });
+    vault.on("error", (error2) => {
+      this.handleEvent(`x Vault error: ${error2.message}`, "error");
+    });
+  }
+  /**
+   * Remove all event listeners from a vault.
+   */
+  cleanupVaultListeners(vault) {
+    vault.removeAllListeners("balanceUpdated");
+    vault.removeAllListeners("transactionSigned");
+    vault.removeAllListeners("transactionBroadcast");
+    vault.removeAllListeners("signingProgress");
+    vault.removeAllListeners("chainAdded");
+    vault.removeAllListeners("chainRemoved");
+    vault.removeAllListeners("tokenAdded");
+    vault.removeAllListeners("tokenRemoved");
+    vault.removeAllListeners("renamed");
+    vault.removeAllListeners("valuesUpdated");
+    vault.removeAllListeners("totalValueUpdated");
+    vault.removeAllListeners("saved");
+    vault.removeAllListeners("loaded");
+    vault.removeAllListeners("unlocked");
+    vault.removeAllListeners("locked");
+    vault.removeAllListeners("swapQuoteReceived");
+    vault.removeAllListeners("swapApprovalRequired");
+    vault.removeAllListeners("swapApprovalGranted");
+    vault.removeAllListeners("swapPrepared");
+    vault.removeAllListeners("error");
+  }
+};
+
+// src/interactive/session.ts
+import { fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
+import chalk9 from "chalk";
+import ora3 from "ora";
+import * as repl from "repl";
+
+// src/interactive/shell-commands.ts
+import chalk8 from "chalk";
+import Table from "cli-table3";
+import inquirer6 from "inquirer";
+import ora2 from "ora";
+function formatTimeRemaining(ms) {
+  if (!ms || ms <= 0) return "expired";
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes > 0) {
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  return `${remainingSeconds}s`;
+}
+async function executeLock(ctx2) {
+  const vault = ctx2.getActiveVault();
+  if (!vault) {
+    console.log(chalk8.red("No active vault."));
+    console.log(chalk8.yellow('Use "vault <name>" to switch to a vault first.'));
+    return;
+  }
+  ctx2.lockVault(vault.id);
+  console.log(chalk8.green("\n+ Vault locked"));
+  console.log(chalk8.gray("Password cache cleared. You will need to enter the password again."));
+}
+async function executeUnlock(ctx2) {
+  const vault = ctx2.getActiveVault();
+  if (!vault) {
+    console.log(chalk8.red("No active vault."));
+    console.log(chalk8.yellow('Use "vault <name>" to switch to a vault first.'));
+    return;
+  }
+  if (ctx2.isVaultUnlocked(vault.id)) {
+    const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
+    console.log(chalk8.yellow("\nVault is already unlocked."));
+    console.log(chalk8.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
+    return;
+  }
+  const { password } = await inquirer6.prompt([
+    {
+      type: "password",
+      name: "password",
+      message: "Enter vault password:",
+      mask: "*"
+    }
+  ]);
+  const spinner = ora2("Unlocking vault...").start();
+  try {
+    await vault.unlock(password);
+    ctx2.cachePassword(vault.id, password);
+    const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
+    spinner.succeed("Vault unlocked");
+    console.log(chalk8.green(`
++ Vault unlocked for ${formatTimeRemaining(timeRemaining)}`));
+  } catch (err) {
+    spinner.fail("Failed to unlock vault");
+    console.error(chalk8.red(`
+x ${err.message}`));
+  }
+}
+async function executeStatus(ctx2) {
+  const vault = ctx2.getActiveVault();
+  if (!vault) {
+    console.log(chalk8.red("No active vault."));
+    console.log(chalk8.yellow('Use "vault <name>" to switch to a vault first.'));
+    return;
+  }
+  const isUnlocked = ctx2.isVaultUnlocked(vault.id);
+  let timeRemaining;
+  let timeRemainingFormatted;
+  if (isUnlocked) {
+    timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
+    timeRemainingFormatted = formatTimeRemaining(timeRemaining);
+  }
+  const status = {
+    name: vault.name,
+    id: vault.id,
+    type: vault.type,
+    isUnlocked,
+    timeRemaining,
+    timeRemainingFormatted,
+    createdAt: vault.createdAt,
+    lastModified: vault.lastModified,
+    threshold: vault.threshold,
+    totalSigners: vault.totalSigners,
+    libType: vault.libType,
+    isEncrypted: vault.isEncrypted,
+    isBackedUp: vault.isBackedUp,
+    chains: vault.chains.length,
+    currency: vault.currency,
+    availableSigningModes: vault.availableSigningModes
+  };
+  displayStatus(status);
+}
+function displayStatus(status) {
+  console.log(chalk8.cyan("\n+----------------------------------------+"));
+  console.log(chalk8.cyan("|            Vault Status                |"));
+  console.log(chalk8.cyan("+----------------------------------------+\n"));
+  console.log(chalk8.bold("Vault:"));
+  console.log(`  Name:     ${chalk8.green(status.name)}`);
+  console.log(`  ID:       ${status.id}`);
+  console.log(`  Type:     ${chalk8.yellow(status.type)}`);
+  console.log(chalk8.bold("\nSecurity:"));
+  if (status.isUnlocked) {
+    console.log(`  Status:   ${chalk8.green("Unlocked")} ${chalk8.green("\u{1F513}")}`);
+    console.log(`  Expires:  ${status.timeRemainingFormatted}`);
+  } else {
+    console.log(`  Status:   ${chalk8.yellow("Locked")} ${chalk8.yellow("\u{1F512}")}`);
+  }
+  console.log(`  Encrypted: ${status.isEncrypted ? chalk8.green("Yes") : chalk8.gray("No")}`);
+  console.log(`  Backed Up: ${status.isBackedUp ? chalk8.green("Yes") : chalk8.yellow("No")}`);
+  console.log(chalk8.bold("\nMPC Configuration:"));
+  console.log(`  Library:   ${status.libType}`);
+  console.log(`  Threshold: ${chalk8.cyan(status.threshold)} of ${chalk8.cyan(status.totalSigners)}`);
+  console.log(chalk8.bold("\nSigning Modes:"));
+  status.availableSigningModes.forEach((mode) => {
+    console.log(`  - ${mode}`);
+  });
+  console.log(chalk8.bold("\nDetails:"));
+  console.log(`  Chains:   ${status.chains}`);
+  console.log(`  Currency: ${status.currency.toUpperCase()}`);
+  console.log(`  Created:  ${new Date(status.createdAt).toLocaleString()}`);
+  console.log(`  Modified: ${new Date(status.lastModified).toLocaleString()}
+`);
+}
+function showHelp() {
+  const table = new Table({
+    head: [chalk8.bold("Available Commands")],
+    colWidths: [50],
+    chars: {
+      mid: "",
+      "left-mid": "",
+      "mid-mid": "",
+      "right-mid": ""
+    },
+    style: {
+      head: ["cyan"],
+      border: ["cyan"]
+    }
+  });
+  table.push(
+    [chalk8.bold("Vault Management:")],
+    ["  vaults              - List all vaults"],
+    ["  vault <name>        - Switch to vault"],
+    ["  import <file>       - Import vault from file"],
+    ["  create              - Create new vault"],
+    ["  info                - Show vault details"],
+    ["  export [path]       - Export vault to file"],
+    [""],
+    [chalk8.bold("Wallet Operations:")],
+    ["  balance [chain]     - Show balances"],
+    ["  send <chain> <to> <amount> - Send transaction"],
+    ["  portfolio [-c usd]  - Show portfolio value"],
+    ["  addresses           - Show all addresses"],
+    ["  chains [--add/--remove] - Manage chains"],
+    ["  tokens <chain>      - Manage tokens"],
+    [""],
+    [chalk8.bold("Swap Operations:")],
+    ["  swap-chains         - List swap-enabled chains"],
+    ["  swap-quote <from> <to> <amount> - Get quote"],
+    ["  swap <from> <to> <amount> - Execute swap"],
+    [""],
+    [chalk8.bold("Session Commands (shell only):")],
+    ["  lock                - Lock vault"],
+    ["  unlock              - Unlock vault"],
+    ["  status              - Show vault status"],
+    [""],
+    [chalk8.bold("Settings:")],
+    ["  currency [code]     - View/set currency"],
+    ["  server              - Check server status"],
+    ["  address-book        - Manage saved addresses"],
+    [""],
+    [chalk8.bold("Help & Navigation:")],
+    ["  help, ?             - Show this help"],
+    ["  .clear              - Clear screen"],
+    ["  .exit               - Exit shell"]
+  );
+  console.log("\n" + table.toString() + "\n");
+}
+
+// src/interactive/shell-context.ts
+import inquirer7 from "inquirer";
+var ShellContext = class extends BaseCommandContext {
+  vaults = /* @__PURE__ */ new Map();
+  constructor(sdk, options) {
+    super(sdk, options);
+  }
+  get isInteractive() {
+    return true;
+  }
+  /**
+   * Get all loaded vaults
+   */
+  getVaults() {
+    return this.vaults;
+  }
+  /**
+   * Add a vault to the context
+   */
+  addVault(vault) {
+    this.vaults.set(vault.id, vault);
+  }
+  /**
+   * Get vault by ID
+   */
+  getVaultById(id) {
+    return this.vaults.get(id);
+  }
+  /**
+   * Find vault by name (case-insensitive)
+   */
+  findVaultByName(name) {
+    const nameLower = name.toLowerCase();
+    for (const vault of this.vaults.values()) {
+      if (vault.name.toLowerCase() === nameLower) {
+        return vault;
+      }
+    }
     return null;
+  }
+  /**
+   * Get password for a vault
+   * In Shell mode, we check cache first, then env, then prompt
+   * Passwords are cached for the session
+   */
+  async getPassword(vaultId, vaultName) {
+    const cached = this.getCachedPassword(vaultId);
+    if (cached) {
+      return cached;
+    }
+    const envPassword = getPasswordFromEnv(vaultId, vaultName);
+    if (envPassword) {
+      this.cachePassword(vaultId, envPassword);
+      return envPassword;
+    }
+    const displayName = vaultName || vaultId;
+    const { password } = await inquirer7.prompt([
+      {
+        type: "password",
+        name: "password",
+        message: `Enter password for vault "${displayName}":`,
+        mask: "*"
+      }
+    ]);
+    this.cachePassword(vaultId, password);
+    return password;
+  }
+  /**
+   * Lock a vault (clear its cached password)
+   */
+  lockVault(vaultId) {
+    this.clearPasswordCache(vaultId);
+    const vault = this.vaults.get(vaultId);
+    if (vault) {
+      vault.lock();
+    }
+  }
+  /**
+   * Get unlock time remaining for a vault
+   */
+  getUnlockTimeRemaining(vaultId) {
+    const entry = this.passwordCache.get(vaultId);
+    if (!entry) return void 0;
+    const remaining = entry.expiresAt - Date.now();
+    return remaining > 0 ? remaining : void 0;
+  }
+  /**
+   * Check if a vault is unlocked (has cached password)
+   */
+  isVaultUnlocked(vaultId) {
+    return this.isPasswordCached(vaultId);
+  }
+};
+function createShellContext(sdk, options) {
+  return new ShellContext(sdk, {
+    passwordTtlMs: options?.passwordTtlMs ?? DEFAULT_PASSWORD_CACHE_TTL
+  });
 }
-async function init(vaultOverride) {
-    if (!ctx) {
-        const sdk = new Vultisig({
-            onPasswordRequired: createPasswordCallback(),
+
+// src/interactive/session.ts
+function createReplSafeSpinner(text) {
+  return ora3({
+    text,
+    hideCursor: false,
+    stream: process.stdout,
+    isEnabled: true,
+    isSilent: false
+  });
+}
+var ShellSession = class {
+  ctx;
+  eventBuffer;
+  replServer;
+  constructor(sdk, options) {
+    this.ctx = createShellContext(sdk, options);
+    this.eventBuffer = new EventBuffer();
+  }
+  /**
+   * Start the interactive shell
+   */
+  async start() {
+    console.clear();
+    console.log(chalk9.cyan.bold("\n=============================================="));
+    console.log(chalk9.cyan.bold("         Vultisig Interactive Shell"));
+    console.log(chalk9.cyan.bold("==============================================\n"));
+    await this.loadAllVaults();
+    this.displayVaultList();
+    console.log(chalk9.gray('Type "help" for available commands, ".exit" to quit\n'));
+    this.replServer = repl.start({
+      prompt: this.getPrompt(),
+      eval: this.evalCommand.bind(this),
+      ignoreUndefined: true,
+      terminal: true,
+      useColors: true,
+      completer: createCompleter(this.ctx)
+    });
+    this.setupReplCommands();
+  }
+  /**
+   * Custom eval function for command processing
+   */
+  async evalCommand(cmd, _context, _filename, callback) {
+    const input = cmd.trim();
+    if (!input) {
+      callback(null);
+      return;
+    }
+    const [command, ...args] = input.split(/\s+/);
+    try {
+      this.eventBuffer.startCommand();
+      await this.executeCommand(command.toLowerCase(), args);
+      this.eventBuffer.endCommand();
+      this.replServer.setPrompt(this.getPrompt());
+      callback(null);
+      this.restoreTerminalState();
+    } catch (error2) {
+      this.eventBuffer.endCommand();
+      console.error(chalk9.red(`
+x Error: ${error2.message}`));
+      this.replServer.setPrompt(this.getPrompt());
+      callback(null);
+      this.restoreTerminalState();
+    }
+  }
+  /**
+   * Restore terminal state after commands that may have altered it.
+   * Some libraries (like ora spinners) pause stdin and disable raw mode.
+   */
+  restoreTerminalState() {
+    if (process.stdin.isPaused()) {
+      process.stdin.resume();
+    }
+    if (process.stdin.isTTY && !process.stdin.isRaw) {
+      process.stdin.setRawMode(true);
+    }
+    this.replServer.displayPrompt();
+  }
+  /**
+   * Execute a command
+   */
+  async executeCommand(command, args) {
+    switch (command) {
+      // Vault management
+      case "vaults":
+        await executeVaults(this.ctx);
+        break;
+      case "vault":
+        await this.switchVault(args);
+        break;
+      case "import":
+        await this.importVault(args);
+        break;
+      case "create":
+        await this.createVault();
+        break;
+      case "info":
+        await executeInfo(this.ctx);
+        break;
+      case "export":
+        await executeExport(this.ctx, { outputPath: args.join(" ") || void 0 });
+        break;
+      case "rename":
+        if (args.length === 0) {
+          console.log(chalk9.yellow("Usage: rename <newName>"));
+          return;
+        }
+        await executeRename(this.ctx, args.join(" "));
+        break;
+      // Balance commands
+      case "balance":
+      case "bal":
+        await this.runBalance(args);
+        break;
+      case "portfolio":
+        await this.runPortfolio(args);
+        break;
+      // Transaction
+      case "send":
+        await this.runSend(args);
+        break;
+      // Chain management
+      case "addresses":
+        await executeAddresses(this.ctx);
+        break;
+      case "chains":
+        await this.runChains(args);
+        break;
+      case "tokens":
+        await this.runTokens(args);
+        break;
+      // Swap commands
+      case "swap-chains":
+        await executeSwapChains(this.ctx);
+        break;
+      case "swap-quote":
+        await this.runSwapQuote(args);
+        break;
+      case "swap":
+        await this.runSwap(args);
+        break;
+      // Shell-only commands
+      case "lock":
+        await executeLock(this.ctx);
+        break;
+      case "unlock":
+        await executeUnlock(this.ctx);
+        break;
+      case "status":
+        await executeStatus(this.ctx);
+        break;
+      // Settings
+      case "currency":
+        await executeCurrency(this.ctx, args[0]);
+        break;
+      case "server":
+        await executeServer(this.ctx);
+        break;
+      case "address-book":
+        await this.runAddressBook(args);
+        break;
+      // Help
+      case "help":
+      case "?":
+        showHelp();
+        break;
+      default:
+        if (command && !command.startsWith(".")) {
+          console.log(chalk9.yellow(`Unknown command: ${command}`));
+          console.log(chalk9.gray('Type "help" for available commands'));
+        }
+        break;
+    }
+  }
+  // ===== Command Helpers =====
+  async switchVault(args) {
+    if (args.length === 0) {
+      console.log(chalk9.yellow("Usage: vault <name>"));
+      console.log(chalk9.gray('Run "vaults" to see available vaults'));
+      return;
+    }
+    const vaultName = args.join(" ");
+    const vault = this.ctx.findVaultByName(vaultName);
+    if (!vault) {
+      console.log(chalk9.red(`Vault not found: ${vaultName}`));
+      console.log(chalk9.gray('Run "vaults" to see available vaults'));
+      return;
+    }
+    await this.ctx.setActiveVault(vault);
+    console.log(chalk9.green(`
++ Switched to: ${vault.name}`));
+    const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
+    const status = isUnlocked ? chalk9.green("Unlocked") : chalk9.yellow("Locked");
+    console.log(`Status: ${status}`);
+  }
+  async importVault(args) {
+    if (args.length === 0) {
+      console.log(chalk9.yellow("Usage: import <file>"));
+      return;
+    }
+    const filePath = args.join(" ");
+    const vault = await executeImport(this.ctx, filePath);
+    this.ctx.addVault(vault);
+    this.eventBuffer.setupVaultListeners(vault);
+  }
+  async createVault() {
+    const vault = await executeCreate(this.ctx, { type: "fast" });
+    this.ctx.addVault(vault);
+    this.eventBuffer.setupVaultListeners(vault);
+  }
+  async runBalance(args) {
+    const chainStr = args[0];
+    const includeTokens = args.includes("-t") || args.includes("--tokens");
+    await executeBalance(this.ctx, {
+      chain: chainStr ? findChainByName(chainStr) || chainStr : void 0,
+      includeTokens
+    });
+  }
+  async runPortfolio(args) {
+    let currency = "usd";
+    for (let i = 0; i < args.length; i++) {
+      if ((args[i] === "-c" || args[i] === "--currency") && i + 1 < args.length) {
+        currency = args[i + 1].toLowerCase();
+        i++;
+      }
+    }
+    if (!fiatCurrencies3.includes(currency)) {
+      console.log(chalk9.red(`Invalid currency: ${currency}`));
+      console.log(chalk9.yellow(`Supported currencies: ${fiatCurrencies3.join(", ")}`));
+      return;
+    }
+    await executePortfolio(this.ctx, { currency });
+  }
+  async runSend(args) {
+    if (args.length < 3) {
+      console.log(chalk9.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
+      return;
+    }
+    const [chainStr, to, amount, ...rest] = args;
+    const chain = findChainByName(chainStr) || chainStr;
+    let tokenId;
+    let memo;
+    for (let i = 0; i < rest.length; i++) {
+      if (rest[i] === "--token" && i + 1 < rest.length) {
+        tokenId = rest[i + 1];
+        i++;
+      } else if (rest[i] === "--memo" && i + 1 < rest.length) {
+        memo = rest.slice(i + 1).join(" ");
+        break;
+      }
+    }
+    try {
+      await executeSend(this.ctx, { chain, to, amount, tokenId, memo });
+    } catch (err) {
+      if (err.message === "Transaction cancelled by user") {
+        console.log(chalk9.yellow("\nTransaction cancelled"));
+        return;
+      }
+      throw err;
+    }
+  }
+  async runChains(args) {
+    let addChain;
+    let removeChain;
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === "--add" && i + 1 < args.length) {
+        const chain = findChainByName(args[i + 1]);
+        if (!chain) {
+          console.log(chalk9.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk9.gray("Use tab completion to see available chains"));
+          return;
+        }
+        addChain = chain;
+        i++;
+      } else if (args[i] === "--remove" && i + 1 < args.length) {
+        const chain = findChainByName(args[i + 1]);
+        if (!chain) {
+          console.log(chalk9.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk9.gray("Use tab completion to see available chains"));
+          return;
+        }
+        removeChain = chain;
+        i++;
+      }
+    }
+    await executeChains(this.ctx, { add: addChain, remove: removeChain });
+  }
+  async runTokens(args) {
+    if (args.length === 0) {
+      console.log(chalk9.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
+      return;
+    }
+    const chainStr = args[0];
+    const chain = findChainByName(chainStr) || chainStr;
+    let add;
+    let remove;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--add" && i + 1 < args.length) {
+        add = args[i + 1];
+        i++;
+      } else if (args[i] === "--remove" && i + 1 < args.length) {
+        remove = args[i + 1];
+        i++;
+      }
+    }
+    await executeTokens(this.ctx, { chain, add, remove });
+  }
+  async runSwapQuote(args) {
+    if (args.length < 3) {
+      console.log(
+        chalk9.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
+      );
+      return;
+    }
+    const [fromChainStr, toChainStr, amountStr, ...rest] = args;
+    const fromChain = findChainByName(fromChainStr) || fromChainStr;
+    const toChain = findChainByName(toChainStr) || toChainStr;
+    const amount = parseFloat(amountStr);
+    let fromToken;
+    let toToken;
+    for (let i = 0; i < rest.length; i++) {
+      if (rest[i] === "--from-token" && i + 1 < rest.length) {
+        fromToken = rest[i + 1];
+        i++;
+      } else if (rest[i] === "--to-token" && i + 1 < rest.length) {
+        toToken = rest[i + 1];
+        i++;
+      }
+    }
+    await executeSwapQuote(this.ctx, { fromChain, toChain, amount, fromToken, toToken });
+  }
+  async runSwap(args) {
+    if (args.length < 3) {
+      console.log(
+        chalk9.yellow(
+          "Usage: swap <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>] [--slippage <pct>]"
+        )
+      );
+      return;
+    }
+    const [fromChainStr, toChainStr, amountStr, ...rest] = args;
+    const fromChain = findChainByName(fromChainStr) || fromChainStr;
+    const toChain = findChainByName(toChainStr) || toChainStr;
+    const amount = parseFloat(amountStr);
+    let fromToken;
+    let toToken;
+    let slippage;
+    for (let i = 0; i < rest.length; i++) {
+      if (rest[i] === "--from-token" && i + 1 < rest.length) {
+        fromToken = rest[i + 1];
+        i++;
+      } else if (rest[i] === "--to-token" && i + 1 < rest.length) {
+        toToken = rest[i + 1];
+        i++;
+      } else if (rest[i] === "--slippage" && i + 1 < rest.length) {
+        slippage = parseFloat(rest[i + 1]);
+        i++;
+      }
+    }
+    try {
+      await executeSwap(this.ctx, { fromChain, toChain, amount, fromToken, toToken, slippage });
+    } catch (err) {
+      if (err.message === "Swap cancelled by user") {
+        console.log(chalk9.yellow("\nSwap cancelled"));
+        return;
+      }
+      throw err;
+    }
+  }
+  async runAddressBook(args) {
+    let add = false;
+    let remove;
+    let chain;
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === "--add") {
+        add = true;
+      } else if (args[i] === "--remove" && i + 1 < args.length) {
+        remove = args[i + 1];
+        i++;
+      } else if (args[i] === "--chain" && i + 1 < args.length) {
+        chain = findChainByName(args[i + 1]) || args[i + 1];
+        i++;
+      }
+    }
+    await executeAddressBook(this.ctx, { add, remove, chain });
+  }
+  // ===== Setup =====
+  setupReplCommands() {
+    this.replServer.defineCommand("help", {
+      help: "Show available commands",
+      action: () => {
+        showHelp();
+        this.replServer.displayPrompt();
+      }
+    });
+    this.replServer.defineCommand("clear", {
+      help: "Clear the screen",
+      action: () => {
+        console.clear();
+        this.displayVaultList();
+        this.replServer.displayPrompt();
+      }
+    });
+    const originalExit = this.replServer.commands.exit;
+    this.replServer.defineCommand("exit", {
+      help: originalExit.help,
+      action: () => {
+        console.log(chalk9.yellow("\nGoodbye!"));
+        this.ctx.dispose();
+        originalExit.action.call(this.replServer);
+      }
+    });
+  }
+  async loadAllVaults() {
+    const spinner = createReplSafeSpinner("Loading vaults...").start();
+    try {
+      const activeVault = await this.ctx.sdk.getActiveVault();
+      if (activeVault) {
+        this.ctx.addVault(activeVault);
+        await this.ctx.setActiveVault(activeVault);
+        this.eventBuffer.setupVaultListeners(activeVault);
+      }
+      const vaultList = await this.ctx.sdk.listVaults();
+      if (vaultList && vaultList.length > 0) {
+        vaultList.forEach((vault) => {
+          if (!this.ctx.getVaultById(vault.id)) {
+            this.ctx.addVault(vault);
+            this.eventBuffer.setupVaultListeners(vault);
+          }
         });
-        await sdk.initialize();
-        ctx = new CLIContext(sdk);
-        // Determine which vault to use (precedence: flag > env var > stored active)
-        const vaultSelector = vaultOverride || process.env.VULTISIG_VAULT;
-        let vault = null;
-        if (vaultSelector) {
-            vault = await findVaultByNameOrId(sdk, vaultSelector);
-            if (!vault) {
-                throw new Error(`Vault not found: "${vaultSelector}"`);
-            }
+        if (!this.ctx.getActiveVault() && this.ctx.getVaults().size > 0) {
+          const firstVault = this.ctx.getVaults().values().next().value;
+          await this.ctx.setActiveVault(firstVault);
         }
-        else {
-            vault = await sdk.getActiveVault();
+        spinner.succeed(`Loaded ${this.ctx.getVaults().size} vault(s)`);
+      } else if (this.ctx.getVaults().size > 0) {
+        spinner.succeed(`Loaded ${this.ctx.getVaults().size} vault(s)`);
+      } else {
+        spinner.succeed("No vaults found");
+      }
+    } catch (error2) {
+      if (this.ctx.getVaults().size > 0) {
+        spinner.succeed(`Loaded ${this.ctx.getVaults().size} vault(s)`);
+      } else {
+        spinner.fail("Failed to load vaults");
+        throw error2;
+      }
+    }
+  }
+  getPrompt() {
+    const vault = this.ctx.getActiveVault();
+    if (!vault) return chalk9.cyan("wallet> ");
+    const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
+    const status = isUnlocked ? chalk9.green("\u{1F513}") : chalk9.yellow("\u{1F512}");
+    return chalk9.cyan(`wallet[${vault.name}]${status}> `);
+  }
+  displayVaultList() {
+    const vaults = Array.from(this.ctx.getVaults().values());
+    const activeVault = this.ctx.getActiveVault();
+    if (vaults.length === 0) {
+      console.log(chalk9.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
+      return;
+    }
+    console.log(chalk9.cyan("Loaded Vaults:\n"));
+    vaults.forEach((vault) => {
+      const isActive = vault.id === activeVault?.id;
+      const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
+      const activeMarker = isActive ? chalk9.green(" (active)") : "";
+      const lockIcon = isUnlocked ? chalk9.green("\u{1F513}") : chalk9.yellow("\u{1F512}");
+      console.log(`  ${lockIcon} ${vault.name}${activeMarker} - ${vault.type}`);
+    });
+    console.log();
+  }
+};
+
+// src/lib/errors.ts
+import chalk10 from "chalk";
+
+// src/lib/version.ts
+import chalk11 from "chalk";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var cachedVersion = null;
+function getVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const packagePath = new URL("../../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+    cachedVersion = pkg.version;
+    return cachedVersion;
+  } catch {
+    cachedVersion = "0.1.0-beta.1";
+    return cachedVersion;
+  }
+}
+var CACHE_DIR = join(homedir(), ".vultisig", "cache");
+var VERSION_CACHE_FILE = join(CACHE_DIR, "version-check.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function readVersionCache() {
+  try {
+    if (!existsSync(VERSION_CACHE_FILE)) return null;
+    const data = readFileSync(VERSION_CACHE_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function writeVersionCache(cache) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync(VERSION_CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch("https://registry.npmjs.org/@vultisig/cli/latest", {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewerVersion(v1, v2) {
+  const parse = (v) => {
+    const clean = v.replace(/^v/, "").replace(/-.*$/, "");
+    return clean.split(".").map((n) => parseInt(n, 10) || 0);
+  };
+  const p1 = parse(v1);
+  const p2 = parse(v2);
+  for (let i = 0; i < 3; i++) {
+    const n1 = p1[i] ?? 0;
+    const n2 = p2[i] ?? 0;
+    if (n2 > n1) return true;
+    if (n2 < n1) return false;
+  }
+  if (v1.includes("-") && !v2.includes("-")) return true;
+  return false;
+}
+async function checkForUpdates() {
+  if (process.env.VULTISIG_NO_UPDATE_CHECK === "1") {
+    return null;
+  }
+  const currentVersion = getVersion();
+  const cache = readVersionCache();
+  if (cache && Date.now() - cache.lastCheck < CACHE_TTL_MS) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      updateAvailable: cache.latestVersion ? isNewerVersion(currentVersion, cache.latestVersion) : false
+    };
+  }
+  const latestVersion = await fetchLatestVersion();
+  writeVersionCache({
+    lastCheck: Date.now(),
+    latestVersion
+  });
+  return {
+    currentVersion,
+    latestVersion,
+    updateAvailable: latestVersion ? isNewerVersion(currentVersion, latestVersion) : false
+  };
+}
+function formatVersionShort() {
+  return `vultisig/${getVersion()}`;
+}
+function formatVersionDetailed() {
+  const lines = [];
+  lines.push(chalk11.bold(`Vultisig CLI v${getVersion()}`));
+  lines.push("");
+  lines.push(`  Node.js:   ${process.version}`);
+  lines.push(`  Platform:  ${process.platform}-${process.arch}`);
+  lines.push(`  Config:    ~/.vultisig/`);
+  return lines.join("\n");
+}
+function detectInstallMethod() {
+  const execPath = process.execPath;
+  if (execPath.includes("homebrew") || execPath.includes("Cellar")) {
+    return "homebrew";
+  }
+  if (process.env.npm_execpath?.includes("yarn")) {
+    return "yarn";
+  }
+  if (process.env.npm_config_user_agent?.includes("npm")) {
+    return "npm";
+  }
+  if (execPath.includes("node_modules")) {
+    return "npm";
+  }
+  return "unknown";
+}
+function getUpdateCommand() {
+  const method = detectInstallMethod();
+  switch (method) {
+    case "npm":
+      return "npm update -g @vultisig/cli";
+    case "yarn":
+      return "yarn global upgrade @vultisig/cli";
+    case "homebrew":
+      return "brew upgrade vultisig";
+    default:
+      return "npm update -g @vultisig/cli";
+  }
+}
+
+// src/lib/completion.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+var tabtab = null;
+async function getTabtab() {
+  if (!tabtab) {
+    try {
+      tabtab = await import("tabtab");
+      if (tabtab.default) {
+        tabtab = tabtab.default;
+      }
+    } catch {
+      return null;
+    }
+  }
+  return tabtab;
+}
+var COMMANDS2 = [
+  "create",
+  "import",
+  "verify",
+  "balance",
+  "send",
+  "portfolio",
+  "currency",
+  "server",
+  "export",
+  "addresses",
+  "address-book",
+  "chains",
+  "vaults",
+  "switch",
+  "rename",
+  "info",
+  "tokens",
+  "swap-chains",
+  "swap-quote",
+  "swap",
+  "completion",
+  "version",
+  "update"
+];
+var CHAINS = [
+  "Ethereum",
+  "Bitcoin",
+  "Solana",
+  "Polygon",
+  "Arbitrum",
+  "Optimism",
+  "Avalanche",
+  "BSC",
+  "Base",
+  "Cosmos",
+  "THORChain",
+  "Maya",
+  "Dydx",
+  "Kujira",
+  "Sui",
+  "Polkadot",
+  "Ripple",
+  "Dogecoin",
+  "Litecoin",
+  "Dash",
+  "Zcash"
+];
+function getVaultNames() {
+  try {
+    const vaultDir = join2(homedir2(), ".vultisig", "vaults");
+    if (!existsSync2(vaultDir)) return [];
+    const { readdirSync } = __require("fs");
+    const files = readdirSync(vaultDir);
+    const names = [];
+    for (const file of files) {
+      if (file.startsWith("vault:") && file.endsWith(".json")) {
+        try {
+          const content = readFileSync2(join2(vaultDir, file), "utf-8");
+          const vault = JSON.parse(content);
+          if (vault.name) names.push(vault.name);
+          if (vault.id) names.push(vault.id);
+        } catch {
         }
-        if (vault) {
-            await ctx.setActiveVault(vault);
-            setupVaultEvents(vault);
+      }
+    }
+    return names;
+  } catch {
+    return [];
+  }
+}
+async function handleCompletion() {
+  const tt = await getTabtab();
+  if (!tt) return false;
+  const env = tt.parseEnv(process.env);
+  if (!env.complete) return false;
+  const { line, lastPartial } = env;
+  const parts = line.split(/\s+/).filter(Boolean);
+  const cmd = parts[1];
+  let completions = [];
+  if (!cmd || parts.length === 1 || parts.length === 2 && lastPartial) {
+    completions = COMMANDS2.filter((c) => c.startsWith(lastPartial || ""));
+  } else {
+    switch (cmd) {
+      case "balance":
+      case "tokens":
+      case "send":
+        if (parts.length === 2 || parts.length === 3 && lastPartial) {
+          completions = CHAINS.filter((c) => c.toLowerCase().startsWith((lastPartial || "").toLowerCase()));
+        }
+        break;
+      case "switch":
+      case "verify":
+        if (parts.length === 2 || parts.length === 3 && lastPartial) {
+          completions = getVaultNames().filter((n) => n.toLowerCase().startsWith((lastPartial || "").toLowerCase()));
+        }
+        break;
+      case "import":
+      case "export":
+        break;
+      case "chains":
+        if (lastPartial?.startsWith("-")) {
+          completions = ["--add", "--remove"].filter((o) => o.startsWith(lastPartial));
+        } else if (parts.includes("--add") || parts.includes("--remove")) {
+          completions = CHAINS.filter((c) => c.toLowerCase().startsWith((lastPartial || "").toLowerCase()));
+        }
+        break;
+      case "swap":
+      case "swap-quote":
+        if (parts.length <= 3 || parts.length === 4 && lastPartial) {
+          completions = CHAINS.filter((c) => c.toLowerCase().startsWith((lastPartial || "").toLowerCase()));
         }
+        break;
+      case "completion":
+        if (parts.length === 2 || parts.length === 3 && lastPartial) {
+          completions = ["install", "uninstall", "bash", "zsh", "fish"].filter(
+            (s) => s.startsWith((lastPartial || "").toLowerCase())
+          );
+        }
+        break;
     }
-    return ctx;
-}
-// ============================================================================
-// Commands
-// ============================================================================
-// Command: Create new vault
-program
-    .command('create')
-    .description('Create a new vault')
-    .option('--type <type>', 'Vault type: fast or secure', 'fast')
-    .option('--name <name>', 'Vault name')
-    .option('--password <password>', 'Vault password')
-    .option('--email <email>', 'Email for verification (fast vault)')
-    .option('--code <code>', 'Verification code (if already received)')
-    .option('--threshold <m>', 'Signing threshold (secure vault)')
-    .option('--shares <n>', 'Total shares (secure vault)')
-    .action(withExit(async (options) => {
-    const context = await init(program.opts().vault);
-    await executeCreate(context, {
+  }
+  if (lastPartial?.startsWith("-")) {
+    const flags = ["-h", "--help", "-v", "--version", "-i", "--interactive", "--debug"];
+    completions = [...completions, ...flags.filter((f) => f.startsWith(lastPartial))];
+  }
+  if (completions.length > 0) {
+    tt.log(completions);
+  }
+  return true;
+}
+function setupCompletionCommand(program2) {
+  program2.command("completion [shell]").description("Generate shell completion scripts").option("--install", "Install completion for current shell").option("--uninstall", "Remove completion scripts").action(async (shell, options) => {
+    const tt = await getTabtab();
+    if (!tt) {
+      console.error("Shell completion is not available. Install tabtab: npm install -g tabtab");
+      process.exit(1);
+    }
+    if (options.install) {
+      try {
+        await tt.install({
+          name: "vultisig",
+          completer: "vultisig"
+        });
+        await tt.install({
+          name: "vsig",
+          completer: "vsig"
+        });
+        console.log("Shell completion installed successfully for vultisig and vsig!");
+        console.log("Restart your shell or run: source ~/.bashrc (or ~/.zshrc)");
+      } catch (err) {
+        console.error(`Failed to install completion: ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+    if (options.uninstall) {
+      try {
+        await tt.uninstall({
+          name: "vultisig"
+        });
+        await tt.uninstall({
+          name: "vsig"
+        });
+        console.log("Shell completion uninstalled successfully!");
+      } catch (err) {
+        console.error(`Failed to uninstall completion: ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+    if (shell) {
+      const scripts = {
+        bash: getBashCompletionScript(),
+        zsh: getZshCompletionScript(),
+        fish: getFishCompletionScript()
+      };
+      const script = scripts[shell.toLowerCase()];
+      if (script) {
+        console.log(script);
+      } else {
+        console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
+        process.exit(1);
+      }
+      return;
+    }
+    console.log("Usage: vultisig completion [shell] [options]");
+    console.log("");
+    console.log("Generate shell completion scripts");
+    console.log("");
+    console.log("Arguments:");
+    console.log("  shell          Shell type: bash, zsh, fish");
+    console.log("");
+    console.log("Options:");
+    console.log("  --install      Install completion for current shell");
+    console.log("  --uninstall    Remove completion scripts");
+    console.log("");
+    console.log("Examples:");
+    console.log("  vultisig completion --install");
+    console.log("  vultisig completion bash >> ~/.bashrc");
+    console.log("  vultisig completion zsh >> ~/.zshrc");
+  });
+}
+function getBashCompletionScript() {
+  return `
+# vultisig bash completion
+_vultisig_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local cmd="\${COMP_WORDS[1]}"
+
+  if [ "\${COMP_CWORD}" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "${COMMANDS2.join(" ")}" -- "\${cur}"))
+    return
+  fi
+
+  case "\${cmd}" in
+    balance|tokens|send)
+      COMPREPLY=($(compgen -W "${CHAINS.join(" ")}" -- "\${cur}"))
+      ;;
+    chains)
+      COMPREPLY=($(compgen -W "--add --remove ${CHAINS.join(" ")}" -- "\${cur}"))
+      ;;
+    swap|swap-quote)
+      COMPREPLY=($(compgen -W "${CHAINS.join(" ")}" -- "\${cur}"))
+      ;;
+    completion)
+      COMPREPLY=($(compgen -W "install uninstall bash zsh fish" -- "\${cur}"))
+      ;;
+    import|export)
+      COMPREPLY=($(compgen -f -- "\${cur}"))
+      ;;
+    *)
+      COMPREPLY=($(compgen -W "-h --help" -- "\${cur}"))
+      ;;
+  esac
+}
+
+complete -F _vultisig_completions vultisig
+complete -F _vultisig_completions vsig
+`.trim();
+}
+function getZshCompletionScript() {
+  return `
+#compdef vultisig vsig
+
+_vultisig() {
+  local -a commands chains
+  commands=(${COMMANDS2.map((c) => `'${c}:${c} command'`).join(" ")})
+  chains=(${CHAINS.join(" ")})
+
+  _arguments -C \\
+    '1: :->command' \\
+    '*: :->args'
+
+  case "$state" in
+    command)
+      _describe 'command' commands
+      ;;
+    args)
+      case "$words[2]" in
+        balance|tokens|send|swap|swap-quote)
+          _describe 'chain' chains
+          ;;
+        completion)
+          _describe 'shell' '(install uninstall bash zsh fish)'
+          ;;
+        import|export)
+          _files
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_vultisig
+`.trim();
+}
+function getFishCompletionScript() {
+  const commands = ["vultisig", "vsig"];
+  const commandCompletions = commands.flatMap((cmd) => COMMANDS2.map((c) => `complete -c ${cmd} -n "__fish_use_subcommand" -a "${c}"`)).join("\n");
+  const chainCompletions = commands.flatMap(
+    (cmd) => CHAINS.map(
+      (c) => `complete -c ${cmd} -n "__fish_seen_subcommand_from balance tokens send swap swap-quote" -a "${c}"`
+    )
+  ).join("\n");
+  return `
+# vultisig/vsig fish completion
+${commandCompletions}
+${chainCompletions}
+complete -c vultisig -n "__fish_seen_subcommand_from completion" -a "install uninstall bash zsh fish"
+complete -c vsig -n "__fish_seen_subcommand_from completion" -a "install uninstall bash zsh fish"
+complete -c vultisig -n "__fish_seen_subcommand_from import export" -a "(__fish_complete_path)"
+complete -c vsig -n "__fish_seen_subcommand_from import export" -a "(__fish_complete_path)"
+`.trim();
+}
+
+// src/index.ts
+(async () => {
+  const handled = await handleCompletion();
+  if (handled) process.exit(0);
+})();
+var ctx;
+program.name("vultisig").description("Vultisig CLI - Secure multi-party crypto wallet").version(formatVersionShort(), "-v, --version", "Show version").option("--debug", "Enable debug output").option("--silent", "Suppress informational output, show only results").option("-o, --output <format>", "Output format: table, json (default: table)", "table").option("-i, --interactive", "Start interactive shell mode").option("--vault <nameOrId>", "Specify vault by name or ID").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  initOutputMode({ silent: opts.silent, output: opts.output });
+});
+async function findVaultByNameOrId(sdk, nameOrId) {
+  const vaults = await sdk.listVaults();
+  const byId = vaults.find((v) => v.id === nameOrId);
+  if (byId) return byId;
+  const byName = vaults.find((v) => v.name.toLowerCase() === nameOrId.toLowerCase());
+  if (byName) return byName;
+  const byPartialId = vaults.find((v) => v.id.startsWith(nameOrId));
+  if (byPartialId) return byPartialId;
+  return null;
+}
+async function init(vaultOverride) {
+  if (!ctx) {
+    const sdk = new Vultisig3({
+      onPasswordRequired: createPasswordCallback()
+    });
+    await sdk.initialize();
+    ctx = new CLIContext(sdk);
+    const vaultSelector = vaultOverride || process.env.VULTISIG_VAULT;
+    let vault = null;
+    if (vaultSelector) {
+      vault = await findVaultByNameOrId(sdk, vaultSelector);
+      if (!vault) {
+        throw new Error(`Vault not found: "${vaultSelector}"`);
+      }
+    } else {
+      vault = await sdk.getActiveVault();
+    }
+    if (vault) {
+      await ctx.setActiveVault(vault);
+      setupVaultEvents(vault);
+    }
+  }
+  return ctx;
+}
+program.command("create").description("Create a new vault").option("--type <type>", "Vault type: fast or secure", "fast").option("--name <name>", "Vault name").option("--password <password>", "Vault password").option("--email <email>", "Email for verification (fast vault)").option("--code <code>", "Verification code (if already received)").option("--threshold <m>", "Signing threshold (secure vault)").option("--shares <n>", "Total shares (secure vault)").action(
+  withExit(
+    async (options) => {
+      const context = await init(program.opts().vault);
+      await executeCreate(context, {
         type: options.type,
         name: options.name,
         password: options.password,
         email: options.email,
         code: options.code,
-        threshold: options.threshold ? parseInt(options.threshold, 10) : undefined,
-        shares: options.shares ? parseInt(options.shares, 10) : undefined,
-    });
-}));
-// Command: Import vault from file
-program
-    .command('import <file>')
-    .description('Import vault from .vult file')
-    .action(withExit(async (file) => {
+        threshold: options.threshold ? parseInt(options.threshold, 10) : void 0,
+        shares: options.shares ? parseInt(options.shares, 10) : void 0
+      });
+    }
+  )
+);
+program.command("import <file>").description("Import vault from .vult file").action(
+  withExit(async (file) => {
     const context = await init(program.opts().vault);
     await executeImport(context, file);
-}));
-// Command: Verify vault with email code
-program
-    .command('verify <vaultId>')
-    .description('Verify vault with email verification code')
-    .option('-r, --resend', 'Resend verification email')
-    .option('--code <code>', 'Verification code')
-    .action(withExit(async (vaultId, options) => {
+  })
+);
+program.command("verify <vaultId>").description("Verify vault with email verification code").option("-r, --resend", "Resend verification email").option("--code <code>", "Verification code").action(
+  withExit(async (vaultId, options) => {
     const context = await init(program.opts().vault);
     const verified = await executeVerify(context, vaultId, options);
     if (!verified) {
-        const err = new Error('Verification failed');
-        err.exitCode = 1;
-        throw err;
+      const err = new Error("Verification failed");
+      err.exitCode = 1;
+      throw err;
     }
-}));
-// Command: Show balances
-program
-    .command('balance [chain]')
-    .description('Show balance for a chain or all chains')
-    .option('-t, --tokens', 'Include token balances')
-    .action(withExit(async (chainStr, options) => {
+  })
+);
+program.command("balance [chain]").description("Show balance for a chain or all chains").option("-t, --tokens", "Include token balances").action(
+  withExit(async (chainStr, options) => {
     const context = await init(program.opts().vault);
     await executeBalance(context, {
-        chain: chainStr ? findChainByName(chainStr) || chainStr : undefined,
-        includeTokens: options.tokens,
-    });
-}));
-// Command: Send transaction
-program
-    .command('send <chain> <to> <amount>')
-    .description('Send tokens to an address')
-    .option('--token <tokenId>', 'Token to send (default: native)')
-    .option('--memo <memo>', 'Transaction memo')
-    .option('-y, --yes', 'Skip confirmation prompt')
-    .action(withExit(async (chainStr, to, amount, options) => {
-    const context = await init(program.opts().vault);
-    try {
+      chain: chainStr ? findChainByName(chainStr) || chainStr : void 0,
+      includeTokens: options.tokens
+    });
+  })
+);
+program.command("send <chain> <to> <amount>").description("Send tokens to an address").option("--token <tokenId>", "Token to send (default: native)").option("--memo <memo>", "Transaction memo").option("-y, --yes", "Skip confirmation prompt").action(
+  withExit(
+    async (chainStr, to, amount, options) => {
+      const context = await init(program.opts().vault);
+      try {
         await executeSend(context, {
-            chain: findChainByName(chainStr) || chainStr,
-            to,
-            amount,
-            tokenId: options.token,
-            memo: options.memo,
-            yes: options.yes,
+          chain: findChainByName(chainStr) || chainStr,
+          to,
+          amount,
+          tokenId: options.token,
+          memo: options.memo,
+          yes: options.yes
         });
-    }
-    catch (err) {
-        if (err.message === 'Transaction cancelled by user') {
-            warn('\nx Transaction cancelled');
-            return;
+      } catch (err) {
+        if (err.message === "Transaction cancelled by user") {
+          warn("\nx Transaction cancelled");
+          return;
         }
         throw err;
+      }
     }
-}));
-// Command: Show portfolio value
-program
-    .command('portfolio')
-    .description('Show total portfolio value')
-    .option('-c, --currency <currency>', 'Fiat currency (usd, eur, gbp, etc.)', 'usd')
-    .action(withExit(async (options) => {
+  )
+);
+program.command("portfolio").description("Show total portfolio value").option("-c, --currency <currency>", "Fiat currency (usd, eur, gbp, etc.)", "usd").action(
+  withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executePortfolio(context, { currency: options.currency.toLowerCase() });
-}));
-// Command: Manage currency
-program
-    .command('currency [newCurrency]')
-    .description('View or set the vault currency preference')
-    .action(withExit(async (newCurrency) => {
+  })
+);
+program.command("currency [newCurrency]").description("View or set the vault currency preference").action(
+  withExit(async (newCurrency) => {
     const context = await init(program.opts().vault);
     await executeCurrency(context, newCurrency);
-}));
-// Command: Server status
-program
-    .command('server')
-    .description('Check server connectivity and status')
-    .action(withExit(async () => {
+  })
+);
+program.command("server").description("Check server connectivity and status").action(
+  withExit(async () => {
     const context = await init(program.opts().vault);
     await executeServer(context);
-}));
-// Command: Export vault
-program
-    .command('export [path]')
-    .description('Export vault to file')
-    .option('--encrypt', 'Encrypt the export with a password')
-    .option('--no-encrypt', 'Export without encryption')
-    .option('--password <password>', 'Password for encryption')
-    .action(withExit(async (path, options) => {
+  })
+);
+program.command("export [path]").description("Export vault to file").option("--encrypt", "Encrypt the export with a password").option("--no-encrypt", "Export without encryption").option("--password <password>", "Password for encryption").action(
+  withExit(async (path2, options) => {
     const context = await init(program.opts().vault);
     await executeExport(context, {
-        outputPath: path,
-        encrypt: options.encrypt,
-        password: options.password,
+      outputPath: path2,
+      encrypt: options.encrypt,
+      password: options.password
     });
-}));
-// Command: Show addresses
-program
-    .command('addresses')
-    .description('Show all vault addresses')
-    .action(withExit(async () => {
+  })
+);
+program.command("addresses").description("Show all vault addresses").action(
+  withExit(async () => {
     const context = await init(program.opts().vault);
     await executeAddresses(context);
-}));
-// Command: Manage address book
-program
-    .command('address-book')
-    .description('Manage address book entries')
-    .option('--add', 'Add a new address book entry')
-    .option('--remove <address>', 'Remove an address from the address book')
-    .option('--chain <chain>', 'Chain for the address (for --add or --remove)')
-    .option('--address <address>', 'Address to add (for --add)')
-    .option('--name <name>', 'Name/label for the address (for --add)')
-    .action(withExit(async (options) => {
+  })
+);
+program.command("address-book").description("Manage address book entries").option("--add", "Add a new address book entry").option("--remove <address>", "Remove an address from the address book").option("--chain <chain>", "Chain for the address (for --add or --remove)").option("--address <address>", "Address to add (for --add)").option("--name <name>", "Name/label for the address (for --add)").action(
+  withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executeAddressBook(context, {
-        add: options.add,
-        remove: options.remove,
-        chain: options.chain ? findChainByName(options.chain) || options.chain : undefined,
-        address: options.address,
-        name: options.name,
+      add: options.add,
+      remove: options.remove,
+      chain: options.chain ? findChainByName(options.chain) || options.chain : void 0,
+      address: options.address,
+      name: options.name
     });
-}));
-// Command: Manage chains
-program
-    .command('chains')
-    .description('List and manage chains')
-    .option('--add <chain>', 'Add a chain')
-    .option('--remove <chain>', 'Remove a chain')
-    .action(withExit(async (options) => {
+  })
+);
+program.command("chains").description("List and manage chains").option("--add <chain>", "Add a chain").option("--remove <chain>", "Remove a chain").action(
+  withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executeChains(context, {
-        add: options.add ? findChainByName(options.add) || options.add : undefined,
-        remove: options.remove ? findChainByName(options.remove) || options.remove : undefined,
-    });
-}));
-// Command: List all vaults
-program
-    .command('vaults')
-    .description('List all stored vaults')
-    .action(withExit(async () => {
+      add: options.add ? findChainByName(options.add) || options.add : void 0,
+      remove: options.remove ? findChainByName(options.remove) || options.remove : void 0
+    });
+  })
+);
+program.command("vaults").description("List all stored vaults").action(
+  withExit(async () => {
     const context = await init(program.opts().vault);
     await executeVaults(context);
-}));
-// Command: Switch active vault
-program
-    .command('switch <vaultId>')
-    .description('Switch to a different vault')
-    .action(withExit(async (vaultId) => {
+  })
+);
+program.command("switch <vaultId>").description("Switch to a different vault").action(
+  withExit(async (vaultId) => {
     const context = await init(program.opts().vault);
     await executeSwitch(context, vaultId);
-}));
-// Command: Rename vault
-program
-    .command('rename <newName>')
-    .description('Rename the active vault')
-    .action(withExit(async (newName) => {
+  })
+);
+program.command("rename <newName>").description("Rename the active vault").action(
+  withExit(async (newName) => {
     const context = await init(program.opts().vault);
     await executeRename(context, newName);
-}));
-// Command: Show vault info
-program
-    .command('info')
-    .description('Show detailed vault information')
-    .action(withExit(async () => {
+  })
+);
+program.command("info").description("Show detailed vault information").action(
+  withExit(async () => {
     const context = await init(program.opts().vault);
     await executeInfo(context);
-}));
-// Command: Manage tokens
-program
-    .command('tokens <chain>')
-    .description('List and manage tokens for a chain')
-    .option('--add <contractAddress>', 'Add a token by contract address')
-    .option('--remove <tokenId>', 'Remove a token by ID')
-    .option('--symbol <symbol>', 'Token symbol (for --add)')
-    .option('--name <name>', 'Token name (for --add)')
-    .option('--decimals <decimals>', 'Token decimals (for --add)', '18')
-    .action(withExit(async (chainStr, options) => {
-    const context = await init(program.opts().vault);
-    await executeTokens(context, {
+  })
+);
+program.command("tokens <chain>").description("List and manage tokens for a chain").option("--add <contractAddress>", "Add a token by contract address").option("--remove <tokenId>", "Remove a token by ID").option("--symbol <symbol>", "Token symbol (for --add)").option("--name <name>", "Token name (for --add)").option("--decimals <decimals>", "Token decimals (for --add)", "18").action(
+  withExit(
+    async (chainStr, options) => {
+      const context = await init(program.opts().vault);
+      await executeTokens(context, {
         chain: findChainByName(chainStr) || chainStr,
         add: options.add,
         remove: options.remove,
         symbol: options.symbol,
         name: options.name,
-        decimals: options.decimals ? parseInt(options.decimals, 10) : undefined,
-    });
-}));
-// ============================================================================
-// Swap Commands
-// ============================================================================
-// Command: List supported swap chains
-program
-    .command('swap-chains')
-    .description('List chains that support swaps')
-    .action(withExit(async () => {
+        decimals: options.decimals ? parseInt(options.decimals, 10) : void 0
+      });
+    }
+  )
+);
+program.command("swap-chains").description("List chains that support swaps").action(
+  withExit(async () => {
     const context = await init(program.opts().vault);
     await executeSwapChains(context);
-}));
-// Command: Get swap quote
-program
-    .command('swap-quote <fromChain> <toChain> <amount>')
-    .description('Get a swap quote without executing')
-    .option('--from-token <address>', 'Token address to swap from (default: native)')
-    .option('--to-token <address>', 'Token address to swap to (default: native)')
-    .action(withExit(async (fromChainStr, toChainStr, amountStr, options) => {
-    const context = await init(program.opts().vault);
-    await executeSwapQuote(context, {
+  })
+);
+program.command("swap-quote <fromChain> <toChain> <amount>").description("Get a swap quote without executing").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").action(
+  withExit(
+    async (fromChainStr, toChainStr, amountStr, options) => {
+      const context = await init(program.opts().vault);
+      await executeSwapQuote(context, {
         fromChain: findChainByName(fromChainStr) || fromChainStr,
         toChain: findChainByName(toChainStr) || toChainStr,
         amount: parseFloat(amountStr),
         fromToken: options.fromToken,
-        toToken: options.toToken,
-    });
-}));
-// Command: Execute swap
-program
-    .command('swap <fromChain> <toChain> <amount>')
-    .description('Swap tokens between chains')
-    .option('--from-token <address>', 'Token address to swap from (default: native)')
-    .option('--to-token <address>', 'Token address to swap to (default: native)')
-    .option('--slippage <percent>', 'Slippage tolerance in percent', '1')
-    .option('-y, --yes', 'Skip confirmation prompt')
-    .action(withExit(async (fromChainStr, toChainStr, amountStr, options) => {
-    const context = await init(program.opts().vault);
-    try {
+        toToken: options.toToken
+      });
+    }
+  )
+);
+program.command("swap <fromChain> <toChain> <amount>").description("Swap tokens between chains").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").option("--slippage <percent>", "Slippage tolerance in percent", "1").option("-y, --yes", "Skip confirmation prompt").action(
+  withExit(
+    async (fromChainStr, toChainStr, amountStr, options) => {
+      const context = await init(program.opts().vault);
+      try {
         await executeSwap(context, {
-            fromChain: findChainByName(fromChainStr) || fromChainStr,
-            toChain: findChainByName(toChainStr) || toChainStr,
-            amount: parseFloat(amountStr),
-            fromToken: options.fromToken,
-            toToken: options.toToken,
-            slippage: options.slippage ? parseFloat(options.slippage) : undefined,
-            yes: options.yes,
+          fromChain: findChainByName(fromChainStr) || fromChainStr,
+          toChain: findChainByName(toChainStr) || toChainStr,
+          amount: parseFloat(amountStr),
+          fromToken: options.fromToken,
+          toToken: options.toToken,
+          slippage: options.slippage ? parseFloat(options.slippage) : void 0,
+          yes: options.yes
         });
-    }
-    catch (err) {
-        if (err.message === 'Swap cancelled by user') {
-            warn('\nx Swap cancelled');
-            return;
+      } catch (err) {
+        if (err.message === "Swap cancelled by user") {
+          warn("\nx Swap cancelled");
+          return;
         }
         throw err;
+      }
     }
-}));
-// ============================================================================
-// CLI Management Commands
-// ============================================================================
-// Command: Show detailed version
-program
-    .command('version')
-    .description('Show detailed version information')
-    .action(withExit(async () => {
+  )
+);
+program.command("version").description("Show detailed version information").action(
+  withExit(async () => {
     printResult(formatVersionDetailed());
-    // Check for updates
     const result = await checkForUpdates();
     if (result?.updateAvailable && result.latestVersion) {
-        info('');
-        info(chalk.yellow(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
-        info(chalk.gray(`Run "${getUpdateCommand()}" to update`));
-    }
-}));
-// Command: Check for updates
-program
-    .command('update')
-    .description('Check for updates and show update command')
-    .option('--check', 'Just check for updates, do not update')
-    .action(withExit(async (options) => {
-    info('Checking for updates...');
+      info("");
+      info(chalk12.yellow(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
+      info(chalk12.gray(`Run "${getUpdateCommand()}" to update`));
+    }
+  })
+);
+program.command("update").description("Check for updates and show update command").option("--check", "Just check for updates, do not update").action(
+  withExit(async (options) => {
+    info("Checking for updates...");
     const result = await checkForUpdates();
     if (!result) {
-        printResult(chalk.gray('Update checking is disabled'));
-        return;
+      printResult(chalk12.gray("Update checking is disabled"));
+      return;
     }
     if (result.updateAvailable && result.latestVersion) {
-        printResult('');
-        printResult(chalk.green(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
-        printResult('');
-        if (options.check) {
-            printResult(`Run "${getUpdateCommand()}" to update`);
-        }
-        else {
-            const updateCmd = getUpdateCommand();
-            printResult(`To update, run:`);
-            printResult(chalk.cyan(`  ${updateCmd}`));
-        }
-    }
-    else {
-        printResult(chalk.green(`You're on the latest version (${result.currentVersion})`));
+      printResult("");
+      printResult(chalk12.green(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
+      printResult("");
+      if (options.check) {
+        printResult(`Run "${getUpdateCommand()}" to update`);
+      } else {
+        const updateCmd = getUpdateCommand();
+        printResult(`To update, run:`);
+        printResult(chalk12.cyan(`  ${updateCmd}`));
+      }
+    } else {
+      printResult(chalk12.green(`You're on the latest version (${result.currentVersion})`));
     }
-}));
-// Setup completion command
+  })
+);
 setupCompletionCommand(program);
-// ============================================================================
-// Interactive Mode
-// ============================================================================
 async function startInteractiveMode() {
-    const sdk = new Vultisig({
-        onPasswordRequired: createPasswordCallback(),
-    });
-    await sdk.initialize();
-    const session = new ShellSession(sdk);
-    await session.start();
-}
-// ============================================================================
-// Cleanup & Entry Point
-// ============================================================================
-process.on('SIGINT', () => {
-    warn('\n\nShutting down...');
-    ctx?.dispose();
-    process.exit(0);
-});
-// Check for interactive mode before parsing commands
-if (process.argv.includes('-i') || process.argv.includes('--interactive')) {
-    startInteractiveMode().catch(err => {
-        error(`Failed to start interactive mode: ${err.message}`);
-        process.exit(1);
-    });
+  const sdk = new Vultisig3({
+    onPasswordRequired: createPasswordCallback()
+  });
+  await sdk.initialize();
+  const session = new ShellSession(sdk);
+  await session.start();
 }
-else {
-    program.parse();
+process.on("SIGINT", () => {
+  warn("\n\nShutting down...");
+  ctx?.dispose();
+  process.exit(0);
+});
+if (process.argv.includes("-i") || process.argv.includes("--interactive")) {
+  startInteractiveMode().catch((err) => {
+    error(`Failed to start interactive mode: ${err.message}`);
+    process.exit(1);
+  });
+} else {
+  program.parse();
 }
-//# sourceMappingURL=index.js.map