@darksol/terminal 0.10.0 → 0.12.0

package/src/wallet/history.js

@@ -1,93 +1,94 @@
 import fetch from 'node-fetch';
 import { loadWallet } from './keystore.js';
-import { getConfig, getRPC } from '../config/store.js';
+import { getConfig } from '../config/store.js';
 import { theme } from '../ui/theme.js';
-import { spinner, kvDisplay, success, error, warn, info, table } from '../ui/components.js';
+import { spinner, error, info, table } from '../ui/components.js';
 import { showSection } from '../ui/banner.js';
 
-// ══════════════════════════════════════════════════
-// TRANSACTION HISTORY
-// ══════════════════════════════════════════════════
-
 const EXPLORER_APIS = {
-  base:     { api: 'https://api.basescan.org/api',                  explorer: 'https://basescan.org' },
-  ethereum: { api: 'https://api.etherscan.io/api',                  explorer: 'https://etherscan.io' },
-  arbitrum: { api: 'https://api.arbiscan.io/api',                   explorer: 'https://arbiscan.io' },
-  optimism: { api: 'https://api-optimistic.etherscan.io/api',       explorer: 'https://optimistic.etherscan.io' },
-  polygon:  { api: 'https://api.polygonscan.com/api',               explorer: 'https://polygonscan.com' },
+  base: { api: 'https://api.basescan.org/api', explorer: 'https://basescan.org' },
+  ethereum: { api: 'https://api.etherscan.io/api', explorer: 'https://etherscan.io' },
+  arbitrum: { api: 'https://api.arbiscan.io/api', explorer: 'https://arbiscan.io' },
+  optimism: { api: 'https://api-optimistic.etherscan.io/api', explorer: 'https://optimistic.etherscan.io' },
+  polygon: { api: 'https://api.polygonscan.com/api', explorer: 'https://polygonscan.com' },
 };
 
-/**
- * Show recent transaction history
- */
-export async function showHistory(walletName, opts = {}) {
+export async function fetchHistorySnapshot(walletName, opts = {}) {
   const name = walletName || getConfig('activeWallet');
   if (!name) {
-    error('No wallet specified. Use: darksol wallet history <name>');
-    return;
+    throw new Error('No wallet specified. Use: darksol wallet history <name>');
   }
 
   const walletData = loadWallet(name);
   const address = walletData.address;
   const chain = opts.chain || walletData.chain || getConfig('chain') || 'base';
-  const limit = parseInt(opts.limit || '10');
-
+  const limit = parseInt(opts.limit || '10', 10);
   const explorerConfig = EXPLORER_APIS[chain];
+
   if (!explorerConfig) {
-    error(`No explorer API for chain: ${chain}`);
+    throw new Error(`No explorer API for chain: ${chain}`);
+  }
+
+  const url = `${explorerConfig.api}?module=account&action=txlist&address=${address}&startblock=0&endblock=99999999&page=1&offset=${limit}&sort=desc`;
+  const resp = await fetch(url);
+  const data = await resp.json();
+
+  return {
+    name,
+    address,
+    chain,
+    explorer: explorerConfig.explorer,
+    status: data.status,
+    transactions: Array.isArray(data.result) ? data.result : [],
+  };
+}
+
+export async function showHistory(walletName, opts = {}) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    error('No wallet specified. Use: darksol wallet history <name>');
     return;
   }
 
