@solana-compass/cli 0.1.0

package/README.md

@@ -0,0 +1,327 @@
+# sol — Solana for Humans and LLM Agents
+
+A Solana CLI that reads like English. Every command has structured `--json` output so LLM agents like Claude Code can drive it programmatically — managing wallets, executing swaps, staking, lending, and tracking portfolios without ever touching raw transactions.
+
+```bash
+sol token swap 50 usdc bonk          # Swap via Jupiter
+sol stake new 10                      # Stake SOL in one command
+sol lend deposit 100 usdc             # Earn yield on Kamino
+sol portfolio                         # See everything you hold
+```
+
+---
+
+## Why This Exists
+
+Solana has great infrastructure but terrible UX for automation. An LLM agent that wants to "swap 50 USDC for BONK" shouldn't need to construct transaction messages, manage blockhashes, or parse binary account data. **sol** wraps all of that behind natural-language commands with structured JSON responses:
+
+```bash
+$ sol token swap 50 usdc bonk --json
+{
+  "ok": true,
+  "data": {
+    "inputToken": "USDC",
+    "outputToken": "BONK",
+    "inputAmount": 50,
+    "outputAmount": 3842519.52,
+    "signature": "4xK9...",
+    "explorerUrl": "https://solscan.io/tx/4xK9..."
+  },
+  "meta": { "elapsed_ms": 1823 }
+}
+```
+
+No API keys required. No SDK integration. Just commands and JSON.
+
+---
+
+## Install
+
+```bash
+npm install -g @solana-compass/cli
+```
+
+Or run without installing:
+
+```bash
+npx @solana-compass/cli wallet list
+```
+
+Requires Node.js >= 20.
+
+### First-time setup
+
+```bash
+sol config set rpc.url https://api.mainnet-beta.solana.com
+sol wallet create
+```
+
+Use a dedicated RPC endpoint for production — the public one rate-limits aggressively. Helius, Triton, or QuickNode all offer free tiers.
+
+---
+
+## Commands
+
+### wallet — Create, import, and manage Solana keypairs
+
+```bash
+sol wallet create                             # New wallet, auto-named
+sol wallet create --name trading --count 3    # Batch-create 3 wallets
+sol wallet list                               # List all wallets with SOL balances
+sol wallet balance                            # Full token balances + USD values
+sol wallet balance trading                    # Balance for a specific wallet
+
+sol wallet import --solana-cli                # Import from ~/.config/solana/id.json
+sol wallet import ./keypair.json --name cold  # Import from file
+sol wallet export main                        # Show key file path
+sol wallet remove old-wallet                  # Remove from registry
+
+sol wallet set-default trading                 # Change the active wallet
+sol wallet label main --add trading           # Tag wallets for organization
+sol wallet history                            # Recent transaction activity
+sol wallet history --type swap --limit 5      # Filtered
+sol wallet fund --amount 100                  # Generate fiat onramp URL (Transak)
+```
+
+Wallets are stored locally as key files. The first wallet created becomes the default for all commands. Change it with `sol wallet set-default <name>`, or override per-command with `--wallet <name-or-address>`.
+
+### token — Prices, swaps, transfers, and account management
+
+```bash
+sol token price sol                           # Current SOL price
+sol token price sol usdc bonk                 # Multiple prices at once
+sol token info bonk                           # Token metadata (mint, decimals)
+sol token list                                # All tokens in your wallet
+sol token sync                                # Refresh token metadata cache
+
+sol token swap 50 usdc bonk                   # Swap via Jupiter
+sol token swap 1.5 sol usdc --slippage 100    # 1% slippage tolerance
+sol token swap 50 usdc bonk --quote-only      # Preview without executing
+
+sol token swap 5 usdc sol --wallet backup      # Swap from a specific wallet
+sol token send 2 sol GkX...abc                # Send SOL to an address
+sol token burn bonk --all                     # Burn all of a token
+sol token close --all --yes                   # Close empty accounts, reclaim rent
+```
+
+Swaps use Jupiter's aggregator — best price across all Solana DEXes, no API key needed. Every swap is logged with cost-basis prices for portfolio tracking.
+
+### Token resolution
+
+Anywhere a command takes a token, you can use a **symbol** (`sol`, `usdc`, `bonk`) or a **mint address** (`EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`). Resolution works in three steps:
+
+1. **Hardcoded well-known list** — 15 major tokens (SOL, USDC, USDT, JUP, BONK, mSOL, jitoSOL, bSOL, ETH, wBTC, PYTH, JTO, WEN, RNDR, JLP) resolve instantly offline. These are immune to spoofing.
+
+2. **Local cache** — Previously resolved tokens are cached in SQLite with a 24-hour TTL. Populated by prior lookups and `sol token sync`.
+
+3. **Jupiter Token API** — If not cached, the CLI searches Jupiter's token database. Results are ranked by liquidity and trading volume, so `usdc` returns the real USDC — not a scam token with the same symbol. The result is cached for next time.
+
+**For unfamiliar tokens, verify before transacting:**
+
+```bash
+sol token info peng                           # Check the resolved mint address
+sol token swap 50 usdc EPjFW...1v --quote-only  # Use the mint address directly
+```
+
+Using a mint address bypasses symbol search entirely — useful when you know exactly which token you want, or when dealing with tokens that share a ticker. Agents should prefer mint addresses for safety when operating autonomously.
+
+### stake — Native SOL staking with MEV compounding
+
+```bash
+sol stake new 10                              # Stake 10 SOL (default: Solana Compass)
+sol stake new 5 --validator DPm...xyz         # Stake with a specific validator
+sol stake list                                # All stake accounts + claimable MEV
+sol stake claim-mev                           # Compound MEV tips (re-stake)
+sol stake claim-mev --withdraw                # Withdraw MEV to wallet instead
+sol stake withdraw 7gK...abc                  # Smart withdraw (handles deactivation)
+```
+
+Creates a stake account, funds it, and delegates — all in a single transaction. The CLI handles the multi-step Solana staking process so you don't have to.
+
+### lend — Lending and borrowing on Kamino Finance
+
+```bash
+sol lend rates sol                            # Deposit/borrow APY for SOL
+sol lend rates usdc                           # USDC rates
+
+sol lend deposit 100 usdc                     # Deposit USDC to earn yield
+sol lend deposit 5 sol                        # Deposit SOL as collateral
+sol lend withdraw 50 usdc                     # Partial withdrawal
+sol lend withdraw max sol                     # Withdraw entire deposit
+
+sol lend borrow 500 usdc --collateral sol     # Borrow against collateral
+sol lend repay 250 usdc                       # Partial repay
+sol lend repay max usdc                       # Repay full outstanding debt
+
+sol lend positions                            # All deposits, borrows, health factor
+```
+
+Positions include real-time APY, USD values, and health factor monitoring. The CLI warns when health factor drops below 1.1.
+
+### portfolio — Unified view across all positions
+
+```bash
+sol portfolio                                 # Everything: tokens, stakes, lending
+sol portfolio --wallet trading                # Single wallet view
+
+sol portfolio snapshot                        # Save current state
+sol portfolio snapshot --label "pre-trade"    # With a label
+sol portfolio history                         # List all snapshots
+
+sol portfolio compare                         # Diff vs latest snapshot
+sol portfolio compare 3                       # Diff vs snapshot #3
+sol portfolio pnl                             # P&L since first snapshot
+sol portfolio pnl --since 5                   # P&L since snapshot #5
+```
+
+The portfolio aggregates tokens, staked SOL, and Kamino lending positions across all wallets. Snapshots enable tracking changes over time — useful for agents that need to measure the impact of their actions.
+
+### config — Persistent settings
+
+```bash
+sol config set rpc.url https://my-rpc.com     # Set RPC endpoint
+sol config get rpc.url                         # Read a value
+sol config list                                # Show all settings
+sol config path                                # Config file location
+```
+
+### Other commands
+
+```bash
+sol network                                   # Epoch, TPS, inflation, staking APY
+sol tx 4xK9...abc                             # Look up a transaction by signature
+```
+
+---
+
+## For LLM Agents
+
+Every command supports `--json` for structured output. Responses follow a consistent envelope:
+
+**Success:**
+```json
+{
+  "ok": true,
+  "data": { ... },
+  "meta": { "elapsed_ms": 450 }
+}
+```
+
+**Error:**
+```json
+{
+  "ok": false,
+  "error": "SWAP_FAILED",
+  "message": "Insufficient SOL balance"
+}
+```
+
+Error codes are predictable `UPPER_SNAKE_CASE` identifiers (`WALLET_CREATE_FAILED`, `LEND_DEPOSIT_FAILED`, etc.). An agent can branch on `ok`, read `data` for results, and use `error` codes for programmatic error handling without parsing human text.
+
+### Agent workflow example
+
+A Claude Code agent managing a DeFi portfolio might run:
+
+```bash
+# 1. Check what we're working with
+sol wallet balance --json
+sol portfolio --json
+
+# 2. Sell some BONK for USDC
+sol token swap 1000000 bonk usdc --json
+
+# 3. Put idle USDC to work earning yield
+sol lend deposit 100 usdc --json
+
+# 4. Stake idle SOL
+sol stake new 5 --json
+
+# 5. Verify final state and snapshot for tracking
+sol portfolio --json
+sol portfolio snapshot --label "rebalanced" --json
+```
+
+Each step returns structured data the agent can parse and act on. No web scraping, no API key management, no transaction construction.
+
+### What agents get for free
+
+- **Wallet management** — Create and fund wallets without touching key files
+- **Token resolution** — Say `sol` or `usdc` instead of mint addresses
+- **Transaction handling** — Automatic retries, blockhash management, confirmation polling
+- **Cost-basis tracking** — Every swap is logged with USD prices at execution time
+- **Portfolio snapshots** — Track P&L across sessions without external databases
+- **Error classification** — Structured errors distinguish transient failures (retry) from terminal ones (stop)
+
+---
+
+## Global Flags
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Structured JSON output |
+| `--wallet <name>` | Override default wallet |
+| `--rpc <url>` | Override RPC endpoint |
+| `--verbose` | Show debug logging |
+
+These work on every command: `sol --json --wallet trading token swap 50 usdc bonk`
+
+## RPC Resolution
+
+The CLI resolves an RPC endpoint in this order:
+
+1. `--rpc` flag
+2. `SOL_RPC_URL` environment variable
+3. `~/.sol/config.toml` → `rpc.url`
+4. Solana CLI config (`solana config get`)
+5. Public mainnet RPC (with warning)
+
+## Data Storage
+
+All data lives in `~/.sol/`:
+
+| Path | Contents |
+|------|----------|
+| `config.toml` | Configuration (TOML) |
+| `data.db` | SQLite — wallets, token cache, transaction log, snapshots |
+| `wallets/*.json` | Keypair files (Solana CLI format, chmod 600) |
+
+The transaction log is the source of truth for cost basis and P&L — every swap, transfer, deposit, and withdrawal is recorded with USD prices at the time of execution.
+
+---
+
+## Architecture
+
+- **Runtime**: Node.js via `tsx` — no build step needed
+- **CLI framework**: commander.js
+- **Solana SDK**: `@solana/kit` v2
+- **Swaps**: Jupiter REST API (no SDK, no API key)
+- **Lending**: Kamino Finance via `@kamino-finance/klend-sdk`
+- **Prices**: Jupiter Price API with CoinGecko fallback
+- **Database**: SQLite via `better-sqlite3` (WAL mode)
+- **Config**: TOML via `smol-toml`
+
+```
+src/
+  index.ts              # CLI entry point, global flags
+  commands/             # One file per command group
+  core/                 # Business logic (wallet-manager, swap-service, etc.)
+  db/                   # SQLite with migration runner
+  output/               # JSON envelope + table/portfolio renderers
+  utils/                # Solana helpers, token list, retry logic
+```
+
+## Security
+
+- Key files are plain JSON (Solana CLI compatible), stored with `chmod 600`
+- Private keys are never logged or printed to stdout
+- `wallet export` returns the file path, not the key contents
+- All transactions are logged to SQLite for audit
+- Swap commands show quote details before executing
+
+## Disclaimer
+
+This software interacts with the Solana blockchain and can execute irreversible transactions involving real funds. You are solely responsible for your own transactions, wallet security, and any financial outcomes. The authors are not liable for any losses. Use at your own risk.
+
+## License
+
+MIT

