@darksol/terminal 0.4.7 → 0.4.9

package/package.json

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

package/src/web/commands.js

@@ -69,6 +69,169 @@ 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 'keys_provider':
+      if (value === 'back') {
+        ws.sendLine('');
+        return {};
+      }
+      // Ask for the key via a prompt
+      const svc = SERVICES[value];
+      if (!svc) return {};
+      ws.sendLine('');
+      ws.sendLine(`  ${ANSI.gold}◆ ${svc.name}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}Docs: ${svc.docsUrl}${ANSI.reset}`);
+      if (value === 'ollama') {
+        ws.sendLine(`  ${ANSI.dim}Enter your Ollama host URL (e.g. http://localhost:11434)${ANSI.reset}`);
+      } else {
+        ws.sendLine(`  ${ANSI.dim}Paste your API key below:${ANSI.reset}`);
+      }
+      ws.sendLine('');
+      // Send a prompt request to the client
+      ws.send(JSON.stringify({
+        type: 'prompt',
+        id: 'keys_input',
+        label: `${svc.name} key:`,
+        service: value,
+        mask: value !== 'ollama', // mask API keys, not URLs
+      }));
+      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 {};
+}
+
+/**
+ * Handle text prompt responses from the client
+ */
+export async function handlePromptResponse(id, value, meta, ws) {
+  if (id === 'keys_input') {
+    const service = meta.service;
+    const svc = SERVICES[service];
+    if (!svc || !value) {
+      ws.sendLine(`  ${ANSI.red}✗ Cancelled${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    // Validate
+    if (svc.validate && !svc.validate(value)) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid format for ${svc.name}${ANSI.reset}`);
+      if (service === 'openai') ws.sendLine(`  ${ANSI.dim}Key should start with sk-${ANSI.reset}`);
+      if (service === 'anthropic') ws.sendLine(`  ${ANSI.dim}Key should start with sk-ant-${ANSI.reset}`);
+      if (service === 'openrouter') ws.sendLine(`  ${ANSI.dim}Key should start with sk-or-${ANSI.reset}`);
+      if (service === 'ollama') ws.sendLine(`  ${ANSI.dim}Should be a URL like http://localhost:11434${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    // Store it
+    try {
+      addKeyDirect(service, value);
+      ws.sendLine(`  ${ANSI.green}✓ ${svc.name} key stored securely${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}Encrypted at ~/.darksol/keys/vault.json${ANSI.reset}`);
+      ws.sendLine('');
+
+      // Clear cached AI engine
+      // (chatEngines is WeakMap keyed by ws, but we can't access the real ws here — 
+      //  the engine will reinit on next ai command since keys changed)
+      ws.sendLine(`  ${ANSI.green}● AI ready!${ANSI.reset} ${ANSI.dim}Type ${ANSI.gold}ai <question>${ANSI.dim} to start chatting.${ANSI.reset}`);
+      ws.sendLine('');
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ Failed: ${err.message}${ANSI.reset}`);
+      ws.sendLine('');
+    }
+    return {};
+  }
+
+  return {};
+}
+
 /**
  * AI status check — shown on connection
  */
@@ -90,14 +253,12 @@ export function getAIStatus() {
   return [
     `  ${red}○ AI not configured${reset} ${dim}— no LLM provider connected${reset}`,
     '',
-    `  ${gold}Quick setup — pick one:${reset}`,
+    `  ${dim}Type ${gold}keys${dim} to set up an LLM provider, or paste directly:${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');
 }
 
@@ -402,47 +563,121 @@ async function cmdMarket(args, ws) {
 // WALLET
 // ══════════════════════════════════════════════════
 async function cmdWallet(args, ws) {
-  const sub = args[0] || 'list';
+  const sub = args[0];
 
-  if (sub === 'list') {
-    const { listWallets } = await import('../wallet/keystore.js');
-    const wallets = listWallets();
-    const active = getConfig('activeWallet');
+  // If a specific subcommand, handle directly
+  if (sub === 'balance') {
+    return await showWalletDetail(args[1] || getConfig('activeWallet'), ws);
+  }
 
-    ws.sendLine(`${ANSI.gold}  ◆ WALLETS${ANSI.reset}`);
-    ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  if (sub === 'use' && args[1]) {
+    setConfig('activeWallet', args[1]);
+    ws.sendLine(`  ${ANSI.green}✓ Active wallet set to "${args[1]}"${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
 
-    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}`);
-      }
-    }
+  // 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}`);
+    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 {};
 }
 
 // ══════════════════════════════════════════════════
@@ -581,8 +816,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 {};
 }
 
