@darksol/terminal 0.4.6 → 0.4.8

package/package.json

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

package/src/web/commands.js

@@ -1,7 +1,37 @@
 import fetch from 'node-fetch';
 import { getConfig, setConfig } from '../config/store.js';
-import { hasKey, getKeyAuto } from '../config/keys.js';
+import { hasKey, hasAnyLLM, getKeyAuto, addKeyDirect, SERVICES } from '../config/keys.js';
 import { ethers } from 'ethers';
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// ══════════════════════════════════════════════════
+// CHAT LOG PERSISTENCE
+// ══════════════════════════════════════════════════
+const CHAT_LOG_DIR = join(homedir(), '.darksol', 'chat-logs');
+
+function ensureChatLogDir() {
+  if (!existsSync(CHAT_LOG_DIR)) mkdirSync(CHAT_LOG_DIR, { recursive: true });
+}
+
+function logChat(role, content) {
+  ensureChatLogDir();
+  const date = new Date().toISOString().slice(0, 10);
+  const time = new Date().toISOString().slice(11, 19);
+  const file = join(CHAT_LOG_DIR, `${date}.jsonl`);
+  const entry = JSON.stringify({ ts: new Date().toISOString(), time, role, content });
+  appendFileSync(file, entry + '\n');
+}
+
+function getChatHistory(limit = 20) {
+  ensureChatLogDir();
+  const date = new Date().toISOString().slice(0, 10);
+  const file = join(CHAT_LOG_DIR, `${date}.jsonl`);
+  if (!existsSync(file)) return [];
+  const lines = readFileSync(file, 'utf-8').trim().split('\n').filter(Boolean);
+  return lines.slice(-limit).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+}
 
 // ══════════════════════════════════════════════════
 // WEB SHELL COMMAND HANDLER