package/bin/sol.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+await import(join(__dirname, '..', 'dist', 'index.js'));

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerConfigCommand(program: Command): void;

package/dist/commands/config.js

@@ -0,0 +1,73 @@
+import { getConfigValue, setConfigValue, listConfig, getConfigPath } from '../core/config-manager.js';
+import { output, success, failure, isJsonMode } from '../output/formatter.js';
+import { table } from '../output/table.js';
+export function registerConfigCommand(program) {
+    const config = program.command('config').description('Manage CLI configuration');
+    config
+        .command('set <key> <value>')
+        .description('Set a config value (e.g., sol config set rpc.url https://my-rpc.com)')
+        .action((key, value) => {
+        try {
+            setConfigValue(key, value);
+            if (isJsonMode()) {
+                output(success({ key, value: getConfigValue(key) }));
+            }
+            else {
+                console.log(`Set ${key} = ${value}`);
+            }
+        }
+        catch (err) {
+            output(failure('CONFIG_SET_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+    config
+        .command('get <key>')
+        .description('Get a config value')
+        .action((key) => {
+        const value = getConfigValue(key);
+        if (isJsonMode()) {
+            output(success({ key, value }));
+        }
+        else if (value === undefined) {
+            console.log(`(not set)`);
+        }
+        else {
+            console.log(String(value));
+        }
+    });
+    config
+        .command('list')
+        .description('List all config values')
+        .action(() => {
+        const values = listConfig();
+        if (isJsonMode()) {
+            output(success(values));
+        }
+        else {
+            const entries = Object.entries(values);
+            if (entries.length === 0) {
+                console.log('No configuration set. Use: sol config set <key> <value>');
+            }
+            else {
+                console.log(table(entries.map(([key, value]) => ({ key, value: String(value) })), [
+                    { key: 'key', header: 'Key' },
+                    { key: 'value', header: 'Value' },
+                ]));
+            }
+        }
+    });
+    config
+        .command('path')
+        .description('Show config file path')
+        .action(() => {
+        const path = getConfigPath();
+        if (isJsonMode()) {
+            output(success({ path }));
+        }
+        else {
+            console.log(path);
+        }
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"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"}

package/dist/commands/lend.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLendCommand(program: Command): void;

package/dist/commands/lend.js

@@ -0,0 +1,262 @@
+import * as lendService from '../core/lend-service.js';
+import { getDefaultWalletName, resolveWalletName } from '../core/wallet-manager.js';
+import { output, success, failure, isJsonMode, timed } from '../output/formatter.js';
+import { table } from '../output/table.js';
+import * as walletRepo from '../db/repos/wallet-repo.js';
+export function registerLendCommand(program) {
+    const lend = program.command('lend').description('Lending and borrowing (Kamino Finance)');
+    // ── rates ───────────────────────────────────────────────
+    lend
+        .command('rates <token>')
+        .description('Show Kamino deposit/borrow APY for a token')
+        .action(async (token) => {
+        try {
+            const { result: rates, elapsed_ms } = await timed(() => lendService.getRates(token));
+            if (isJsonMode()) {
+                output(success({ token, rates }, { elapsed_ms }));
+            }
+            else if (rates.length === 0) {
+                console.log(`No Kamino lending reserve found for "${token}".`);
+            }
+            else {
+                const r = rates[0];
+                console.log(`Kamino Lending — ${r.token}\n`);
+                console.log(table([{
+                        depositApy: `${(r.depositApy * 100).toFixed(2)}%`,
+                        borrowApy: `${(r.borrowApy * 100).toFixed(2)}%`,
+                        utilization: `${r.utilizationPct.toFixed(1)}%`,
+                        totalDeposited: fmtLargeAmount(r.totalDeposited),
+                        totalBorrowed: fmtLargeAmount(r.totalBorrowed),
+                    }], [
+                    { key: 'depositApy', header: 'Deposit APY', align: 'right' },
+                    { key: 'borrowApy', header: 'Borrow APY', align: 'right' },
+                    { key: 'utilization', header: 'Utilization', align: 'right' },
+                    { key: 'totalDeposited', header: 'Total Deposited', align: 'right' },
+                    { key: 'totalBorrowed', header: 'Total Borrowed', align: 'right' },
+                ]));
+                console.log(`\nRun \`sol lend deposit <amount> ${token}\` to start earning.`);
+            }
+        }
+        catch (err) {
+            output(failure('LEND_RATES_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+    // ── positions ───────────────────────────────────────────
+    lend
+        .command('positions')
+        .description('List all Kamino lending/borrowing positions')
+        .option('--wallet <name>', 'Wallet to check')
+        .action(async (opts) => {
+        try {
+            const walletName = opts.wallet ? resolveWalletName(opts.wallet) : getDefaultWalletName();
+            const wallet = walletRepo.getWallet(walletName);
+            if (!wallet)
+                throw new Error(`Wallet "${walletName}" not found`);
+            const { result: positions, elapsed_ms } = await timed(() => lendService.getPositions(wallet.address));
+            if (isJsonMode()) {
+                output(success({ wallet: walletName, positions }, { elapsed_ms }));
+            }
+            else if (positions.length === 0) {
+                console.log('No Kamino lending positions found.');
+                console.log('Run `sol lend rates <token>` to see available rates.');
+            }
+            else {
+                const deposits = positions.filter(p => p.type === 'deposit');
+                const borrows = positions.filter(p => p.type === 'borrow');
+                if (deposits.length > 0) {
+                    console.log('Deposits');
+                    console.log(table(deposits.map(p => ({
+                        token: p.token,
+                        amount: fmtAmount(p.amount),
+                        value: `$${p.valueUsd.toFixed(2)}`,
+                        apy: `${(p.apy * 100).toFixed(2)}%`,
+                    })), [
+                        { key: 'token', header: 'Token' },
+                        { key: 'amount', header: 'Amount', align: 'right' },
+                        { key: 'value', header: 'Value', align: 'right' },
+                        { key: 'apy', header: 'APY', align: 'right' },
+                    ]));
+                    console.log('');
+                }
+                if (borrows.length > 0) {
+                    console.log('Borrows');
+                    console.log(table(borrows.map(p => ({
+                        token: p.token,
+                        amount: fmtAmount(p.amount),
+                        value: `$${p.valueUsd.toFixed(2)}`,
+                        apy: `${(p.apy * 100).toFixed(2)}%`,
+                        health: p.healthFactor != null ? p.healthFactor.toFixed(2) : '—',
+                    })), [
+                        { key: 'token', header: 'Token' },
+                        { key: 'amount', header: 'Amount', align: 'right' },
+                        { key: 'value', header: 'Value', align: 'right' },
+                        { key: 'apy', header: 'APY', align: 'right' },
+                        { key: 'health', header: 'Health', align: 'right' },
+                    ]));
+                    // Health factor warning
+                    const minHealth = Math.min(...borrows.map(p => p.healthFactor ?? Infinity));
+                    if (minHealth < 1.1) {
+                        console.log('\nWarning: health factor below 1.1. Consider repaying or adding collateral.');
+                    }
+                    console.log('');
+                }
+                // Net value
+                const totalDeposits = deposits.reduce((s, p) => s + p.valueUsd, 0);
+                const totalBorrows = borrows.reduce((s, p) => s + p.valueUsd, 0);
+                console.log(`Net lending value: $${(totalDeposits - totalBorrows).toFixed(2)}`);
+            }
+        }
+        catch (err) {
+            output(failure('LEND_POSITIONS_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+    // ── deposit ─────────────────────────────────────────────
+    lend
+        .command('deposit <amount> <token>')
+        .description('Deposit into Kamino lending vault')
+        .option('--wallet <name>', 'Wallet to use')
+        .action(async (amountStr, token, opts) => {
+        try {
+            const amount = parseFloat(amountStr);
+            if (isNaN(amount) || amount <= 0)
+                throw new Error('Invalid amount');
+            const walletName = opts.wallet ? resolveWalletName(opts.wallet) : getDefaultWalletName();
+            const { result, elapsed_ms } = await timed(() => lendService.deposit(walletName, token, amount));
+            if (isJsonMode()) {
+                output(success(result, { elapsed_ms }));
+            }
+            else {
+                console.log(`Deposited ${amount} ${token.toUpperCase()} into Kamino`);
+                console.log(`  Tx: ${result.explorerUrl}`);
+                console.log(`\nRun \`sol lend positions\` to see your deposits.`);
+            }
+        }
+        catch (err) {
+            output(failure('LEND_DEPOSIT_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+    // ── withdraw ────────────────────────────────────────────
+    lend
+        .command('withdraw <amount> <token>')
+        .description('Withdraw from Kamino lending position (use "max" for full withdrawal)')
+        .option('--wallet <name>', 'Wallet to use')
+        .action(async (amountStr, token, opts) => {
+        try {
+            const amount = parseMaxAmount(amountStr);
+            const walletName = opts.wallet ? resolveWalletName(opts.wallet) : getDefaultWalletName();
+            const { result, elapsed_ms } = await timed(() => lendService.withdraw(walletName, token, amount));
+            if (isJsonMode()) {
+                output(success(result, { elapsed_ms }));
+            }
+            else {
+                const label = isFinite(amount) ? `${amount} ${token.toUpperCase()}` : `all ${token.toUpperCase()}`;
+                console.log(`Withdrew ${label} from Kamino`);
+                console.log(`  Tx: ${result.explorerUrl}`);
+                console.log(`\nRun \`sol lend positions\` to check remaining positions.`);
+            }
+        }
+        catch (err) {
+            output(failure('LEND_WITHDRAW_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+    // ── borrow ──────────────────────────────────────────────
+    lend
+        .command('borrow <amount> <token>')
+        .description('Borrow against collateral on Kamino')
+        .option('--collateral <token>', 'Collateral token (required)')
+        .option('--wallet <name>', 'Wallet to use')
+        .action(async (amountStr, token, opts) => {
+        try {
+            const amount = parseFloat(amountStr);
+            if (isNaN(amount) || amount <= 0)
+                throw new Error('Invalid amount');
+            if (!opts.collateral)
+                throw new Error('--collateral is required');
+            const walletName = opts.wallet ? resolveWalletName(opts.wallet) : getDefaultWalletName();
+            const { result, elapsed_ms } = await timed(() => lendService.borrow(walletName, token, amount, opts.collateral));
+            if (isJsonMode()) {
+                output(success(result, { elapsed_ms }));
+            }
+            else {
+                console.log(`Borrowed ${amount} ${token.toUpperCase()} from Kamino`);
+                console.log(`  Tx: ${result.explorerUrl}`);
+                if (result.healthFactor != null) {
+                    console.log(`  Health factor: ${result.healthFactor.toFixed(2)}`);
+                    if (result.healthFactor < 1.1) {
+                        console.log('  Warning: health factor is low. Monitor closely.');
+                    }
+                }
+                console.log(`\nRun \`sol lend positions\` to view all positions.`);
+            }
+        }
+        catch (err) {
+            output(failure('LEND_BORROW_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+    // ── repay ───────────────────────────────────────────────
+    lend
+        .command('repay <amount> <token>')
+        .description('Repay a Kamino loan (use "max" to repay full debt)')
+        .option('--wallet <name>', 'Wallet to use')
+        .action(async (amountStr, token, opts) => {
+        try {
+            const amount = parseMaxAmount(amountStr);
+            const walletName = opts.wallet ? resolveWalletName(opts.wallet) : getDefaultWalletName();
+            const { result, elapsed_ms } = await timed(() => lendService.repay(walletName, token, amount));
+            if (isJsonMode()) {
+                output(success(result, { elapsed_ms }));
+            }
+            else {
+                const label = isFinite(amount) ? `${amount} ${token.toUpperCase()}` : `all ${token.toUpperCase()}`;
+                console.log(`Repaid ${label} on Kamino`);
+                console.log(`  Tx: ${result.explorerUrl}`);
+                if (result.remainingDebt != null) {
+                    if (result.remainingDebt === 0) {
+                        console.log('  Loan fully repaid!');
+                    }
+                    else {
+                        console.log(`  Remaining debt: ${fmtAmount(result.remainingDebt)} ${token.toUpperCase()}`);
+                    }
+                }
+                console.log(`\nRun \`sol lend positions\` to check remaining positions.`);
+            }
+        }
+        catch (err) {
+            output(failure('LEND_REPAY_FAILED', err.message));
+            process.exitCode = 1;
+        }
+    });
+}
+// ── Helpers ───────────────────────────────────────────────
+function fmtAmount(n) {
+    if (n >= 1_000_000)
+        return n.toFixed(0);
+    if (n >= 1)
+        return n.toFixed(4);
+    if (n >= 0.0001)
+        return n.toFixed(6);
+    return n.toFixed(9);
+}
+function parseMaxAmount(str) {
+    if (str === 'max' || str === 'all')
+        return Infinity;
+    const n = parseFloat(str);
+    if (isNaN(n) || n <= 0)
+        throw new Error('Invalid amount (use a number or "max")');
+    return n;
+}
+function fmtLargeAmount(n) {
+    if (n >= 1_000_000_000)
+        return `${(n / 1_000_000_000).toFixed(2)}B`;
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(2)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(2)}K`;
+    return fmtAmount(n);
+}
+//# sourceMappingURL=lend.js.map