@darksol/terminal 0.4.1 → 0.4.2

package/src/web/server.js

@@ -0,0 +1,247 @@
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import open from 'open';
+import { theme } from '../ui/theme.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ══════════════════════════════════════════════════
+// DARKSOL WEB SHELL — Terminal in the browser
+// ══════════════════════════════════════════════════
+
+/**
+ * Command handler registry — maps command strings to async functions
+ * that return { output: string } with ANSI stripped for web
+ */
+import { handleCommand } from './commands.js';
+
+export async function startWebShell(opts = {}) {
+  process.on('uncaughtException', (err) => {
+    console.error('Uncaught:', err.message, err.stack);
+  });
+  const port = parseInt(opts.port || '18791');
+  const noOpen = opts.noOpen || false;
+
+  // Serve static files
+  const html = readFileSync(join(__dirname, 'index.html'), 'utf-8');
+  const css = readFileSync(join(__dirname, 'terminal.css'), 'utf-8');
+  const js = readFileSync(join(__dirname, 'terminal.js'), 'utf-8');
+
+  const server = createServer((req, res) => {
+    try {
+      const pathname = req.url.split('?')[0];
+
+      if (pathname === '/' || pathname === '/index.html') {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+      } else if (pathname === '/terminal.css') {
+        res.writeHead(200, { 'Content-Type': 'text/css' });
+        res.end(css);
+      } else if (pathname === '/terminal.js') {
+        res.writeHead(200, { 'Content-Type': 'application/javascript' });
+        res.end(js);
+      } else if (pathname === '/health') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ status: 'ok', version: '0.4.0' }));
+      } else {
+        res.writeHead(404);
+        res.end('Not found');
+      }
+    } catch (err) {
+      res.writeHead(500);
+      res.end('Internal error');
+    }
+  });
+
+  // WebSocket for terminal I/O
+  const wss = new WebSocketServer({ noServer: true });
+
+  server.on('upgrade', (request, socket, head) => {
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit('connection', ws, request);
+    });
+  });
+
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`  ✗ Port ${port} is in use. Try: darksol serve --port ${port + 1}`);
+    } else {
+      console.error(`  ✗ Server error: ${err.message}`);
+    }
+    process.exit(1);
+  });
+
+  wss.on('error', (err) => {
+    console.error(`  ✗ WebSocket error: ${err.message}`);
+  });
+
+  wss.on('connection', (ws) => {
+    // Send welcome banner
+    ws.send(JSON.stringify({
+      type: 'output',
+      data: getBanner(),
+    }));
+
+    ws.on('message', async (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+
+        if (msg.type === 'command') {
+          const cmd = msg.data.trim();
+
+          if (!cmd) return;
+
+          if (cmd === 'clear' || cmd === 'cls') {
+            ws.send(JSON.stringify({ type: 'clear' }));
+            return;
+          }
+
+          if (cmd === 'help') {
+            ws.send(JSON.stringify({ type: 'output', data: getHelp() }));
+            return;
+          }
+
+          if (cmd === 'banner') {
+            ws.send(JSON.stringify({ type: 'output', data: getBanner() }));
+            return;
+          }
+
+          if (cmd === 'exit' || cmd === 'quit') {
+            ws.send(JSON.stringify({ type: 'output', data: '\r\n  👋 Goodbye.\r\n' }));
+            ws.close();
+            return;
+          }
+
+          // Route to command handler
+          try {
+            ws.send(JSON.stringify({ type: 'output', data: '\r\n' }));
+
+            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' })),
+            });
+
+            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`,
+            }));
+          }
+        }
+      } catch {
+        // Ignore malformed messages
+      }
+    });
+
+    ws.on('close', () => {
+      // Client disconnected
+    });
+  });
+
+  server.listen(port, '0.0.0.0', () => {
+    console.log('');
+    console.log(theme.gold.bold('  🌑 DARKSOL WEB SHELL'));
+    console.log(theme.dim('  ─────────────────────────────'));
+    console.log('');
+    console.log(theme.dim('  Server:  ') + theme.gold(`http://127.0.0.1:${port}`));
+    console.log(theme.dim('  WebSocket: ') + theme.gold(`ws://127.0.0.1:${port}`));
+    console.log('');
+    console.log(theme.dim('  Press Ctrl+C to stop'));
+    console.log('');
+
+    if (!noOpen) {
+      open(`http://127.0.0.1:${port}`).catch(() => {});
+    }
+  });
+
+  // Keep alive
+  await new Promise((resolve) => {
+    process.on('SIGINT', () => {
+      console.log(theme.dim('\n  Shutting down web shell...'));
+      wss.close();
+      server.close();
+      resolve();
+    });
+  });
+}
+
+// ══════════════════════════════════════════════════
+// Banner & Help (ANSI formatted for xterm.js)
+// ══════════════════════════════════════════════════
+
+function getBanner() {
+  const gold = '\x1b[38;2;255;215;0m';
+  const dim = '\x1b[38;2;102;102;102m';
+  const white = '\x1b[1;37m';
+  const reset = '\x1b[0m';
+  const darkGold = '\x1b[38;2;184;134;11m';
+
+  return [
+    '',
+    `${gold}  ██████╗  █████╗ ██████╗ ██╗  ██╗███████╗ ██████╗ ██╗     ${reset}`,
+    `${gold}  ██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝██╔════╝██╔═══██╗██║     ${reset}`,
+    `${darkGold}  ██║  ██║███████║██████╔╝█████╔╝ ███████╗██║   ██║██║     ${reset}`,
+    `${darkGold}  ██║  ██║██╔══██║██╔══██╗██╔═██╗ ╚════██║██║   ██║██║     ${reset}`,
+    `${gold}  ██████╔╝██║  ██║██║  ██║██║  ██╗███████║╚██████╔╝███████╗${reset}`,
+    `${gold}  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚══════╝${reset}`,
+    '',
+    `${dim}  ╔══════════════════════════════════════════════════════════╗${reset}`,
+    `${dim}  ║${reset} ${gold}${white} DARKSOL TERMINAL${reset}${dim}  —  ${reset}${dim}Ghost in the machine with teeth${reset}${dim}  ║${reset}`,
+    `${dim}  ║${reset}${dim}  v0.4.0                                                ${reset}${gold}🌑${reset}${dim} ║${reset}`,
+    `${dim}  ╚══════════════════════════════════════════════════════════╝${reset}`,
+    '',
+    `${dim}  All services. One terminal. Zero trust required.${reset}`,
+    '',
+    `${dim}  Type ${gold}help${dim} for commands. Tab to autocomplete.${reset}`,
+    '',
+  ].join('\r\n');
+}
+
+function getHelp() {
+  const gold = '\x1b[38;2;255;215;0m';
+  const dim = '\x1b[38;2;102;102;102m';
+  const green = '\x1b[38;2;0;255;136m';
+  const reset = '\x1b[0m';
+
+  const cmds = [
+    ['price <token...>', 'Quick price check'],
+    ['watch <token>', 'Live price monitor'],
+    ['gas [chain]', 'Gas prices & estimates'],
+    ['portfolio', 'Multi-chain balances'],
+    ['history', 'Transaction history'],
+    ['market <token>', 'Market intel & data'],
+    ['mail status', 'AgentMail status'],
+    ['mail inbox', 'Check email inbox'],
+    ['mail send', 'Send an email'],
+    ['oracle roll', 'On-chain random oracle'],
+    ['casino status', 'Casino status'],
+    ['wallet list', 'List wallets'],
+    ['wallet balance', 'Wallet balance'],
+    ['config', 'Show configuration'],
+    ['banner', 'Show banner'],
+    ['clear', 'Clear screen'],
+    ['help', 'This help message'],
+    ['exit', 'Close session'],
+  ];
+
+  let out = '\r\n';
+  out += `${gold}  ◆ COMMANDS${reset}\r\n`;
+  out += `${dim}  ${'─'.repeat(50)}${reset}\r\n`;
+
+  for (const [cmd, desc] of cmds) {
+    out += `  ${green}${cmd.padEnd(22)}${reset}${dim}${desc}${reset}\r\n`;
+  }
+
+  out += '\r\n';
+  out += `${dim}  Full CLI: npm i -g @darksol/terminal${reset}\r\n`;
+  out += '\r\n';
+
+  return out;
+}

package/src/web/terminal.css

@@ -0,0 +1,177 @@
+/* ══════════════════════════════════════════════════
+   DARKSOL WEB SHELL — Terminal Theme
+   ══════════════════════════════════════════════════ */
+
+:root {
+  --bg: #0a0a1a;
+  --bg-surface: #111128;
+  --gold: #FFD700;
+  --dark-gold: #B8860B;
+  --text: #e0e0e0;
+  --text-dim: #666666;
+  --accent: #e94560;
+  --green: #00ff88;
+  --blue: #4488ff;
+  --border: #1a1a3e;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html, body {
+  height: 100%;
+  background: var(--bg);
+  color: var(--text);
+  font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'Consolas', monospace;
+  overflow: hidden;
+}
+
+/* Top bar */
+.top-bar {
+  height: 36px;
+  background: var(--bg-surface);
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  padding: 0 16px;
+  gap: 12px;
+  user-select: none;
+  -webkit-app-region: drag;
+}
+
+.top-bar .dots {
+  display: flex;
+  gap: 6px;
+}
+
+.top-bar .dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+}
+
+.dot.red { background: #ff5f57; }
+.dot.yellow { background: #febc2e; }
+.dot.green { background: #28c840; }
+
+.top-bar .title {
+  color: var(--text-dim);
+  font-size: 12px;
+  letter-spacing: 1px;
+  flex: 1;
+  text-align: center;
+}
+
+.top-bar .badge {
+  background: rgba(255, 215, 0, 0.15);
+  color: var(--gold);
+  font-size: 10px;
+  padding: 2px 8px;
+  border-radius: 3px;
+  letter-spacing: 1px;
+  font-weight: bold;
+}
+
+/* Terminal container */
+#terminal-container {
+  height: calc(100vh - 36px);
+  background: var(--bg);
+  padding: 0;
+}
+
+/* Status bar */
+.status-bar {
+  height: 24px;
+  background: var(--bg-surface);
+  border-top: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  padding: 0 16px;
+  font-size: 11px;
+  color: var(--text-dim);
+  gap: 16px;
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  z-index: 10;
+}
+
+.status-bar .status-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--green);
+  display: inline-block;
+}
+
+.status-bar .status-dot.disconnected {
+  background: var(--accent);
+}
+
+/* xterm.js overrides */
+.xterm {
+  padding: 8px;
+}
+
+.xterm-viewport::-webkit-scrollbar {
+  width: 6px;
+}
+
+.xterm-viewport::-webkit-scrollbar-track {
+  background: var(--bg);
+}
+
+.xterm-viewport::-webkit-scrollbar-thumb {
+  background: var(--border);
+  border-radius: 3px;
+}
+
+.xterm-viewport::-webkit-scrollbar-thumb:hover {
+  background: var(--text-dim);
+}
+
+/* Selection */
+::selection {
+  background: rgba(255, 215, 0, 0.2);
+}
+
+/* Loading state */
+.loading {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  color: var(--gold);
+  font-size: 14px;
+  letter-spacing: 2px;
+}
+
+.loading .spinner {
+  display: inline-block;
+  animation: pulse 1.5s ease-in-out infinite;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 0.3; }
+  50% { opacity: 1; }
+}
+
+/* Responsive */
+@media (max-width: 600px) {
+  .top-bar {
+    height: 30px;
+    padding: 0 10px;
+  }
+
+  .top-bar .title {
+    font-size: 10px;
+  }
+
+  #terminal-container {
+    height: calc(100vh - 30px);
+  }
+}

