@execra/core 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,1162 @@
+#!/usr/bin/env node
+
+// 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/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 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.");
+  }
+}
+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 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 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 updateAccountStore(accountStore) {
+  const config = loadConfig();
+  config.accountStore = accountStore;
+  saveConfig(config);
+}
+function getRpcUrl() {
+  return loadConfig().rpcUrl;
+}
+function getCluster() {
+  return loadConfig().cluster;
+}
+
+// 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;
+}
+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;
+}
+
+// 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/solana/simulate.ts
+import {
+  Transaction,
+  VersionedTransaction,
+  LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2
+} from "@solana/web3.js";
+
+// src/solana/tx.ts
+import {
+  Transaction as Transaction2,
+  VersionedTransaction as VersionedTransaction2,
+  Keypair
+} from "@solana/web3.js";
+import nacl2 from "tweetnacl";
+import bs582 from "bs58";
+
+// src/handler/index.ts
+import bs583 from "bs58";
+
+// 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 removeSession(topic) {
+  const store = read();
+  store.sessions = store.sessions.filter((s) => s.topic !== topic);
+  write(store);
+}
+function getAllSessions() {
+  return read().sessions.filter((s) => s.active);
+}
+
+// src/handler/walletConnect.ts
+var SignClient = SignClientPkg.default ?? SignClientPkg;
+var signClient = null;
+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)}...`)
+  );
+}
+
+// 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 {
+  addLog,
+  cmdAccounts,
+  cmdAirdrop,
+  cmdConnect,
+  cmdDisconnect,
+  cmdInit,
+  cmdLock,
+  cmdNewAccount,
+  cmdSend,
+  cmdSessions,
+  cmdSetCluster,
+  cmdUnlock,
+  cmdUseAccount,
+  inkConfirm,
+  inkPassword,
+  inkSelect,
+  isUnlocked,
+  startInkUI
+};
+//# sourceMappingURL=index.js.map