@execra/core 1.0.0

package/dist/index.js

@@ -0,0 +1,2046 @@
+#!/usr/bin/env node
+
+// src/vault/mnemonic.ts
+import * as bip39 from "bip39";
+function generateMnemonic2(strength = 12) {
+  const mnemonic = bip39.generateMnemonic(strength == 12 ? 128 : 256);
+  const wordCount = strength;
+  return { mnemonic, wordCount };
+}
+function validateMnemonic2(mnemonic) {
+  const cleaned = cleanMnemonic(mnemonic);
+  return bip39.validateMnemonic(cleaned);
+}
+async function mnemonicToSeed2(mnemonic, passphrase = "") {
+  const cleaned = cleanMnemonic(mnemonic);
+  if (!validateMnemonic2(cleaned)) {
+    throw new Error("Invalid mnemonic: failed wordlist or checksum validation");
+  }
+  return bip39.mnemonicToSeed(cleaned, passphrase);
+}
+function mnemonicToNumberedWords(mnemonic) {
+  return cleanMnemonic(mnemonic).split(" ").map((word, i) => `${i + 1}. ${word}`);
+}
+function wordsToMnemonic(words) {
+  return words.map((w) => w.trim().toLowerCase()).join(" ");
+}
+function cleanMnemonic(mnemonic) {
+  return mnemonic.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+// src/vault/keystore.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var VAULT_VERSION = 1;
+var PBKDF2_ITERATIONS = 21e4;
+var PBKDF2_DIGEST = "sha512";
+var KEY_LENGTH = 32;
+var SALT_LENGTH = 32;
+var IV_LENGTH = 16;
+var CIPHER = "aes-256-gcm";
+function getWalletDir() {
+  return path.join(os.homedir(), ".wallet");
+}
+function getVaultPath() {
+  return path.join(getWalletDir(), "vault.enc");
+}
+function getConfigPath() {
+  return path.join(getWalletDir(), "config.json");
+}
+function getSessionsPath() {
+  return path.join(getWalletDir(), "sessions.json");
+}
+var SESSIONS_FILE = getSessionsPath();
+function ensureWalletDir() {
+  const dir = getWalletDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function vaultExists() {
+  return fs.existsSync(getVaultPath());
+}
+async function saveVault(data, password) {
+  ensureWalletDir();
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const key = await deriveKey(password, salt);
+  const plaintext = JSON.stringify(data);
+  const cipher = crypto.createCipheriv(CIPHER, key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  const vault = {
+    version: VAULT_VERSION,
+    salt: salt.toString("hex"),
+    iv: iv.toString("hex"),
+    authTag: authTag.toString("hex"),
+    ciphertext: encrypted.toString("hex")
+  };
+  fs.writeFileSync(getVaultPath(), JSON.stringify(vault, null, 2), {
+    mode: 384
+    // owner read/write only
+  });
+}
+async function loadVault(password) {
+  if (!vaultExists()) {
+    throw new Error("No vault found. Run `wallet init` to create one.");
+  }
+  const raw = fs.readFileSync(getVaultPath(), "utf8");
+  const vault = JSON.parse(raw);
+  if (vault.version !== VAULT_VERSION) {
+    throw new Error(`Unsupported vault version: ${vault.version}`);
+  }
+  const salt = Buffer.from(vault.salt, "hex");
+  const iv = Buffer.from(vault.iv, "hex");
+  const authTag = Buffer.from(vault.authTag, "hex");
+  const ciphertext = Buffer.from(vault.ciphertext, "hex");
+  const key = await deriveKey(password, salt);
+  try {
+    const decipher = crypto.createDecipheriv(CIPHER, key, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return JSON.parse(decrypted.toString("utf8"));
+  } catch {
+    throw new Error("Decryption failed: wrong password or vault is corrupted.");
+  }
+}
+async function changePassword(oldPassword, newPassword) {
+  const data = await loadVault(oldPassword);
+  await saveVault(data, newPassword);
+}
+function deriveKey(password, salt) {
+  return new Promise((resolve, reject) => {
+    crypto.pbkdf2(
+      password,
+      salt,
+      PBKDF2_ITERATIONS,
+      KEY_LENGTH,
+      PBKDF2_DIGEST,
+      (err, key) => {
+        if (err) reject(err);
+        else resolve(key);
+      }
+    );
+  });
+}
+
+// src/vault/accounts.ts
+import { derivePath } from "ed25519-hd-key";
+import nacl from "tweetnacl";
+import bs58 from "bs58";
+function deriveAccount(seed, index, name = `Account ${index + 1}`) {
+  const path2 = derivationPath(index);
+  const { key: privateKeyBytes } = derivePath(path2, seed.toString("hex"));
+  const keypair = nacl.sign.keyPair.fromSeed(privateKeyBytes);
+  const publicKey = bs58.encode(Buffer.from(keypair.publicKey));
+  return {
+    index,
+    name,
+    publicKey,
+    secretKey: keypair.secretKey,
+    // 64 bytes: seed + public key
+    derivationPath: path2,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function deriveAccounts(seed, accountStore) {
+  return accountStore.accounts.map(
+    (account) => deriveAccount(seed, account.index, account.name)
+  );
+}
+async function deriveAccountFromMnemonic(mnemonic, index, name, passphrase) {
+  const seed = await mnemonicToSeed2(mnemonic, passphrase);
+  return deriveAccount(seed, index, name);
+}
+function createAccountStore(firstAccountName = "Account 1") {
+  return {
+    accounts: [
+      {
+        index: 0,
+        name: firstAccountName,
+        publicKey: "",
+        // filled in after derivation
+        derivationPath: derivationPath(0),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ],
+    activeIndex: 0
+  };
+}
+function addAccount(store, seed, name) {
+  const nextIndex = store.accounts.length > 0 ? Math.max(...store.accounts.map((a) => a.index)) + 1 : 0;
+  const accountName = name ?? `Account ${nextIndex + 1}`;
+  const keypair = deriveAccount(seed, nextIndex, accountName);
+  const newAccount = {
+    index: nextIndex,
+    name: accountName,
+    publicKey: keypair.publicKey,
+    derivationPath: keypair.derivationPath,
+    createdAt: keypair.createdAt
+  };
+  const updatedStore = {
+    ...store,
+    accounts: [...store.accounts, newAccount]
+  };
+  return { store: updatedStore, keypair };
+}
+function setActiveAccount(store, index) {
+  const exists = store.accounts.find((a) => a.index === index);
+  if (!exists) {
+    throw new Error(`Account index ${index} does not exist.`);
+  }
+  return { ...store, activeIndex: index };
+}
+function renameAccount(store, index, newName) {
+  return {
+    ...store,
+    accounts: store.accounts.map(
+      (a) => a.index === index ? { ...a, name: newName } : a
+    )
+  };
+}
+function getActiveAccount(store) {
+  const account = store.accounts.find((a) => a.index === store.activeIndex);
+  if (!account) throw new Error("No active account found.");
+  return account;
+}
+function signMessage(message, secretKey) {
+  const signature = nacl.sign.detached(message, secretKey);
+  return bs58.encode(Buffer.from(signature));
+}
+function formatAccount(account, isActive) {
+  const activeMarker = isActive ? "\u25CF" : "\u25CB";
+  const shortKey = `${account.publicKey.slice(0, 4)}...${account.publicKey.slice(-4)}`;
+  return `${activeMarker} [${account.index}] ${account.name.padEnd(20)} ${shortKey}`;
+}
+function derivationPath(index) {
+  return `m/44'/501'/${index}'/0'`;
+}
+
+// src/vault/config.ts
+import fs2 from "fs";
+var HELIUS_API_KEY = process.env.HELIUS_API_KEY;
+var RPC_URLS = {
+  "mainnet-beta": HELIUS_API_KEY ? `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}` : "https://api.mainnet-beta.solana.com",
+  devnet: HELIUS_API_KEY ? `https://devnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}` : "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  localnet: "http://localhost:8899"
+};
+var CONFIG_VERSION = 1;
+function configExists() {
+  return fs2.existsSync(getConfigPath());
+}
+function loadConfig() {
+  if (!configExists()) {
+    throw new Error("No config found. Run `wallet init` first.");
+  }
+  const raw = fs2.readFileSync(getConfigPath(), "utf8");
+  return JSON.parse(raw);
+}
+function saveConfig(config) {
+  ensureWalletDir();
+  const updated = { ...config, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  fs2.writeFileSync(getConfigPath(), JSON.stringify(updated, null, 2), {
+    mode: 384
+  });
+}
+function createConfig(walletConnectProjectId = "", cluster = "devnet") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: CONFIG_VERSION,
+    cluster,
+    rpcUrl: RPC_URLS[cluster],
+    walletConnectProjectId,
+    accountStore: createAccountStore("Account 1"),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function updateCluster(cluster) {
+  const config = loadConfig();
+  config.cluster = cluster;
+  config.rpcUrl = RPC_URLS[cluster];
+  saveConfig(config);
+}
+function updateRpcUrl(url) {
+  const config = loadConfig();
+  config.rpcUrl = url;
+  saveConfig(config);
+}
+function updateAccountStore(accountStore) {
+  const config = loadConfig();
+  config.accountStore = accountStore;
+  saveConfig(config);
+}
+function getRpcUrl() {
+  return loadConfig().rpcUrl;
+}
+function getCluster() {
+  return loadConfig().cluster;
+}
+function getAccountStore() {
+  return loadConfig().accountStore;
+}
+
+// src/vault/index.ts
+var WalletVault = class {
+  _keypairs = [];
+  _seed = null;
+  // cached for agent account derivation
+  _config = null;
+  _unlocked = false;
+  _mnemonic = null;
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+  /**
+   * Initialize a brand new wallet.
+   * Generates a mnemonic, encrypts it, writes config.
+   * Returns the mnemonic for the user to write down — shown ONCE.
+   */
+  async init(password, options = {}) {
+    if (vaultExists()) {
+      throw new Error(
+        "Wallet already exists. Use `wallet unlock` to access it."
+      );
+    }
+    const { mnemonic } = generateMnemonic2(options.strength ?? 12);
+    const vaultData = {
+      mnemonic,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    await saveVault(vaultData, password);
+    const config = createConfig(
+      options.walletConnectProjectId ?? "",
+      options.cluster ?? "devnet"
+    );
+    if (options.firstAccountName) {
+      config.accountStore.accounts[0].name = options.firstAccountName;
+    }
+    const seed = await mnemonicToSeed2(mnemonic);
+    const firstKeypair = deriveAccount(
+      seed,
+      0,
+      config.accountStore.accounts[0].name
+    );
+    config.accountStore.accounts[0].publicKey = firstKeypair.publicKey;
+    saveConfig(config);
+    return mnemonic;
+  }
+  /**
+   * Unlock the wallet for a session.
+   * Decrypts the vault, derives all account keypairs into memory.
+   */
+  async unlock(password) {
+    const vaultData = await loadVault(password);
+    const config = loadConfig();
+    const seed = await mnemonicToSeed2(vaultData.mnemonic);
+    this._seed = seed;
+    this._mnemonic = vaultData.mnemonic;
+    this._keypairs = deriveAccounts(seed, config.accountStore);
+    this._config = config;
+    this._unlocked = true;
+  }
+  /**
+   * Restore wallet from an existing mnemonic (import flow).
+   */
+  async restore(mnemonic, password, options = {}) {
+    if (!validateMnemonic2(mnemonic)) {
+      throw new Error("Invalid mnemonic phrase.");
+    }
+    const vaultData = {
+      mnemonic,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    await saveVault(vaultData, password);
+    const config = createConfig("", options.cluster ?? "devnet");
+    const seed = await mnemonicToSeed2(mnemonic);
+    const firstKeypair = deriveAccount(seed, 0, "Account 1");
+    config.accountStore.accounts[0].publicKey = firstKeypair.publicKey;
+    saveConfig(config);
+  }
+  lock() {
+    this._keypairs = [];
+    this._mnemonic = null;
+    this._seed = null;
+    this._config = null;
+    this._unlocked = false;
+  }
+  // ── Account Management ─────────────────────────────────────────────────────
+  /**
+   * Get the currently active keypair (used for signing + dApp connections).
+   */
+  getActiveKeypair() {
+    this.assertUnlocked();
+    const active = getActiveAccount(this._config.accountStore);
+    const keypair = this._keypairs.find((k) => k.index === active.index);
+    if (!keypair) throw new Error("Active keypair not found in session.");
+    return keypair;
+  }
+  /**
+   * Lock the wallet — wipe all keypairs from memory.
+   */
+  /**
+   * Returns the mnemonic — only available while unlocked.
+   * Used by agent_connect to derive new accounts on demand.
+   */
+  getMnemonic() {
+    if (!this._mnemonic) throw new Error("Wallet is locked");
+    return this._mnemonic;
+  }
+  /**
+   * Reload config and re-derive keypairs from seed.
+   * Call after adding new accounts so the vault picks them up.
+   */
+  async reload() {
+    if (!this._seed) throw new Error("Wallet is locked");
+    this._config = loadConfig();
+    this._keypairs = deriveAccounts(this._seed, this._config.accountStore);
+  }
+  /**
+   * Get a keypair by account index.
+   */
+  getKeypair(index) {
+    this.assertUnlocked();
+    const keypair = this._keypairs.find((k) => k.index === index);
+    if (!keypair) throw new Error(`Account ${index} not found.`);
+    return keypair;
+  }
+  /**
+   * Get all loaded keypairs.
+   */
+  getAllKeypairs() {
+    this.assertUnlocked();
+    return [...this._keypairs];
+  }
+  /**
+   * Add a new derived account.
+   */
+  async addAccount(name, password) {
+    this.assertUnlocked();
+    if (!password) throw new Error("Password required to add a new account.");
+    const vaultData = await loadVault(password);
+    const seed = await mnemonicToSeed2(vaultData.mnemonic);
+    const { store, keypair } = addAccount(
+      this._config.accountStore,
+      seed,
+      name
+    );
+    this._config.accountStore = store;
+    this._keypairs.push(keypair);
+    updateAccountStore(store);
+    return keypair;
+  }
+  /**
+   * Switch the active account.
+   */
+  setActiveAccount(index) {
+    this.assertUnlocked();
+    const updated = setActiveAccount(this._config.accountStore, index);
+    this._config.accountStore = updated;
+    updateAccountStore(updated);
+  }
+  /**
+   * Rename an account.
+   */
+  renameAccount(index, newName) {
+    this.assertUnlocked();
+    const updated = renameAccount(this._config.accountStore, index, newName);
+    this._config.accountStore = updated;
+    this._keypairs = this._keypairs.map(
+      (k) => k.index === index ? { ...k, name: newName } : k
+    );
+    updateAccountStore(updated);
+  }
+  // ── Display ────────────────────────────────────────────────────────────────
+  /**
+   * Format all accounts for terminal display.
+   */
+  listAccounts() {
+    this.assertUnlocked();
+    const activeIndex = this._config.accountStore.activeIndex;
+    return this._keypairs.map((k) => formatAccount(k, k.index === activeIndex));
+  }
+  /**
+   * Sign a message with the active account.
+   */
+  signMessage(message) {
+    const keypair = this.getActiveKeypair();
+    return signMessage(message, keypair.secretKey);
+  }
+  // ── State ──────────────────────────────────────────────────────────────────
+  get isUnlocked() {
+    return this._unlocked;
+  }
+  get config() {
+    this.assertUnlocked();
+    return this._config;
+  }
+  static exists() {
+    return vaultExists() && configExists();
+  }
+  /**
+   * Display mnemonic as numbered words — for backup verification flow.
+   */
+  static formatMnemonicForDisplay(mnemonic) {
+    const words = mnemonicToNumberedWords(mnemonic);
+    const cols = 3;
+    const rows = [];
+    for (let i = 0; i < words.length; i += cols) {
+      rows.push(
+        words.slice(i, i + cols).map((w) => w.padEnd(18)).join("  ")
+      );
+    }
+    return rows.join("\n");
+  }
+  // ── Internal ───────────────────────────────────────────────────────────────
+  assertUnlocked() {
+    if (!this._unlocked) {
+      throw new Error("Wallet is locked. Run `wallet unlock` first.");
+    }
+  }
+  /**
+   * Find an account by name or create it if it doesn't exist.
+   * Uses the cached seed — no password needed.
+   * This is the primary way agents acquire their account.
+   */
+  async findOrCreate(name) {
+    this.assertUnlocked();
+    const existing = this._keypairs.find((k) => k.name === name);
+    if (existing) return existing;
+    const nextIndex = this._config.accountStore.accounts.length;
+    const { store, keypair } = addAccount(
+      this._config.accountStore,
+      this._seed,
+      name
+    );
+    this._config.accountStore = store;
+    this._keypairs.push(keypair);
+    updateAccountStore(store);
+    console.log(
+      `[Vault] Created account "${name}" at index ${nextIndex} (${keypair.publicKey})`
+    );
+    return keypair;
+  }
+  /**
+   * Find an account by name. Returns null if not found.
+   */
+  findByName(name) {
+    this.assertUnlocked();
+    return this._keypairs.find((k) => k.name === name) ?? null;
+  }
+};
+
+// src/solana/rpc.ts
+import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
+var _connection = null;
+function getConnection(forceNew = false) {
+  if (!_connection || forceNew) {
+    const rpcUrl = getRpcUrl();
+    _connection = new Connection(rpcUrl, "confirmed");
+  }
+  return _connection;
+}
+function resetConnection() {
+  _connection = null;
+}
+async function getBalance(publicKeyStr) {
+  const connection = getConnection();
+  const pubkey = new PublicKey(publicKeyStr);
+  const lamports = await connection.getBalance(pubkey);
+  return {
+    lamports,
+    sol: lamports / LAMPORTS_PER_SOL
+  };
+}
+async function requestAirdrop(publicKeyStr, solAmount = 1) {
+  const cluster = getCluster();
+  if (cluster === "mainnet-beta") {
+    throw new Error("Airdrops are not available on mainnet.");
+  }
+  const connection = getConnection();
+  const pubkey = new PublicKey(publicKeyStr);
+  const lamports = solAmount * LAMPORTS_PER_SOL;
+  const signature = await connection.requestAirdrop(pubkey, lamports);
+  await connection.confirmTransaction(signature, "confirmed");
+  return signature;
+}
+async function getLatestBlockhash() {
+  const connection = getConnection();
+  return connection.getLatestBlockhash("confirmed");
+}
+async function confirmTransaction(signature, timeoutMs = 3e4) {
+  const connection = getConnection();
+  const { blockhash, lastValidBlockHeight } = await getLatestBlockhash();
+  const result = await connection.confirmTransaction(
+    { signature, blockhash, lastValidBlockHeight },
+    "confirmed"
+  );
+  return !result.value.err;
+}
+async function healthCheck() {
+  try {
+    const connection = getConnection();
+    await connection.getVersion();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/solana/simulate.ts
+import {
+  Transaction,
+  VersionedTransaction,
+  LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2
+} from "@solana/web3.js";
+async function simulateTransaction(serializedTx, signerPublicKey, conn) {
+  const connection = conn ?? getConnection();
+  try {
+    const txBuffer = Buffer.from(serializedTx, "base64");
+    let simulation;
+    try {
+      const versionedTx = VersionedTransaction.deserialize(txBuffer);
+      simulation = await connection.simulateTransaction(versionedTx, {
+        sigVerify: false,
+        // skip sig verification — wallet hasn't signed yet
+        replaceRecentBlockhash: true
+      });
+    } catch {
+      const legacyTx = Transaction.from(txBuffer);
+      simulation = await connection.simulateTransaction(legacyTx, []);
+    }
+    const { value } = simulation;
+    return parseSimulationResult(value, signerPublicKey, txBuffer);
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Simulation failed",
+      logs: [],
+      accountChanges: [],
+      tokenChanges: [],
+      computeUnitsConsumed: 0,
+      programIds: [],
+      fee: 0,
+      rawLogs: []
+    };
+  }
+}
+function parseSimulationResult(value, signerPublicKey, txBuffer) {
+  const success = !value.err;
+  const logs = value.logs ?? [];
+  const accountChanges = (value.accounts ?? []).map((account, i) => {
+    if (!account) return null;
+    const preBalance = account.lamports ?? 0;
+    const postBalance = account.lamports ?? 0;
+    return {
+      address: signerPublicKey,
+      // simplified — full impl maps account indices
+      preBalance,
+      postBalance,
+      solDelta: (postBalance - preBalance) / LAMPORTS_PER_SOL2,
+      isWritable: true,
+      isSigner: i === 0
+    };
+  }).filter(Boolean);
+  const programIds = extractProgramIds(logs);
+  const computeUnitsConsumed = extractComputeUnits(logs);
+  const fee = 5e3;
+  return {
+    success,
+    error: value.err ? JSON.stringify(value.err) : null,
+    logs: formatLogs(logs),
+    accountChanges,
+    tokenChanges: [],
+    // full SPL parsing requires additional RPC calls
+    computeUnitsConsumed,
+    programIds,
+    fee,
+    rawLogs: logs
+  };
+}
+function extractProgramIds(logs) {
+  const ids = /* @__PURE__ */ new Set();
+  const invokePattern = /Program (\w+) invoke/;
+  for (const log of logs) {
+    const match = log.match(invokePattern);
+    if (match) ids.add(match[1]);
+  }
+  return Array.from(ids);
+}
+function extractComputeUnits(logs) {
+  for (const log of logs) {
+    const match = log.match(/consumed (\d+) of/);
+    if (match) return parseInt(match[1], 10);
+  }
+  return 0;
+}
+function formatLogs(logs) {
+  return logs.map((log) => {
+    return log.replace(/\b([1-9A-HJ-NP-Za-km-z]{32,44})\b/g, (addr) => {
+      const known = KNOWN_PROGRAMS[addr];
+      return known ? known : `${addr.slice(0, 4)}..${addr.slice(-4)}`;
+    });
+  });
+}
+var KNOWN_PROGRAMS = {
+  "11111111111111111111111111111111": "System Program",
+  TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA: "SPL Token",
+  JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4: "Jupiter V6",
+  "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin": "Serum DEX",
+  ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJe1bv: "Associated Token",
+  SysvarRent111111111111111111111111111111111: "Sysvar Rent",
+  SysvarC1ock11111111111111111111111111111111: "Sysvar Clock"
+};
+
+// src/solana/tx.ts
+import {
+  Transaction as Transaction2,
+  VersionedTransaction as VersionedTransaction2,
+  Keypair
+} from "@solana/web3.js";
+import nacl2 from "tweetnacl";
+import bs582 from "bs58";
+async function signTransaction(serializedTx, keypair) {
+  const txBuffer = Buffer.from(serializedTx, "base64");
+  const solanaKeypair = toSolanaKeypair(keypair);
+  try {
+    const versionedTx = VersionedTransaction2.deserialize(txBuffer);
+    versionedTx.sign([solanaKeypair]);
+    const serialized = Buffer.from(versionedTx.serialize()).toString("base64");
+    const signature = bs582.encode(versionedTx.signatures[0]);
+    return { serialized, signature };
+  } catch {
+    const legacyTx = Transaction2.from(txBuffer);
+    legacyTx.partialSign(solanaKeypair);
+    const serialized = legacyTx.serialize({ requireAllSignatures: false }).toString("base64");
+    const signature = bs582.encode(legacyTx.signature);
+    return { serialized, signature };
+  }
+}
+async function signAllTransactions(serializedTxs, keypair) {
+  return Promise.all(serializedTxs.map((tx) => signTransaction(tx, keypair)));
+}
+async function signAndSendTransaction(serializedTx, keypair, options = {}, conn) {
+  const { serialized } = await signTransaction(serializedTx, keypair);
+  return sendSignedTransaction(serialized, options, conn);
+}
+async function sendSignedTransaction(serializedSignedTx, options = {}, conn) {
+  const connection = conn ?? getConnection();
+  const txBuffer = Buffer.from(serializedSignedTx, "base64");
+  const sendOptions = {
+    skipPreflight: false,
+    // run preflight checks
+    preflightCommitment: "confirmed",
+    ...options
+  };
+  let txHash;
+  try {
+    const versionedTx = VersionedTransaction2.deserialize(txBuffer);
+    txHash = await connection.sendTransaction(versionedTx, sendOptions);
+  } catch {
+    const legacyTx = Transaction2.from(txBuffer);
+    txHash = await connection.sendRawTransaction(
+      legacyTx.serialize(),
+      sendOptions
+    );
+  }
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  const confirmResult = await connection.confirmTransaction(
+    { signature: txHash, blockhash, lastValidBlockHeight },
+    "confirmed"
+  );
+  return {
+    txHash,
+    confirmed: !confirmResult.value.err
+  };
+}
+function signOffchainMessage(message, keypair) {
+  const signature = nacl2.sign.detached(message, keypair.secretKey);
+  return bs582.encode(Buffer.from(signature));
+}
+function toSolanaKeypair(keypair) {
+  return Keypair.fromSecretKey(keypair.secretKey);
+}
+
+// src/cli/ui.tsx
+import React2, { useState as useState2, useEffect, useRef as useRef2 } from "react";
+import { render as render2, Box as Box2, Text as Text2, useInput as useInput2, useApp as useApp2 } from "ink";
+
+// src/cli/commands.ts
+import chalk2 from "chalk";
+
+// src/handler/walletConnect.ts
+import SignClientPkg from "@walletconnect/sign-client";
+import { getSdkError } from "@walletconnect/utils";
+import chalk from "chalk";
+
+// src/handler/index.ts
+import bs583 from "bs58";
+var ERROR_CODES = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  CHAIN_DISCONNECTED: 4901
+};
+var WalletRequestHandler = class {
+  vault;
+  constructor(vault) {
+    this.vault = vault;
+  }
+  /**
+   * Handle any incoming wallet request.
+   * This is the single entry point — all bridges call this.
+   */
+  async handle(request) {
+    try {
+      switch (request.method) {
+        case "solana_connect":
+          return this.handleConnect(request);
+        case "solana_disconnect":
+          return this.handleDisconnect(request);
+        case "solana_signTransaction":
+          return this.handleSignTransaction(request);
+        case "solana_signAndSendTransaction":
+          return this.handleSignAndSend(request);
+        case "solana_signAllTransactions":
+          return this.handleSignAll(request);
+        case "solana_signMessage":
+          return this.handleSignMessage(request);
+        default:
+          return this.errorResponse(
+            request.id,
+            ERROR_CODES.UNSUPPORTED_METHOD,
+            `Method not supported: ${request.method}`
+          );
+      }
+    } catch (err) {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        err instanceof Error ? err.message : "Unknown error"
+      );
+    }
+  }
+  // ── Connect / Disconnect ───────────────────────────────────────────────────
+  async handleConnect(request) {
+    const keypair = this.vault.getActiveKeypair();
+    return {
+      id: request.id,
+      result: {
+        publicKey: keypair.publicKey
+      }
+    };
+  }
+  async handleDisconnect(request) {
+    return { id: request.id, result: { disconnected: true } };
+  }
+  // ── Sign Transaction ───────────────────────────────────────────────────────
+  async handleSignTransaction(request) {
+    const tx = request.params.transaction;
+    if (!tx) return this.errorResponse(request.id, 4e3, "Missing transaction");
+    const keypair = this.vault.getActiveKeypair();
+    const simulation = await simulateTransaction(tx, keypair.publicKey);
+    this.log(request, `simulate \u2192 ${simulation.success ? "ok" : "fail"}`);
+    if (!simulation.success) {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        `Simulation failed: ${simulation.error}`
+      );
+    }
+    const signed = await signTransaction(tx, keypair);
+    this.log(request, `signed \u2192 ${signed.signature.slice(0, 8)}...`);
+    return {
+      id: request.id,
+      result: { signedTransaction: signed.serialized }
+    };
+  }
+  // ── Sign and Send ──────────────────────────────────────────────────────────
+  async handleSignAndSend(request) {
+    const tx = request.params.transaction;
+    if (!tx) return this.errorResponse(request.id, 4e3, "Missing transaction");
+    const keypair = this.vault.getActiveKeypair();
+    const simulation = await simulateTransaction(tx, keypair.publicKey);
+    this.log(request, `simulate \u2192 ${simulation.success ? "ok" : "fail"}`);
+    if (!simulation.success) {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        `Simulation failed: ${simulation.error}`
+      );
+    }
+    const result = await signAndSendTransaction(tx, keypair);
+    this.log(request, `sent \u2192 ${result.txHash.slice(0, 8)}...`);
+    return {
+      id: request.id,
+      result: {
+        signature: result.txHash,
+        confirmed: result.confirmed
+      }
+    };
+  }
+  // ── Sign All Transactions ──────────────────────────────────────────────────
+  async handleSignAll(request) {
+    const txs = request.params.transactions;
+    if (!txs?.length)
+      return this.errorResponse(request.id, 4e3, "Missing transactions");
+    const keypair = this.vault.getActiveKeypair();
+    for (const tx of txs) {
+      const simulation = await simulateTransaction(tx, keypair.publicKey);
+      if (!simulation.success) {
+        return this.errorResponse(
+          request.id,
+          4e3,
+          `Simulation failed for tx in batch: ${simulation.error}`
+        );
+      }
+    }
+    const signed = await signAllTransactions(txs, keypair);
+    this.log(request, `signed ${signed.length} transactions`);
+    return {
+      id: request.id,
+      result: { signedTransactions: signed.map((s) => s.serialized) }
+    };
+  }
+  // ── Sign Message ───────────────────────────────────────────────────────────
+  async handleSignMessage(request) {
+    const message = request.params.message;
+    if (!message)
+      return this.errorResponse(request.id, 4e3, "Missing message");
+    const keypair = this.vault.getActiveKeypair();
+    let messageBytes;
+    try {
+      messageBytes = decodeMessage(message);
+    } catch {
+      return this.errorResponse(
+        request.id,
+        4e3,
+        "Could not decode message bytes"
+      );
+    }
+    const signature = signOffchainMessage(messageBytes, keypair);
+    this.log(request, "message signed");
+    return {
+      id: request.id,
+      result: {
+        signature,
+        publicKey: keypair.publicKey
+      }
+    };
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  errorResponse(id, code, message) {
+    return { id, error: { code, message } };
+  }
+  // TODO: handle logging
+  log(request, note) {
+  }
+};
+function decodeMessage(message) {
+  try {
+    const decoded = bs583.decode(message);
+    if (decoded.length > 0) return decoded;
+  } catch {
+  }
+  try {
+    const decoded = Buffer.from(message, "base64");
+    if (decoded.length > 0) return decoded;
+  } catch {
+  }
+  return new TextEncoder().encode(message);
+}
+async function handleRequest(request, options) {
+  const handler = new WalletRequestHandler(options.vault);
+  return handler.handle(request);
+}
+
+// src/session/index.ts
+import * as fs3 from "fs";
+function read() {
+  ensureWalletDir();
+  if (!fs3.existsSync(SESSIONS_FILE)) return { sessions: [] };
+  return JSON.parse(fs3.readFileSync(SESSIONS_FILE, "utf8"));
+}
+function write(store) {
+  ensureWalletDir();
+  fs3.writeFileSync(SESSIONS_FILE, JSON.stringify(store, null, 2));
+}
+function saveSession(session) {
+  const store = read();
+  const idx = store.sessions.findIndex((s) => s.topic === session.topic);
+  if (idx >= 0) {
+    store.sessions[idx] = session;
+  } else {
+    store.sessions.push(session);
+  }
+  write(store);
+}
+function removeSession(topic) {
+  const store = read();
+  store.sessions = store.sessions.filter((s) => s.topic !== topic);
+  write(store);
+}
+function getSession(topic) {
+  return read().sessions.find((s) => s.topic === topic);
+}
+function getAllSessions() {
+  return read().sessions.filter((s) => s.active);
+}
+function updateActivity(topic) {
+  const store = read();
+  const sess = store.sessions.find((s) => s.topic === topic);
+  if (sess) {
+    sess.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    write(store);
+  }
+}
+function markInactive(topic) {
+  const store = read();
+  const sess = store.sessions.find((s) => s.topic === topic);
+  if (sess) {
+    sess.active = false;
+    write(store);
+  }
+}
+
+// src/handler/walletConnect.ts
+var SignClient = SignClientPkg.default ?? SignClientPkg;
+var CHAIN_ID = "solana:devnet";
+var signClient = null;
+async function initWalletConnect(opts) {
+  signClient = await SignClient.init({
+    projectId: opts.projectId,
+    metadata: {
+      name: "Agentic Wallet",
+      description: "Autonomous AI agent wallet for Solana",
+      url: "https://github.com/your-repo/agentic-wallet",
+      icons: []
+    }
+  });
+  console.log(chalk.green("[WC] WalletConnect initialized"));
+  signClient.on("session_proposal", async ({ id, params }) => {
+    const meta = params.proposer.metadata;
+    console.log(
+      chalk.cyan(`
+[WC] Session proposal from: ${meta.name} (${meta.url})`)
+    );
+    let approved = true;
+    if (opts.onSessionProposal) {
+      approved = await opts.onSessionProposal(meta);
+    }
+    if (!approved) {
+      await signClient.reject({ id, reason: getSdkError("USER_REJECTED") });
+      console.log(chalk.red("[WC] Session rejected"));
+      return;
+    }
+    const account = opts.handlerOptions.vault.getActiveKeypair();
+    const { topic, acknowledged } = await signClient.approve({
+      id,
+      namespaces: {
+        solana: {
+          accounts: [`${CHAIN_ID}:${account.publicKey}`],
+          methods: [
+            "solana_signTransaction",
+            "solana_signAndSendTransaction",
+            "solana_signAllTransactions",
+            "solana_signMessage"
+          ],
+          events: []
+        }
+      }
+    });
+    await acknowledged();
+    saveSession({
+      topic,
+      dappName: meta.name,
+      dappUrl: meta.url,
+      dappIcon: meta.icons?.[0],
+      connectedAccount: account.publicKey,
+      connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      permissions: [
+        "solana_signTransaction",
+        "solana_signAndSendTransaction",
+        "solana_signAllTransactions",
+        "solana_signMessage"
+      ],
+      chainId: CHAIN_ID,
+      active: true
+    });
+    console.log(chalk.green(`[WC] Connected to ${meta.name}`));
+    console.log(chalk.dim(`     Address: ${account.publicKey}`));
+  });
+  signClient.on("session_request", async ({ id, topic, params }) => {
+    const session = signClient.session.get(topic);
+    const dapp = {
+      name: session.peer.metadata.name,
+      url: session.peer.metadata.url
+    };
+    console.log(
+      chalk.yellow(
+        `
+[WC] Request: ${params.request.method} from ${dapp.name}`
+      )
+    );
+    const request = {
+      id,
+      method: params.request.method,
+      params: params.request.params,
+      dapp,
+      topic
+    };
+    const response = await handleRequest(request, opts.handlerOptions);
+    const jsonRpcResponse = response.error ? {
+      id,
+      jsonrpc: "2.0",
+      error: { code: response.error.code, message: response.error.message }
+    } : { id, jsonrpc: "2.0", result: response.result ?? null };
+    await signClient.respond({ topic, response: jsonRpcResponse });
+    if (response.error) {
+      console.log(chalk.red(`[WC] Rejected: ${response.error.message}`));
+    } else {
+      console.log(chalk.green(`[WC] Request fulfilled`));
+    }
+  });
+  signClient.on("session_delete", ({ topic }) => {
+    markInactive(topic);
+    console.log(
+      chalk.dim(`[WC] dApp disconnected (topic: ${topic.slice(0, 8)}...)`)
+    );
+  });
+  return signClient;
+}
+async function pairWithDapp(uri) {
+  if (!signClient) throw new Error("WalletConnect not initialised");
+  console.log(chalk.dim("[WC] Connecting to dApp..."));
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signClient.off("session_proposal", onProposal);
+      reject(new Error("WalletConnect pairing timed out after 30s"));
+    }, 3e4);
+    const onProposal = ({ params }) => {
+      clearTimeout(timeout);
+      signClient.off("session_proposal", onProposal);
+      const meta = params.proposer.metadata;
+      console.log(
+        chalk.cyan(
+          `[WC] Request from: ${chalk.bold(meta.name)} (${meta.url})`,
+          params
+        )
+      );
+      resolve();
+    };
+    signClient.on("session_proposal", onProposal);
+    signClient.core.pairing.pair({ uri }).catch((err) => {
+      clearTimeout(timeout);
+      signClient.off("session_proposal", onProposal);
+      reject(err);
+    });
+  });
+}
+async function disconnectDapp(topic) {
+  if (!signClient) throw new Error("WalletConnect not initialised");
+  await signClient.disconnect({
+    topic,
+    reason: getSdkError("USER_DISCONNECTED")
+  });
+  removeSession(topic);
+  console.log(
+    chalk.dim(`[WC] Disconnected from topic ${topic.slice(0, 8)}...`)
+  );
+}
+function getSignClient() {
+  return signClient;
+}
+
+// src/cli/prompts.tsx
+import React, { useState, useRef } from "react";
+import { render, Box, Text, useInput, useApp } from "ink";
+function inkPassword(question) {
+  return new Promise((resolve) => {
+    let result = "";
+    function PasswordPrompt() {
+      const { exit } = useApp();
+      const valueRef = useRef("");
+      const [maskLen, setMaskLen] = useState(0);
+      useInput((input, key) => {
+        if (key.return) {
+          result = valueRef.current;
+          exit();
+          return;
+        }
+        if (key.backspace || key.delete) {
+          if (valueRef.current.length > 0) {
+            valueRef.current = valueRef.current.slice(0, -1);
+            setMaskLen(valueRef.current.length);
+          }
+          return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+          valueRef.current += input;
+          setMaskLen(valueRef.current.length);
+        }
+      });
+      return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { bold: true }, question, " "), /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "*".repeat(maskLen)));
+    }
+    const { waitUntilExit } = render(/* @__PURE__ */ React.createElement(PasswordPrompt, null));
+    waitUntilExit().then(() => resolve(result));
+  });
+}
+function inkSelect(message, choices) {
+  return new Promise((resolve) => {
+    let result = choices[0].value;
+    function SelectPrompt() {
+      const { exit } = useApp();
+      const cursorRef = useRef(0);
+      const [cursor, setCursor] = useState(0);
+      useInput((_, key) => {
+        if (key.upArrow) {
+          const n = Math.max(0, cursorRef.current - 1);
+          cursorRef.current = n;
+          setCursor(n);
+        }
+        if (key.downArrow) {
+          const n = Math.min(choices.length - 1, cursorRef.current + 1);
+          cursorRef.current = n;
+          setCursor(n);
+        }
+        if (key.return) {
+          result = choices[cursorRef.current].value;
+          exit();
+        }
+      });
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true }, message), choices.map((choice, i) => /* @__PURE__ */ React.createElement(Box, { key: i }, /* @__PURE__ */ React.createElement(Text, { color: i === cursor ? "cyan" : "gray" }, i === cursor ? "\u276F " : "  ", choice.name))));
+    }
+    const { waitUntilExit } = render(/* @__PURE__ */ React.createElement(SelectPrompt, null));
+    waitUntilExit().then(() => resolve(result));
+  });
+}
+function inkConfirm(message, defaultYes = false) {
+  return new Promise((resolve) => {
+    let result = defaultYes;
+    function ConfirmPrompt() {
+      const { exit } = useApp();
+      useInput((input, key) => {
+        if (key.return) {
+          result = defaultYes;
+          exit();
+          return;
+        }
+        const ch = input.toLowerCase();
+        if (ch === "y") {
+          result = true;
+          exit();
+        } else if (ch === "n") {
+          result = false;
+          exit();
+        }
+      });
+      const hint = defaultYes ? "Y/n" : "y/N";
+      return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { bold: true }, message, " "), /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "[", hint, "] "));
+    }
+    const { waitUntilExit } = render(/* @__PURE__ */ React.createElement(ConfirmPrompt, null));
+    waitUntilExit().then(() => resolve(result));
+  });
+}
+
+// src/cli/commands.ts
+var sessionPassword = null;
+var sessionMnemonic = null;
+function isUnlocked() {
+  return sessionMnemonic !== null;
+}
+async function requireUnlocked() {
+  if (!sessionPassword || !sessionMnemonic) {
+    throw new Error("Wallet is locked. Run: wallet unlock");
+  }
+  return { password: sessionPassword, mnemonic: sessionMnemonic };
+}
+async function cmdInit() {
+  if (vaultExists()) {
+    console.log(
+      chalk2.yellow("Vault already exists. Use `wallet unlock` to access it.")
+    );
+    return;
+  }
+  const wordCount = await inkSelect("Mnemonic length:", [
+    { name: "12 words (standard)", value: 12 },
+    { name: "24 words (extra secure)", value: 24 }
+  ]);
+  const { mnemonic } = generateMnemonic2(wordCount);
+  console.log(
+    chalk2.bold("\n\u26A0\uFE0F  Write down your seed phrase. Store it safely.\n")
+  );
+  console.log(chalk2.yellow(mnemonic));
+  console.log();
+  const confirmed = await inkConfirm(
+    "I have written down my seed phrase",
+    false
+  );
+  if (!confirmed) {
+    console.log(chalk2.red("Aborted."));
+    return;
+  }
+  const password = await inkPassword("Set vault password:");
+  const confirm = await inkPassword("Confirm password:");
+  if (password !== confirm) {
+    console.log(chalk2.red("Passwords do not match."));
+    return;
+  }
+  const seed = await mnemonicToSeed2(mnemonic);
+  const firstKp = deriveAccount(seed, 0, "Main");
+  await saveVault(
+    { mnemonic, createdAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 },
+    password
+  );
+  const config = createConfig("");
+  config.accountStore.accounts[0] = {
+    index: 0,
+    name: "Main",
+    publicKey: firstKp.publicKey,
+    derivationPath: `m/44'/501'/0'/0'`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveConfig(config);
+  sessionPassword = password;
+  sessionMnemonic = mnemonic;
+  console.log(chalk2.green("\n\u2713 Wallet created"));
+  console.log(chalk2.dim(`  Address: ${firstKp.publicKey}`));
+}
+async function cmdUnlock() {
+  if (!vaultExists()) {
+    console.log(chalk2.red("No vault found. Run: wallet init"));
+    return;
+  }
+  const password = await inkPassword("Vault password:");
+  try {
+    const vault = await loadVault(password);
+    sessionPassword = password;
+    sessionMnemonic = vault.mnemonic;
+    console.log(chalk2.green("\u2713 Wallet unlocked"));
+  } catch {
+    console.log(chalk2.red("Wrong password."));
+  }
+}
+function cmdLock() {
+  sessionPassword = null;
+  sessionMnemonic = null;
+  console.log(chalk2.green("\u2713 Wallet locked"));
+}
+async function cmdAccounts() {
+  await requireUnlocked();
+  const config = loadConfig();
+  console.log(chalk2.bold("\n\u2500\u2500 Accounts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  for (const entry of config.accountStore.accounts) {
+    const active = entry.index === config.accountStore.activeIndex;
+    const marker = active ? chalk2.green("\u25CF") : chalk2.dim("\u25CB");
+    let balance = "...";
+    try {
+      const { sol } = await getBalance(entry.publicKey);
+      balance = sol.toFixed(4) + " SOL";
+    } catch {
+    }
+    console.log(
+      `  ${marker} [${entry.index}] ${entry.name.padEnd(16)} ${entry.publicKey}  ${balance}`
+    );
+  }
+  console.log(chalk2.dim(`
+  Network: ${config.cluster} (${config.rpcUrl})`));
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+}
+async function cmdNewAccount(name) {
+  const { mnemonic } = await requireUnlocked();
+  const config = loadConfig();
+  const nextIndex = config.accountStore.accounts.length;
+  const accountName = name || `Account ${nextIndex + 1}`;
+  const seed = await mnemonicToSeed2(mnemonic);
+  const keypair = deriveAccount(seed, nextIndex, accountName);
+  updateAccountStore({
+    ...config.accountStore,
+    accounts: [
+      ...config.accountStore.accounts,
+      {
+        index: nextIndex,
+        name: accountName,
+        publicKey: keypair.publicKey,
+        derivationPath: `m/44'/501'/${nextIndex}'/0'`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  });
+  console.log(chalk2.green(`\u2713 Account created: ${accountName}`));
+  console.log(chalk2.dim(`  Address: ${keypair.publicKey}`));
+}
+async function cmdUseAccount(nameOrIndex) {
+  await requireUnlocked();
+  const config = loadConfig();
+  const found = config.accountStore.accounts.find(
+    (a) => a.name === nameOrIndex || a.index === parseInt(nameOrIndex)
+  );
+  if (!found) {
+    console.log(chalk2.red(`Account not found: ${nameOrIndex}`));
+    return;
+  }
+  updateAccountStore({ ...config.accountStore, activeIndex: found.index });
+  console.log(
+    chalk2.green(`\u2713 Active account: ${found.name} (${found.publicKey})`)
+  );
+}
+async function cmdAirdrop(sol = 1) {
+  await requireUnlocked();
+  const config = loadConfig();
+  const active = config.accountStore.accounts.find(
+    (a) => a.index === config.accountStore.activeIndex
+  );
+  if (!active) {
+    console.log(chalk2.red("No active account."));
+    return;
+  }
+  console.log(chalk2.dim(`Requesting ${sol} SOL airdrop...`));
+  try {
+    const sig = await requestAirdrop(active.publicKey, sol);
+    console.log(chalk2.green(`\u2713 Airdrop complete`));
+    console.log(chalk2.dim(`  tx: ${sig}`));
+  } catch (err) {
+    console.log(chalk2.red(`Airdrop failed: ${err.message}`));
+  }
+}
+async function cmdConnect(wcUri) {
+  if (!wcUri || !wcUri.startsWith("wc:")) {
+    console.log(chalk2.red("Invalid WalletConnect URI. Must start with wc:"));
+    return;
+  }
+  console.log(chalk2.dim("Pairing with dApp..."));
+  await pairWithDapp(wcUri);
+}
+function cmdSessions() {
+  const sessions = getAllSessions();
+  if (sessions.length === 0) {
+    console.log(chalk2.dim("No active sessions."));
+    return;
+  }
+  console.log(chalk2.bold("\n\u2500\u2500 Connected dApps \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  sessions.forEach((s) => {
+    console.log(
+      `  ${chalk2.cyan(s.dappName.padEnd(20))} ${s.connectedAccount.slice(0, 8)}...  since ${s.connectedAt.slice(0, 10)}`
+    );
+    console.log(
+      chalk2.dim(`    ${s.dappUrl}  topic: ${s.topic.slice(0, 8)}...`)
+    );
+  });
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+}
+async function cmdDisconnect(dappName) {
+  const sessions = getAllSessions();
+  const session = sessions.find(
+    (s) => s.dappName.toLowerCase().includes(dappName.toLowerCase())
+  );
+  if (!session) {
+    console.log(chalk2.red(`No session found for: ${dappName}`));
+    return;
+  }
+  await disconnectDapp(session.topic);
+  console.log(chalk2.green(`\u2713 Disconnected from ${session.dappName}`));
+}
+async function cmdSend(to, sol, vault) {
+  const { PublicKey: PublicKey2, SystemProgram, Transaction: Transaction3, LAMPORTS_PER_SOL: LAMPORTS_PER_SOL3 } = await import("@solana/web3.js");
+  const keypair = vault.getActiveKeypair();
+  const { Keypair: Keypair2 } = await import("@solana/web3.js");
+  const solanaKeypair = Keypair2.fromSecretKey(keypair.secretKey);
+  const connection = getConnection();
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+  const tx = new Transaction3().add(
+    SystemProgram.transfer({
+      fromPubkey: solanaKeypair.publicKey,
+      toPubkey: new PublicKey2(to),
+      lamports: Math.round(sol * LAMPORTS_PER_SOL3)
+    })
+  );
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = solanaKeypair.publicKey;
+  tx.sign(solanaKeypair);
+  const raw = tx.serialize();
+  const sig = await connection.sendRawTransaction(raw, {
+    skipPreflight: false,
+    preflightCommitment: "confirmed"
+  });
+  await connection.confirmTransaction(
+    { signature: sig, blockhash, lastValidBlockHeight },
+    "confirmed"
+  );
+  console.log(chalk2.green(`\u2713 Sent ${sol} SOL to ${to}`));
+  console.log(chalk2.dim(`  tx: ${sig}`));
+}
+function cmdSetCluster(cluster) {
+  const valid = ["mainnet-beta", "devnet", "testnet"];
+  if (!valid.includes(cluster)) {
+    console.log(chalk2.red(`Valid clusters: ${valid.join(", ")}`));
+    return;
+  }
+  updateCluster(cluster);
+  console.log(chalk2.green(`\u2713 Cluster set to: ${cluster}`));
+}
+
+// src/cli/ui.tsx
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function logColor(type) {
+  switch (type) {
+    case "success":
+      return "green";
+    case "error":
+      return "red";
+    case "warn":
+      return "yellow";
+    default:
+      return "gray";
+  }
+}
+function Header({ cluster }) {
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u2B21 Agentic Wallet"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " ", cluster)), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(60)));
+}
+function AccountRow({
+  index,
+  name,
+  publicKey,
+  balance,
+  isActive
+}) {
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: isActive ? "green" : "gray" }, isActive ? "\u25CF" : "\u25CB", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "[", index, "] "), /* @__PURE__ */ React2.createElement(Text2, { bold: isActive }, name.padEnd(18)), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, publicKey.slice(0, 6), "...", publicKey.slice(-4), " "), /* @__PURE__ */ React2.createElement(Text2, { color: isActive ? "cyan" : "gray" }, balance));
+}
+function SessionRow({
+  name,
+  url,
+  account
+}) {
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "\u25C9 "), /* @__PURE__ */ React2.createElement(Text2, { bold: true }, name.padEnd(20)), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, url.slice(0, 30).padEnd(32)), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, account.slice(0, 6), "...", account.slice(-4)));
+}
+function AgentRow({ agent }) {
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: agent.running ? "green" : "gray" }, agent.running ? "\u25B6" : "\u25A0", " "), /* @__PURE__ */ React2.createElement(Text2, { bold: agent.running }, agent.id.padEnd(22)), /* @__PURE__ */ React2.createElement(Text2, { color: agent.running ? "cyan" : "gray" }, agent.running ? "RUNNING" : "STOPPED", "  "), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "runs: ", agent.runCount), agent.error && /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, " \u26A0 ", agent.error.slice(0, 30)));
+}
+function LogRow({ entry }) {
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, entry.time, " "), /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, entry.source.padEnd(20)), /* @__PURE__ */ React2.createElement(Text2, { color: logColor(entry.type) }, entry.message));
+}
+function PromptRow({
+  prompt,
+  maskLen,
+  cursor
+}) {
+  if (prompt.type === "password") {
+    return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, prompt.question, " "), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "*".repeat(maskLen)), /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "\u2588"));
+  }
+  if (prompt.type === "select") {
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { bold: true }, prompt.message), prompt.choices.map((c, i) => /* @__PURE__ */ React2.createElement(Box2, { key: i }, /* @__PURE__ */ React2.createElement(Text2, { color: i === cursor ? "cyan" : "gray" }, i === cursor ? "\u276F " : "  ", c.name))));
+  }
+  if (prompt.type === "confirm") {
+    const hint = prompt.defaultYes ? "Y/n" : "y/N";
+    return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true }, prompt.message, " "), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "[", hint, "]"));
+  }
+  return null;
+}
+function CommandBar({ buffer, running }) {
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "green", bold: true }, "wallet"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " \u203A "), running ? /* @__PURE__ */ React2.createElement(Text2, { color: "yellow", dimColor: true }, "running\u2026") : /* @__PURE__ */ React2.createElement(Text2, null, buffer, /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "\u2588")));
+}
+function Dashboard({ vault, agentStatus, onExit }) {
+  const { exit } = useApp2();
+  const [view, setView] = useState2("dashboard");
+  const [accounts, setAccounts] = useState2([]);
+  const [balances, setBalances] = useState2({});
+  const [sessions, setSessions] = useState2([]);
+  const [cluster, setCluster] = useState2("devnet");
+  const [cmdBuffer, setCmdBuffer] = useState2("");
+  const [cmdRunning, setCmdRunning] = useState2(false);
+  const [promptState, setPromptState] = useState2(null);
+  const promptResolverRef = useRef2(null);
+  const passwordValueRef = useRef2("");
+  const [passwordMaskLen, setPasswordMaskLen] = useState2(0);
+  const selectCursorRef = useRef2(0);
+  const [selectCursor, setSelectCursor] = useState2(0);
+  const [uiLogs, setUiLogs] = useState2([...logBuffer]);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      try {
+        const keypairs = vault.getAllKeypairs();
+        setAccounts(keypairs);
+        setCluster(getCluster());
+        setSessions(getAllSessions());
+        keypairs.forEach(async (kp) => {
+          try {
+            const { sol } = await getBalance(kp.publicKey);
+            setBalances((prev) => ({
+              ...prev,
+              [kp.publicKey]: sol.toFixed(4) + " SOL"
+            }));
+          } catch {
+            setBalances((prev) => ({ ...prev, [kp.publicKey]: "..." }));
+          }
+        });
+      } catch {
+      }
+    }, 2e3);
+    return () => clearInterval(interval);
+  }, []);
+  useEffect(() => {
+    const interval = setInterval(() => setSessions(getAllSessions()), 5e3);
+    return () => clearInterval(interval);
+  }, []);
+  useEffect(() => {
+    const fn = (updated) => setUiLogs(updated);
+    logListeners.push(fn);
+    return () => {
+      const idx = logListeners.indexOf(fn);
+      if (idx >= 0) logListeners.splice(idx, 1);
+    };
+  }, []);
+  const requestPrompt = (state) => new Promise((resolve) => {
+    promptResolverRef.current = resolve;
+    if (state.type === "password") {
+      passwordValueRef.current = "";
+      setPasswordMaskLen(0);
+    }
+    if (state.type === "select") {
+      selectCursorRef.current = 0;
+      setSelectCursor(0);
+    }
+    setPromptState(state);
+  });
+  const resolvePrompt = (val) => {
+    promptResolverRef.current?.(val);
+    promptResolverRef.current = null;
+    passwordValueRef.current = "";
+    setPasswordMaskLen(0);
+    selectCursorRef.current = 0;
+    setSelectCursor(0);
+    setPromptState(null);
+  };
+  const withCapture = async (fn) => {
+    const origLog = console.log;
+    const origError = console.error;
+    console.log = (...args) => {
+      const msg = stripAnsi(args.map(String).join(" ")).trim();
+      if (msg) addLog("wallet", msg, "info");
+    };
+    console.error = (...args) => {
+      const msg = stripAnsi(args.map(String).join(" ")).trim();
+      if (msg) addLog("wallet", msg, "error");
+    };
+    try {
+      await fn();
+    } finally {
+      console.log = origLog;
+      console.error = origError;
+    }
+  };
+  const handleInit = async () => {
+    if (vaultExists()) {
+      addLog(
+        "wallet",
+        "Vault already exists. Use `unlock` to access it.",
+        "warn"
+      );
+      return;
+    }
+    const wordCount = await requestPrompt({
+      type: "select",
+      message: "Mnemonic length:",
+      choices: [
+        { name: "12 words (standard)", value: 12 },
+        { name: "24 words (extra secure)", value: 24 }
+      ]
+    });
+    const { mnemonic } = generateMnemonic2(wordCount);
+    addLog(
+      "wallet",
+      "\u26A0  Write down your seed phrase and store it safely.",
+      "warn"
+    );
+    addLog("wallet", mnemonic, "warn");
+    const confirmed = await requestPrompt({
+      type: "confirm",
+      message: "I have written down my seed phrase",
+      defaultYes: false
+    });
+    if (!confirmed) {
+      addLog("wallet", "Aborted.", "error");
+      return;
+    }
+    const password = await requestPrompt({
+      type: "password",
+      question: "Set vault password:"
+    });
+    const confirmPw = await requestPrompt({
+      type: "password",
+      question: "Confirm password:"
+    });
+    if (password !== confirmPw) {
+      addLog("wallet", "Passwords do not match.", "error");
+      return;
+    }
+    const seed = await mnemonicToSeed2(mnemonic);
+    const firstKp = deriveAccount(seed, 0, "Main");
+    await saveVault(
+      { mnemonic, createdAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 },
+      password
+    );
+    const cfg = createConfig("");
+    cfg.accountStore.accounts[0] = {
+      index: 0,
+      name: "Main",
+      publicKey: firstKp.publicKey,
+      derivationPath: `m/44'/501'/0'/0'`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveConfig(cfg);
+    addLog("wallet", `\u2713 Wallet created \u2014 ${firstKp.publicKey}`, "success");
+  };
+  const handleUnlock = async () => {
+    if (!vaultExists()) {
+      addLog("wallet", "No vault found. Run: init", "error");
+      return;
+    }
+    const password = await requestPrompt({
+      type: "password",
+      question: "Vault password:"
+    });
+    try {
+      await loadVault(password);
+      addLog("wallet", "\u2713 Wallet unlocked", "success");
+    } catch {
+      addLog("wallet", "Wrong password.", "error");
+    }
+  };
+  const handleSend = async (to, amount) => {
+    if (!to || !amount) {
+      addLog("wallet", "Usage: send <address> <sol>", "warn");
+      return;
+    }
+    const confirmed = await requestPrompt({
+      type: "confirm",
+      message: `Send ${amount} SOL to ${to.slice(0, 8)}...${to.slice(-4)}?`,
+      defaultYes: false
+    });
+    if (!confirmed) {
+      addLog("wallet", "Cancelled.", "warn");
+      return;
+    }
+    await withCapture(() => cmdSend(to, amount, vault));
+  };
+  const executeCommand = async (line) => {
+    const parts = line.trim().split(/\s+/);
+    const cmd = parts[0];
+    setCmdRunning(true);
+    addLog("wallet", `> ${line}`, "info");
+    try {
+      switch (cmd) {
+        case "":
+          break;
+        case "help":
+          addLog(
+            "wallet",
+            "init  unlock  lock  accounts [new|use]  send <addr> <sol>  airdrop [sol]  connect <wc:uri>  sessions  disconnect <dapp>  cluster <name>  exit",
+            "info"
+          );
+          break;
+        case "exit":
+        case "quit":
+          onExit();
+          exit();
+          break;
+        case "init":
+          await handleInit();
+          break;
+        case "unlock":
+          await handleUnlock();
+          break;
+        case "lock":
+          await withCapture(async () => cmdLock());
+          break;
+        case "send":
+          await handleSend(parts[1], Number(parts[2]));
+          break;
+        case "airdrop":
+          await withCapture(() => cmdAirdrop(Number(parts[1]) || 1));
+          break;
+        case "connect":
+          await withCapture(() => cmdConnect(parts[1]));
+          break;
+        case "sessions":
+          await withCapture(async () => cmdSessions());
+          break;
+        case "disconnect":
+          await withCapture(() => cmdDisconnect(parts.slice(1).join(" ")));
+          break;
+        case "cluster":
+          await withCapture(async () => cmdSetCluster(parts[1]));
+          break;
+        case "accounts":
+          if (parts[1] === "new") {
+            await withCapture(() => cmdNewAccount(parts.slice(2).join(" ")));
+          } else if (parts[1] === "use") {
+            await withCapture(() => cmdUseAccount(parts[2]));
+          } else {
+            await withCapture(() => cmdAccounts());
+          }
+          break;
+        default:
+          addLog("wallet", `Unknown: ${cmd}. Type "help".`, "warn");
+      }
+    } catch (err) {
+      addLog("wallet", `Error: ${err.message}`, "error");
+    } finally {
+      setCmdRunning(false);
+    }
+  };
+  useInput2((input, key) => {
+    if (key.ctrl && input === "c") {
+      onExit();
+      exit();
+      return;
+    }
+    if (promptState) {
+      if (promptState.type === "password") {
+        if (key.return) {
+          resolvePrompt(passwordValueRef.current);
+        } else if (key.backspace || key.delete) {
+          if (passwordValueRef.current.length > 0) {
+            passwordValueRef.current = passwordValueRef.current.slice(0, -1);
+            setPasswordMaskLen(passwordValueRef.current.length);
+          }
+        } else if (input && !key.ctrl && !key.meta) {
+          passwordValueRef.current += input;
+          setPasswordMaskLen(passwordValueRef.current.length);
+        }
+        return;
+      }
+      if (promptState.type === "select") {
+        if (key.upArrow) {
+          const n = Math.max(0, selectCursorRef.current - 1);
+          selectCursorRef.current = n;
+          setSelectCursor(n);
+        } else if (key.downArrow) {
+          const n = Math.min(
+            promptState.choices.length - 1,
+            selectCursorRef.current + 1
+          );
+          selectCursorRef.current = n;
+          setSelectCursor(n);
+        } else if (key.return) {
+          resolvePrompt(promptState.choices[selectCursorRef.current].value);
+        }
+        return;
+      }
+      if (promptState.type === "confirm") {
+        if (key.return) {
+          resolvePrompt(promptState.defaultYes);
+        } else if (input === "y" || input === "Y") {
+          resolvePrompt(true);
+        } else if (input === "n" || input === "N") {
+          resolvePrompt(false);
+        }
+        return;
+      }
+    }
+    if (!cmdBuffer && !cmdRunning) {
+      if (input === "1") {
+        setView("dashboard");
+        return;
+      }
+      if (input === "2") {
+        setView("accounts");
+        return;
+      }
+      if (input === "q") {
+        onExit();
+        exit();
+        return;
+      }
+    }
+    if (cmdRunning) return;
+    if (key.return) {
+      const cmd = cmdBuffer.trim();
+      setCmdBuffer("");
+      if (cmd) executeCommand(cmd);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setCmdBuffer((b) => b.slice(0, -1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta && !key.escape) {
+      setCmdBuffer((b) => b + input);
+    }
+  });
+  const activeKeypair = (() => {
+    try {
+      return vault.getActiveKeypair();
+    } catch {
+      return null;
+    }
+  })();
+  const recentLogs = uiLogs.slice(-12);
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React2.createElement(Header, { cluster }), /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React2.createElement(
+    Text2,
+    {
+      color: view === "dashboard" ? "cyan" : "gray",
+      bold: view === "dashboard"
+    },
+    "[1] Dashboard",
+    "  "
+  ), /* @__PURE__ */ React2.createElement(
+    Text2,
+    {
+      color: view === "accounts" ? "cyan" : "gray",
+      bold: view === "accounts"
+    },
+    "[2] Accounts",
+    "  "
+  ), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " q: quit")), view === "dashboard" && /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, "Active Account"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(40)), activeKeypair ? /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "\u25CF "), /* @__PURE__ */ React2.createElement(Text2, { bold: true }, activeKeypair.name.padEnd(18)), /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, activeKeypair.publicKey), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " ", balances[activeKeypair.publicKey] ?? "...")) : /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "No active account")), /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, "Connected dApps (", sessions.length, ")"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(40)), sessions.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "None \u2014 paste a wc: URI to connect") : sessions.map((s) => /* @__PURE__ */ React2.createElement(
+    SessionRow,
+    {
+      key: s.topic,
+      name: s.dappName,
+      url: s.dappUrl,
+      account: s.connectedAccount
+    }
+  ))), agentStatus.length > 0 && /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, "Agents (", agentStatus.filter((a) => a.running).length, " running)"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(40)), agentStatus.map((agent) => /* @__PURE__ */ React2.createElement(AgentRow, { key: agent.id, agent }))), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, "Activity"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(40)), recentLogs.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "Waiting for activity\u2026") : recentLogs.map((entry, i) => /* @__PURE__ */ React2.createElement(LogRow, { key: i, entry })))), view === "accounts" && /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, "All Accounts"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(60)), accounts.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "No accounts found") : accounts.map((acc) => /* @__PURE__ */ React2.createElement(
+    AccountRow,
+    {
+      key: acc.publicKey,
+      index: acc.index,
+      name: acc.name,
+      publicKey: acc.publicKey,
+      balance: balances[acc.publicKey] ?? "...",
+      isActive: acc.publicKey === activeKeypair?.publicKey
+    }
+  ))), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(60))), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "WebSocket: "), /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, "ws://localhost:3000"), /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, " \u2502 [1] Dashboard [2] Accounts [q] Quit")), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, "\u2500".repeat(60)), promptState ? /* @__PURE__ */ React2.createElement(
+    PromptRow,
+    {
+      prompt: promptState,
+      maskLen: passwordMaskLen,
+      cursor: selectCursor
+    }
+  ) : /* @__PURE__ */ React2.createElement(CommandBar, { buffer: cmdBuffer, running: cmdRunning })));
+}
+var logBuffer = [];
+var logListeners = [];
+function addLog(source, message, type = "info") {
+  const entry = {
+    time: (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8),
+    source,
+    message,
+    type
+  };
+  logBuffer.push(entry);
+  if (logBuffer.length > 200) logBuffer.shift();
+  logListeners.forEach((fn) => fn([...logBuffer]));
+}
+function startInkUI(vault, getAgentStatus, onExit) {
+  function App() {
+    const [agentStatus, setAgentStatus] = useState2(getAgentStatus());
+    useEffect(() => {
+      const interval = setInterval(
+        () => setAgentStatus(getAgentStatus()),
+        2e3
+      );
+      return () => clearInterval(interval);
+    }, []);
+    return /* @__PURE__ */ React2.createElement(Dashboard, { vault, agentStatus, onExit });
+  }
+  render2(/* @__PURE__ */ React2.createElement(App, null));
+}
+export {
+  ERROR_CODES,
+  KNOWN_PROGRAMS,
+  RPC_URLS,
+  SESSIONS_FILE,
+  WalletRequestHandler,
+  WalletVault,
+  addAccount,
+  addLog,
+  changePassword,
+  cmdAccounts,
+  cmdAirdrop,
+  cmdConnect,
+  cmdDisconnect,
+  cmdInit,
+  cmdLock,
+  cmdNewAccount,
+  cmdSend,
+  cmdSessions,
+  cmdSetCluster,
+  cmdUnlock,
+  cmdUseAccount,
+  configExists,
+  confirmTransaction,
+  createAccountStore,
+  createConfig,
+  deriveAccount,
+  deriveAccountFromMnemonic,
+  deriveAccounts,
+  disconnectDapp,
+  ensureWalletDir,
+  formatAccount,
+  generateMnemonic2 as generateMnemonic,
+  getAccountStore,
+  getActiveAccount,
+  getAllSessions,
+  getBalance,
+  getCluster,
+  getConfigPath,
+  getConnection,
+  getLatestBlockhash,
+  getRpcUrl,
+  getSession,
+  getSessionsPath,
+  getSignClient,
+  getVaultPath,
+  getWalletDir,
+  handleRequest,
+  healthCheck,
+  initWalletConnect,
+  inkConfirm,
+  inkPassword,
+  inkSelect,
+  isUnlocked,
+  loadConfig,
+  loadVault,
+  markInactive,
+  mnemonicToNumberedWords,
+  mnemonicToSeed2 as mnemonicToSeed,
+  pairWithDapp,
+  removeSession,
+  renameAccount,
+  requestAirdrop,
+  resetConnection,
+  saveConfig,
+  saveSession,
+  saveVault,
+  sendSignedTransaction,
+  setActiveAccount,
+  signAllTransactions,
+  signAndSendTransaction,
+  signMessage,
+  signOffchainMessage,
+  signTransaction,
+  simulateTransaction,
+  startInkUI,
+  updateAccountStore,
+  updateActivity,
+  updateCluster,
+  updateRpcUrl,
+  validateMnemonic2 as validateMnemonic,
+  vaultExists,
+  wordsToMnemonic
+};
+//# sourceMappingURL=index.js.map