@@ -39,6 +69,128 @@ const USDC_ADDRESSES = {
 
 const ERC20_ABI = ['function balanceOf(address) view returns (uint256)'];
 
+/**
+ * Handle interactive menu selections from the client
+ */
+export async function handleMenuSelect(id, value, item, ws) {
+  switch (id) {
+    case 'wallet_select':
+      return await showWalletDetail(value, ws);
+
+    case 'wallet_action':
+      switch (value) {
+        case 'receive': {
+          const name = getConfig('activeWallet');
+          if (!name) return {};
+          const { loadWallet } = await import('../wallet/keystore.js');
+          const w = loadWallet(name);
+          ws.sendLine('');
+          ws.sendLine(`${ANSI.gold}  ◆ RECEIVE — ${name}${ANSI.reset}`);
+          ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+          ws.sendLine('');
+          ws.sendLine(`  ${ANSI.white}Your address:${ANSI.reset}`);
+          ws.sendLine('');
+          const addr = w.address;
+          ws.sendLine(`  ${ANSI.dim}┌${'─'.repeat(addr.length + 4)}┐${ANSI.reset}`);
+          ws.sendLine(`  ${ANSI.dim}│  ${ANSI.gold}${addr}${ANSI.dim}  │${ANSI.reset}`);
+          ws.sendLine(`  ${ANSI.dim}└${'─'.repeat(addr.length + 4)}┘${ANSI.reset}`);
+          ws.sendLine('');
+          ws.sendLine(`  ${ANSI.dim}Works on ALL EVM chains: Base • Ethereum • Arbitrum • Optimism • Polygon${ANSI.reset}`);
+          ws.sendLine(`  ${ANSI.red}Make sure the sender is on the same chain!${ANSI.reset}`);
+          ws.sendLine('');
+          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('');
+          return {};
+        case 'portfolio':
+          return await handleCommand('portfolio', ws);
+        case 'history':
+          return await handleCommand('history', ws);
+        case 'switch': {
+          const chains = ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon'];
+          const current = getConfig('chain') || 'base';
+          ws.sendMenu('chain_select', '◆ Select Chain', chains.map(c => ({
+            value: c,
+            label: c === current ? `★ ${c}` : c,
+            desc: c === current ? 'current' : '',
+          })));
+          return {};
+        }
+        case 'back':
+          ws.sendLine('');
+          return {};
+      }
+      break;
+
+    case 'chain_select':
+      setConfig('chain', value);
+      ws.sendLine('');
+      ws.sendLine(`  ${ANSI.green}✓ Chain set to ${value}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+
+    case 'config_action':
+      if (value === 'chain') {
+        const chains = ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon'];
+        const current = getConfig('chain') || 'base';
+        ws.sendMenu('chain_select', '◆ Select Chain', chains.map(c => ({
+          value: c,
+          label: c === current ? `★ ${c}` : c,
+          desc: c === current ? 'current' : '',
+        })));
+        return {};
+      }
+      if (value === 'keys') {
+        return await handleCommand('keys', ws);
+      }
+      ws.sendLine('');
+      return {};
+
+    case 'main_menu':
+      return await handleCommand(value, ws);
+  }
+
+  return {};
+}
+
+/**
+ * AI status check — shown on connection
+ */
+export function getAIStatus() {
+  const gold = '\x1b[38;2;255;215;0m';
+  const green = '\x1b[38;2;0;255;136m';
+  const red = '\x1b[38;2;233;69;96m';
+  const dim = '\x1b[38;2;102;102;102m';
+  const reset = '\x1b[0m';
+
+  const providers = ['openai', 'anthropic', 'openrouter', 'ollama'];
+  const connected = providers.filter(p => hasKey(p));
+
+  if (connected.length > 0) {
+    const names = connected.map(p => SERVICES[p]?.name || p).join(', ');
+    return `  ${green}● AI ready${reset} ${dim}(${names})${reset}\r\n  ${dim}Type ${gold}ai <question>${dim} to start chatting. Chat logs saved to ~/.darksol/chat-logs/${reset}\r\n\r\n`;
+  }
+
+  return [
+    `  ${red}○ AI not configured${reset} ${dim}— no LLM provider connected${reset}`,
+    '',
+    `  ${gold}Quick setup — pick one:${reset}`,
+    `  ${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 ollama http://...${reset}      ${dim}Ollama (free, local)${reset}`,
+    '',
+    `  ${dim}Or run the full setup wizard: ${gold}darksol setup${reset}`,
+    '',
+  ].join('\r\n');
+}
+
 /**
  * Handle a command string, return { output } or stream via ws helpers
  */
@@ -80,6 +232,12 @@ export async function handleCommand(cmd, ws) {
     case 'ask':
     case 'chat':
       return await cmdAI(args, ws);
+    case 'keys':
+    case 'llm':
+      return await cmdKeys(args, ws);
+    case 'logs':
+    case 'chatlog':
+      return await cmdChatLogs(args, ws);
     default: {
       // Fuzzy: if it looks like natural language, route to AI
       const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca)\b/i;
@@ -334,47 +492,121 @@ async function cmdMarket(args, ws) {
 // WALLET
 // ══════════════════════════════════════════════════
 async function cmdWallet(args, ws) {
-  const sub = args[0] || 'list';
+  const sub = args[0];
+
+  // If a specific subcommand, handle directly
+  if (sub === 'balance') {
+    return await showWalletDetail(args[1] || getConfig('activeWallet'), ws);
+  }
 
-  if (sub === 'list') {
-    const { listWallets } = await import('../wallet/keystore.js');
-    const wallets = listWallets();
-    const active = getConfig('activeWallet');
+  if (sub === 'use' && args[1]) {
+    setConfig('activeWallet', args[1]);
+    ws.sendLine(`  ${ANSI.green}✓ Active wallet set to "${args[1]}"${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
 
+  // Default: interactive wallet picker
+  const { listWallets } = await import('../wallet/keystore.js');
+  const wallets = listWallets();
+  const active = getConfig('activeWallet');
+
+  if (wallets.length === 0) {
     ws.sendLine(`${ANSI.gold}  ◆ WALLETS${ANSI.reset}`);
     ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
-
-    if (wallets.length === 0) {
-      ws.sendLine(`  ${ANSI.dim}No wallets. Create one in the CLI: darksol wallet create${ANSI.reset}`);
-    } else {
-      for (const w of wallets) {
-        const indicator = w === active ? `${ANSI.gold}► ${ANSI.reset}` : '  ';
-        ws.sendLine(`  ${indicator}${ANSI.white}${w}${ANSI.reset}`);
-      }
-    }
-
+    ws.sendLine(`  ${ANSI.dim}No wallets found.${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Create one: ${ANSI.gold}darksol wallet create <name>${ANSI.reset}`);
     ws.sendLine('');
     return {};
   }
 
-  if (sub === 'balance') {
-    const name = args[1] || getConfig('activeWallet');
-    if (!name) return { output: `  ${ANSI.red}No active wallet${ANSI.reset}\r\n` };
+  if (wallets.length === 1) {
+    // Only one wallet — go straight to it
+    return await showWalletDetail(wallets[0].name, ws);
+  }
 
-    const { loadWallet } = await import('../wallet/keystore.js');
-    const w = loadWallet(name);
-    const chain = getConfig('chain') || 'base';
-    const provider = new ethers.JsonRpcProvider(RPCS[chain]);
-    const bal = parseFloat(ethers.formatEther(await provider.getBalance(w.address)));
+  // Multiple wallets — show interactive menu
+  const menuItems = wallets.map(w => ({
+    value: w.name,
+    label: `${w.name === active ? '★ ' : ''}${w.name}`,
+    desc: `${w.address.slice(0, 6)}...${w.address.slice(-4)}`,
+  }));
+
+  ws.sendMenu('wallet_select', '◆ Select Wallet', menuItems);
+  return {};
+}
+
+async function showWalletDetail(name, ws) {
+  if (!name) {
+    ws.sendLine(`  ${ANSI.red}No wallet selected${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
 
-    ws.sendLine(`${ANSI.gold}  ◆ BALANCE — ${name}${ANSI.reset}`);
-    ws.sendLine(`${ANSI.dim}  ${w.address}${ANSI.reset}`);
-    ws.sendLine(`  ${ANSI.white}${bal.toFixed(6)} ETH${ANSI.reset} on ${chain}`);
+  const { loadWallet } = await import('../wallet/keystore.js');
+  let walletData;
+  try {
+    walletData = loadWallet(name);
+  } catch {
+    ws.sendLine(`  ${ANSI.red}Wallet "${name}" not found${ANSI.reset}`);
     ws.sendLine('');
     return {};
   }
 
-  return { output: `  ${ANSI.dim}Wallet commands: list, balance${ANSI.reset}\r\n` };
+  const chain = getConfig('chain') || 'base';
+  const provider = new ethers.JsonRpcProvider(RPCS[chain]);
+
+  ws.sendLine(`${ANSI.gold}  ◆ WALLET — ${name}${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.darkGold}Address${ANSI.reset}      ${ANSI.white}${walletData.address}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.darkGold}Chain${ANSI.reset}        ${ANSI.white}${chain}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.darkGold}Created${ANSI.reset}      ${ANSI.dim}${walletData.createdAt ? new Date(walletData.createdAt).toLocaleDateString() : 'unknown'}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.darkGold}Encryption${ANSI.reset}   ${ANSI.dim}AES-256-GCM + scrypt${ANSI.reset}`);
+
+  // Fetch balance
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.dim}Fetching balance...${ANSI.reset}`);
+
+  try {
+    const balance = await provider.getBalance(walletData.address);
+    const ethBal = parseFloat(ethers.formatEther(balance));
+
+    // Also check USDC
+    const usdcAddr = USDC_ADDRESSES[chain];
+    let usdcBal = 0;
+    if (usdcAddr) {
+      try {
+        const usdc = new ethers.Contract(usdcAddr, ['function balanceOf(address) view returns (uint256)'], provider);
+        const raw = await usdc.balanceOf(walletData.address);
+        usdcBal = parseFloat(ethers.formatUnits(raw, 6));
+      } catch {}
+    }
+
+    // Get ETH price for USD value
+    const ethPrice = await getEthPrice();
+    const usdValue = (ethBal * ethPrice) + usdcBal;
+
+    // Overwrite "Fetching..." line
+    ws.sendLine(`\x1b[1A\x1b[2K  ${ANSI.darkGold}ETH${ANSI.reset}          ${ANSI.white}${ethBal.toFixed(6)}${ANSI.reset} ${ANSI.dim}($${(ethBal * ethPrice).toFixed(2)})${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}USDC${ANSI.reset}         ${ANSI.white}$${usdcBal.toFixed(2)}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.darkGold}Total${ANSI.reset}        ${ANSI.green}$${usdValue.toFixed(2)}${ANSI.reset}`);
+  } catch (err) {
+    ws.sendLine(`  ${ANSI.red}Balance fetch failed: ${err.message}${ANSI.reset}`);
+  }
+
+  ws.sendLine('');
+
+  // Show action menu
+  ws.sendMenu('wallet_action', '◆ What would you like to do?', [
+    { value: 'receive', label: '📥 Receive', desc: 'Show address to receive funds' },
+    { value: 'send', label: '📤 Send', desc: 'Send ETH or tokens (CLI required)' },
+    { value: 'portfolio', label: '📊 Portfolio', desc: 'Multi-chain balance view' },
+    { value: 'history', label: '📜 History', desc: 'Transaction history' },
+    { value: 'switch', label: '🔄 Switch chain', desc: `Currently: ${chain}` },
+    { value: 'back', label: '← Back', desc: '' },
+  ]);
+
+  return {};
 }
 
 // ══════════════════════════════════════════════════
@@ -513,8 +745,16 @@ async function cmdConfig(ws) {
   ws.sendLine(`  ${ANSI.darkGold}Wallet${ANSI.reset}        ${ANSI.white}${wallet}${ANSI.reset}`);
   ws.sendLine(`  ${ANSI.darkGold}Slippage${ANSI.reset}      ${ANSI.white}${slippage}%${ANSI.reset}`);
   ws.sendLine(`  ${ANSI.darkGold}Mail${ANSI.reset}          ${ANSI.white}${email}${ANSI.reset}`);
-  ws.sendLine(`  ${ANSI.darkGold}AI${ANSI.reset}            ${hasKey('openai') || hasKey('anthropic') || hasKey('openrouter') || hasKey('ollama') ? `${ANSI.green}● Ready${ANSI.reset}` : `${ANSI.dim}○ Not configured${ANSI.reset}`}`);
+  ws.sendLine(`  ${ANSI.darkGold}AI${ANSI.reset}            ${hasAnyLLM() ? `${ANSI.green}● Ready${ANSI.reset}` : `${ANSI.dim}○ Not configured${ANSI.reset}`}`);
   ws.sendLine('');
+
+  // Offer interactive config
+  ws.sendMenu('config_action', '◆ Configure', [
+    { value: 'chain', label: '🔗 Change chain', desc: `Currently: ${chain}` },
+    { value: 'keys', label: '🔑 LLM / API keys', desc: '' },
+    { value: 'back', label: '← Back', desc: '' },
+  ]);
+
   return {};
 }
 
@@ -649,6 +889,9 @@ COMMAND REFERENCE:
     enriched += `\n\n[Live market data: ${priceData.join(', ')}]`;
   }
 
+  // Log user message
+  logChat('user', input);
+
   // Send to LLM
   ws.sendLine(`  ${ANSI.dim}Thinking...${ANSI.reset}`);
 
@@ -656,6 +899,9 @@ COMMAND REFERENCE:
     const result = await engine.chat(enriched);
     const usage = engine.getUsage();
 
+    // Log AI response
+    logChat('assistant', result.content);
+
     // Display response with formatting
     ws.sendLine('');
     ws.sendLine(`${ANSI.gold}  ◆ DARKSOL AI${ANSI.reset}`);
@@ -690,6 +936,130 @@ COMMAND REFERENCE:
   return {};
 }
 
+// ══════════════════════════════════════════════════
+// KEYS — LLM provider configuration from web shell
+// ══════════════════════════════════════════════════
+async function cmdKeys(args, ws) {
+  const sub = args[0]?.toLowerCase();
+
+  if (sub === 'add' && args[1]) {
+    const service = args[1].toLowerCase();
+    const key = args[2];
+    const svc = SERVICES[service];
+
+    if (!svc) {
+      ws.sendLine(`  ${ANSI.red}✗ Unknown service: ${service}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}Available: openai, anthropic, openrouter, ollama${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    if (!key) {
+      ws.sendLine(`  ${ANSI.red}✗ No key provided${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}Usage: keys add ${service} <your-api-key>${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}Get a key: ${svc.docsUrl}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    if (svc.validate && !svc.validate(key)) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid key format for ${svc.name}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    try {
+      addKeyDirect(service, key);
+      ws.sendLine(`  ${ANSI.green}✓ ${svc.name} key stored securely${ANSI.reset}`);
+
+      // Clear cached engine so it picks up new key
+      chatEngines.delete(ws);
+      ws.sendLine(`  ${ANSI.dim}AI session refreshed — type ${ANSI.gold}ai <question>${ANSI.dim} to chat${ANSI.reset}`);
+      ws.sendLine('');
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ Failed to store key: ${err.message}${ANSI.reset}`);
+      ws.sendLine('');
+    }
+    return {};
+  }
+
+  if (sub === 'remove' && args[1]) {
+    const service = args[1].toLowerCase();
+    // Can't remove via web shell without password prompt — point to CLI
+    ws.sendLine(`  ${ANSI.dim}To remove keys, use the CLI:${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}darksol keys remove ${service}${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  // Default: show status
+  ws.sendLine(`${ANSI.gold}  ◆ API KEYS / LLM CONFIG${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine('');
+
+  const llmProviders = ['openai', 'anthropic', 'openrouter', 'ollama'];
+  ws.sendLine(`  ${ANSI.gold}LLM Providers:${ANSI.reset}`);
+  for (const p of llmProviders) {
+    const svc = SERVICES[p];
+    const has = hasKey(p);
+    const status = has ? `${ANSI.green}● Connected${ANSI.reset}` : `${ANSI.dim}○ Not set${ANSI.reset}`;
+    ws.sendLine(`    ${status}  ${ANSI.white}${svc.name.padEnd(20)}${ANSI.reset}${ANSI.dim}${svc.description}${ANSI.reset}`);
+  }
+
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.gold}Quick Setup:${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.green}keys add openai sk-...${ANSI.reset}       ${ANSI.dim}Add OpenAI key${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.green}keys add anthropic sk-ant-...${ANSI.reset} ${ANSI.dim}Add Anthropic key${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.green}keys add openrouter sk-or-...${ANSI.reset} ${ANSI.dim}Add OpenRouter key${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.green}keys add ollama http://...${ANSI.reset}   ${ANSI.dim}Add Ollama host${ANSI.reset}`);
+  ws.sendLine('');
+
+  const dataProviders = ['coingecko', 'dexscreener', 'alchemy', 'agentmail'];
+  ws.sendLine(`  ${ANSI.gold}Other Services:${ANSI.reset}`);
+  for (const p of dataProviders) {
+    const svc = SERVICES[p];
+    if (!svc) continue;
+    const has = hasKey(p);
+    const status = has ? `${ANSI.green}●${ANSI.reset}` : `${ANSI.dim}○${ANSI.reset}`;
+    ws.sendLine(`    ${status}  ${ANSI.white}${svc.name.padEnd(20)}${ANSI.reset}${ANSI.dim}${svc.description}${ANSI.reset}`);
+  }
+
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.dim}Keys are AES-256-GCM encrypted at ~/.darksol/keys/vault.json${ANSI.reset}`);
+  ws.sendLine('');
+  return {};
+}
+
+// ══════════════════════════════════════════════════
+// CHAT LOGS — View conversation history
+// ══════════════════════════════════════════════════
+async function cmdChatLogs(args, ws) {
+  const limit = parseInt(args[0]) || 20;
+  const history = getChatHistory(limit);
+
+  ws.sendLine(`${ANSI.gold}  ◆ CHAT LOG${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine('');
+
+  if (history.length === 0) {
+    ws.sendLine(`  ${ANSI.dim}No chat history today. Start with: ai <question>${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  for (const entry of history) {
+    const time = entry.time || '';
+    const role = entry.role === 'user' ? `${ANSI.gold}You${ANSI.reset}` : `${ANSI.green}AI${ANSI.reset}`;
+    const preview = entry.content.split('\n')[0].slice(0, 80);
+    ws.sendLine(`  ${ANSI.dim}${time}${ANSI.reset} ${role}: ${preview}${entry.content.length > 80 ? ANSI.dim + '...' + ANSI.reset : ''}`);
+  }
+
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.dim}Logs: ~/.darksol/chat-logs/ (${history.length} messages shown)${ANSI.reset}`);
+  ws.sendLine('');
+  return {};
+}
+
 // ══════════════════════════════════════════════════
 // SEND / RECEIVE (web shell — info only, actual sends require CLI)
 // ══════════════════════════════════════════════════

package/src/web/server.js

@@ -20,7 +20,7 @@ const __dirname = dirname(__filename);
  * Command handler registry — maps command strings to async functions
  * that return { output: string } with ANSI stripped for web
  */
-import { handleCommand } from './commands.js';
+import { handleCommand, getAIStatus } from './commands.js';
 
 export async function startWebShell(opts = {}) {
   process.on('uncaughtException', (err) => {
@@ -89,10 +89,38 @@ export async function startWebShell(opts = {}) {
       data: getBanner(),
     }));
 
+    // AI connection check right after banner
+    const aiStatus = getAIStatus();
+    ws.send(JSON.stringify({
+      type: 'output',
+      data: aiStatus,
+    }));
+
     ws.on('message', async (raw) => {
       try {
         const msg = JSON.parse(raw.toString());
 
+        if (msg.type === 'menu_select') {
+          // User selected something from an interactive menu
+          try {
+            const { handleMenuSelect } = await import('./commands.js');
+            const result = await handleMenuSelect(msg.id, msg.value, msg.item, {
+              send: (text) => ws.send(JSON.stringify({ type: 'output', data: text })),
+              sendLine: (text) => ws.send(JSON.stringify({ type: 'output', data: text + '\r\n' })),
+              sendMenu: (id, title, items) => ws.send(JSON.stringify({ type: 'menu', id, title, items })),
+            });
+            if (result?.output) {
+              ws.send(JSON.stringify({ type: 'output', data: result.output }));
+            }
+          } catch (err) {
+            ws.send(JSON.stringify({
+              type: 'output',
+              data: `\r\n  \x1b[31m✗ Error: ${err.message}\x1b[0m\r\n`,
+            }));
+          }
+          return;
+        }
+
         if (msg.type === 'command') {
           const cmd = msg.data.trim();
 
@@ -126,6 +154,7 @@ export async function startWebShell(opts = {}) {
             const result = await handleCommand(cmd, {
               send: (text) => ws.send(JSON.stringify({ type: 'output', data: text })),
               sendLine: (text) => ws.send(JSON.stringify({ type: 'output', data: text + '\r\n' })),
+              sendMenu: (id, title, items) => ws.send(JSON.stringify({ type: 'menu', id, title, items })),
             });
 
             if (result?.output) {

package/src/web/terminal.js

@@ -4,11 +4,20 @@
 
 const PROMPT = '\x1b[38;2;255;215;0m❯\x1b[0m ';
 const PROMPT_LENGTH = 2; // visible chars: ❯ + space
+const A = {
+  gold: '\x1b[38;2;255;215;0m',
+  dim: '\x1b[38;2;102;102;102m',
+  green: '\x1b[38;2;0;255;136m',
+  red: '\x1b[38;2;233;69;96m',
+  white: '\x1b[1;37m',
+  blue: '\x1b[38;2;68;136;255m',
+  r: '\x1b[0m',
+};
 
 const COMMANDS = [
-  'price', 'watch', 'gas', 'portfolio', 'history', 'market',
-  'wallet', 'mail', 'oracle', 'casino', 'facilitator', 'config',
-  'help', 'clear', 'banner', 'exit',
+  'ai', 'price', 'watch', 'gas', 'portfolio', 'history', 'market',
+  'wallet', 'send', 'receive', 'mail', 'keys', 'oracle', 'casino',
+  'facilitator', 'config', 'logs', 'help', 'clear', 'banner', 'exit',
 ];
 
 let term;
@@ -18,8 +27,14 @@ let commandHistory = [];
 let historyIndex = -1;
 let connected = false;
 
+// ── MENU STATE ────────────────────────────────
+let menuActive = false;
+let menuItems = [];
+let menuIndex = 0;
+let menuId = '';
+let menuTitle = '';
+
 async function init() {
-  // Load xterm.js
   term = new Terminal({
     theme: {
       background: '#0a0a1a',
@@ -64,16 +79,42 @@ async function init() {
 
   window.addEventListener('resize', () => fitAddon.fit());
 
-  // Connect WebSocket
   connectWS();
 
-  // Input handling
   term.onKey(({ key, domEvent }) => {
     const code = domEvent.keyCode;
     const ctrl = domEvent.ctrlKey;
 
+    // ── MENU MODE ──
+    if (menuActive) {
+      if (code === 38) { // Up
+        if (menuIndex > 0) { menuIndex--; renderMenu(); }
+        return;
+      }
+      if (code === 40) { // Down
+        if (menuIndex < menuItems.length - 1) { menuIndex++; renderMenu(); }
+        return;
+      }
+      if (code === 13) { // Enter — select
+        const selected = menuItems[menuIndex];
+        menuActive = false;
+        // Clear menu display
+        term.write('\x1b[?25h'); // show cursor
+        sendMenuSelection(menuId, selected);
+        return;
+      }
+      if (code === 27 || (ctrl && code === 67)) { // Esc or Ctrl+C — cancel
+        menuActive = false;
+        term.write('\r\n');
+        term.write(`  ${A.dim}Cancelled${A.r}\r\n\r\n`);
+        writePrompt();
+        return;
+      }
+      return; // Ignore other keys in menu mode
+    }
+
+    // ── NORMAL MODE ──
     if (ctrl && code === 67) {
-      // Ctrl+C — cancel
       currentLine = '';
       term.write('^C\r\n');
       writePrompt();
@@ -81,14 +122,12 @@ async function init() {
     }
 
     if (ctrl && code === 76) {
-      // Ctrl+L — clear
       term.clear();
       writePrompt();
       return;
     }
 
     if (code === 13) {
-      // Enter
       term.write('\r\n');
       const cmd = currentLine.trim();
 
@@ -106,7 +145,6 @@ async function init() {
     }
 
     if (code === 8) {
-      // Backspace
       if (currentLine.length > 0) {
         currentLine = currentLine.slice(0, -1);
         term.write('\b \b');
@@ -115,7 +153,6 @@ async function init() {
     }
 
     if (code === 38) {
-      // Arrow up — history
       if (historyIndex < commandHistory.length - 1) {
         historyIndex++;
         replaceInput(commandHistory[historyIndex]);
@@ -124,7 +161,6 @@ async function init() {
     }
 
     if (code === 40) {
-      // Arrow down — history
       if (historyIndex > 0) {
         historyIndex--;
         replaceInput(commandHistory[historyIndex]);
@@ -136,13 +172,11 @@ async function init() {
     }
 
     if (code === 9) {
-      // Tab — autocomplete
       domEvent.preventDefault();
       autocomplete();
       return;
     }
 
-    // Printable characters
     if (key.length === 1 && !ctrl) {
       currentLine += key;
       term.write(key);
@@ -151,7 +185,7 @@ async function init() {
 
   // Paste support
   term.onData((data) => {
-    // Only handle paste (multi-char input)
+    if (menuActive) return;
     if (data.length > 1 && !data.startsWith('\x1b')) {
       const clean = data.replace(/[\r\n]/g, '');
       currentLine += clean;
@@ -162,6 +196,67 @@ async function init() {
   term.focus();
 }
 
+// ── MENU RENDERING ────────────────────────────
+function renderMenu() {
+  // Move cursor up to redraw (clear previous menu)
+  const totalLines = menuItems.length + 2; // title + items + hint
+  term.write(`\x1b[${totalLines}A\x1b[J`);
+
+  term.write(`  ${A.gold}${menuTitle}${A.r}\r\n`);
+
+  for (let i = 0; i < menuItems.length; i++) {
+    const item = menuItems[i];
+    const label = item.label || item.value || String(item);
+    const desc = item.desc ? `  ${A.dim}${item.desc}${A.r}` : '';
+
+    if (i === menuIndex) {
+      term.write(`  ${A.gold}► ${A.white}${label}${A.r}${desc}\r\n`);
+    } else {
+      term.write(`    ${A.dim}${label}${A.r}${desc}\r\n`);
+    }
+  }
+
+  term.write(`  ${A.dim}↑/↓ navigate • Enter select • Esc cancel${A.r}\r\n`);
+}
+
+function showMenu(id, title, items) {
+  menuActive = true;
+  menuId = id;
+  menuTitle = title;
+  menuItems = items;
+  menuIndex = 0;
+
+  term.write('\x1b[?25l'); // hide cursor during menu
+  term.write('\r\n');
+
+  // Initial render
+  term.write(`  ${A.gold}${menuTitle}${A.r}\r\n`);
+  for (let i = 0; i < menuItems.length; i++) {
+    const item = menuItems[i];
+    const label = item.label || item.value || String(item);
+    const desc = item.desc ? `  ${A.dim}${item.desc}${A.r}` : '';
+
+    if (i === menuIndex) {
+      term.write(`  ${A.gold}► ${A.white}${label}${A.r}${desc}\r\n`);
+    } else {
+      term.write(`    ${A.dim}${label}${A.r}${desc}\r\n`);
+    }
+  }
+  term.write(`  ${A.dim}↑/↓ navigate • Enter select • Esc cancel${A.r}\r\n`);
+}
+
+function sendMenuSelection(id, item) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({
+      type: 'menu_select',
+      id,
+      value: item.value || item.label || String(item),
+      item,
+    }));
+  }
+}
+
+// ── WEBSOCKET ─────────────────────────────────
 function connectWS() {
   const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
   ws = new WebSocket(`${protocol}//${window.location.host}`);
@@ -177,13 +272,15 @@ function connectWS() {
 
       if (msg.type === 'output') {
         term.write(msg.data);
-        writePrompt();
+        if (!menuActive) writePrompt();
       } else if (msg.type === 'clear') {
         term.clear();
         writePrompt();
+      } else if (msg.type === 'menu') {
+        // Server is requesting user to pick from a menu
+        showMenu(msg.id, msg.title, msg.items);
       }
     } catch {
-      // Raw text fallback
       term.write(event.data);
     }
   };
@@ -191,12 +288,8 @@ function connectWS() {
   ws.onclose = () => {
     connected = false;
     updateStatus(false);
-    term.write('\r\n\x1b[38;2;233;69;96m  ⚡ Connection lost. Reconnecting...\x1b[0m\r\n');
-
-    // Reconnect after 3s
-    setTimeout(() => {
-      connectWS();
-    }, 3000);
+    term.write(`\r\n${A.red}  ⚡ Connection lost. Reconnecting...${A.r}\r\n`);
+    setTimeout(() => connectWS(), 3000);
   };
 
   ws.onerror = () => {
@@ -209,7 +302,7 @@ function sendCommand(cmd) {
   if (ws && ws.readyState === WebSocket.OPEN) {
     ws.send(JSON.stringify({ type: 'command', data: cmd }));
   } else {
-    term.write('\x1b[38;2;233;69;96m  ✗ Not connected\x1b[0m\r\n');
+    term.write(`${A.red}  ✗ Not connected${A.r}\r\n`);
     writePrompt();
   }
 }
@@ -219,28 +312,20 @@ function writePrompt() {
 }
 
 function replaceInput(text) {
-  // Clear current input
   const clearLen = currentLine.length;
-  for (let i = 0; i < clearLen; i++) {
-    term.write('\b \b');
-  }
+  for (let i = 0; i < clearLen; i++) term.write('\b \b');
   currentLine = text;
   term.write(text);
 }
 
 function autocomplete() {
   if (!currentLine) return;
-
   const matches = COMMANDS.filter((c) => c.startsWith(currentLine.toLowerCase()));
-
   if (matches.length === 1) {
     replaceInput(matches[0]);
   } else if (matches.length > 1) {
-    // Show options
     term.write('\r\n');
-    term.write(
-      matches.map((m) => `  \x1b[38;2;102;102;102m${m}\x1b[0m`).join('    ')
-    );
+    term.write(matches.map((m) => `  ${A.dim}${m}${A.r}`).join('    '));
     term.write('\r\n');
     writePrompt();
     term.write(currentLine);
@@ -250,13 +335,8 @@ function autocomplete() {
 function updateStatus(isConnected) {
   const dot = document.querySelector('.status-dot');
   const text = document.querySelector('.status-text');
-  if (dot) {
-    dot.className = isConnected ? 'status-dot' : 'status-dot disconnected';
-  }
-  if (text) {
-    text.textContent = isConnected ? 'Connected' : 'Disconnected';
-  }
+  if (dot) dot.className = isConnected ? 'status-dot' : 'status-dot disconnected';
+  if (text) text.textContent = isConnected ? 'Connected' : 'Disconnected';
 }
 
-// Boot
 document.addEventListener('DOMContentLoaded', init);