@@ -842,6 +1085,19 @@ async function cmdKeys(args, ws) {
   ws.sendLine(`  ${ANSI.green}keys add ollama http://...${ANSI.reset}   ${ANSI.dim}Add Ollama host${ANSI.reset}`);
   ws.sendLine('');
 
+  // Interactive menu to add keys
+  const llmItems = llmProviders.map(p => {
+    const svc = SERVICES[p];
+    const has = hasKey(p);
+    return {
+      value: p,
+      label: `${has ? '✓' : '+'} ${svc.name}`,
+      desc: has ? 'Connected — replace key' : `Add key (${svc.docsUrl})`,
+    };
+  });
+  llmItems.push({ value: 'back', label: '← Back', desc: '' });
+  ws.sendMenu('keys_provider', '◆ Add / Update API Key', llmItems);
+
   const dataProviders = ['coingecko', 'dexscreener', 'alchemy', 'agentmail'];
   ws.sendLine(`  ${ANSI.gold}Other Services:${ANSI.reset}`);
   for (const p of dataProviders) {

package/src/web/server.js

@@ -100,6 +100,48 @@ export async function startWebShell(opts = {}) {
       try {
         const msg = JSON.parse(raw.toString());
 
+        if (msg.type === 'prompt_response') {
+          // User typed a response to a prompt (e.g. API key input)
+          try {
+            const { handlePromptResponse } = await import('./commands.js');
+            const result = await handlePromptResponse(msg.id, msg.value, msg.meta || {}, {
+              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 === '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();
 
@@ -133,6 +175,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,21 @@ let commandHistory = [];
 let historyIndex = -1;
 let connected = false;
 
+// ── MENU STATE ────────────────────────────────
+let menuActive = false;
+let menuItems = [];
+let menuIndex = 0;
+let menuId = '';
+let menuTitle = '';
+
+// ── PROMPT STATE (text input) ─────────────────
+let promptActive = false;
+let promptId = '';
+let promptMeta = {};
+let promptInput = '';
+let promptMask = false;
+
 async function init() {
-  // Load xterm.js
   term = new Terminal({
     theme: {
       background: '#0a0a1a',
@@ -64,16 +86,84 @@ 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;
 
+    // ── PROMPT MODE (text input) ──
+    if (promptActive) {
+      if (code === 13) { // Enter — submit
+        promptActive = false;
+        term.write('\r\n');
+        if (promptInput) {
+          ws.send(JSON.stringify({
+            type: 'prompt_response',
+            id: promptId,
+            value: promptInput,
+            meta: promptMeta,
+          }));
+        } else {
+          term.write(`  ${A.dim}Cancelled${A.r}\r\n\r\n`);
+          writePrompt();
+        }
+        promptInput = '';
+        return;
+      }
+      if (code === 27 || (ctrl && code === 67)) { // Esc/Ctrl+C — cancel
+        promptActive = false;
+        promptInput = '';
+        term.write('\r\n');
+        term.write(`  ${A.dim}Cancelled${A.r}\r\n\r\n`);
+        writePrompt();
+        return;
+      }
+      if (code === 8) { // Backspace
+        if (promptInput.length > 0) {
+          promptInput = promptInput.slice(0, -1);
+          term.write('\b \b');
+        }
+        return;
+      }
+      // Printable chars
+      if (key.length === 1 && !ctrl) {
+        promptInput += key;
+        term.write(promptMask ? '●' : key);
+      }
+      return;
+    }
+
+    // ── 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 +171,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 +194,6 @@ async function init() {
     }
 
     if (code === 8) {
-      // Backspace
       if (currentLine.length > 0) {
         currentLine = currentLine.slice(0, -1);
         term.write('\b \b');
@@ -115,7 +202,6 @@ async function init() {
     }
 
     if (code === 38) {
-      // Arrow up — history
       if (historyIndex < commandHistory.length - 1) {
         historyIndex++;
         replaceInput(commandHistory[historyIndex]);
@@ -124,7 +210,6 @@ async function init() {
     }
 
     if (code === 40) {
-      // Arrow down — history
       if (historyIndex > 0) {
         historyIndex--;
         replaceInput(commandHistory[historyIndex]);
@@ -136,13 +221,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,17 +234,83 @@ 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;
-      term.write(clean);
+      if (promptActive) {
+        promptInput += clean;
+        term.write(promptMask ? '●'.repeat(clean.length) : clean);
+      } else {
+        currentLine += clean;
+        term.write(clean);
+      }
     }
   });
 
   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 +326,22 @@ 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') {
+        showMenu(msg.id, msg.title, msg.items);
+      } else if (msg.type === 'prompt') {
+        // Server wants text input (e.g. API key)
+        promptActive = true;
+        promptId = msg.id;
+        promptMeta = { service: msg.service, ...msg };
+        promptInput = '';
+        promptMask = msg.mask || false;
+        term.write(`  ${A.gold}${msg.label || 'Input:'}${A.r} `);
       }
     } catch {
-      // Raw text fallback
       term.write(event.data);
     }
   };
@@ -191,12 +349,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 +363,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 +373,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 +396,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);