@darksol/terminal 0.6.3 → 0.7.1

package/README.md

@@ -15,7 +15,7 @@ A unified CLI for market intel, trading, AI-powered analysis, on-chain oracle, c
 [![License: MIT](https://img.shields.io/badge/License-MIT-gold.svg)](https://opensource.org/licenses/MIT)
 [![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-green.svg)](https://nodejs.org/)
 
-- Current release: **0.5.0**
+- Current release: **0.7.1**
 - Changelog: `CHANGELOG.md`
 
 ## Install
@@ -67,10 +67,13 @@ darksol agent start main
 
 ## `darksol serve` (Web Terminal UX)
 
-`darksol serve` now supports an interactive keyboard-driven UI:
+`darksol serve` is a full interactive web terminal with keyboard-driven menus:
 
-- Arrow-key menus (`↑/↓` + `Enter`) for wallet/config flows
-- Interactive wallet picker + wallet action menu (receive/send/portfolio/history/switch chain)
+- Arrow-key menus (`↑/↓` + `Enter`) for wallet/config/trade flows
+- **Interactive send** — token → recipient → amount → password → on-chain transfer
+- **Interactive swap** — pair picker (presets + custom) → amount → password → Uniswap V3 execution
+- **Interactive snipe** — contract input → amount → password → fast buy
+- Wallet picker + wallet action menu (receive/send/portfolio/history/switch chain)
 - Agent signer control center (`agent`) with guided wallet selection + start/stop/status
 - Click-through help menu (`help`) with arrow-key command selection
 - AI connection check at startup (shows ready/not configured)
@@ -84,8 +87,10 @@ Useful web-shell commands:
 
 ```bash
 help          # clickable command menu (arrow keys + Enter)
-keys          # provider status + interactive add/update
+trade         # interactive swap / snipe menu
+send          # interactive token transfer
 wallet        # interactive wallet picker and actions
+keys          # provider status + interactive add/update
 agent         # signer start/stop/status controls
 config        # interactive config menu
 logs 20       # show recent AI chat log lines
@@ -201,7 +206,7 @@ darksol ai analyze AERO
 darksol ai chat --provider ollama --model llama3
 ```
 
-**Supported providers:** OpenAI, Anthropic, OpenRouter, Ollama (local = free)
+**Supported providers:** OpenAI, Anthropic, OpenRouter, Bankr LLM Gateway, Ollama (local = free)
 
 The AI gets live market context (prices from DexScreener), knows your config (chain, slippage, wallet), and returns structured intents with confidence scores and risk warnings.
 
@@ -227,7 +232,7 @@ darksol keys remove openai
 **Supported services:**
 | Category | Services |
 |----------|----------|
-| LLM | OpenAI, Anthropic, OpenRouter, Ollama |
+| LLM | OpenAI, Anthropic, OpenRouter, Bankr LLM Gateway, Ollama |
 | Data | CoinGecko Pro, DexScreener, DefiLlama |
 | RPC | Alchemy, Infura, QuickNode |
 | Trading | 1inch, ParaSwap |
@@ -239,14 +244,23 @@ Keys can also come from environment variables (e.g., `OPENAI_API_KEY`).
 ## 💰 Trading
 
 ```bash
-# Swap via Uniswap V3
+# Interactive swap (prompts for pair + amount if flags omitted)
+darksol trade swap
+
+# Swap with full flags (Uniswap V3 with slippage protection)
 darksol trade swap -i ETH -o USDC -a 0.1
 
+# Non-interactive swap (for automation / cron)
+darksol trade swap -i ETH -o USDC -a 0.1 -p "password" -y
+
+# Show common pairs for current chain
+darksol trade pairs
+
 # Snipe a token (Uniswap V2, fast buy)
 darksol trade snipe 0xTOKEN -a 0.05
 
-# Snipe with gas boost
-darksol trade snipe 0xTOKEN -a 0.05 -g 2.0
+# Snipe with gas boost + non-interactive
+darksol trade snipe 0xTOKEN -a 0.05 -g 2.0 -p "password" -y
 
 # Watch for new pairs
 darksol trade watch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "description": "DARKSOL Terminal — unified CLI for all DARKSOL services. Market intel, trading, oracle, casino, and more.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -7,7 +7,7 @@ description: "DARKSOL Terminal — unified CLI + x402 platform for trading, wall
 
 **All DARKSOL services. One terminal. Zero trust required. 🌑**
 
-`@darksol/terminal` v0.6.x | npm: `npm install -g @darksol/terminal`
+`@darksol/terminal` v0.7.1 | npm: `npm install -g @darksol/terminal`
 
 ---
 
@@ -65,10 +65,12 @@ darksol wallet export [name]           # Export (password required for PK)
 
 ### 📊 Trading (5 chains)
 ```bash
+darksol trade swap                             # Interactive swap (prompts for pair + amount)
 darksol trade swap -i ETH -o USDC -a 0.1      # Uniswap V3 swap with slippage protection
-darksol trade swap -i USDC -o ETH -a 100 -c polygon  # Swap on Polygon
+darksol trade swap -i ETH -o USDC -a 0.1 -p "pw" -y  # Non-interactive (automation/cron)
+darksol trade pairs                            # Show common pairs for active chain
 darksol trade snipe <token> -a 0.05            # Fast buy with gas boost
-darksol trade snipe <token> -a 0.05 -g 2.0     # Snipe with 2x gas priority
+darksol trade snipe <token> -a 0.05 -g 2.0 -p "pw" -y  # Non-interactive snipe
 darksol trade watch                             # Monitor new pairs (experimental)
 darksol send                                   # Interactive ETH/ERC-20 transfer
 darksol receive                                # Show your address for receiving
@@ -88,12 +90,16 @@ darksol dca cancel <id>                # Cancel
 ### 🤖 AI Trading Assistant
 ```bash
 darksol ai chat                        # Interactive AI chat (supports swap/send/price/casino/cards)
+darksol ai chat --provider bankr       # Use Bankr LLM Gateway (crypto credits)
+darksol ai chat --provider bankr --model claude-opus-4.6  # Specific Bankr model
 darksol ai ask "buy 0.5 ETH of AERO"  # Parse natural language → trade intent
 darksol ai ask "flip a coin" -x        # Auto-execute if confidence ≥ 60%
 darksol ai strategy VIRTUAL -b 500     # DCA strategy recommendation
 darksol ai analyze AERO                # Token analysis
 ```
 
+**AI Providers:** OpenAI, Anthropic, OpenRouter, Bankr LLM Gateway (`bk_...`), Ollama (local/free)
+**Bankr Models:** claude-opus-4.6, claude-sonnet-4.6, gemini-3-pro, gpt-5.2, kimi-k2.5, qwen3-coder
 **AI Intent Actions:** swap, send, snipe, dca, price, balance, info, analyze, gas, cards, casino, unknown
 
 The AI understands natural language and maps it to executable commands:
@@ -241,7 +247,7 @@ darksol config rpc base https://...    # Custom RPC
 ```bash
 darksol keys list                      # All services + status
 darksol keys add openai                # Add key (encrypted AES-256-GCM)
-darksol keys add anthropic             # Supported: openai, anthropic, openrouter, ollama,
+darksol keys add anthropic             # Supported: openai, anthropic, openrouter, bankr, ollama,
 darksol keys add email                 #   coingecko, dexscreener, alchemy, infura, email
 darksol keys remove <service>          # Remove key
 ```
@@ -293,8 +299,10 @@ const result = await fetchWithX402(
 
 ### Non-interactive mode (for cron / automation)
 ```bash
-# All trading commands accept flags for non-interactive use
-darksol trade swap -i ETH -o USDC -a 0.1 -y
+# All trading commands accept --password (-p) and --yes (-y) for non-interactive use
+darksol trade swap -i ETH -o USDC -a 0.1 -p "password" -y
+darksol trade snipe 0xTOKEN -a 0.05 -p "password" -y
+darksol send --to 0x... --amount 0.1 --token ETH -p "password" -y
 darksol script run my-dca -p "password" -y
 darksol casino bet coinflip -c heads -w 0x1234...
 

package/src/cli.js

@@ -113,19 +113,41 @@ export function cli(argv) {
 
   trade
     .command('swap')
-    .description('Swap tokens via DEX')
-    .requiredOption('-i, --in <token>', 'Token to sell (symbol or address)')
-    .requiredOption('-o, --out <token>', 'Token to buy (symbol or address)')
-    .requiredOption('-a, --amount <amount>', 'Amount to swap')
+    .description('Swap tokens via DEX (interactive if flags omitted)')
+    .option('-i, --in <token>', 'Token to sell (symbol or address)')
+    .option('-o, --out <token>', 'Token to buy (symbol or address)')
+    .option('-a, --amount <amount>', 'Amount to swap')
     .option('-s, --slippage <percent>', 'Max slippage %', '0.5')
     .option('-w, --wallet <name>', 'Wallet to use')
-    .action((opts) => executeSwap({
-      tokenIn: opts.in,
-      tokenOut: opts.out,
-      amount: opts.amount,
-      slippage: parseFloat(opts.slippage),
-      wallet: opts.wallet,
-    }));
+    .option('-p, --password <pw>', 'Wallet password (non-interactive)')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (opts) => {
+      let tokenIn = opts.in;
+      let tokenOut = opts.out;
+      let amount = opts.amount;
+
+      if (!tokenIn || !tokenOut || !amount) {
+        const inquirer = (await import('inquirer')).default;
+        const answers = await inquirer.prompt([
+          { type: 'input', name: 'tokenIn', message: 'Token to sell (e.g. ETH):', default: tokenIn || 'ETH' },
+          { type: 'input', name: 'tokenOut', message: 'Token to buy (e.g. USDC):', default: tokenOut || 'USDC' },
+          { type: 'input', name: 'amount', message: 'Amount to swap:', default: amount || '0.1' },
+        ]);
+        tokenIn = answers.tokenIn;
+        tokenOut = answers.tokenOut;
+        amount = answers.amount;
+      }
+
+      return executeSwap({
+        tokenIn,
+        tokenOut,
+        amount,
+        slippage: parseFloat(opts.slippage),
+        wallet: opts.wallet,
+        password: opts.password,
+        confirm: opts.yes ? true : undefined,
+      });
+    });
 
   trade
     .command('snipe <token>')
@@ -134,10 +156,14 @@ export function cli(argv) {
     .option('-s, --slippage <percent>', 'Max slippage %', '1')
     .option('-g, --gas <multiplier>', 'Gas priority multiplier', '1.5')
     .option('-w, --wallet <name>', 'Wallet to use')
+    .option('-p, --password <pw>', 'Wallet password (non-interactive)')
+    .option('-y, --yes', 'Skip confirmation')
     .action((token, opts) => snipeToken(token, opts.amount, {
       slippage: parseFloat(opts.slippage),
       gas: parseFloat(opts.gas),
       wallet: opts.wallet,
+      password: opts.password,
+      confirm: opts.yes ? true : undefined,
     }));
 
   trade
@@ -147,6 +173,26 @@ export function cli(argv) {
     .option('-a, --amount <eth>', 'Auto-snipe amount')
     .action((opts) => watchSnipe(opts));
 
+  trade
+    .command('pairs')
+    .description('Show common swap pairs for current chain')
+    .action(() => {
+      const chain = getConfig('chain') || 'base';
+      const byChain = {
+        base: ['ETH/USDC', 'ETH/AERO', 'ETH/VIRTUAL', 'USDC/AERO'],
+        ethereum: ['ETH/USDC', 'ETH/USDT', 'ETH/DAI'],
+        arbitrum: ['ETH/USDC', 'ETH/USDT', 'ETH/ARB'],
+        optimism: ['ETH/USDC', 'ETH/OP'],
+        polygon: ['POL/USDC', 'POL/WETH', 'USDC/USDT'],
+      };
+      showSection(`COMMON PAIRS — ${chain.toUpperCase()}`);
+      const pairs = byChain[chain] || byChain.base;
+      pairs.forEach((p) => console.log(`  ${theme.gold(p)}`));
+      console.log('');
+      info('Swap command: darksol trade swap -i <tokenIn> -o <tokenOut> -a <amount>');
+      console.log('');
+    });
+
   // ═══════════════════════════════════════
   // DCA COMMANDS
   // ═══════════════════════════════════════

package/src/config/keys.js

@@ -92,6 +92,14 @@ export const SERVICES = {
     docsUrl: 'https://ollama.ai',
     validate: (key) => key.startsWith('http'),
   },
+  bankr: {
+    name: 'Bankr LLM Gateway',
+    category: 'llm',
+    description: 'Multi-model gateway — Claude, Gemini, GPT via crypto credits',
+    envVar: 'BANKR_LLM_KEY',
+    docsUrl: 'https://docs.bankr.bot/llm-gateway/overview',
+    validate: (key) => key.startsWith('bk_'),
+  },
 
   // Data Providers
   coingecko: {
@@ -404,7 +412,7 @@ export function hasKey(service) {
  */
 export function hasAnyLLM() {
   // Cloud providers — need real validated API keys
-  if (['openai', 'anthropic', 'openrouter'].some(s => hasKey(s))) return true;
+  if (['openai', 'anthropic', 'openrouter', 'bankr'].some(s => hasKey(s))) return true;
   // Ollama — check if explicitly configured via hasKey (validates URL format)
   if (hasKey('ollama')) return true;
   return false;

package/src/llm/engine.js

@@ -51,6 +51,13 @@ const PROVIDERS = {
     parseResponse: (data) => data.choices?.[0]?.message?.content || data.message?.content,
     parseUsage: () => ({ input: 0, output: 0 }),
   },
+  bankr: {
+    url: 'https://llm.bankr.bot/v1/chat/completions',
+    defaultModel: 'claude-sonnet-4.6',
+    authHeader: (key) => ({ 'X-API-Key': key }),
+    parseResponse: (data) => data.choices?.[0]?.message?.content,
+    parseUsage: (data) => data.usage,
+  },
 };
 
 // ──────────────────────────────────────────────────
@@ -85,6 +92,12 @@ export class LLMEngine {
       }
     }
 
+    if (!this.apiKey && this.provider !== 'ollama') {
+      // Try auto-stored keys as last resort
+      const { getKeyAuto } = await import('../config/keys.js');
+      this.apiKey = getKeyAuto(this.provider);
+    }
+
     if (!this.apiKey && this.provider !== 'ollama') {
       throw new Error(`No API key for ${this.provider}. Run: darksol keys add ${this.provider}`);
     }

package/src/services/skills.js

@@ -25,42 +25,149 @@ const SKILL_CATALOG = [
   {
     name: 'darksol-facilitator',
     description: 'Free on-chain x402 payment facilitator — verify and settle micropayments',
-    version: '1.0.0',
+    version: '1.0.1',
     source: 'url',
     url: 'https://facilitator.darksol.net/skill/SKILL.md',
+    urlCandidates: [
+      'https://facilitator.darksol.net/skill/SKILL.md',
+      'https://facilitator.darksol.net/skill',
+    ],
+    fallbackSkill: 'facilitator',
     category: 'payments',
     installed: () => existsSync(join(OPENCLAW_SKILLS_DIR, 'darksol-facilitator', 'SKILL.md')),
   },
   {
     name: 'darksol-prepaid-cards',
     description: 'Crypto → prepaid Visa/MC cards, no KYC, agent-native REST API',
-    version: '1.0.0',
+    version: '1.0.1',
     source: 'url',
     url: 'https://acp.darksol.net/dist/darksol-prepaid-cards.skill',
     skillMdUrl: 'https://acp.darksol.net/cards/skill/SKILL.md',
+    urlCandidates: [
+      'https://acp.darksol.net/cards/skill/SKILL.md',
+      'https://acp.darksol.net/dist/darksol-prepaid-cards.skill',
+    ],
+    fallbackSkill: 'cards',
     category: 'payments',
     installed: () => existsSync(join(OPENCLAW_SKILLS_DIR, 'darksol-prepaid-cards', 'SKILL.md')),
   },
   {
     name: 'random-oracle',
     description: 'On-chain random oracle — verifiable randomness via x402',
-    version: '1.0.0',
+    version: '1.0.1',
     source: 'url',
     url: 'https://acp.darksol.net/oracle/skill/SKILL.md',
+    urlCandidates: [
+      'https://acp.darksol.net/oracle/skill/SKILL.md',
+      'https://acp.darksol.net/oracle/skill',
+    ],
+    fallbackSkill: 'oracle',
     category: 'oracle',
     installed: () => existsSync(join(OPENCLAW_SKILLS_DIR, 'random-oracle', 'SKILL.md')),
   },
   {
     name: 'the-clawsino',
     description: 'On-chain agent casino — coin flip, dice, hi-lo, slots via x402',
-    version: '1.0.0',
+    version: '1.0.1',
     source: 'url',
     url: 'https://casino.darksol.net/skill/SKILL.md',
+    urlCandidates: [
+      'https://casino.darksol.net/skill/SKILL.md',
+      'https://casino.darksol.net/skill',
+    ],
+    fallbackSkill: 'casino',
     category: 'gaming',
     installed: () => existsSync(join(OPENCLAW_SKILLS_DIR, 'the-clawsino', 'SKILL.md')),
   },
 ];
 
+const FALLBACK_SKILLS = {
+  facilitator: `---
+name: darksol-facilitator
+description: Free on-chain x402 payment facilitator by DARKSOL. Verifies and settles EIP-3009 micropayments on Base and Polygon.
+---
+
+# DARKSOL Facilitator
+
+## Base URL
+- https://facilitator.darksol.net
+
+## Endpoints
+- GET /  (service health/info)
+- POST /verify  (verify payment payload)
+- POST /settle  (settle payment on-chain)
+
+Use this for free x402 settlement flows.`,
+  oracle: `---
+name: random-oracle
+description: On-chain random oracle — verifiable randomness via x402.
+---
+
+# Random Oracle
+
+## Base URL
+- https://acp.darksol.net/api/oracle
+
+## Endpoints
+- GET /health
+- GET /coin
+- GET /dice?sides=6
+- GET /number?min=1&max=100
+- POST /shuffle
+
+Game endpoints are x402-gated; health is public.`,
+  cards: `---
+name: darksol-prepaid-cards
+description: Crypto to prepaid cards via DARKSOL Cards API.
+---
+
+# DARKSOL Prepaid Cards
+
+## Base URL
+- https://acp.darksol.net/api/cards
+
+## Endpoints
+- GET /catalog
+- POST /order
+- GET /status?tradeId=<id>
+
+Supports provider/amount/email + optional ticker/network route selection.`,
+  casino: `---
+name: the-clawsino
+description: On-chain casino endpoints for coin flip, dice, hi-lo, slots.
+---
+
+# The Clawsino
+
+## Base URL
+- https://casino.darksol.net
+
+## Endpoints
+- GET /api/stats
+- GET /api/tables
+- POST /api/bet
+- GET /api/receipt/:id
+- GET /api/verify/:id
+
+All bets are $1 USDC with payment proof in bet request.`,
+};
+
+async function fetchFirstAvailable(urls = []) {
+  for (const u of urls.filter(Boolean)) {
+    try {
+      const resp = await fetch(u);
+      if (!resp.ok) continue;
+      const content = await resp.text();
+      if (content && content.trim().length > 0) {
+        return { url: u, content };
+      }
+    } catch {
+      // try next URL
+    }
+  }
+  return null;
+}
+
 // ──────────────────────────────────────────────────
 // LIST SKILLS
 // ──────────────────────────────────────────────────
@@ -129,18 +236,17 @@ export async function installSkill(name) {
         throw new Error('Bundled SKILL.md not found in package');
       }
     } else if (skill.source === 'url') {
-      // Fetch from remote
-      const url = skill.skillMdUrl || skill.url;
-      const resp = await fetch(url);
-      if (!resp.ok) throw new Error(`Failed to fetch: ${resp.status}`);
-      const content = await resp.text();
-
-      // Handle .skill files (may be a zip or just SKILL.md content)
-      if (url.endsWith('.skill')) {
-        // .skill files are typically just the SKILL.md content
-        writeFileSync(join(targetDir, 'SKILL.md'), content);
+      // Fetch from first live endpoint, with fallback stub if remote is unavailable
+      const candidates = skill.urlCandidates || [skill.skillMdUrl, skill.url];
+      const fetched = await fetchFirstAvailable(candidates);
+
+      if (fetched?.content) {
+        writeFileSync(join(targetDir, 'SKILL.md'), fetched.content);
+      } else if (skill.fallbackSkill && FALLBACK_SKILLS[skill.fallbackSkill]) {
+        writeFileSync(join(targetDir, 'SKILL.md'), FALLBACK_SKILLS[skill.fallbackSkill]);
+        warn(`Remote skill endpoint unavailable — installed fallback spec for ${name}`);
       } else {
-        writeFileSync(join(targetDir, 'SKILL.md'), content);
+        throw new Error(`Failed to fetch skill from: ${candidates.filter(Boolean).join(', ')}`);
       }
     }
 

package/src/trading/snipe.js

@@ -34,6 +34,8 @@ export async function snipeToken(tokenAddress, amount, opts = {}) {
   const chain = getConfig('chain') || 'base';
   const maxSlippage = opts.slippage || getConfig('slippage') || 1.0;
   const gasMultiplier = opts.gas || getConfig('gasMultiplier') || 1.5;
+  const providedPassword = opts.password;
+  const providedConfirm = opts.confirm;
 
   if (!tokenAddress || !tokenAddress.startsWith('0x')) {
     error('Provide a valid token contract address');
@@ -45,13 +47,17 @@ export async function snipeToken(tokenAddress, amount, opts = {}) {
     return;
   }
 
-  // Get password
-  const { password } = await inquirer.prompt([{
-    type: 'password',
-    name: 'password',
-    message: theme.gold('Wallet password:'),
-    mask: '●',
-  }]);
+  // Get password (prompt unless provided)
+  let password = providedPassword;
+  if (!password) {
+    const prompted = await inquirer.prompt([{
+      type: 'password',
+      name: 'password',
+      message: theme.gold('Wallet password:'),
+      mask: '●',
+    }]);
+    password = prompted.password;
+  }
 
   const spin = spinner('Preparing snipe...').start();
 
@@ -107,12 +113,16 @@ export async function snipeToken(tokenAddress, amount, opts = {}) {
     ]);
     console.log('');
 
-    const { confirm } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'confirm',
-      message: theme.accent('Execute snipe? This is HIGH RISK.'),
-      default: false,
-    }]);
+    let confirm = providedConfirm;
+    if (typeof confirm !== 'boolean') {
+      const prompted = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: theme.accent('Execute snipe? This is HIGH RISK.'),
+        default: false,
+      }]);
+      confirm = prompted.confirm;
+    }
 
     if (!confirm) {
       warn('Snipe cancelled');

package/src/trading/swap.js

@@ -137,6 +137,8 @@ export async function executeSwap(opts = {}) {
     amount,
     wallet: walletName,
     slippage,
+    password: providedPassword,
+    confirm: providedConfirm,
   } = opts;
 
   const chain = getConfig('chain') || 'base';
@@ -155,13 +157,17 @@ export async function executeSwap(opts = {}) {
     return;
   }
 
-  // Get password for wallet
-  const { password } = await inquirer.prompt([{
-    type: 'password',
-    name: 'password',
-    message: theme.gold('Wallet password:'),
-    mask: '●',
-  }]);
+  // Get password for wallet (prompt unless provided)
+  let password = providedPassword;
+  if (!password) {
+    const prompted = await inquirer.prompt([{
+      type: 'password',
+      name: 'password',
+      message: theme.gold('Wallet password:'),
+      mask: '●',
+    }]);
+    password = prompted.password;
+  }
 
   const spin = spinner('Preparing swap...').start();
 
@@ -214,12 +220,16 @@ export async function executeSwap(opts = {}) {
     ]);
     console.log('');
 
-    const { confirm } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'confirm',
-      message: theme.gold('Execute swap?'),
-      default: false,
-    }]);
+    let confirm = providedConfirm;
+    if (typeof confirm !== 'boolean') {
+      const prompted = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: theme.gold('Execute swap?'),
+        default: false,
+      }]);
+      confirm = prompted.confirm;
+    }
 
     if (!confirm) {
       warn('Swap cancelled');

package/src/wallet/manager.js

@@ -269,6 +269,8 @@ const ERC20_SEND_ABI = [
 
 export async function sendFunds(opts = {}) {
   const name = opts.wallet || getConfig('activeWallet');
+  const providedPassword = opts.password;
+  const providedConfirm = opts.confirm;
   if (!name) {
     error('No active wallet. Set one: darksol wallet use <name>');
     return;
@@ -331,13 +333,17 @@ export async function sendFunds(opts = {}) {
     }]));
   }
 
-  // Password
-  const { password } = await inquirer.prompt([{
-    type: 'password',
-    name: 'password',
-    message: theme.gold('Wallet password:'),
-    mask: '●',
-  }]);
+  // Password (prompt unless provided)
+  let password = providedPassword;
+  if (!password) {
+    const prompted = await inquirer.prompt([{
+      type: 'password',
+      name: 'password',
+      message: theme.gold('Wallet password:'),
+      mask: '●',
+    }]);
+    password = prompted.password;
+  }
 
   const spin = spinner('Preparing transaction...').start();
 
@@ -420,12 +426,16 @@ export async function sendFunds(opts = {}) {
     ]);
     console.log('');
 
-    const { confirm } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'confirm',
-      message: theme.accent('Send this transaction?'),
-      default: false,
-    }]);
+    let confirm = providedConfirm;
+    if (typeof confirm !== 'boolean') {
+      const prompted = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: theme.accent('Send this transaction?'),
+        default: false,
+      }]);
+      confirm = prompted.confirm;
+    }
 
     if (!confirm) {
       warn('Transaction cancelled');

package/src/web/commands.js

@@ -115,12 +115,12 @@ export async function handleMenuSelect(id, value, item, ws) {
           return {};
         }
         case 'send':
-          ws.sendLine('');
-          ws.sendLine(`  ${ANSI.gold}◆ SEND${ANSI.reset}`);
-          ws.sendLine(`  ${ANSI.dim}Sending requires wallet password — use the CLI:${ANSI.reset}`);
-          ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 0.1 --token ETH${ANSI.reset}`);
-          ws.sendLine(`  ${ANSI.gold}darksol send${ANSI.reset}  ${ANSI.dim}(interactive mode)${ANSI.reset}`);
-          ws.sendLine('');
+          ws.sendMenu('send_token', '◆ Send Token', [
+            { value: 'ETH', label: 'ETH', desc: 'Native token transfer' },
+            { value: 'USDC', label: 'USDC', desc: 'Stablecoin transfer' },
+            { value: 'custom', label: 'Custom token (0x...)', desc: 'ERC-20 contract address' },
+            { value: 'back', label: '← Back', desc: '' },
+          ]);
           return {};
         case 'portfolio':
           return await handleCommand('portfolio', ws);
@@ -221,6 +221,86 @@ export async function handleMenuSelect(id, value, item, ws) {
     case 'cards_status_check':
       return await showCardStatus(value, ws);
 
+    case 'trade_action':
+      if (value === 'swap') {
+        ws.sendMenu('trade_swap_pair', '◆ Swap Pair', [
+          { value: 'ETH->USDC', label: 'ETH → USDC', desc: 'Most common' },
+          { value: 'USDC->ETH', label: 'USDC → ETH', desc: 'Reverse' },
+          { value: 'ETH->AERO', label: 'ETH → AERO', desc: 'Base ecosystem' },
+          { value: 'ETH->VIRTUAL', label: 'ETH → VIRTUAL', desc: 'Base ecosystem' },
+          { value: 'custom', label: 'Custom pair', desc: 'Any symbol or 0x token' },
+          { value: 'back', label: '← Back', desc: '' },
+        ]);
+        return {};
+      }
+      if (value === 'snipe') {
+        ws.sendPrompt('trade_snipe_token', 'Token contract (0x...):', {});
+        return {};
+      }
+      if (value === 'watch') {
+        return await handleCommand('trade watch', ws);
+      }
+      return {};
+
+    case 'trade_swap_pair': {
+      if (value === 'back') return {};
+      if (value === 'custom') {
+        ws.sendPrompt('trade_swap_custom_pair', 'Pair (format: TOKEN_IN TOKEN_OUT):', {});
+        return {};
+      }
+      const [tokenIn, tokenOut] = value.split('->');
+      ws.sendMenu('trade_swap_amount', `◆ Amount (${tokenIn} → ${tokenOut})`, [
+        { value: '0.01', label: `0.01 ${tokenIn}`, desc: 'small' , meta: { tokenIn, tokenOut }},
+        { value: '0.05', label: `0.05 ${tokenIn}`, desc: 'small' , meta: { tokenIn, tokenOut }},
+        { value: '0.1', label: `0.1 ${tokenIn}`, desc: 'standard' , meta: { tokenIn, tokenOut }},
+        { value: '0.25', label: `0.25 ${tokenIn}`, desc: 'medium' , meta: { tokenIn, tokenOut }},
+        { value: '1', label: `1 ${tokenIn}`, desc: 'large' , meta: { tokenIn, tokenOut }},
+        { value: 'custom', label: 'Custom amount', desc: '', meta: { tokenIn, tokenOut }},
+      ]);
+      return {};
+    }
+
+    case 'trade_swap_amount':
+      if (value === 'custom') {
+        ws.sendPrompt('trade_swap_custom_amount', `Amount (${item?.meta?.tokenIn || 'token'}):`, item?.meta || {});
+        return {};
+      }
+      ws.sendPrompt('trade_swap_password', `Wallet password (${item?.meta?.tokenIn || ''} → ${item?.meta?.tokenOut || ''}, ${value}):`, {
+        ...(item?.meta || {}),
+        amount: value,
+        mask: true,
+      });
+      return {};
+
+    case 'trade_snipe_amount':
+      ws.sendPrompt('trade_snipe_password', `Wallet password (snipe ${item?.meta?.token || ''} with ${value} ETH):`, {
+        ...(item?.meta || {}),
+        amount: value,
+        mask: true,
+      });
+      return {};
+
+    case 'send_token':
+      if (value === 'back') return {};
+      if (value === 'custom') {
+        ws.sendPrompt('send_custom_token', 'Token contract address (0x...):', {});
+        return {};
+      }
+      ws.sendPrompt('send_to', `Recipient address (for ${value}):`, { token: value });
+      return {};
+
+    case 'send_amount':
+      if (value === 'custom') {
+        ws.sendPrompt('send_custom_amount', `Amount (${item?.meta?.token || 'token'}):`, item?.meta || {});
+        return {};
+      }
+      ws.sendPrompt('send_password', `Wallet password (send ${value} ${item?.meta?.token || 'token'}):`, {
+        ...(item?.meta || {}),
+        amount: value,
+        mask: true,
+      });
+      return {};
+
     case 'agent_action':
       if (value === 'start') {
         const { listWallets } = await import('../wallet/keystore.js');
@@ -348,6 +428,185 @@ export async function handlePromptResponse(id, value, meta, ws) {
     return {};
   }
 
+  if (id === 'send_custom_token') {
+    if (!value || !value.startsWith('0x') || value.length !== 42) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid token address${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+    ws.sendPrompt('send_to', 'Recipient address:', { token: value.trim() });
+    return {};
+  }
+
+  if (id === 'send_to') {
+    if (!value || !value.startsWith('0x') || value.length !== 42) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid recipient address${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    const token = meta?.token || 'ETH';
+    const defaultAmounts = token === 'ETH'
+      ? ['0.005', '0.01', '0.05', '0.1']
+      : ['1', '5', '10', '25'];
+
+    ws.sendMenu('send_amount', `◆ Amount (${token})`, [
+      ...defaultAmounts.map(a => ({ value: a, label: `${a} ${token === 'ETH' ? 'ETH' : ''}`.trim(), desc: 'quick', meta: { token, to: value.trim() } })),
+      { value: 'custom', label: 'Custom amount', desc: '', meta: { token, to: value.trim() } },
+    ]);
+    return {};
+  }
+
+  if (id === 'send_custom_amount') {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid amount${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+    ws.sendPrompt('send_password', `Wallet password (send ${value} ${meta?.token || 'token'}):`, {
+      ...meta,
+      amount: String(value),
+      mask: true,
+    });
+    return {};
+  }
+
+  if (id === 'send_password') {
+    if (!meta?.to || !meta?.token || !meta?.amount || !value) {
+      ws.sendLine(`  ${ANSI.red}✗ Missing send details${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    ws.sendLine(`  ${ANSI.dim}Sending ${meta.amount} ${meta.token} to ${meta.to.slice(0, 8)}...${ANSI.reset}`);
+    ws.sendLine('');
+
+    try {
+      const { sendFunds } = await import('../wallet/manager.js');
+      await sendFunds({
+        wallet: getConfig('activeWallet'),
+        to: meta.to,
+        amount: meta.amount,
+        token: meta.token,
+        password: value,
+        confirm: true,
+      });
+      ws.sendLine(`  ${ANSI.green}✓ Send flow completed (check terminal output for receipt)${ANSI.reset}`);
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ Send failed: ${err.message}${ANSI.reset}`);
+    }
+    ws.sendLine('');
+    return {};
+  }
+
+  if (id === 'trade_swap_custom_pair') {
+    if (!value) { ws.sendLine(`  ${ANSI.red}✗ Cancelled${ANSI.reset}`); ws.sendLine(''); return {}; }
+    const parts = value.trim().split(/\s+/).filter(Boolean);
+    if (parts.length < 2) {
+      ws.sendLine(`  ${ANSI.red}✗ Format: TOKEN_IN TOKEN_OUT${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+    const [tokenIn, tokenOut] = parts;
+    ws.sendMenu('trade_swap_amount', `◆ Amount (${tokenIn} → ${tokenOut})`, [
+      { value: '0.01', label: `0.01 ${tokenIn}`, desc: 'small', meta: { tokenIn, tokenOut } },
+      { value: '0.05', label: `0.05 ${tokenIn}`, desc: 'small', meta: { tokenIn, tokenOut } },
+      { value: '0.1', label: `0.1 ${tokenIn}`, desc: 'standard', meta: { tokenIn, tokenOut } },
+      { value: '0.25', label: `0.25 ${tokenIn}`, desc: 'medium', meta: { tokenIn, tokenOut } },
+      { value: '1', label: `1 ${tokenIn}`, desc: 'large', meta: { tokenIn, tokenOut } },
+      { value: 'custom', label: 'Custom amount', desc: '', meta: { tokenIn, tokenOut } },
+    ]);
+    return {};
+  }
+
+  if (id === 'trade_swap_custom_amount') {
+    if (!value) { ws.sendLine(`  ${ANSI.red}✗ Cancelled${ANSI.reset}`); ws.sendLine(''); return {}; }
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid amount${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+    ws.sendPrompt('trade_swap_password', `Wallet password (${meta?.tokenIn || ''} → ${meta?.tokenOut || ''}, ${value}):`, {
+      ...meta,
+      amount: String(value),
+      mask: true,
+    });
+    return {};
+  }
+
+  if (id === 'trade_swap_password') {
+    if (!meta?.tokenIn || !meta?.tokenOut || !meta?.amount || !value) {
+      ws.sendLine(`  ${ANSI.red}✗ Missing swap details${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    ws.sendLine(`  ${ANSI.dim}Executing swap ${meta.amount} ${meta.tokenIn} → ${meta.tokenOut}...${ANSI.reset}`);
+    ws.sendLine('');
+
+    try {
+      const { executeSwap } = await import('../trading/swap.js');
+      await executeSwap({
+        tokenIn: meta.tokenIn,
+        tokenOut: meta.tokenOut,
+        amount: meta.amount,
+        slippage: parseFloat(getConfig('slippage') || 0.5),
+        wallet: getConfig('activeWallet'),
+        password: value,
+        confirm: true,
+      });
+      ws.sendLine(`  ${ANSI.green}✓ Swap flow completed (check terminal output for receipt)${ANSI.reset}`);
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ Swap failed: ${err.message}${ANSI.reset}`);
+    }
+    ws.sendLine('');
+    return {};
+  }
+
+  if (id === 'trade_snipe_token') {
+    if (!value || !value.startsWith('0x') || value.length !== 42) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid token contract${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+    ws.sendMenu('trade_snipe_amount', '◆ Snipe Amount (ETH)', [
+      { value: '0.01', label: '0.01 ETH', desc: 'small', meta: { token: value.trim() } },
+      { value: '0.05', label: '0.05 ETH', desc: 'standard', meta: { token: value.trim() } },
+      { value: '0.1', label: '0.1 ETH', desc: 'medium', meta: { token: value.trim() } },
+      { value: '0.25', label: '0.25 ETH', desc: 'large', meta: { token: value.trim() } },
+    ]);
+    return {};
+  }
+
+  if (id === 'trade_snipe_password') {
+    if (!meta?.token || !meta?.amount || !value) {
+      ws.sendLine(`  ${ANSI.red}✗ Missing snipe details${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    ws.sendLine(`  ${ANSI.dim}Executing snipe ${meta.amount} ETH -> ${meta.token.slice(0, 8)}...${ANSI.reset}`);
+    ws.sendLine('');
+
+    try {
+      const { snipeToken } = await import('../trading/snipe.js');
+      await snipeToken(meta.token, meta.amount, {
+        slippage: parseFloat(getConfig('slippage') || 1),
+        gas: parseFloat(getConfig('gasMultiplier') || 1.5),
+        wallet: getConfig('activeWallet'),
+        password: value,
+        confirm: true,
+      });
+      ws.sendLine(`  ${ANSI.green}✓ Snipe flow completed (check terminal output for receipt)${ANSI.reset}`);
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ Snipe failed: ${err.message}${ANSI.reset}`);
+    }
+    ws.sendLine('');
+    return {};
+  }
+
   if (id === 'agent_signer_password') {
     const wallet = meta.wallet;
     if (!wallet || !value) {
@@ -383,7 +642,7 @@ export function getAIStatus() {
   const dim = '\x1b[38;2;102;102;102m';
   const reset = '\x1b[0m';
 
-  const providers = ['openai', 'anthropic', 'openrouter', 'ollama'];
+  const providers = ['openai', 'anthropic', 'openrouter', 'ollama', 'bankr'];
   const connected = providers.filter(p => hasKey(p));
 
   if (connected.length > 0) {
@@ -398,6 +657,7 @@ export function getAIStatus() {
     `  ${green}keys add openai sk-...${reset}         ${dim}OpenAI (GPT-4o)${reset}`,
     `  ${green}keys add anthropic sk-ant-...${reset}   ${dim}Anthropic (Claude)${reset}`,
     `  ${green}keys add openrouter sk-or-...${reset}   ${dim}OpenRouter (any model)${reset}`,
+    `  ${green}keys add bankr bk_...${reset}           ${dim}Bankr LLM Gateway (crypto credits)${reset}`,
     `  ${green}keys add ollama http://...${reset}      ${dim}Ollama (free, local)${reset}`,
     '',
   ].join('\r\n');
@@ -424,6 +684,8 @@ export async function handleCommand(cmd, ws) {
       return await cmdHistory(args, ws);
     case 'market':
       return await cmdMarket(args, ws);
+    case 'trade':
+      return await cmdTrade(args, ws);
     case 'wallet':
       return await cmdWallet(args, ws);
     case 'mail':
@@ -705,6 +967,34 @@ async function cmdMarket(args, ws) {
   return {};
 }
 
+// ══════════════════════════════════════════════════
+// TRADE (interactive web flow)
+// ══════════════════════════════════════════════════
+async function cmdTrade(args, ws) {
+  const sub = (args[0] || '').toLowerCase();
+
+  if (sub === 'watch') {
+    ws.sendLine(`${ANSI.dim}Pair watch is CLI-first right now:${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}darksol trade watch${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  ws.sendLine(`${ANSI.gold}  ◆ TRADE${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.white}Choose an execution flow:${ANSI.reset}`);
+  ws.sendLine('');
+
+  ws.sendMenu('trade_action', '◆ Trade Actions', [
+    { value: 'swap', label: '🔄 Swap', desc: 'Interactive token swap (password prompt)' },
+    { value: 'snipe', label: '⚡ Snipe', desc: 'Fast buy by token contract' },
+    { value: 'watch', label: '👀 Watch Pairs', desc: 'Monitor new pairs (CLI guidance)' },
+    { value: 'back', label: '← Back', desc: '' },
+  ]);
+
+  return {};
+}
+
 // ══════════════════════════════════════════════════
 // WALLET
 // ══════════════════════════════════════════════════
@@ -1470,7 +1760,7 @@ async function cmdKeys(args, ws) {
   ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
   ws.sendLine('');
 
-  const llmProviders = ['openai', 'anthropic', 'openrouter', 'ollama'];
+  const llmProviders = ['openai', 'anthropic', 'openrouter', 'ollama', 'bankr'];
   ws.sendLine(`  ${ANSI.gold}LLM Providers:${ANSI.reset}`);
   for (const p of llmProviders) {
     const svc = SERVICES[p];
@@ -1564,24 +1854,17 @@ async function cmdSend(args, ws) {
     return {};
   }
 
-  ws.sendLine(`  ${ANSI.white}Send ETH or any ERC-20 token from your wallet.${ANSI.reset}`);
-  ws.sendLine('');
-  ws.sendLine(`  ${ANSI.darkGold}Usage:${ANSI.reset}`);
-  ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 0.1 --token ETH${ANSI.reset}`);
-  ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 50 --token USDC${ANSI.reset}`);
-  ws.sendLine(`  ${ANSI.gold}darksol send${ANSI.reset}  ${ANSI.dim}(interactive mode — prompts for everything)${ANSI.reset}`);
-  ws.sendLine('');
-  ws.sendLine(`  ${ANSI.darkGold}Features:${ANSI.reset}`);
-  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} ETH and any ERC-20 token`);
-  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Balance check before sending`);
-  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Gas estimation in preview`);
-  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Confirmation prompt before execution`);
-  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} On-chain receipt after confirmation`);
-  ws.sendLine('');
-  ws.sendLine(`  ${ANSI.darkGold}Active:${ANSI.reset} ${ANSI.white}${wallet}${ANSI.reset} on ${ANSI.white}${chain}${ANSI.reset}`);
-  ws.sendLine('');
-  ws.sendLine(`  ${ANSI.dim}⚠ Sending requires the CLI. Install: npm i -g @darksol/terminal${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.white}Wallet:${ANSI.reset} ${ANSI.gold}${wallet}${ANSI.reset} ${ANSI.dim}on ${chain}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.dim}Interactive send flow will ask token → recipient → amount → password.${ANSI.reset}`);
   ws.sendLine('');
+
+  ws.sendMenu('send_token', '◆ Send Token', [
+    { value: 'ETH', label: 'ETH', desc: 'Native token transfer' },
+    { value: 'USDC', label: 'USDC', desc: 'Stablecoin transfer' },
+    { value: 'custom', label: 'Custom token (0x...)', desc: 'ERC-20 contract address' },
+    { value: 'back', label: '← Back', desc: '' },
+  ]);
+
   return {};
 }
 

package/src/web/server.js

@@ -163,10 +163,12 @@ export async function startWebShell(opts = {}) {
               items: [
                 { value: 'ai', label: '🧠 AI Chat', desc: 'Natural language assistant' },
                 { value: 'wallet', label: '👛 Wallet', desc: 'Picker + balance + actions' },
+                { value: 'send', label: '📤 Send', desc: 'Interactive transfer flow' },
                 { value: 'agent', label: '🔐 Agent Signer', desc: 'Start/stop/status controls' },
                 { value: 'keys', label: '🔑 Keys', desc: 'Add/update LLM providers' },
                 { value: 'config', label: '⚙ Config', desc: 'Chain + settings' },
                 { value: 'portfolio', label: '📊 Portfolio', desc: 'Multi-chain balances' },
+                { value: 'trade', label: '🔄 Trade', desc: 'Swap / snipe click-through flows' },
                 { value: 'market', label: '📈 Market', desc: 'Price + liquidity intel' },
                 { value: 'mail', label: '📧 Mail', desc: 'AgentMail status/inbox' },
                 { value: 'cards', label: '💳 Cards', desc: 'Order prepaid Visa/MC' },
@@ -298,6 +300,7 @@ function getHelp() {
     ['watch <token>', 'Live price monitor'],
     ['gas [chain]', 'Gas prices & estimates'],
     ['portfolio', 'Multi-chain balances'],
+    ['trade', 'Interactive swap/snipe menu'],
     ['send', 'Send ETH or tokens'],
     ['receive', 'Show address to receive'],
     ['wallet', 'Interactive wallet menu'],