+  const chain = opts.chain || getConfig('chain') || 'base';
   const spin = spinner(`Fetching history on ${chain}...`).start();
 
   try {
-    // Fetch normal transactions
-    const url = `${explorerConfig.api}?module=account&action=txlist&address=${address}&startblock=0&endblock=99999999&page=1&offset=${limit}&sort=desc`;
-    const resp = await fetch(url);
-    const data = await resp.json();
+    const snapshot = await fetchHistorySnapshot(name, opts);
+    const { address, chain: resolvedChain, explorer, status, transactions } = snapshot;
 
-    if (data.status !== '1' || !data.result?.length) {
+    if (status !== '1' || !transactions.length) {
       spin.succeed('No transactions found');
-      info(`No recent transactions on ${chain}`);
+      info(`No recent transactions on ${resolvedChain}`);
       return;
     }
 
-    spin.succeed(`Found ${data.result.length} transactions`);
+    spin.succeed(`Found ${transactions.length} transactions`);
 
     console.log('');
-    showSection(`HISTORY — ${name} (${chain})`);
+    showSection(`HISTORY - ${name} (${resolvedChain})`);
     console.log(theme.dim(`  ${address}`));
     console.log('');
 
-    const rows = data.result.map(tx => {
+    const rows = transactions.map((tx) => {
       const isOutgoing = tx.from.toLowerCase() === address.toLowerCase();
-      const direction = isOutgoing ? theme.accent('OUT →') : theme.success('← IN');
+      const direction = isOutgoing ? theme.accent('OUT ->') : theme.success('<- IN');
       const value = parseFloat(tx.value) / 1e18;
       const valueStr = value > 0 ? `${value.toFixed(4)} ETH` : theme.dim('0 ETH');
-      const status = tx.isError === '0' ? theme.success('✓') : theme.accent('✗');
-      const date = new Date(parseInt(tx.timeStamp) * 1000);
+      const statusMark = tx.isError === '0' ? theme.success('OK') : theme.accent('XX');
+      const date = new Date(parseInt(tx.timeStamp, 10) * 1000);
       const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
       const timeStr = date.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit' });
       const counterparty = isOutgoing ? tx.to : tx.from;
-      const shortAddr = counterparty ? `${counterparty.slice(0, 6)}...${counterparty.slice(-4)}` : '—';
-      const method = tx.functionName ? tx.functionName.split('(')[0] : (value > 0 ? 'transfer' : '—');
-
-      return [
-        status,
-        direction,
-        valueStr,
-        shortAddr,
-        method.slice(0, 16),
-        `${dateStr} ${timeStr}`,
-      ];
+      const shortAddr = counterparty ? `${counterparty.slice(0, 6)}...${counterparty.slice(-4)}` : '--';
+      const method = tx.functionName ? tx.functionName.split('(')[0] : (value > 0 ? 'transfer' : '--');
+      return [statusMark, direction, valueStr, shortAddr, method.slice(0, 16), `${dateStr} ${timeStr}`];
     });
 
     table(['', 'Dir', 'Value', 'Address', 'Method', 'Date'], rows);
-
     console.log('');
-    info(`Explorer: ${explorerConfig.explorer}/address/${address}`);
+    info(`Explorer: ${explorer}/address/${address}`);
     console.log('');
-
   } catch (err) {
     spin.fail('Failed to fetch history');
     error(err.message);

package/src/wallet/portfolio.js

@@ -1,20 +1,16 @@
 import { ethers } from 'ethers';
-import { loadWallet, listWallets } from './keystore.js';
+import { loadWallet } from './keystore.js';
 import { getConfig, getRPC } from '../config/store.js';
 import { theme } from '../ui/theme.js';
-import { spinner, kvDisplay, success, error, warn, info, table } from '../ui/components.js';
+import { spinner, kvDisplay, error, info, table } from '../ui/components.js';
 import { showSection } from '../ui/banner.js';
 
-// ══════════════════════════════════════════════════
-// MULTI-CHAIN PORTFOLIO VIEW
-// ══════════════════════════════════════════════════
-
 const CHAINS = {
-  base:     { name: 'Base',     rpc: 'https://mainnet.base.org',        usdc: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', explorer: 'https://basescan.org' },
-  ethereum: { name: 'Ethereum', rpc: 'https://eth.llamarpc.com',        usdc: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', explorer: 'https://etherscan.io' },
-  arbitrum: { name: 'Arbitrum', rpc: 'https://arb1.arbitrum.io/rpc',    usdc: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', explorer: 'https://arbiscan.io' },
-  optimism: { name: 'Optimism', rpc: 'https://mainnet.optimism.io',     usdc: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', explorer: 'https://optimistic.etherscan.io' },
-  polygon:  { name: 'Polygon',  rpc: 'https://polygon-rpc.com',         usdc: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', explorer: 'https://polygonscan.com' },
+  base: { name: 'Base', rpc: 'https://mainnet.base.org', usdc: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', explorer: 'https://basescan.org' },
+  ethereum: { name: 'Ethereum', rpc: 'https://eth.llamarpc.com', usdc: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', explorer: 'https://etherscan.io' },
+  arbitrum: { name: 'Arbitrum', rpc: 'https://arb1.arbitrum.io/rpc', usdc: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', explorer: 'https://arbiscan.io' },
+  optimism: { name: 'Optimism', rpc: 'https://mainnet.optimism.io', usdc: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', explorer: 'https://optimistic.etherscan.io' },
+  polygon: { name: 'Polygon', rpc: 'https://polygon-rpc.com', usdc: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', explorer: 'https://polygonscan.com' },
 };
 
 const ERC20_ABI = [
@@ -22,68 +18,50 @@ const ERC20_ABI = [
   'function decimals() view returns (uint8)',
 ];
 
-/**
- * Show portfolio across all EVM chains
- */
-export async function showPortfolio(walletName, opts = {}) {
+export async function fetchPortfolioSnapshot(walletName) {
   const name = walletName || getConfig('activeWallet');
   if (!name) {
-    error('No wallet specified. Use: darksol wallet portfolio <name>');
-    return;
+    throw new Error('No wallet specified. Use: darksol wallet portfolio <name>');
   }
 
   const walletData = loadWallet(name);
   const address = walletData.address;
 
-  console.log('');
-  showSection(`PORTFOLIO — ${name}`);
-  console.log(theme.dim(`  ${address}`));
-  console.log('');
-
-  const spin = spinner('Scanning all chains...').start();
-  const results = [];
-  let totalUSD = 0;
-
-  // Fetch ETH price for USD conversion
   let ethPrice = 0;
   try {
     const fetch = (await import('node-fetch')).default;
     const priceResp = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
     const priceData = await priceResp.json();
     ethPrice = priceData.ethereum?.usd || 0;
-  } catch { ethPrice = 3000; /* fallback estimate */ }
+  } catch {
+    ethPrice = 3000;
+  }
 
-  // Scan each chain in parallel
-  const chainPromises = Object.entries(CHAINS).map(async ([chainId, chain]) => {
+  const chains = await Promise.all(Object.entries(CHAINS).map(async ([chainId, chain]) => {
     try {
       const rpc = getRPC(chainId) || chain.rpc;
       const provider = new ethers.JsonRpcProvider(rpc);
-
-      // ETH balance
       const balance = await provider.getBalance(address);
-      const ethBal = parseFloat(ethers.formatEther(balance));
+      const eth = parseFloat(ethers.formatEther(balance));
 
-      // USDC balance
-      let usdcBal = 0;
+      let usdc = 0;
       if (chain.usdc) {
         try {
-          const usdc = new ethers.Contract(chain.usdc, ERC20_ABI, provider);
-          const raw = await usdc.balanceOf(address);
-          const decimals = await usdc.decimals();
-          usdcBal = parseFloat(ethers.formatUnits(raw, decimals));
-        } catch { }
+          const usdcContract = new ethers.Contract(chain.usdc, ERC20_ABI, provider);
+          const raw = await usdcContract.balanceOf(address);
+          const decimals = await usdcContract.decimals();
+          usdc = parseFloat(ethers.formatUnits(raw, decimals));
+        } catch {}
       }
 
-      const ethUSD = ethBal * ethPrice;
-      const chainTotal = ethUSD + usdcBal;
-
+      const ethUSD = eth * ethPrice;
       return {
         chain: chain.name,
         chainId,
-        eth: ethBal,
-        usdc: usdcBal,
+        eth,
+        usdc,
         ethUSD,
-        total: chainTotal,
+        total: ethUSD + usdc,
         explorer: chain.explorer,
       };
     } catch (err) {
@@ -94,58 +72,68 @@ export async function showPortfolio(walletName, opts = {}) {
         usdc: 0,
         ethUSD: 0,
         total: 0,
+        explorer: chain.explorer,
         error: err.message,
       };
     }
-  });
-
-  const chainResults = await Promise.all(chainPromises);
-  spin.succeed('Scan complete');
-
-  // Build table
-  const rows = chainResults.map(r => {
-    const ethStr = r.eth > 0 ? `${r.eth.toFixed(6)} ETH` : theme.dim('0');
-    const usdcStr = r.usdc > 0 ? `$${r.usdc.toFixed(2)}` : theme.dim('$0');
-    const totalStr = r.total > 0.01 ? theme.gold(`$${r.total.toFixed(2)}`) : theme.dim('$0');
-    const status = r.error ? theme.accent('⚠') : (r.total > 0 ? theme.success('●') : theme.dim('○'));
-    totalUSD += r.total;
-
-    return [
-      `${status} ${r.chain}`,
-      ethStr,
-      usdcStr,
-      totalStr,
-    ];
-  });
+  }));
 
-  console.log('');
-  table(['Chain', 'ETH', 'USDC', 'Total USD'], rows);
+  const totalUSD = chains.reduce((sum, item) => sum + item.total, 0);
+  return { name, address, chains, totalUSD, ethPrice };
+}
+
+export async function showPortfolio(walletName) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    error('No wallet specified. Use: darksol wallet portfolio <name>');
+    return;
+  }
 
-  // Summary
   console.log('');
-  kvDisplay([
-    ['Total Value', theme.gold(`$${totalUSD.toFixed(2)}`)],
-    ['ETH Price', `$${ethPrice.toFixed(2)}`],
-    ['Chains', `${chainResults.filter(r => !r.error).length}/${Object.keys(CHAINS).length} connected`],
-  ]);
-
-  // Show explorer links for chains with balance
-  const withBalance = chainResults.filter(r => r.total > 0.01);
-  if (withBalance.length > 0) {
+  showSection(`PORTFOLIO - ${name}`);
+  const spin = spinner('Scanning all chains...').start();
+
+  try {
+    const snapshot = await fetchPortfolioSnapshot(name);
+    const { address, chains, totalUSD, ethPrice } = snapshot;
+    spin.succeed('Scan complete');
+
+    console.log(theme.dim(`  ${address}`));
     console.log('');
-    info('Explorer links:');
-    withBalance.forEach(r => {
-      console.log(theme.dim(`  ${r.chain}: ${r.explorer}/address/${address}`));
+
+    const rows = chains.map((item) => {
+      const ethStr = item.eth > 0 ? `${item.eth.toFixed(6)} ETH` : theme.dim('0');
+      const usdcStr = item.usdc > 0 ? `$${item.usdc.toFixed(2)}` : theme.dim('$0');
+      const totalStr = item.total > 0.01 ? theme.gold(`$${item.total.toFixed(2)}`) : theme.dim('$0');
+      const status = item.error ? theme.accent('!') : (item.total > 0 ? theme.success('*') : theme.dim('o'));
+      return [`${status} ${item.chain}`, ethStr, usdcStr, totalStr];
     });
-  }
 
-  console.log('');
-  return { address, chains: chainResults, totalUSD, ethPrice };
+    table(['Chain', 'ETH', 'USDC', 'Total USD'], rows);
+    console.log('');
+    kvDisplay([
+      ['Total Value', theme.gold(`$${totalUSD.toFixed(2)}`)],
+      ['ETH Price', `$${ethPrice.toFixed(2)}`],
+      ['Chains', `${chains.filter((item) => !item.error).length}/${Object.keys(CHAINS).length} connected`],
+    ]);
+
+    const withBalance = chains.filter((item) => item.total > 0.01);
+    if (withBalance.length > 0) {
+      console.log('');
+      info('Explorer links:');
+      withBalance.forEach((item) => {
+        console.log(theme.dim(`  ${item.chain}: ${item.explorer}/address/${address}`));
+      });
+    }
+
+    console.log('');
+    return { address, chains, totalUSD, ethPrice };
+  } catch (err) {
+    spin.fail('Scan failed');
+    error(err.message);
+  }
 }
 
-/**
- * Quick balance check (non-verbose, for status bar)
- */
 export async function quickBalance(walletName) {
   const name = walletName || getConfig('activeWallet');
   if (!name) return null;

package/src/web/commands.js

@@ -11,6 +11,7 @@ import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { getConfiguredModel, getModelSelectionMeta, getProviderDefaultModel } from '../llm/models.js';
 import { pokerNewGame, pokerAction, pokerStatus, pokerHistory } from '../services/poker.js';
+import { sendBrowserCommand, installPlaywrightBrowsers } from '../services/browser.js';
 
 // ══════════════════════════════════════════════════
 // CHAT LOG PERSISTENCE
@@ -917,6 +918,8 @@ export async function handleCommand(cmd, ws) {
       return await cmdCasino(args, ws);
     case 'poker':
       return await cmdPoker(args, ws);
+    case 'browser':
+      return await cmdBrowser(args, ws);
     case 'facilitator':
       return await cmdFacilitator(args, ws);
     case 'send':
@@ -940,7 +943,7 @@ export async function handleCommand(cmd, ws) {
       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|order|card|prepaid|visa|mastercard|bet|coinflip|flip|dice|slots|hilo|gamble|play|casino|poker|holdem|bridge|cross-chain|crosschain)\b/i;
+      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca|order|card|prepaid|visa|mastercard|bet|coinflip|flip|dice|slots|hilo|gamble|play|casino|poker|holdem|bridge|cross-chain|crosschain|browser|screenshot|click)\b/i;
       if (nlKeywords.test(cmd)) {
         return await cmdAI(cmd.split(/\s+/), ws);
       }
@@ -954,6 +957,137 @@ export async function handleCommand(cmd, ws) {
 // ══════════════════════════════════════════════════
 // PRICE
 // ══════════════════════════════════════════════════
+async function cmdBrowser(args, ws) {
+  const sub = args[0]?.toLowerCase() || 'status';
+
+  if (sub === 'help') {
+    ws.sendLine(`${ANSI.gold}  ◆ BROWSER AUTOMATION${ANSI.reset}`);
+    ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.green}browser status${ANSI.reset}                 ${ANSI.dim}Show browser state${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.green}browser navigate https://...${ANSI.reset}  ${ANSI.dim}Navigate active page${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.green}browser screenshot${ANSI.reset}             ${ANSI.dim}Save + refresh browser panel${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.green}browser click <selector>${ANSI.reset}       ${ANSI.dim}Click an element${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.green}browser type <selector> <text>${ANSI.reset} ${ANSI.dim}Type text into an input${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.green}browser eval <js>${ANSI.reset}              ${ANSI.dim}Run JavaScript in page context${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.green}browser close${ANSI.reset}                  ${ANSI.dim}Close the browser service${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  if (sub === 'install') {
+    try {
+      await installPlaywrightBrowsers();
+      ws.sendLine(`  ${ANSI.green}✓ Playwright Chromium install complete${ANSI.reset}`);
+      ws.sendLine('');
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ ${err.message}${ANSI.reset}`);
+      ws.sendLine('');
+    }
+    return {};
+  }
+
+  try {
+    if (sub === 'status') {
+      const status = await sendBrowserCommand('status');
+      ws.sendLine(`${ANSI.gold}  ◆ BROWSER STATUS${ANSI.reset}`);
+      ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Running${ANSI.reset}    ${status.running ? ANSI.green + 'yes' : ANSI.dim + 'no'}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Type${ANSI.reset}       ${ANSI.white}${status.browserType || 'chromium'}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Profile${ANSI.reset}    ${ANSI.white}${status.profile || 'default'}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Mode${ANSI.reset}       ${ANSI.white}${status.headed ? 'headed' : 'headless'}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}URL${ANSI.reset}        ${status.url ? ANSI.white + status.url : ANSI.dim + '(blank)'}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Title${ANSI.reset}      ${status.title ? ANSI.white + status.title : ANSI.dim + '(none)'}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Pages${ANSI.reset}      ${ANSI.white}${status.pageCount || 0}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    if (sub === 'navigate') {
+      const url = args[1];
+      if (!url) {
+        ws.sendLine(`  ${ANSI.dim}Usage: browser navigate <url>${ANSI.reset}`);
+        ws.sendLine('');
+        return {};
+      }
+      const status = await sendBrowserCommand('navigate', { url });
+      ws.sendLine(`  ${ANSI.green}✓ Navigated to ${status.url}${ANSI.reset}`);
+      ws.sendLine('');
+      ws.send(JSON.stringify({ type: 'browser:refresh' }));
+      return {};
+    }
+
+    if (sub === 'screenshot') {
+      const result = await sendBrowserCommand('screenshot', {});
+      ws.sendLine(`  ${ANSI.green}✓ Screenshot saved${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}${result.path}${ANSI.reset}`);
+      ws.sendLine('');
+      ws.send(JSON.stringify({ type: 'browser:refresh' }));
+      return {};
+    }
+
+    if (sub === 'click') {
+      const selector = args[1];
+      if (!selector) {
+        ws.sendLine(`  ${ANSI.dim}Usage: browser click <selector>${ANSI.reset}`);
+        ws.sendLine('');
+        return {};
+      }
+      await sendBrowserCommand('click', { selector });
+      ws.sendLine(`  ${ANSI.green}✓ Clicked ${selector}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    if (sub === 'type') {
+      const selector = args[1];
+      const text = args.slice(2).join(' ');
+      if (!selector || !text) {
+        ws.sendLine(`  ${ANSI.dim}Usage: browser type <selector> <text>${ANSI.reset}`);
+        ws.sendLine('');
+        return {};
+      }
+      await sendBrowserCommand('type', { selector, text });
+      ws.sendLine(`  ${ANSI.green}✓ Typed into ${selector}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    if (sub === 'eval') {
+      const expression = args.slice(1).join(' ');
+      if (!expression) {
+        ws.sendLine(`  ${ANSI.dim}Usage: browser eval <js>${ANSI.reset}`);
+        ws.sendLine('');
+        return {};
+      }
+      const result = await sendBrowserCommand('eval', { expression });
+      ws.sendLine(`${ANSI.gold}  ◆ BROWSER EVAL${ANSI.reset}`);
+      ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.white}${String(result.formatted)}${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    if (sub === 'close') {
+      await sendBrowserCommand('close');
+      ws.sendLine(`  ${ANSI.green}✓ Browser closed${ANSI.reset}`);
+      ws.sendLine('');
+      ws.send(JSON.stringify({ type: 'browser:refresh' }));
+      return {};
+    }
+
+    ws.sendLine(`  ${ANSI.red}✗ Unknown browser subcommand: ${sub}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Try: browser help${ANSI.reset}`);
+    ws.sendLine('');
+  } catch (err) {
+    ws.sendLine(`  ${ANSI.red}✗ ${err.message}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Start it with: darksol browser launch${ANSI.reset}`);
+    ws.sendLine('');
+  }
+
+  return {};
+}
+
 async function cmdPrice(tokens, ws) {
   if (!tokens.length) {
     return { output: `  ${ANSI.dim}Usage: price ETH AERO VIRTUAL${ANSI.reset}\r\n` };

package/src/web/server.js

@@ -1,12 +1,13 @@
 import { createServer } from 'http';
 import { WebSocketServer } from 'ws';
-import { readFileSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import open from 'open';
 import { theme } from '../ui/theme.js';
 import { getRecentMemories } from '../memory/index.js';
 import { getSoul, hasSoul } from '../soul/index.js';
+import { getBrowserScreenshotPath, sendBrowserCommand } from '../services/browser.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require('../../package.json');
@@ -36,7 +37,7 @@ export async function startWebShell(opts = {}) {
   const css = readFileSync(join(__dirname, 'terminal.css'), 'utf-8');
   const js = readFileSync(join(__dirname, 'terminal.js'), 'utf-8');
 
-  const server = createServer((req, res) => {
+  const server = createServer(async (req, res) => {
     try {
       const pathname = req.url.split('?')[0];
 
@@ -52,6 +53,24 @@ export async function startWebShell(opts = {}) {
       } else if (pathname === '/health') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ status: 'ok', version: PKG_VERSION }));
+      } else if (pathname === '/browser/status') {
+        try {
+          const status = await sendBrowserCommand('status');
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(status));
+        } catch {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ running: false }));
+        }
+      } else if (pathname === '/browser/screenshot') {
+        const screenshotPath = getBrowserScreenshotPath();
+        if (!existsSync(screenshotPath)) {
+          res.writeHead(404);
+          res.end('No screenshot available');
+          return;
+        }
+        res.writeHead(200, { 'Content-Type': 'image/png', 'Cache-Control': 'no-store' });
+        res.end(readFileSync(screenshotPath));
       } else {
         res.writeHead(404);
         res.end('Not found');