dankgrinder 5.24.0 → 5.260.0

package/lib/grinder.js

@@ -316,37 +316,48 @@ function renderDashboard() {
   const tw = Math.min(process.stdout.columns || 80, 78);
   const thinBar = c.dim + '─'.repeat(tw) + c.reset;
   const bar = rgb(139, 92, 246) + c.bold + '━'.repeat(tw) + c.reset;
+  const doubleBar = rgb(139, 92, 246) + '╔' + '═'.repeat(tw - 2) + '╗' + c.reset;
+  const doubleBarBot = rgb(139, 92, 246) + '╚' + '═'.repeat(tw - 2) + '╝' + c.reset;
 
   // Header with dynamic version, command count, and status
-  lines.push(bar);
+  lines.push(doubleBar);
   const cmdCount = AccountWorker.COMMAND_MAP.length;
   const activeCount = workers.filter(w => w.running && !w.paused && !w.dashboardPaused).length;
   const mode = CLUSTER_ENABLED ? `${rgb(34, 211, 238)}Cluster${c.reset}` : `${c.dim}Standalone${c.reset}`;
+
+  // Animated spinner based on time
+  const spinners = ['◐', '◓', '◑', '◒'];
+  const spinner = spinners[Math.floor(Date.now() / 250) % 4];
+  const animatedSpinner = `${rgb(52, 211, 153)}${spinner}${c.reset}`;
+
   lines.push(
     `  ${rgb(139, 92, 246)}${c.bold}DankGrinder${c.reset} ${c.dim}v${PKG_VERSION}${c.reset}` +
     `  ${c.dim}·${c.reset}  ${c.white}${cmdCount} Cmds${c.reset}` +
     `  ${c.dim}·${c.reset}  ${mode}` +
-    `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}${activeCount}${c.reset}${c.dim}/${c.reset}${c.white}${workers.length}${c.reset} ${c.dim}Live${c.reset}`
+    `  ${c.dim}·${c.reset}  ${animatedSpinner} ${rgb(52, 211, 153)}${activeCount}${c.reset}${c.dim}/${c.reset}${c.white}${workers.length}${c.reset} ${c.dim}Live${c.reset}`
   );
 
-  // Stats row
-  const liveIcon = rgb(52, 211, 153) + '◉' + c.reset;
+  // Stats row with enhanced visual indicators
+  const liveIcon = rgb(52, 211, 153) + '●' + c.reset;
   const balStr = `${rgb(192, 132, 252)}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}`;
-  const earnStr = `${rgb(52, 211, 153)}↑ ${formatCoins(totalCoins)}${c.reset}`;
+  const earnStr = `${rgb(52, 211, 153)}▲ ${formatCoins(totalCoins)}${c.reset}`;
   // Coins/hour rate
   const elapsedHrs = (Date.now() - startTime) / 3_600_000;
   const coinsPerHr = elapsedHrs > 0.01 ? Math.round(totalCoins / elapsedHrs) : 0;
   const rateLabel = `${rgb(52, 211, 153)}${formatCoins(coinsPerHr)}/h${c.reset}`;
   const cmdStr = `${rgb(96, 165, 250)}${totalCommands}${c.reset}${c.dim} cmds${c.reset}`;
   const rateStr = successRate >= 95
-    ? `${rgb(52, 211, 153)}${successRate}%${c.reset}`
-    : successRate >= 80 ? `${rgb(251, 191, 36)}${successRate}%${c.reset}`
-    : `${rgb(239, 68, 68)}${successRate}%${c.reset}`;
-  const upStr = `${rgb(251, 191, 36)}⏱ ${formatUptime()}${c.reset}`;
-  // Memory usage (RSS in MB)
+    ? `${rgb(52, 211, 153)}● ${successRate}%${c.reset}`
+    : successRate >= 80 ? `${rgb(251, 191, 36)}● ${successRate}%${c.reset}`
+    : `${rgb(239, 68, 68)}● ${successRate}%${c.reset}`;
+  const upStr = `${rgb(251, 191, 36)}◷ ${formatUptime()}${c.reset}`;
+  // Memory usage (RSS in MB) with bar indicator
   const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
+  const memPct = Math.min(100, (memMB / 1024) * 100);
+  const memBarWidth = Math.floor((memPct / 100) * 10);
+  const memBar = rgb(52, 211, 153) + '▅'.repeat(memBarWidth) + c.dim + '▅'.repeat(10 - memBarWidth) + c.reset;
   const memColor = memMB > 900 ? rgb(239, 68, 68) : memMB > 600 ? rgb(251, 191, 36) : rgb(52, 211, 153);
-  const memStr = `${memColor}${memMB}MB${c.reset}`;
+  const memStr = `${memColor}${memMB}MB${c.reset} ${memBar}`;
   // Commands/minute from SlidingWindowCounter
   const cpmVal = globalCmdRate.getRate().toFixed(1);
   const cpmStr = `${rgb(34, 211, 238)}${cpmVal}${c.reset}${c.dim}/m${c.reset}`;
@@ -394,9 +405,16 @@ function renderDashboard() {
     const bal = wk.stats.balance > 0
       ? `${rgb(251, 191, 36)}⏣${c.reset} ${c.white}${formatCoins(wk.stats.balance).padStart(7)}${c.reset}`
       : `${c.dim}⏣       -${c.reset}`;
-    const earned = wk.stats.coins > 0
-      ? `${rgb(52, 211, 153)}+${formatCoins(wk.stats.coins).padStart(6)}${c.reset}`
-      : `${c.dim}     +0${c.reset}`;
+
+    // Mini progress bar for earned coins (visual indicator of activity)
+    const earnedNum = wk.stats.coins || 0;
+    const earnedBarWidth = earnedNum > 0 ? Math.min(5, Math.max(1, Math.floor(Math.log10(earnedNum + 1)))) : 0;
+    const earnedBar = earnedNum > 0
+      ? `${rgb(52, 211, 153)}${'▰'.repeat(earnedBarWidth)}${c.dim}${'▱'.repeat(5 - earnedBarWidth)}${c.reset}`
+      : `${c.dim}▱▱▱▱▱${c.reset}`;
+    const earned = earnedNum > 0
+      ? `${rgb(52, 211, 153)}+${formatCoins(earnedNum)}${c.reset} ${earnedBar}`
+      : `${c.dim}+0${c.reset} ${earnedBar}`;
 
     lines.push(`  ${dot} ${name.padEnd(nameWidth + wk.color.length + c.bold.length + c.reset.length)} ${bal}  ${earned}  ${stateLabel}`);
   };
@@ -451,7 +469,7 @@ function renderDashboard() {
     }
   }
 