package/src/web/terminal.js

@@ -0,0 +1,262 @@
+// ══════════════════════════════════════════════════
+// DARKSOL WEB SHELL — Client Terminal
+// ══════════════════════════════════════════════════
+
+const PROMPT = '\x1b[38;2;255;215;0m❯\x1b[0m ';
+const PROMPT_LENGTH = 2; // visible chars: ❯ + space
+
+const COMMANDS = [
+  'price', 'watch', 'gas', 'portfolio', 'history', 'market',
+  'wallet', 'mail', 'oracle', 'casino', 'facilitator', 'config',
+  'help', 'clear', 'banner', 'exit',
+];
+
+let term;
+let ws;
+let currentLine = '';
+let commandHistory = [];
+let historyIndex = -1;
+let connected = false;
+
+async function init() {
+  // Load xterm.js
+  term = new Terminal({
+    theme: {
+      background: '#0a0a1a',
+      foreground: '#e0e0e0',
+      cursor: '#FFD700',
+      cursorAccent: '#0a0a1a',
+      selectionBackground: 'rgba(255, 215, 0, 0.2)',
+      selectionForeground: '#ffffff',
+      black: '#0a0a1a',
+      red: '#e94560',
+      green: '#00ff88',
+      yellow: '#FFD700',
+      blue: '#4488ff',
+      magenta: '#B8860B',
+      cyan: '#00bcd4',
+      white: '#e0e0e0',
+      brightBlack: '#666666',
+      brightRed: '#ff6b81',
+      brightGreen: '#69ff9e',
+      brightYellow: '#ffd700',
+      brightBlue: '#7cb3ff',
+      brightMagenta: '#d4a017',
+      brightCyan: '#40e0d0',
+      brightWhite: '#ffffff',
+    },
+    fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'Consolas', monospace",
+    fontSize: 14,
+    lineHeight: 1.3,
+    cursorBlink: true,
+    cursorStyle: 'bar',
+    scrollback: 5000,
+    allowTransparency: true,
+    bellStyle: 'none',
+  });
+
+  const fitAddon = new FitAddon.FitAddon();
+  term.loadAddon(fitAddon);
+
+  const container = document.getElementById('terminal-container');
+  term.open(container);
+  fitAddon.fit();
+
+  window.addEventListener('resize', () => fitAddon.fit());
+
+  // Connect WebSocket
+  connectWS();
+
+  // Input handling
+  term.onKey(({ key, domEvent }) => {
+    const code = domEvent.keyCode;
+    const ctrl = domEvent.ctrlKey;
+
+    if (ctrl && code === 67) {
+      // Ctrl+C — cancel
+      currentLine = '';
+      term.write('^C\r\n');
+      writePrompt();
+      return;
+    }
+
+    if (ctrl && code === 76) {
+      // Ctrl+L — clear
+      term.clear();
+      writePrompt();
+      return;
+    }
+
+    if (code === 13) {
+      // Enter
+      term.write('\r\n');
+      const cmd = currentLine.trim();
+
+      if (cmd) {
+        commandHistory.unshift(cmd);
+        if (commandHistory.length > 50) commandHistory.pop();
+        sendCommand(cmd);
+      } else {
+        writePrompt();
+      }
+
+      currentLine = '';
+      historyIndex = -1;
+      return;
+    }
+
+    if (code === 8) {
+      // Backspace
+      if (currentLine.length > 0) {
+        currentLine = currentLine.slice(0, -1);
+        term.write('\b \b');
+      }
+      return;
+    }
+
+    if (code === 38) {
+      // Arrow up — history
+      if (historyIndex < commandHistory.length - 1) {
+        historyIndex++;
+        replaceInput(commandHistory[historyIndex]);
+      }
+      return;
+    }
+
+    if (code === 40) {
+      // Arrow down — history
+      if (historyIndex > 0) {
+        historyIndex--;
+        replaceInput(commandHistory[historyIndex]);
+      } else if (historyIndex === 0) {
+        historyIndex = -1;
+        replaceInput('');
+      }
+      return;
+    }
+
+    if (code === 9) {
+      // Tab — autocomplete
+      domEvent.preventDefault();
+      autocomplete();
+      return;
+    }
+
+    // Printable characters
+    if (key.length === 1 && !ctrl) {
+      currentLine += key;
+      term.write(key);
+    }
+  });
+
+  // Paste support
+  term.onData((data) => {
+    // Only handle paste (multi-char input)
+    if (data.length > 1 && !data.startsWith('\x1b')) {
+      const clean = data.replace(/[\r\n]/g, '');
+      currentLine += clean;
+      term.write(clean);
+    }
+  });
+
+  term.focus();
+}
+
+function connectWS() {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  ws = new WebSocket(`${protocol}//${window.location.host}`);
+
+  ws.onopen = () => {
+    connected = true;
+    updateStatus(true);
+  };
+
+  ws.onmessage = (event) => {
+    try {
+      const msg = JSON.parse(event.data);
+
+      if (msg.type === 'output') {
+        term.write(msg.data);
+        writePrompt();
+      } else if (msg.type === 'clear') {
+        term.clear();
+        writePrompt();
+      }
+    } catch {
+      // Raw text fallback
+      term.write(event.data);
+    }
+  };
+
+  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);
+  };
+
+  ws.onerror = () => {
+    connected = false;
+    updateStatus(false);
+  };
+}
+
+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');
+    writePrompt();
+  }
+}
+
+function writePrompt() {
+  term.write(PROMPT);
+}
+
+function replaceInput(text) {
+  // Clear current input
+  const clearLen = currentLine.length;
+  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('\r\n');
+    writePrompt();
+    term.write(currentLine);
+  }
+}
+
+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';
+  }
+}
+
+// Boot
+document.addEventListener('DOMContentLoaded', init);