dankgrinder 8.28.0 → 8.32.0

package/lib/grinder.js

@@ -8,6 +8,7 @@ const {
   AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
 } = require('./structures');
 const PKG_VERSION = require('../package.json').version;
+const ui = require('./ui');
 
 // Global shutdown flag
 let shutdownCalled = false;
@@ -88,14 +89,13 @@ async function sendWebhook(title, description, color = 0x5865f2) {
 }
 
 // ── Terminal Colors & ANSI ───────────────────────────────────
-// All colors stripped — plain text output only
 const c = {
-  reset: '', bold: '', dim: '', italic: '',
-  green: '', red: '', yellow: '', cyan: '',
-  magenta: '', white: '', blue: '',
-  bgGreen: '', bgRed: '', bgYellow: '', bgCyan: '',
-  bgMagenta: '', bgBlue: '', bgWhite: '',
-  // Cursor control (kept for functional use)
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', italic: '\x1b[3m',
+  green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', cyan: '\x1b[36m',
+  magenta: '\x1b[35m', white: '\x1b[37m', blue: '\x1b[34m',
+  bgGreen: '\x1b[42m', bgRed: '\x1b[41m', bgYellow: '\x1b[43m', bgCyan: '\x1b[46m',
+  bgMagenta: '\x1b[45m', bgBlue: '\x1b[44m', bgWhite: '\x1b[47m',
+  // Cursor control
   clearLine: '\x1b[2K',
   cursorUp: (n) => `\x1b[${n}A`,
   cursorTo: (col) => `\x1b[${col}G`,
@@ -230,21 +230,34 @@ async function filterClaimableAccounts(accounts) {
   return claimable;
 }
 
-// ── Truecolor gradient helpers (disabled — plain text only) ──
-function rgb(r, g, b) { return ''; }
-function bgRgb(r, g, b) { return ''; }
+// ── Truecolor gradient helpers ─────────────────────────────────
+function rgb(r, g, b) { return `\x1b[38;2;${r};${g};${b}m`; }
+function bgRgb(r, g, b) { return `\x1b[48;2;${r};${g};${b}m`; }
 function lerp(a, b, t) { return Math.round(a + (b - a) * t); }
 
 function gradientLine(text, from, to) {
-  return text;
+  // from/to are [r,g,b] arrays
+  const fr = Array.isArray(from) ? from[0] : 128;
+  const fg = Array.isArray(from) ? from[1] : 128;
+  const fb = Array.isArray(from) ? from[2] : 128;
+  const tr = Array.isArray(to) ? to[0] : 255;
+  const tg = Array.isArray(to) ? to[1] : 255;
+  const tb = Array.isArray(to) ? to[2] : 255;
+  let out = '';
+  for (let i = 0; i < text.length; i++) {
+    const t = text.length <= 1 ? 0 : i / (text.length - 1);
+    out += `\x1b[38;2;${lerp(fr, tr, t)};${lerp(fg, tg, t)};${lerp(fb, tb, t)}m${text[i]}`;
+  }
+  return out + c.reset;
 }
 
 function gradientText(text, from, to) {
-  return text;
+  return gradientLine(text, from, to);
 }
 
 function colorBanner() {
-  return `DANKGRINDER v${PKG_VERSION}`;
+  const title = `DANKGRINDER v${PKG_VERSION}`;
+  return gradientLine(title, [77, 142, 255], [255, 92, 147]);
 }
 
 // ── Simple Logging ─────────────────────────────────────────────
@@ -2647,7 +2660,8 @@ captchaDetector.build();
 // ══════════════════════════════════════════════════════════════
 
 async function start(apiKey, apiUrl, opts = {}) {
-  console.log('DANKGRINDER starting...');
+  ui.init({ workers, getUptime: formatUptime, isShuttingDown: () => shutdownCalled });
+  ui.drawBanner(PKG_VERSION);
   CLOUD_ADMIN_KEY = process.env.CLOUD_ADMIN_KEY || '';
   API_KEY = apiKey;
   API_URL = apiUrl || process.env.DANKGRINDER_URL || 'http://localhost:3000';
@@ -2870,7 +2884,8 @@ async function start(apiKey, apiUrl, opts = {}) {
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
-  console.log(`All grind loops started. v${PKG_VERSION} | Ctrl+C to stop`);
+  ui.start();
+  console.log(`${c.dim}All grind loops started. | Ctrl+C to stop${c.reset}`);
 
   // Cluster heartbeat — lets other nodes see this node is alive
   if (CLUSTER_ENABLED) {
@@ -2931,64 +2946,68 @@ async function start(apiKey, apiUrl, opts = {}) {
     } catch {}
   }, 10_000);
 
-  let sigintHandled = false;
-  process.on('SIGINT', async () => {
-    if (sigintHandled) return;
-    sigintHandled = true;
+  let shutdownInProgress = false;
+
+  async function gracefulShutdown(signal) {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
     shutdownCalled = true;
     setDashboardActive(false);
-    process.stdout.write(c.show);
+    ui.stop();
+    process.stdout.write(c.show + '\n');
 
     console.log('');
-    console.log('Session Summary');
+    console.log(`${c.yellow}[${signal}] Shutting down...${c.reset}`);
 
-    // Collect stats from all workers (including rotated-out ones)
+    // Collect stats from all workers
     let finalCoins = 0;
     let finalCmds = 0;
     for (const wk of workers) {
       const rate = wk.stats.commands > 0 ? ((wk.stats.successes / wk.stats.commands) * 100).toFixed(0) : 0;
-      console.log(`  ${(wk.username || '?').padEnd(18)} +${wk.stats.coins.toLocaleString().padStart(8)} coins  ${wk.stats.commands} cmds  ${rate}% ok`);
+      console.log(`  ${c.dim}${wk.username || '?'}${c.reset} ${c.green}+⏣${wk.stats.coins.toLocaleString()}${c.reset} ${wk.stats.commands}cmds ${rate}%ok`);
       finalCoins += wk.stats.coins || 0;
       finalCmds += wk.stats.commands || 0;
     }
 
     const memFinal = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
-    const avgEarn = globalEarningsEMA.get();
     const cpm = globalCmdRate.getRate().toFixed(1);
-    console.log(`Total: +${finalCoins.toLocaleString()} coins in ${formatUptime()} | ${finalCmds} cmds | ~${cpm} cmd/m | ${memFinal}MB`);
-    console.log('');
+    console.log(`${c.bold}Total:${c.reset} +⏣${finalCoins.toLocaleString()} in ${formatUptime()} | ${finalCmds}cmds | ~${cpm}cmd/m | ${memFinal}MB`);
 
-    // Release all cluster claims before stopping workers
-    const releasePromises = workers.map(wk => releaseClaim(wk.account.id).catch(() => {}));
-    await Promise.all(releasePromises).catch(() => {});
-
-    for (const wk of workers) wk.stop();
+    // Stop workers — max 1s per worker so one hung client doesn't block shutdown
+    await Promise.all(workers.map(wk => Promise.race([
+      new Promise(resolve => { wk.stop(); resolve(true); }),
+      new Promise(resolve => setTimeout(() => resolve(false), 1000)),
+    ])));
     workerMap.clear();
 
-    // Remove this node's heartbeat from Redis
+    // Release cluster claims
+    await Promise.allSettled(workers.map(wk => releaseClaim(wk.account.id)));
+
+    // Remove heartbeat
     if (redis && CLUSTER_ENABLED) {
-      try { await redis.del(`${CLUSTER_PREFIX}node:${NODE_ID}`); } catch {}
+      await Promise.allSettled([redis.del(`${CLUSTER_PREFIX}node:${NODE_ID}`)]);
     }
 
     const totalRecoveries = workers.reduce((sum, wk) => sum + (wk._totalRecoveries || 0), 0);
     const totalDisconnects = workers.reduce((sum, wk) => sum + (wk._disconnectCount || 0), 0);
     const totalRateLimits = workers.reduce((sum, wk) => sum + (wk._rateLimitHits || 0), 0);
 
+    if (totalRecoveries > 0 || totalDisconnects > 0) {
+      console.log(`  ${c.dim}${totalRecoveries} recoveries, ${totalDisconnects} disconnects, ${totalRateLimits} rate-limits${c.reset}`);
+    }
+
     const webhookMsg = `+⏣ ${finalCoins.toLocaleString()} | ${finalCmds} cmds | ${formatUptime()}` +
       (totalRecoveries > 0 ? ` | ${totalRecoveries} auto-recoveries` : '') +
       (CLUSTER_ENABLED ? ` | node: ${NODE_ID.substring(0, 12)}` : '');
     sendWebhook('Session Ended', webhookMsg, 0x8b5cf6);
 
-    if (totalRecoveries > 0 || totalDisconnects > 0) {
-      console.log(`  ${c.dim}Recovery stats: ${totalRecoveries} auto-recoveries, ${totalDisconnects} disconnects, ${totalRateLimits} rate limits${c.reset}`);
-    }
-    if (CLUSTER_ENABLED) {
-      console.log(`  ${c.dim}Cluster node: ${NODE_ID} — claims released${c.reset}`);
-    }
+    if (redis) { redis.disconnect().catch(() => {}); }
+    console.log(`${c.green}Goodbye!${c.reset}\n`);
+    process.exit(0);
+  }
 
-    if (redis) { try { redis.disconnect(); } catch {} }
-    setTimeout(() => process.exit(0), 1500);
-  });
+  process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
 }
 
 // ══════════════════════════════════════════════════════════════

package/lib/ui.js

@@ -0,0 +1,144 @@
+/**
+ * CLI Live Dashboard
+ * Renders a terminal table that updates in place every 10s.
+ * Shows per-account status, earned coins, commands, and session uptime.
+ */
+
+let _workers = [];
+let _getUptime = () => '0s';
+let _isShuttingDown = () => false;
+
+// ANSI helpers
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m',
+  cyan: '\x1b[36m', blue: '\x1b[34m',
+};
+const DIM = c.dim;
+
+function rgb(r, g, b) { return `\x1b[38;2;${r};${g};${b}m`; }
+function lerp(a, b, t) { return Math.round(a + (b - a) * t); }
+function gradientLine(text, from, to) {
+  const fr = Array.isArray(from) ? from[0] : 128;
+  const fg = Array.isArray(from) ? from[1] : 128;
+  const fb = Array.isArray(from) ? from[2] : 128;
+  const tr = Array.isArray(to) ? to[0] : 255;
+  const tg = Array.isArray(to) ? to[1] : 255;
+  const tb = Array.isArray(to) ? to[2] : 255;
+  let out = '';
+  for (let i = 0; i < text.length; i++) {
+    const t = text.length <= 1 ? 0 : i / (text.length - 1);
+    out += `\x1b[38;2;${lerp(fr, tr, t)};${lerp(fg, tg, t)};${lerp(fb, tb, t)}m${text[i]}`;
+  }
+  return out + c.reset;
+}
+
+let _lineCount = 0;
+let _interval = null;
+
+function _statusIcon(w) {
+  if (!w.running || !w.channel) return `${c.red}✗${c.reset}`;
+  if (w.paused || w.dashboardPaused) return `${c.yellow}⏸${c.reset}`;
+  if (w.busy || w._invRunning || w._sellRunning) return `${c.cyan}⚙${c.reset}`;
+  if (Date.now() < w.globalCooldownUntil) return `${c.blue}⏳${c.reset}`;
+  return `${c.green}●${c.reset}`;
+}
+
+function _render() {
+  const workers = _workers;
+  const W = Math.min(process.stdout.columns || 120, 120);
+  const lines = [];
+
+  lines.push(`${c.bold}${'─'.repeat(W)}${c.reset}`);
+  lines.push(
+    `  ${c.bold}#${c.reset}  ${c.bold}Account${c.reset}${' '.repeat(Math.max(1, 20 - 7))}` +
+    `${c.bold}Status${c.reset}${' '.repeat(Math.max(1, 14 - 6))}` +
+    `${c.bold}Earned${c.reset}${' '.repeat(Math.max(1, 12 - 5))}` +
+    `${c.bold}Cmds${c.reset}${' '.repeat(Math.max(1, 7 - 4))}` +
+    `${c.bold}OK%${c.reset}`
+  );
+  lines.push(`${c.bold}${'─'.repeat(W)}${c.reset}`);
+
+  for (let i = 0; i < workers.length; i++) {
+    const w = workers[i];
+    const name = (w.username || '?').substring(0, 20);
+    const status = (w.lastStatus || 'idle').substring(0, 14).padEnd(14);
+    const earned = w.stats.coins > 0 ? `+⏣${w.stats.coins.toLocaleString()}` : DIM + '—' + c.reset;
+    const cmds = String(w.stats.commands || 0);
+    const rate = w.stats.commands > 0 ? Math.round((w.stats.successes / w.stats.commands) * 100) : 0;
+
+    lines.push(
+      `  ${DIM}${String(i + 1).padStart(2)}${c.reset}  ${name.padEnd(20)} ${status}` +
+      `${String(earned).padStart(12)} ${cmds.padStart(6)} ${String(rate).padStart(3)}%`
+    );
+  }
+
+  lines.push(`${c.bold}${'─'.repeat(W)}${c.reset}`);
+
+  // Totals
+  let totalCoins = 0, totalCmds = 0;
+  for (const w of workers) {
+    totalCoins += w.stats.coins || 0;
+    totalCmds += w.stats.commands || 0;
+  }
+  const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
+  lines.push(
+    `  ${c.bold}Total${c.reset}  ` +
+    `${totalCoins > 0 ? c.green + '+⏣' + totalCoins.toLocaleString() + c.reset : DIM + '—' + c.reset}` +
+    `  ${totalCmds} cmds  ${_getUptime()}  ${memMB}MB`
+  );
+  lines.push('');
+
+  // Redraw in place
+  process.stdout.write(`\x1b[${_lineCount}A`);
+  process.stdout.write(lines.join('\n') + '\n');
+  _lineCount = lines.length - 1;
+}
+
+function _clear() {
+  if (_lineCount > 0) {
+    process.stdout.write(`\x1b[${_lineCount}A`);
+    for (let i = 0; i < _lineCount; i++) {
+      process.stdout.write(`\x1b[2K\r${i < _lineCount - 1 ? '\x1b[1A' : ''}`);
+    }
+    _lineCount = 0;
+  }
+}
+
+// ── Public API ────────────────────────────────────────────────
+
+function init({ workers, getUptime, isShuttingDown }) {
+  _workers = workers;
+  _getUptime = getUptime || (() => '0s');
+  _isShuttingDown = isShuttingDown || (() => false);
+}
+
+function drawBanner(version) {
+  const title = `DANKGRINDER v${version}`;
+  const gradient = gradientLine(title, [77, 142, 255], [255, 92, 147]);
+  console.log('');
+  console.log(`  ${gradient}${c.reset}`);
+  console.log(`  ${DIM}Ctrl+C to stop${c.reset}`);
+  console.log('');
+}
+
+function start() {
+  if (_workers.length > 30) return; // too many accounts — stay quiet
+  _lineCount = 0;
+  _render();
+  _interval = setInterval(() => {
+    if (_isShuttingDown()) {
+      clearInterval(_interval);
+      _interval = null;
+      return;
+    }
+    _render();
+  }, 10_000);
+}
+
+function stop() {
+  if (_interval) { clearInterval(_interval); _interval = null; }
+  _clear();
+}
+
+module.exports = { init, drawBanner, start, stop };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dankgrinder",
-  "version": "8.28.0",
+  "version": "8.32.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"