-  lines.push(bar);
+  lines.push(doubleBarBot);
 
   // Absolute cursor home — always draw from row 1
   process.stdout.write('\x1b[H');
@@ -587,6 +605,51 @@ function safeParseJSON(str, fallback = []) {
   try { return JSON.parse(str || '[]'); } catch { return fallback; }
 }
 
+// ── Command Result Formatter ──────────────────────────────────
+// Clean command names and format results with color codes
+const CMD_NAMES_CLEAN = {
+  bj: 'Blackjack', blackjack: 'Blackjack', hl: 'High Low', pm: 'Post Memes', postmemes: 'Post Memes',
+  ct: 'Coin Toss', cointoss: 'Coin Toss', se: 'Snake Eyes', snakeeyes: 'Snake Eyes',
+  hunt: 'Hunt', dig: 'Dig', fish: 'Fish', beg: 'Beg', search: 'Search', crime: 'Crime',
+  tidy: 'Tidy', farm: 'Farm', daily: 'Daily', weekly: 'Weekly', monthly: 'Monthly',
+  scratch: 'Scratch', adventure: 'Adventure', trivia: 'Trivia', stream: 'Stream',
+  drops: 'Drops', use: 'Use Item', dep: 'Deposit', deposit: 'Deposit', inv: 'Inventory',
+  work: 'Work', stream: 'Stream', roulette: 'Roulette', slots: 'Slots',
+};
+
+function formatCommandName(cmd) {
+  if (!cmd) return '?';
+  const clean = cmd.replace(/^pls\s+/, '').replace(/\s+\d+.*$/, '').trim().toLowerCase();
+  return CMD_NAMES_CLEAN[clean] || clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+
+function formatCommandResult(cmdName, result, earned, spent) {
+  const name = formatCommandName(cmdName);
+  const net = (earned || 0) - (spent || 0);
+
+  // Extract clean result text
+  let cleanResult = stripAnsi(result || '').replace(/\n/g, ' ').substring(0, 40);
+
+  // Check for common failure/hold patterns
+  if (cleanResult.toLowerCase().includes('hold tight')) return `${name}: ${c.yellow}Hold Tight${c.reset}`;
+  if (cleanResult.toLowerCase().includes('cooldown')) return `${name}: ${c.dim}On Cooldown${c.reset}`;
+  if (cleanResult.toLowerCase().includes('no response')) return `${name}: ${c.red}No Response${c.reset}`;
+
+  // Format with earnings/losses
+  if (net > 0) {
+    return `${name}: ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`;
+  } else if (net < 0) {
+    return `${name}: ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`;
+  } else if (earned === 0 && spent === 0) {
+    // No coins changed - show result context
+    if (cleanResult.includes('completed') || cleanResult.includes('done')) {
+      return `${name}: ${c.dim}Done${c.reset}`;
+    }
+    return `${name}: ${c.dim}${cleanResult || 'Complete'}${c.reset}`;
+  }
+  return `${name}: ${c.dim}${cleanResult || 'Complete'}${c.reset}`;
+}
+
 // ── Coin Parser — prefers Net:/Winnings: fields, falls back to max ⏣ ──
 function parseCoins(text) {
   if (!text) return 0;
@@ -764,6 +827,13 @@ class MinHeap {
 // ══════════════════════════════════════════════════════════════
 
 class AccountWorker {
+  static SMART_CD_FLOORS = Object.freeze({
+    'farm': 30,
+    'adventure': 300,
+    'stream': 600,
+    'work shift': 1800,
+  });
+
   constructor(account, idx) {
     this.account = account;
     this.idx = idx;
@@ -1114,7 +1184,10 @@ class AccountWorker {
             accountId: this.account.id,
             redis,
             onPageProgress: ({ page, total }) => {
-              this.log('info', `Inventory pages: ${page}/${total}`);
+              // Update same line instead of spamming new lines - uses cursor control
+              const progress = `[inv] ${this.username}: ${page}/${total} pages`;
+              const erase = '\x1b[2K\r'; // Clear line + carriage return
+              process.stdout.write(`${erase}${this.color}${progress}${c.reset}`);
             },
           });
 
@@ -1122,6 +1195,8 @@ class AccountWorker {
             throw new Error(`incomplete pages (${result.pagesVisited || 0}/${result.pagesTotal || 0})`);
           }
 
+          // Add newline after inventory progress
+          process.stdout.write('\n');
           this.log('success', `Inventory: ${result.items?.length || 0} items, ⏣ ${(result.totalValue || 0).toLocaleString()} net`);
           try {
             await fetch(`${API_URL}/api/grinder/inventory`, {
@@ -1524,7 +1599,8 @@ class AccountWorker {
 
       const earned = Math.max(0, cmdResult.coins || 0);
       const spent = Math.max(0, cmdResult.lost || 0);
-      if (earned > 0) this.stats.coins += earned;
+      // Track net earnings (add wins, subtract losses)
+      this.stats.coins += (earned - spent);
       if (cmdResult.nextCooldownSec) {
         await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
         this._lastCooldownOverride = cmdResult.nextCooldownSec;
@@ -1571,8 +1647,9 @@ class AccountWorker {
       }
 
       this.stats.successes++;
-      const shortResult = result.substring(0, 30).replace(/\n/g, ' ');
-      this.setStatus(`${cmdName} → ${shortResult}`);
+      // Format result with clean command name and colored earnings
+      const formattedResult = formatCommandResult(cmdName, result, earned, spent);
+      this.setStatus(formattedResult);
       await sendLog(this.username, cmdName, result, 'success');
       reportEarnings(this.account.id, this.username, earned, spent, cmdName);
 
@@ -1667,7 +1744,7 @@ class AccountWorker {
     { key: 'cmd_snakeeyes', cmd: 'snakeeyes',   cdKey: 'cd_snakeeyes', defaultCd: 3,      priority: 7 },
     // Fast grinders — 10s CD
     { key: 'cmd_hl',        cmd: 'hl',          cdKey: 'cd_hl',        defaultCd: 10,     priority: 6 },
-    { key: 'cmd_farm',      cmd: 'farm',        cdKey: 'cd_farm',      defaultCd: 10,     priority: 6 },
+  { key: 'cmd_farm',      cmd: 'farm',        cdKey: 'cd_farm',      defaultCd: 30,     priority: 4 },
     { key: 'cmd_trivia',    cmd: 'trivia',      cdKey: 'cd_trivia',    defaultCd: 10,     priority: 6 },
     { key: 'cmd_use',       cmd: 'use',         cdKey: 'cd_use',       defaultCd: 10,     priority: 2 },
     // Medium grinders — 20-25s CD
@@ -1681,10 +1758,10 @@ class AccountWorker {
     { key: 'cmd_crime',     cmd: 'crime',       cdKey: 'cd_crime',     defaultCd: 40,     priority: 5 },
     { key: 'cmd_tidy',      cmd: 'tidy',        cdKey: 'cd_tidy',      defaultCd: 40,     priority: 2 },
     // Interactive — response-driven CD (handler sets nextCooldownSec)
-    { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 10,     priority: 3 },
-    { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',    defaultCd: 10,     priority: 3 },
+  { key: 'cmd_adventure', cmd: 'adventure',   cdKey: 'cd_adventure', defaultCd: 300,    priority: 3 },
+  { key: 'cmd_stream',    cmd: 'stream',      cdKey: 'cd_stream',    defaultCd: 600,    priority: 3 },
     { key: 'cmd_scratch',   cmd: 'scratch',     cdKey: 'cd_scratch',   defaultCd: 10,     priority: 3 },
-    { key: 'cmd_work',      cmd: 'work shift',  cdKey: 'cd_work',      defaultCd: 10,     priority: 3 },
+  { key: 'cmd_work',      cmd: 'work shift',  cdKey: 'cd_work',      defaultCd: 1800,   priority: 3 },
     // Time-gated (run ASAP when available)
     { key: 'cmd_daily',     cmd: 'daily',       cdKey: 'cd_daily',     defaultCd: 86400,  priority: 10 },
     { key: 'cmd_weekly',    cmd: 'weekly',       cdKey: 'cd_weekly',    defaultCd: 604800, priority: 10 },
@@ -2029,8 +2106,6 @@ class AccountWorker {
     const microPause = Math.random() < 0.08 ? 1.5 + Math.random() * 3 : 0;
     const totalWait = cd + jitterBase + microPause;
 
-    await this.setCooldown(item.cmd, totalWait);
-
     const timeSinceLastCmd = now - (this.lastCommandRun || 0);
     const gapBase = cd <= 5 ? 1500 : cd <= 20 ? 2000 : 2500;
     const jitterGap = patternMod.minDelay + Math.random() * (patternMod.maxDelay - patternMod.minDelay);
@@ -2059,7 +2134,7 @@ class AccountWorker {
     // Grace period for interactive (button-click) commands — Dank Memer
     // needs time to process the interaction before accepting the next command.
     // Without this, the next command gets "Hold Tight" errors.
-    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'scratch', 'adventure', 'stream', 'fish']);
+    const INTERACTIVE_CMDS = new Set(['hl', 'blackjack', 'trivia', 'scratch', 'adventure', 'stream', 'fish', 'farm', 'work shift']);
     if (INTERACTIVE_CMDS.has(item.cmd)) {
       await new Promise(r => setTimeout(r, 2500 + Math.random() * 1500));
     }
@@ -2078,8 +2153,7 @@ class AccountWorker {
       this.failStreak = 0;
     }
 
-    this.lastCommandRun = Date.now();
-    await this.setCooldown(item.cmd, totalWait);
+  this.lastCommandRun = Date.now();
 
     // Exponential backoff: if too many consecutive failures, slow down
     const backoffMultiplier = this.failStreak > 5 ? Math.min(this.failStreak - 4, 5) : 1;
@@ -2087,12 +2161,25 @@ class AccountWorker {
     const MIN_FAIL_COOLDOWN = 5;
 
     if (this.commandQueue && this.running && !shutdownCalled) {
-      let effectiveWait = this._lastCooldownOverride || totalWait;
+      const hasOverride = Number.isFinite(this._lastCooldownOverride) && this._lastCooldownOverride > 0;
+      let effectiveWait = hasOverride ? this._lastCooldownOverride : totalWait;
       this._lastCooldownOverride = null;
+
+      // Smart fallback floors for long/interactive commands when parser misses exact cooldown.
+      if (!hasOverride) {
+        const floor = AccountWorker.SMART_CD_FLOORS[item.cmd];
+        if (Number.isFinite(floor) && floor > 0) {
+          effectiveWait = Math.max(effectiveWait, floor);
+        }
+      }
+
       if (earned <= 0 && !noFailCmds.includes(item.cmd) && effectiveWait < MIN_FAIL_COOLDOWN) {
         effectiveWait = MIN_FAIL_COOLDOWN;
       }
-      item.nextRunAt = Date.now() + effectiveWait * 1000 * backoffMultiplier;
+
+      const scheduledWaitSec = Math.max(1, effectiveWait * backoffMultiplier);
+      await this.setCooldown(item.cmd, scheduledWaitSec);
+      item.nextRunAt = Date.now() + scheduledWaitSec * 1000;
       this.commandQueue.push(item);
     }
 
@@ -2311,8 +2398,8 @@ class AccountWorker {
           } catch {}
         }
 
-        // Let Discord gateway settle
-        await new Promise(r => setTimeout(r, 2500));
+        // Let Discord gateway settle (reduced for faster startup)
+        await new Promise(r => setTimeout(r, 500));
         resolve();
       });
 
@@ -2437,43 +2524,58 @@ async function start(apiKey, apiUrl) {
   console.log(`  ${checks.join('   ')}`);
   console.log('');
 
-  // Phase 1: Login all accounts (staggered to avoid 429s)
-  const LOGIN_PROGRESS_EVERY = 5;
-  const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '100'), 10);
-  const parsedGapMax = Number.parseInt(String(process.env.LOGIN_GAP_MAX_MS || '300'), 10);
-  const LOGIN_GAP_MIN_MS = Number.isFinite(parsedGapMin) && parsedGapMin >= 0 ? parsedGapMin : 100;
-  const LOGIN_GAP_MAX_MS = Number.isFinite(parsedGapMax) && parsedGapMax >= LOGIN_GAP_MIN_MS ? parsedGapMax : Math.max(LOGIN_GAP_MIN_MS, 300);
+  // Phase 1: Login all accounts (optimized for speed)
+  const LOGIN_PROGRESS_EVERY = 10;
+  // Reduced delays: 50-150ms between logins (faster startup for 1k+ accounts)
+  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;
+  const LOGIN_GAP_MAX_MS = Number.isFinite(parsedGapMax) && parsedGapMax >= LOGIN_GAP_MIN_MS ? parsedGapMax : Math.max(LOGIN_GAP_MIN_MS, 150);
 
   const randomLoginGap = () => {
     if (LOGIN_GAP_MAX_MS <= LOGIN_GAP_MIN_MS) return LOGIN_GAP_MIN_MS;
     return LOGIN_GAP_MIN_MS + Math.floor(Math.random() * (LOGIN_GAP_MAX_MS - LOGIN_GAP_MIN_MS + 1));
   };
 
-  for (let i = 0; i < accounts.length; i++) {
+  // Parallel login in batches of 10 to avoid rate limits while being fast
+  const BATCH_SIZE = 10;
+  for (let i = 0; i < accounts.length; i += BATCH_SIZE) {
     if (shutdownCalled) break;
-    const worker = new AccountWorker(accounts[i], i);
-    workers.push(worker);
-    workerMap.set(accounts[i].id, worker);
-    await worker.start();
-    if (i + 1 < accounts.length) {
+    const batch = accounts.slice(i, Math.min(i + BATCH_SIZE, accounts.length));
+
+    // Login batch in parallel
+    await Promise.all(batch.map(async (acc, idx) => {
+      const worker = new AccountWorker(acc, i + idx);
+      workers.push(worker);
+      workerMap.set(acc.id, worker);
+      await worker.start();
+    }));
+
+    // Small gap between batches
+    if (i + BATCH_SIZE < accounts.length) {
       const gapMs = randomLoginGap();
-      if ((i + 1) % LOGIN_PROGRESS_EVERY === 0) {
-        log('info', `${c.dim}Logged in ${i + 1}/${accounts.length}, next account in ${gapMs}ms...${c.reset}`);
-      }
+      log('info', `${c.dim}Logged in ${Math.min(i + BATCH_SIZE, accounts.length)}/${accounts.length}...${c.reset}`);
       await new Promise(r => setTimeout(r, gapMs));
     }
-    if ((i + 1) % LOGIN_PROGRESS_EVERY === 0) {
-      hintGC();
-    }
+
+    hintGC();
   }
 
   // Phase 2: Run inventory on ALL accounts (must complete before any grinding)
   log('info', `${c.dim}Checking inventory for all ${workers.length} accounts...${c.reset}`);
   let invDone = 0;
   let invFailed = 0;
-  await Promise.all(workers.map(async (w, i) => {
+
+  // Use sequential inventory checks with single-line progress update
+  const totalAccounts = workers.length;
+  for (let i = 0; i < workers.length; i++) {
+    const w = workers[i];
     const label = w?.username || w?.account?.label || w?.account?.id || `account-${i + 1}`;
-    log('info', `${c.dim}[inv-startup] ${i + 1}/${workers.length} ${label}${c.reset}`);
+
+    // Update single line instead of spamming new lines
+    const progressLine = `\x1b[2K\r${c.dim}[inv] ${i + 1}/${totalAccounts}: ${label}${c.reset}`;
+    process.stdout.write(progressLine);
+
     try {
       const invRes = await w.checkInventory({
         force: true,
@@ -2486,9 +2588,11 @@ async function start(apiKey, apiUrl) {
     } catch {
       invFailed++;
     }
-    const invComplete = invDone + invFailed;
-    log('info', `${c.dim}[inv-startup-progress] ${invComplete}/${workers.length} complete (${invDone} ok, ${invFailed} failed)${c.reset}`);
-  }));
+  }
+
+  // Newline after progress
+  process.stdout.write('\n');
+  log('success', `${c.dim}Inventory: ${invDone}/${workers.length} complete${invFailed > 0 ? `, ${c.yellow}${invFailed} failed${c.reset}${c.dim}` : ''}${c.reset}`);
 
   if (invFailed > 0) {
     log('error', `${c.red}Inventory phase incomplete: ${invDone}/${workers.length} complete, ${invFailed} failed/incomplete. Not starting grind loops.${c.reset}`);

package/package.json

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