dankgrinder 7.77.0 → 7.78.0

package/lib/grinder.js

@@ -3,6 +3,7 @@ const Redis = require('ioredis');
 const commands = require('./commands');
 const { setDashboardActive, isCV2, ensureCV2, stripAnsi } = require('./commands/utils');
 const rawLogger = require('./rawLogger');
+const terminal = require('./terminal');
 const {
   BloomFilter, RingBuffer, TokenBucket, EMA, SlidingWindowCounter,
   AhoCorasick, LRUCache, StringPool, AsyncBatchQueue, JitterBackoff,
@@ -1623,6 +1624,8 @@ class AccountWorker {
       // ── Death / lifesaver detection in command responses ──
       if (resultLower.includes('you died') || resultLower.includes('lifesaver protected')) {
         this.log('error', `DEATH DETECTED during ${cmdName}!`);
+        terminal.flashEvent('death', `💀 ${this.username} died — ${lsCount === 0 ? '0 lifesavers!' : (lsCount > 0 ? `${lsCount} lifesavers left` : 'check DM')}`);
+        terminal.markWorkerDirty(this.idx);
         // Check for lifesaver count in the response
         const lsMatch = result.match(/(\d+)\s*life\s*saver/i);
         const lsCount = lsMatch ? parseInt(lsMatch[1]) : -1;
@@ -1639,6 +1642,8 @@ class AccountWorker {
             await redis.set(`dkg:lifesavers:${this.account.id}`, String(lsCount), 'EX', 86400);
             this.log('warn', `Lifesaver used! ${lsCount} remaining.`);
             if (lsCount <= 2) {
+              terminal.flashEvent('lowls', `⚠ ${this.username} low lifesavers: ${lsCount} left`);
+              terminal.markWorkerDirty(this.idx);
               sendWebhook('LOW LIFESAVERS', `**${this.username}** has only **${lsCount}** lifesaver(s) left!`, 0xfbbf24);
             }
           }
@@ -1758,6 +1763,8 @@ class AccountWorker {
       this.setStatus(formattedResult);
       await sendLog(this.username, cmdName, result, 'success');
       reportEarnings(this.account.id, this.username, earned, spent, cmdName);
+      terminal.markWorkerDirty(this.idx);
+      if (earned > 0) terminal.flashEvent('success', `⚔ ${this.username} ${cmdName}: +⏣ ${earned.toLocaleString()}`);
 
       // Auto-sell fish every 5 fishing rounds
       if (cmdName === 'fish') {
@@ -2844,6 +2851,8 @@ async function start(apiKey, apiUrl, opts = {}) {
               w.log?.('error', `DEATH in DMs! 0 lifesavers — disabling crime/search`);
               w.setCooldown?.('crime', 86400);
               w.setCooldown?.('search', 86400);
+              terminal.flashEvent('death', `💀 ${w.username} DEATH in DM — 0 lifesavers!`);
+              terminal.markWorkerDirty(w.idx);
               sendWebhook?.('DEATH ALERT (DM)', `**${w.username}** died in DMs! **0 lifesavers!**\nCrime/search auto-disabled.`, 0xef4444);
             } else {
               w.log?.('warn', `DEATH in DMs — ${event.lifesaversLeft} lifesavers remaining`);
@@ -2861,6 +2870,8 @@ async function start(apiKey, apiUrl, opts = {}) {
         if (event.type === 'levelup') {
           if (event.to > 0) {
             w._level = event.to;
+            terminal.flashEvent('levelup', `⬆️ ${w.username} leveled up to Lv.${event.to}`);
+            terminal.markWorkerDirty(w.idx);
           }
         }
       }
@@ -2876,8 +2887,12 @@ async function start(apiKey, apiUrl, opts = {}) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
+  // ── Terminal renderer init ─────────────────────────────────────
+  terminal.setVersion(PKG_VERSION);
+  terminal.init({ workers, startTime });
+  terminal.startPhase(`Connecting ${accounts.length} accounts to Discord`);
+
   // ── Phase 1: Login accounts ─────────────────────────────────────────
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Logging in ${accounts.length} account(s)...`);
   const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '50'), 10);
   const parsedGapMax = Number.parseInt(String(process.env.LOGIN_GAP_MAX_MS || '150'), 10);
   const LOGIN_GAP_MIN_MS = Number.isFinite(parsedGapMin) && parsedGapMin >= 0 ? parsedGapMin : 50;
@@ -2894,6 +2909,7 @@ async function start(apiKey, apiUrl, opts = {}) {
       workers.push(worker);
       workerMap.set(acc.id, worker);
       await worker.start();
+      terminal.updateProgress(workers.length, accounts.length);
     }));
     if (i + BATCH_SIZE < accounts.length) await new Promise(r => setTimeout(r, randomLoginGap()));
     hintGC();
@@ -2902,8 +2918,9 @@ async function start(apiKey, apiUrl, opts = {}) {
   const loginDone = workers.filter(w => !w._tokenInvalid && w.channel).length;
   const invalidWorkers = workers.filter(w => w._tokenInvalid);
   const timedOutWorkers = workers.filter(w => !w.channel && !w._tokenInvalid);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${loginDone}/${accounts.length} accounts connected`);
+  terminal.endPhase(`${loginDone}/${accounts.length} accounts connected`, true);
   if (invalidWorkers.length > 0) {
+    terminal.flashEvent('error', `${invalidWorkers.length} accounts have INVALID tokens`);
     log('warn', `${rgb(239, 68, 68)}${invalidWorkers.length} account(s) have INVALID tokens`);
     for (const w of invalidWorkers) log('error', `  ${w.account.label || w.account.id} — token invalid or expired`);
   }
@@ -2912,24 +2929,31 @@ async function start(apiKey, apiUrl, opts = {}) {
   const activeWorkers = workers.filter(w => !w._tokenInvalid);
 
   // ── Phase 2: Inventory check ─────────────────────────────────────
-  console.log(`  ${rgb(34, 211, 238)}·${c.reset}  Checking inventory (${activeWorkers.length} accounts)...`);
+  terminal.startPhase('Checking inventory');
+  terminal.updateProgress(0, activeWorkers.length);
   let invDone = 0, invFailed = 0;
   await Promise.all(activeWorkers.map(async (w) => {
     try { await w.checkInventory({ force: true, requireComplete: true, maxAttempts: 3, silent: true }); }
     catch { invFailed++; return; }
     invDone++;
+    terminal.updateProgress(invDone, activeWorkers.length);
   }));
 
   if (invFailed > 0) {
+    terminal.endPhase(`Inventory: ${invFailed} failed`, false);
     console.log(`  ${rgb(239, 68, 68)}✗${c.reset}  Inventory: ${invFailed} failed — not starting grind loops`);
     return;
   }
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Inventory: ${invDone}/${activeWorkers.length} clear`);
+  terminal.endPhase(`Inventory: ${invDone} clear`);
 
   // ── Phase 2.5: Balance check ────────────────────────────────────
-  console.log(`  ${rgb(251, 191, 36)}·${c.reset}  Checking balance (${activeWorkers.length} accounts)...`);
+  terminal.startPhase('Checking balance');
+  terminal.updateProgress(0, activeWorkers.length);
+  let balDone = 0;
   await Promise.all(activeWorkers.map(async (w) => {
     try { await w.checkBalance(true); } catch {}
+    balDone++;
+    terminal.updateProgress(balDone, activeWorkers.length);
   }));
 
   let totalWallet = 0, totalBank = 0, noLifesaverAccounts = [];
@@ -2938,13 +2962,16 @@ async function start(apiKey, apiUrl, opts = {}) {
     totalBank += w.stats?.bankBalance || 0;
     if (w._lifesavers === 0) noLifesaverAccounts.push(w.username || w.account.label);
   }
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  Balance: ${c.green}⏣ ${(totalWallet + totalBank).toLocaleString()}${c.reset} ${c.dim}(wallet: ⏣ ${totalWallet.toLocaleString()} + bank: ⏣ ${totalBank.toLocaleString()})${c.reset}`);
+  terminal.endPhase(`Balance: ⏣ ${(totalWallet + totalBank).toLocaleString()}`);
   if (noLifesaverAccounts.length > 0) {
+    terminal.flashEvent('warn', `${noLifesaverAccounts.length} accounts have 0 LIFESAVERS`);
     console.log(`  ${rgb(239, 68, 68)}⚠${c.reset}  ${noLifesaverAccounts.length} account(s) have 0 LIFESAVERS — crime/search disabled`);
   }
 
   // ── Phase 2.75: DM history check ────────────────────────────────
-  console.log(`  ${rgb(139, 92, 246)}·${c.reset}  Checking DM history...`);
+  terminal.startPhase('Checking DM history');
+  terminal.updateProgress(0, activeWorkers.length);
+  let dmDone = 0;
   let dmDeaths = 0, dmLevelUps = 0, dmNoLs = [], dmUnknown = [];
   for (const w of activeWorkers) {
     try {
@@ -2956,8 +2983,11 @@ async function start(apiKey, apiUrl, opts = {}) {
       if (dm.currentLevel > 0) w._level = dm.currentLevel;
       if (dm.lifesavers >= 0) w._lifesavers = dm.lifesavers;
     } catch {}
+    dmDone++;
+    terminal.updateProgress(dmDone, activeWorkers.length);
   }
   if (dmNoLs.length > 0) {
+    terminal.flashEvent('warn', `No lifesavers: ${dmNoLs.join(', ')}`);
     log('warn', `⚠ No lifesavers: ${dmNoLs.join(', ')}`);
     for (const w of activeWorkers) {
       if (dmNoLs.includes(w.username) && redis) {
@@ -2975,17 +3005,16 @@ async function start(apiKey, apiUrl, opts = {}) {
   if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
   if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
   if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean'}`);
+  terminal.endPhase(`DM check: ${dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean'}`);
 
   // ── Phase 3: Start grind loops ───────────────────────────────────
-  console.log(`  ${rgb(139, 92, 246)}>>>${c.reset}  Starting grind loops...`);
-  // Phase 3: Start all grind loops (only for valid workers)
+  terminal.startPhase(`🚀 Launching ${activeWorkers.length} grinders!`);
   for (const w of activeWorkers) {
     if (!shutdownCalled) w.grindLoop();
   }
-
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  All grind loops started — ${activeWorkers.length} accounts active`);
-  console.log(`  v${PKG_VERSION}  |  press Ctrl+C to stop`);
+  terminal.endPhase(`${activeWorkers.length} grinders active`);
+  terminal.setWorkers(workers);
+  terminal.setActive();
 
   // Cluster heartbeat — lets other nodes see this node is alive
   if (CLUSTER_ENABLED) {
@@ -3052,35 +3081,26 @@ async function start(apiKey, apiUrl, opts = {}) {
     sigintHandled = true;
     shutdownCalled = true;
     setDashboardActive(false);
-    process.stdout.write('\x1b[?25h'); // show cursor
-
-    const tw = process.stdout.columns || 80;
-    const sepBar = rgb(139, 92, 246) + c.bold + '─'.repeat(tw - 4) + c.reset;
-    console.log('');
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Session Summary${c.reset}`);
-    console.log(sepBar);
 
-    // Collect stats from all workers (including rotated-out ones)
-    let finalCoins = 0;
-    let finalCmds = 0;
+    // Collect stats for summary
+    let finalCoins = 0, finalCmds = 0, totalSuccess = 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.color}${c.bold}${(wk.username || '?').padEnd(18)}${c.reset}` +
-        `  ${rgb(52, 211, 153)}+⏣ ${wk.stats.coins.toLocaleString().padStart(8)}${c.reset}` +
-        `  ${c.dim}${wk.stats.commands.toString().padStart(4)} cmds${c.reset}` +
-        `  ${c.dim}${rate}% success${c.reset}`
-      );
       finalCoins += wk.stats.coins || 0;
       finalCmds += wk.stats.commands || 0;
+      totalSuccess += wk.stats.successes || 0;
     }
-    console.log(sepBar);
-
     const memFinal = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
-    const avgEarn = globalEarningsEMA.get();
-    const cpm = globalCmdRate.getRate().toFixed(1);
-    console.log(`  ${rgb(251, 191, 36)}${c.bold}Total: +⏣ ${finalCoins.toLocaleString()}${c.reset} ${c.dim}in ${formatUptime()} | ${finalCmds} cmds | ~${cpm} cmd/m | ${memFinal}MB | avg earn ⏣ ${Math.round(avgEarn)}${c.reset}`);
-    console.log('');
+    const uptimeMs = Date.now() - startTime;
+
+    // Show beautiful session summary via terminal renderer
+    terminal.shutdown({
+      totalCoins: finalCoins,
+      totalCmds: finalCmds,
+      totalSuccess: finalCmds > 0 ? ((totalSuccess / finalCmds) * 100).toFixed(0) : 0,
+      workers,
+      uptime: uptimeMs,
+      memMB: memFinal,
+    });
 
     // Release all cluster claims before stopping workers
     const releasePromises = workers.map(wk => releaseClaim(wk.account.id).catch(() => {}));
@@ -3096,22 +3116,14 @@ async function start(apiKey, apiUrl, opts = {}) {
 
     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);
 
     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) { try { redis.disconnect(); } catch {} }
-    setTimeout(() => process.exit(0), 1500);
+    setTimeout(() => process.exit(0), 500);
   });
 }
 

package/lib/terminal.js

@@ -0,0 +1,820 @@
+/**
+ * terminal.js — Modern animated terminal renderer for DankGrinder
+ *
+ * Design goals:
+ * - Single-line-per-account rows (scales to 10k+ accounts)
+ * - Virtual window: only renders visible slice of accounts
+ * - 4 FPS render loop with dirty-row tracking (no flicker)
+ * - Graceful degradation: falls back to console.log if not a TTY
+ * - Graceful mode: Ctrl+C always restores cursor + shows summary
+ *
+ * Layout (fixed row heights, live-updated):
+ *
+ *  ┌─ DANKGRINDER v7.77.0 ─────────────────────────────────────────────────────┐
+ *  │ ⏱ 00:32   ⬡ 5 accounts   ⏣ 47,230   ⚡ 12 cmd/m   📊 89% success            │
+ *  ├─ ACCOUNTS ──────────────────────────────────────────────────────────────────┤
+ *  │ 💎 alice_99    ⏣ 12,450  L:24  ♥3  34cmds  🟢 grinding   ⚔ adventure        │
+ *  │ 💎 bob_trades  ⏣  8,920  L:18  ♥5  28cmds  🟢 grinding   🐟 fishing        │
+ *  │ 💎 crypto_king ⏣  5,100  L:31  ♥0  19cmds  🟡 depositing  💰 beg           │
+ *  │ 💎 diamond_h.. ⏣  3,780  L:12  ♥8  14cmds  🟢 grinding   🌾 farm           │
+ *  │ 💎 moon_wallet ⏣  1,200  L:9   ♥2   8cmds  🔴 paused     ⚠ captcha        │
+ *  ├─ EVENTS ────────────────────────────────────────────────────────────────────┤
+ *  │ 00:32 ⚔ alice_99 adventure: +⏣ 850                                         │
+ *  │ 00:31 💀 crypto_king DEATH — 0 lifesavers! crime/search disabled             │
+ *  │ 00:30 ⬆️ bob_trades leveled up to Lv.19                                     │
+ *  │ 00:28 🌾 diamond_hands farm: +⏣ 2,100                                       │
+ *  └──────────────────────────────────────────────────────────────────────────────┘
+ */
+
+const READY = (() => {
+  try {
+    return process.stdout.isTTY && !process.env.NO_TERM;
+  } catch (_) { return false; }
+})();
+
+// ── ANSI Helpers ────────────────────────────────────────────────────────────
+
+const A = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+
+  // 256-color RGB shortcuts
+  rgb: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
+
+  // Cursor
+  save: '\x1b7',
+  restore: '\x1b8',
+  hide: '\x1b[?25l',
+  show: '\x1b[?25h',
+  up: (n = 1) => `\x1b[${n}A`,
+  down: (n = 1) => `\x1b[${n}B`,
+  right: (n = 1) => `\x1b[${n}C`,
+  left: (n = 1) => `\x1b[${n}D`,
+  col: (n) => `\x1b[${n}G`,
+  clear: '\x1b[2J',
+  clearLine: '\x1b[2K',
+  home: '\x1b[H',
+
+  // 256-color palette
+  purple: '\x1b[38;5;141m',   // #8b5cf6
+  pink: '\x1b[38;5;205m',    // #ff5c93
+  orange: '\x1b[38;5;214m',  // #ff9f43
+  teal: '\x1b[38;5;44m',     // #2dd4bf
+  lime: '\x1b[38;5;82m',     // #4cd137
+  crimson: '\x1b[38;5;196m',  // #ff4757
+  slate: '\x1b[38;5;245m',    // #a0a0b0
+  gold: '\x1b[38;5;220m',     // #ffc233
+  emerald: '\x1b[38;5;48m',  // #2ed573
+};
+
+// ── Color scheme ────────────────────────────────────────────────────────────
+
+const C = {
+  header: A.purple,
+  headerDim: A.rgb(100, 70, 180),
+  border: A.rgb(60, 50, 90),
+  borderDim: A.rgb(40, 35, 60),
+
+  rowDefault: A.white,
+  rowAlt: A.rgb(30, 28, 45),
+  rowHighlight: A.rgb(25, 23, 40),
+
+  name: A.rgb(255, 255, 255),
+  nameDim: A.slate,
+
+  coins: A.gold,
+  level: A.cyan,
+  lifesavers: A.pink,
+  lifesaversLow: A.crimson,
+  lifesaversMid: A.orange,
+
+  statusActive: A.emerald,    // 🟢 grinding
+  statusPaused: A.crimson,    // 🔴 paused
+  statusWarning: A.orange,     // 🟡 warning
+  statusOffline: A.slate,      // ⚫ offline
+  statusConnecting: A.yellow,  // 🟡 connecting
+
+  cmdSuccess: A.emerald,
+  cmdError: A.crimson,
+  cmdEvent: A.purple,
+  cmdWarn: A.orange,
+
+  statLabel: A.slate,
+  statValue: A.white,
+
+  headerBg: A.rgb(20, 15, 35),
+  rowBg1: '',
+  rowBg2: A.rgb(25, 22, 38),
+  rowBgPaused: A.rgb(40, 15, 20),
+  rowBgWarning: A.rgb(40, 35, 15),
+  rowBgDeath: A.rgb(50, 15, 15),
+};
+
+// ── Spinner frames ──────────────────────────────────────────────────────────
+
+const SPINNERS = {
+  dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠿'],
+  moon: ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'],
+  arrows: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙'],
+  pulse: ['▓', '▒', '░', '▒'],
+};
+
+// ── Terminal Renderer ────────────────────────────────────────────────────────
+
+class Terminal {
+  constructor() {
+    this.workers = [];
+    this.events = [];           // recent event feed (last N events)
+    this.MAX_EVENTS = 5;
+
+    this.phaseName = '';
+    this.phaseFrame = 0;
+    this.phaseTimer = null;
+
+    this.dirtyWorkers = new Set();
+    this.dirtyEvents = false;
+    this.dirtyStats = true;
+    this._renderTimer = null;
+    this._startTime = 0;
+
+    // Virtual window state
+    this.windowStart = 0;
+    this.windowSize = 10;
+    this.scrollLocked = false;   // true = auto-follow most active worker
+
+    this._lineCount = 0;
+    this._active = false;
+    this._shutdown = false;
+
+    // Row offsets (set during render)
+    this._headerRow = 0;
+    this._statsRow = 0;
+    this._accountsRow = 0;
+    this._eventsRow = 0;
+    this._footerRow = 0;
+
+    // ── Scroll position state ──
+    this._followWorkerIdx = -1;  // -1 = follow newest active worker
+
+    this._w = 80;
+    this._h = 24;
+    this._resizeTimer = null;
+    this._col = (n) => `\x1b[${n}G`;
+  }
+
+  // ── Public API ──────────────────────────────────────────────────────────
+
+  init(opts = {}) {
+    if (opts.startTime) this._startTime = opts.startTime;
+    this.workers = opts.workers || [];
+    this._updateSize();
+
+    if (READY) {
+      process.stdout.write(A.hide);
+      process.stdout.on('resize', this._onResize.bind(this));
+      this._drawStartupScreen();
+    } else {
+      console.log(`${C.header}🚀 DankGrinder starting...${A.reset}`);
+    }
+  }
+
+  setVersion(v) { this._version = v; }
+
+  startPhase(name) {
+    this.phaseName = name;
+    this.phaseFrame = 0;
+    if (!READY) {
+      console.log(`  ${A.dim}⟳${A.reset} ${name}...`);
+      return;
+    }
+    if (this.phaseTimer) clearInterval(this.phaseTimer);
+    this.phaseTimer = setInterval(() => {
+      this.phaseFrame = (this.phaseFrame + 1) % SPINNERS.dots.length;
+      this._redrawPhaseSpinner();
+    }, 120);
+    this._redrawPhaseSpinner();
+  }
+
+  updateProgress(done, total) {
+    if (!READY) return;
+    this._writePhaseProgress(done, total);
+  }
+
+  endPhase(name, ok = true) {
+    if (this.phaseTimer) { clearInterval(this.phaseTimer); this.phaseTimer = null; }
+    if (!READY) {
+      const icon = ok ? `${C.header}✓${A.reset}` : `${A.crimson}✗${A.reset}`;
+      console.log(`  ${icon} ${name}`);
+      return;
+    }
+    const icon = ok ? `${C.header}✓${A.reset}` : `${A.crimson}✗${A.reset}`;
+    const frame = SPINNERS.dots[0];
+    const cols = this._w;
+    const label = `  ${frame}  ${name}`;
+    const pad = cols - this._ansiLen(label) - 4;
+    process.stdout.write(
+      A.save +
+      this._cursor(2, 1) +
+      A.clearLine +
+      `${A.save}${A.home}` +
+      `${label}${pad > 0 ? ' '.repeat(pad) : ''}` +
+      `${this._rpad('', cols - this._ansiLen(`  ${icon}  ${name}`) - 2)}${icon}  ${name}` +
+      A.restore
+    );
+    // Clear spinner line
+    process.stdout.write(this._cursor(3, 1) + A.clearLine);
+  }
+
+  flashEvent(type, msg) {
+    const now = new Date();
+    const ts = `${A.dim}${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}${A.reset}`;
+    this.events.unshift({ ts, type, msg, id: Date.now() });
+    if (this.events.length > this.MAX_EVENTS) this.events.pop();
+    this.dirtyEvents = true;
+  }
+
+  setWorkers(workers) {
+    this.workers = workers;
+    this.dirtyWorkers = new Set(workers.map((_, i) => i));
+    this.dirtyStats = true;
+  }
+
+  markWorkerDirty(idx) {
+    this.dirtyWorkers.add(idx);
+  }
+
+  setActive() {
+    if (this._active) return;
+    this._active = true;
+    if (!READY) return;
+
+    // Clear startup, draw live view
+    process.stdout.write(A.clear + A.home);
+    this._drawLiveView();
+    this._startRenderLoop();
+  }
+
+  scrollBy(delta) {
+    if (!READY || this._shutdown) return;
+    const max = Math.max(0, this.workers.length - this.windowSize);
+    this.windowStart = Math.max(0, Math.min(max, this.windowStart + delta));
+    this._followWorkerIdx = -1;  // manual scroll cancels auto-follow
+    this.dirtyWorkers = new Set();
+    for (let i = this.windowStart; i < this.windowStart + this.windowSize; i++) {
+      if (i < this.workers.length) this.dirtyWorkers.add(i);
+    }
+  }
+
+  followWorker(idx) {
+    this._followWorkerIdx = idx;
+    this.scrollLocked = true;
+    // Ensure the worker is visible
+    if (idx < this.windowStart) {
+      this.windowStart = idx;
+    } else if (idx >= this.windowStart + this.windowSize) {
+      this.windowStart = idx - this.windowSize + 1;
+    }
+  }
+
+  shutdown(summary = {}) {
+    this._shutdown = true;
+    if (this._renderTimer) { clearInterval(this._renderTimer); this._renderTimer = null; }
+    if (this._phaseTimer) { clearInterval(this._phaseTimer); this._phaseTimer = null; }
+
+    process.stdout.write(A.show);
+
+    if (!READY) {
+      this._printSummaryPlain(summary);
+      return;
+    }
+
+    // Move to clean area below any existing output
+    const cols = this._w;
+    const { totalCoins = 0, totalCmds = 0, totalSuccess = 0,
+            workers = [], uptime = 0, memMB = 0 } = summary;
+
+    const b = C.border;
+    const h = C.header;
+    const g = C.statValue;
+    const dim = A.dim;
+    const r = A.reset;
+
+    const sep = (c) => `${b}${c.repeat(cols - 2)}${r}`;
+    const bar = `${b}${'─'.repeat(cols - 2)}${r}`;
+    const icon = (e) => `${h}${e}${r}`;
+
+    let out = '';
+    out += `${A.clear}${A.home}`;
+    out += `${A.save}`;
+
+    // Box title
+    out += `${this._at(1, 1)}${bar}`;
+    out += `${this._at(2, 1)}${b} ${h}${A.bold}⬡  DANKGRINDER — Session Summary${r} ${b}${'─'.repeat(Math.max(0, cols - 37))}${r}`;
+    out += `${this._at(3, 1)}${bar}`;
+
+    // Per-account summary
+    let row = 4;
+    for (const wk of workers) {
+      const coins = `+⏣ ${(wk.stats?.coins || 0).toLocaleString()}`;
+      const cmds = `${wk.stats?.commands || 0}cmds`;
+      const rate = wk.stats?.commands > 0
+        ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
+        : '0%';
+      const ls = wk._lifesavers ?? '?';
+      const lv = wk._level ?? '?';
+      const line = ` ${icon('💎')} ${g}${A.bold}${(wk.username || '?').padEnd(18)}${r}  ${C.coins}${coins}${r}  ${dim}${cmds}${r}  ${g}${rate} OK${r}  ${C.level}Lv.${lv}${r}  ${C.lifesavers}♥${ls}${r}`;
+      out += `${this._at(row++, 1)}${b}${this._rpad(line, cols - 2)}${r}`;
+    }
+
+    row++; // blank row
+    out += `${this._at(row++, 1)}${bar}`;
+
+    // Totals
+    const totalLine = ` ${icon('💰')} ${h}${A.bold}Total:${r}  ${C.coins}${A.bold}⏣ ${totalCoins.toLocaleString()}${r}  ${dim}${totalCmds} cmds${r}  ${g}${totalSuccess}% OK${r}  ${dim}${this._fmtUptime(uptime)}${r}  ${dim}${memMB}MB${r}`;
+    out += `${this._at(row++, 1)}${b}${this._rpad(totalLine, cols - 2)}${r}`;
+    out += `${this._at(row++, 1)}${sep('─')}`;
+    out += `${A.restore}`;
+    out += `${A.show}`;
+
+    process.stdout.write(out);
+    setTimeout(() => {}, 100);
+  }
+
+  // ── Internal ────────────────────────────────────────────────────────────
+
+  _updateSize() {
+    try {
+      this._w = process.stdout.columns || 80;
+      this._h = process.stdout.rows || 24;
+      // Window size: leave room for header (3 rows) + stats (2) + events footer (3) + border (2)
+      this.windowSize = Math.max(3, this._h - 12);
+    } catch (_) {
+      this._w = 80; this._h = 24; this.windowSize = 10;
+    }
+  }
+
+  _onResize() {
+    if (this._resizeTimer) clearTimeout(this._resizeTimer);
+    this._resizeTimer = setTimeout(() => {
+      this._updateSize();
+      if (this._active) {
+        this._clearScreen();
+        this._drawLiveView();
+      }
+    }, 100);
+  }
+
+  _ansiLen(s) {
+    // Fast ANSI strip — just count escape sequences by looking for \x1b[
+    let len = 0;
+    let i = 0;
+    const str = String(s);
+    while (i < str.length) {
+      if (str.charCodeAt(i) === 0x1b && str[i + 1] === '[') {
+        let j = i + 2;
+        while (j < str.length && str[j] !== 'm') j++;
+        i = j + 1;
+      } else {
+        len++;
+        i++;
+      }
+    }
+    return len;
+  }
+
+  _rpad(s, width) {
+    const len = this._ansiLen(s);
+    const pad = width > len ? width - len : 0;
+    return s + (pad > 0 ? ' '.repeat(pad) : '');
+  }
+
+  _cursor(row, col) {
+    // Position cursor at absolute row/col (1-indexed)
+    return `\x1b[${row};${col}H`;
+  }
+
+  _at(row, col) {
+    return `\x1b[${row};${col}H`;
+  }
+
+  _write(str) {
+    process.stdout.write(str);
+  }
+
+  _ansi(s, code) { return `${code}${s}${A.reset}`; }
+  _bold(s) { return `${A.bold}${s}${A.reset}`; }
+  _dim(s) { return `${A.dim}${s}${A.reset}`; }
+
+  _fmtUptime(ms) {
+    if (!ms) return '0s';
+    const s = Math.floor(ms / 1000);
+    if (s < 60) return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60) return `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    if (h < 24) return `${h}h ${m % 60}m`;
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h`;
+  }
+
+  _fmtCoins(n) {
+    if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+  }
+
+  _buildAccountRow(wk, idx) {
+    const w = this._w;
+    // Row layout (all in one line):
+    // #N 💎 username  ⏣coins  Lv.N  ♥N  Ncmds  ● status  ⚔ current_cmd
+    // We need to fit within `w` columns, truncate username if needed
+
+    const num = `${idx + 1}.`.padEnd(3);
+    const username = (wk.username || '?').substring(0, 16).padEnd(17);
+    const coins = `⏣${this._fmtCoins(wk.stats?.coins || 0)}`.padEnd(8);
+    const level = `Lv.${wk._level ?? '?'}`.padEnd(5);
+    const ls = wk._lifesavers ?? '?';
+    const lifesaversColor = ls === 0 ? C.lifesaversLow
+      : ls <= 2 ? C.lifesaversMid
+      : C.lifesavers;
+    const lifesavers = `${lifesaversColor}♥${ls}`.padEnd(4);
+    const cmds = `${wk.stats?.commands || 0}cmds`.padEnd(7);
+
+    // Status dot + text
+    let statusDot, statusText, rowBg;
+    if (!wk.running || wk._tokenInvalid) {
+      statusDot = '⚫'; statusText = 'offline'; rowBg = C.rowBgPaused;
+    } else if (wk.paused) {
+      statusDot = '🔴'; statusText = 'paused'; rowBg = C.rowBgPaused;
+    } else if (wk.dashboardPaused) {
+      statusDot = '🟠'; statusText = 'dashboard'; rowBg = C.rowBgWarning;
+    } else {
+      statusDot = '🟢'; statusText = 'grinding'; rowBg = '';
+    }
+
+    // Current command
+    const cmd = (wk.lastStatus || '').substring(0, 20).padEnd(21);
+    const successRate = wk.stats?.commands > 0
+      ? `${((wk.stats.successes / wk.stats.commands) * 100).toFixed(0)}%`
+      : '0%';
+
+    const parts = [
+      `${C.header}${num}${A.reset}`,
+      `${C.name}${username}${A.reset}`,
+      `${C.coins}${coins}${A.reset}`,
+      `${C.level}${level}${A.reset}`,
+      `${lifesaversColor}${lifesavers}${A.reset}`,
+      `${C.statValue}${cmds}${A.reset}`,
+      `${C.statValue}${successRate}`.padEnd(5) + A.reset,
+      `${statusDot} ${statusText}`.padEnd(14),
+      `${this._dim(cmd)}`,
+    ];
+
+    // Join and pad to screen width
+    const line = parts.join('  ');
+    return this._rpad(line, w);
+  }
+
+  _drawStartupScreen() {
+    const w = this._w;
+    const b = C.border;
+    const h = C.header;
+    const g = C.statValue;
+    const dim = A.dim;
+    const r = A.reset;
+
+    const sep = (c) => `${b}${c.repeat(w - 2)}${r}`;
+
+    // Figure out how many rows we need for the spinner
+    const spinnerRow = 3;
+    const progressRow = 5;
+    const readyRow = 7;
+
+    let out = '';
+    out += `${A.clear}${A.home}`;
+
+    // Title box
+    const titleText = ` ⬡  DANKGRINDER v${this._version || '?'} `;
+    const titlePad = w - 2 - this._ansiLen(titleText);
+    out += `${this._at(1, 1)}${sep('─')}`;
+    out += `${this._at(2, 1)}${b} ${h}${A.bold}${titleText}${r}${b}${'─'.repeat(Math.max(0, titlePad))}${r}`;
+    out += `${this._at(3, 1)}${sep('─')}`;
+
+    // Spinner + phase text
+    out += `${this._at(5, 1)}${b}${' '.repeat(w - 2)}${r}`;
+    out += `${this._at(6, 1)}${b}${' '.repeat(w - 2)}${r}`;
+
+    // Footer hint
+    out += `${this._at(8, 1)}${sep('─')}`;
+    const hint = `${dim}Starting up...${r}`;
+    out += `${this._at(9, 1)}${b} ${hint}${' '.repeat(Math.max(0, w - 2 - this._ansiLen(hint)))}${r}`;
+    out += `${this._at(10, 1)}${sep('─')}`;
+
+    this._lineCount = 10;
+    this._write(out);
+  }
+
+  _redrawPhaseSpinner() {
+    if (!READY) return;
+    const frame = SPINNERS.dots[this.phaseFrame];
+    const label = this.phaseName;
+    const w = this._w;
+
+    const line = ` ${frame}  ${label}...`;
+    const pad = w - this._ansiLen(line) - 2;
+    const padded = line + (pad > 0 ? ' '.repeat(pad) : '');
+
+    const b = C.border;
+    const r = A.reset;
+    this._write(
+      `${A.save}` +
+      `${this._cursor(6, 1)}` +
+      `${b}${padded}${r}` +
+      `${A.restore}`
+    );
+  }
+
+  _writePhaseProgress(done, total) {
+    if (!READY) {
+      console.log(`  ${A.dim}  → ${done}/${total}${A.reset}`);
+      return;
+    }
+    const w = this._w;
+    const b = C.border;
+    const h = C.header;
+    const dim = A.dim;
+    const r = A.reset;
+    const barLen = Math.max(10, w - 30);
+    const filled = Math.round((done / total) * barLen);
+    const empty = barLen - filled;
+
+    const bar = `${h}${'█'.repeat(filled)}${dim}${'░'.repeat(empty)}${r}`;
+    const label = ` ${done}/${total} `;
+    const line = `${bar} ${label}`;
+    const pad = w - this._ansiLen(line) - 2;
+
+    this._write(
+      `${A.save}` +
+      `${this._cursor(6, 1)}` +
+      `${b}${line}${' '.repeat(Math.max(0, pad))}${r}` +
+      `${A.restore}`
+    );
+  }
+
+  _clearScreen() {
+    this._write(`${A.clear}${A.home}`);
+  }
+
+  _drawLiveView() {
+    if (!READY) return;
+    this._drawHeader();
+    this._drawAccounts();
+    this._drawEvents();
+    this._drawFooter();
+  }
+
+  _drawHeader() {
+    const w = this._w;
+    const b = C.border;
+    const h = C.header;
+    const g = C.statValue;
+    const dim = A.dim;
+    const r = A.reset;
+
+    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+    const title = ` ⬡  DANKGRINDER v${this._version || '?'} `;
+    const titlePad = w - 2 - this._ansiLen(title);
+
+    this._headerRow = 1;
+    this._write(`${this._at(1, 1)}${sep}`);
+    this._write(`${this._at(2, 1)}${b} ${h}${A.bold}${title}${r}${b}${'─'.repeat(Math.max(0, titlePad))}${r}`);
+    this._write(`${this._at(3, 1)}${sep}`);
+    this._statsRow = 4;
+
+    // Stats bar
+    const stats = this._buildStatsLine();
+    this._write(`${this._at(4, 1)}${b}${this._rpad(' ' + stats, w - 2)}${r}`);
+    this._accountsRow = 5;
+    this._write(`${this._at(5, 1)}${sep}`);
+  }
+
+  _buildStatsLine() {
+    const g = C.statValue;
+    const dim = A.dim;
+    const h = C.header;
+    const coins = C.coins;
+
+    let totalCoins = 0, totalCmds = 0, totalSuccess = 0, totalLs = 0;
+    let pausedCount = 0, activeCount = 0;
+
+    for (const wk of this.workers) {
+      totalCoins += wk.stats?.coins || 0;
+      totalCmds += wk.stats?.commands || 0;
+      totalSuccess += wk.stats?.successes || 0;
+      if (wk._lifesavers != null) totalLs += wk._lifesavers;
+      if (!wk.running || wk._tokenInvalid) {}
+      else if (wk.paused || wk.dashboardPaused) pausedCount++;
+      else activeCount++;
+    }
+
+    const uptime = this._fmtUptime(Date.now() - (this._startTime || Date.now()));
+    const rate = totalCmds > 0 ? ((totalSuccess / totalCmds) * 100).toFixed(0) : 0;
+
+    return [
+      `${dim}⏱${A.reset} ${g}${uptime}${A.reset}`,
+      `${dim}⬡${A.reset} ${g}${this.workers.length}${A.reset} ${dim}accounts${A.reset}`,
+      `${coins}⏣${A.reset} ${g}${totalCoins.toLocaleString()}${A.reset}`,
+      `${dim}⚡${A.reset} ${g}${totalCmds}${A.reset} ${dim}cmds${A.reset}`,
+      `${dim}📊${A.reset} ${g}${rate}%${A.reset}`,
+      `${C.lifesavers}♥${A.reset} ${g}${totalLs}${A.reset}`,
+      `${h}🟢${A.reset} ${g}${activeCount}${A.reset} ${h}🔴${A.reset} ${g}${pausedCount}${A.reset}`,
+    ].join('   ');
+  }
+
+  _drawAccounts() {
+    const w = this._w;
+    const b = C.border;
+    const dim = A.dim;
+    const r = A.reset;
+    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+
+    const visible = this.workers.slice(this.windowStart, this.windowStart + this.windowSize);
+
+    // Column header
+    const cols = [
+      `${C.header}#${A.reset}`,
+      `${C.header}ACCOUNT${A.reset}`,
+      `${C.header}COINS${A.reset}`,
+      `${C.header}LV${A.reset}`,
+      `${C.header}♥${A.reset}`,
+      `${C.header}CMDS${A.reset}`,
+      `${C.header}OK%${A.reset}`,
+      `${C.header}STATUS${A.reset}`,
+      `${C.header}CURRENT${A.reset}`,
+    ].join('  ');
+    this._write(`${this._at(this._accountsRow, 1)}${b}${this._rpad(' ' + cols, w - 2)}${r}`);
+    this._write(`${this._at(this._accountsRow + 1, 1)}${sep}`);
+
+    // Worker rows
+    for (let i = 0; i < this.windowSize; i++) {
+      const row = this._accountsRow + 2 + i;
+      if (row > this._h - 4) break;
+
+      if (i < visible.length) {
+        const wk = visible[i];
+        const line = this._buildAccountRow(wk, this.windowStart + i);
+        this._write(`${this._at(row, 1)}${b}${line}${r}`);
+      } else {
+        this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
+      }
+    }
+    this._eventsRow = this._accountsRow + 2 + this.windowSize + 1;
+  }
+
+  _drawEvents() {
+    const w = this._w;
+    const b = C.border;
+    const dim = A.dim;
+    const r = A.reset;
+    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+
+    if (this._eventsRow > this._h - 4) return;
+    this._write(`${this._at(this._eventsRow, 1)}${sep}`);
+
+    const visibleEvents = this.events.slice(0, Math.min(this.MAX_EVENTS, this._h - this._eventsRow - 3));
+    for (let i = 0; i < visibleEvents.length; i++) {
+      const row = this._eventsRow + 1 + i;
+      if (row > this._h - 2) break;
+      const evt = visibleEvents[i];
+      const typeColor = evt.type === 'error' || evt.type === 'death' ? C.cmdError
+        : evt.type === 'warn' || evt.type === 'lowls' ? C.cmdWarn
+        : evt.type === 'success' || evt.type === 'levelup' ? C.cmdSuccess
+        : C.cmdEvent;
+
+      const line = ` ${dim}${evt.ts}${A.reset} ${typeColor}${evt.msg}${A.reset}`;
+      this._write(`${this._at(row, 1)}${b}${this._rpad(line, w - 2)}${r}`);
+    }
+    this._footerRow = this._eventsRow + 1 + visibleEvents.length;
+  }
+
+  _drawFooter() {
+    const w = this._w;
+    const b = C.border;
+    const dim = A.dim;
+    const r = A.reset;
+    const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+
+    if (this._footerRow > this._h - 1) this._footerRow = this._h - 2;
+    this._write(`${this._at(this._footerRow, 1)}${sep}`);
+
+    const hint = `${dim}↑↓ scroll · j/k navigate · Ctrl+C quit${r}`;
+    this._write(`${this._at(this._footerRow + 1, 1)}${b} ${hint}${' '.repeat(Math.max(0, w - 2 - this._ansiLen(hint)))}${r}`);
+  }
+
+  _render() {
+    if (!READY || this._shutdown || !this._active) return;
+
+    // Auto-follow newest active worker
+    if (this._followWorkerIdx >= 0 && this._followWorkerIdx < this.workers.length) {
+      const target = this._followWorkerIdx;
+      if (target < this.windowStart) {
+        this.windowStart = target;
+        this.dirtyWorkers = new Set();
+        for (let i = this.windowStart; i < this.windowStart + this.windowSize; i++) {
+          if (i < this.workers.length) this.dirtyWorkers.add(i);
+        }
+      } else if (target >= this.windowStart + this.windowSize) {
+        this.windowStart = target - this.windowSize + 1;
+        this.dirtyWorkers = new Set();
+        for (let i = this.windowStart; i < this.windowStart + this.windowSize; i++) {
+          if (i < this.workers.length) this.dirtyWorkers.add(i);
+        }
+      }
+    }
+
+    // Redraw everything on resize changes
+    if (this.dirtyStats) {
+      this._drawHeader();
+      this.dirtyWorkers = new Set(this.workers.map((_, i) => i));
+    }
+
+    if (this.dirtyWorkers.size > 0) {
+      const w = this._w;
+      const b = C.border;
+      const r = A.reset;
+      const sep = `${b}${'─'.repeat(w - 2)}${r}`;
+
+      for (const idx of this.dirtyWorkers) {
+        const localIdx = idx - this.windowStart;
+        const row = this._accountsRow + 2 + localIdx;
+        if (row < this._accountsRow + 2 || row > this._h - 4) continue;
+
+        if (idx < this.workers.length) {
+          const line = this._buildAccountRow(this.workers[idx], idx);
+          this._write(`${this._at(row, 1)}${b}${line}${r}`);
+        } else {
+          this._write(`${this._at(row, 1)}${b}${' '.repeat(w - 2)}${r}`);
+        }
+      }
+    }
+
+    if (this.dirtyEvents) {
+      this._drawEvents();
+      this._drawFooter();
+    }
+
+    this.dirtyWorkers.clear();
+    this.dirtyEvents = false;
+    this.dirtyStats = false;
+  }
+
+  _startRenderLoop() {
+    if (this._renderTimer) clearInterval(this._renderTimer);
+    this._renderTimer = setInterval(() => this._render(), 250); // 4 FPS
+  }
+
+  _printSummaryPlain(summary) {
+    const { totalCoins = 0, totalCmds = 0, totalSuccess = 0,
+            workers = [], uptime = 0, memMB = 0 } = summary;
+    const b = '═'.repeat(60);
+    console.log('');
+    console.log(`  ${'═'.repeat(60)}`);
+    console.log(`  ⬡  DANKGRINDER — Session Summary`);
+    console.log(`  ${'─'.repeat(60)}`);
+    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 || 0).toLocaleString().padStart(8)}  ` +
+        `${(wk.stats?.commands || 0)}cmds  ${rate}  ♥${wk._lifesavers ?? '?'}  Lv.${wk._level ?? '?'}`
+      );
+    }
+    console.log(`  ${'─'.repeat(60)}`);
+    console.log(`  💰 Total: ⏣ ${totalCoins.toLocaleString()}  ${totalCmds}cmds  ${totalSuccess}%OK  ${this._fmtUptime(uptime)}  ${memMB}MB`);
+    console.log(`  ${'═'.repeat(60)}`);
+    console.log('');
+  }
+}
+
+module.exports = new Terminal();

package/package.json

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