dankgrinder 5.25.0 → 5.281.0

package/lib/afkMode.js

@@ -0,0 +1,349 @@
+/**
+ * AFK Mode - Smart Command Queuing
+ *
+ * Users want to run the bot and forget about it. This module provides:
+ *   - Smart prioritization based on cooldowns and earnings
+ *   - Auto-deposit when wallet is full
+ *   - Auto-sell junk items
+ *   - Sleep mode (pause during night hours)
+ *   - Smart bank management
+ */
+
+'use strict';
+
+// ── Configuration ─────────────────────────────────────────────
+const AFK_CONFIG = Object.freeze({
+  // Wallet management
+  AUTO_DEPOSIT_THRESHOLD: 100000,  // Deposit when wallet > 100k
+  AUTO_DEPOSIT_KEEP: 20000,        // Keep 20k in wallet after deposit
+
+  // Inventory management
+  AUTO_SELL_THRESHOLD: 0.85,       // Sell when inventory > 85% full
+  JUNK_ITEMS: new Set([            // Always sell these
+    'trash', 'junk', 'rock', 'stick', 'bottle', 'can', 'old shoe',
+    'broken compass', 'rusty key', 'tattered flag', 'empty chest',
+  ]),
+  VALUABLE_ITEMS: new Set([        // Never sell these
+    'diamond', 'ruby', 'emerald', 'sapphire', 'gold bar', 'coin',
+    'legendary', 'mythical', 'artifact', 'treasure',
+  ]),
+
+  // Sleep mode (optional - pause during these hours)
+  SLEEP_MODE_ENABLED: false,
+  SLEEP_START_HOUR: 2,   // 2 AM
+  SLEEP_END_HOUR: 6,     // 6 AM
+
+  // Command prioritization
+  HIGH_VALUE_COMMANDS: new Set(['daily', 'weekly', 'monthly', 'work', 'stream']),
+  INCOME_COMMANDS: new Set(['beg', 'search', 'crime', 'hunt', 'dig', 'fish']),
+  GAMBLE_COMMANDS: new Set(['blackjack', 'roulette', 'slots', 'snakeeyes', 'cointoss']),
+
+  // Gambling limits in AFK mode
+  GAMBLE_MAX_LOSSES: 10,          // Stop after 10 losses
+  GAMBLE_MAX_LOSS_AMOUNT: 50000,  // Stop after losing 50k
+});
+
+// ── Command Priority Calculator ───────────────────────────────
+/**
+ * Calculate priority score for a command.
+ * Higher score = should run sooner.
+ */
+function calculateCommandPriority(cmdName, cooldownMs, account) {
+  let score = 0;
+
+  // Ready commands get highest priority
+  if (cooldownMs <= 0) {
+    score += 1000;
+  } else {
+    // Penalize by wait time (in minutes)
+    score -= Math.floor(cooldownMs / 60000);
+  }
+
+  // High-value commands get bonus
+  if (AFK_CONFIG.HIGH_VALUE_COMMANDS.has(cmdName)) {
+    score += 500;
+  }
+
+  // Income commands are important
+  if (AFK_CONFIG.INCOME_COMMANDS.has(cmdName)) {
+    score += 200;
+  }
+
+  // Gambling commands are lower priority in AFK mode
+  if (AFK_CONFIG.GAMBLE_COMMANDS.has(cmdName)) {
+    score -= 100;
+  }
+
+  // Periodic commands (daily/weekly/monthly) get huge bonus when ready
+  const now = Date.now();
+  const dailyCd = account?.doneToday?.get('daily') || 0;
+  const weeklyCd = account?.doneToday?.get('weekly') || 0;
+  const monthlyCd = account?.doneToday?.get('monthly') || 0;
+
+  if (cmdName === 'daily' && dailyCd <= now) score += 800;
+  if (cmdName === 'weekly' && weeklyCd <= now) score += 900;
+  if (cmdName === 'monthly' && monthlyCd <= now) score += 1000;
+
+  return score;
+}
+
+// ── Smart Command Queue Builder ───────────────────────────────
+/**
+ * Build optimized command queue based on cooldowns and priorities.
+ */
+function buildSmartQueue(account, cooldowns) {
+  const enabledCmds = getEnabledCommands(account);
+  const now = Date.now();
+
+  // Calculate priority for each command
+  const priorities = enabledCmds.map(cmd => {
+    const cdUntil = cooldowns.get(cmd) || 0;
+    const cooldownMs = Math.max(0, cdUntil - now);
+    const priority = calculateCommandPriority(cmd, cooldownMs, account);
+
+    return { cmd, priority, cooldownMs };
+  });
+
+  // Sort by priority (highest first)
+  priorities.sort((a, b) => b.priority - a.priority);
+
+  // Return queue of command names
+  return priorities.map(p => p.cmd);
+}
+
+// ── Get Enabled Commands ──────────────────────────────────────
+function getEnabledCommands(account) {
+  const cmdMap = [
+    { key: 'cmd_beg', name: 'beg' },
+    { key: 'cmd_search', name: 'search' },
+    { key: 'cmd_crime', name: 'crime' },
+    { key: 'cmd_hunt', name: 'hunt' },
+    { key: 'cmd_dig', name: 'dig' },
+    { key: 'cmd_fish', name: 'fish' },
+    { key: 'cmd_farm', name: 'farm' },
+    { key: 'cmd_work', name: 'work' },
+    { key: 'cmd_stream', name: 'stream' },
+    { key: 'cmd_daily', name: 'daily' },
+    { key: 'cmd_weekly', name: 'weekly' },
+    { key: 'cmd_monthly', name: 'monthly' },
+    { key: 'cmd_highlow', name: 'hl' },
+    { key: 'cmd_blackjack', name: 'blackjack' },
+    { key: 'cmd_roulette', name: 'roulette' },
+    { key: 'cmd_slots', name: 'slots' },
+    { key: 'cmd_snakeeyes', name: 'snakeeyes' },
+    { key: 'cmd_trivia', name: 'trivia' },
+    { key: 'cmd_scratch', name: 'scratch' },
+    { key: 'cmd_adventure', name: 'adventure' },
+    { key: 'cmd_postmemes', name: 'postmemes' },
+    { key: 'cmd_tidy', name: 'tidy' },
+    { key: 'cmd_use', name: 'use' },
+    { key: 'cmd_deposit', name: 'deposit' },
+  ];
+
+  return cmdMap
+    .filter(c => account[c.key] === true)
+    .map(c => c.name);
+}
+
+// ── Auto-Deposit Check ────────────────────────────────────────
+/**
+ * Check if auto-deposit should run.
+ */
+function shouldAutoDeposit(walletBalance, account) {
+  if (!account.cmd_deposit) return false;
+
+  const threshold = account.afk_deposit_threshold || AFK_CONFIG.AUTO_DEPOSIT_THRESHOLD;
+  return walletBalance > threshold;
+}
+
+// ── Auto-Sell Check ───────────────────────────────────────────
+/**
+ * Check if inventory auto-sell should run.
+ */
+function shouldAutoSell(inventoryCount, maxInventory, account) {
+  if (!account.cmd_use) return false;
+
+  const threshold = account.afk_sell_threshold || AFK_CONFIG.AUTO_SELL_THRESHOLD;
+  return inventoryCount / maxInventory >= threshold;
+}
+
+// ── Get Items To Sell ─────────────────────────────────────────
+/**
+ * Determine which items to auto-sell.
+ */
+function getItemsToSell(inventory) {
+  const toSell = [];
+
+  for (const item of inventory) {
+    const itemName = (item.name || '').toLowerCase();
+
+    // Always sell junk
+    if (AFK_CONFIG.JUNK_ITEMS.some(junk => itemName.includes(junk))) {
+      toSell.push(item.name);
+      continue;
+    }
+
+    // Never sell valuables
+    if (AFK_CONFIG.VALUABLE_ITEMS.some(val => itemName.includes(val))) {
+      continue;
+    }
+
+    // Sell common items (value < 1000)
+    if (item.value && item.value < 1000) {
+      toSell.push(item.name);
+    }
+  }
+
+  return toSell;
+}
+
+// ── Sleep Mode Check ──────────────────────────────────────────
+/**
+ * Check if sleep mode is active.
+ */
+function isSleepMode() {
+  if (!AFK_CONFIG.SLEEP_MODE_ENABLED) return false;
+
+  const hour = new Date().getHours();
+  const start = AFK_CONFIG.SLEEP_START_HOUR;
+  const end = AFK_CONFIG.SLEEP_END_HOUR;
+
+  if (start < end) {
+    return hour >= start && hour < end;
+  }
+  // Handles overnight ranges (e.g., 22:00 - 06:00)
+  return hour >= start || hour < end;
+}
+
+// ── AFK Mode Presets ──────────────────────────────────────────
+const AFK_PRESETS = {
+  // Casual: Run every 2 hours, low priority commands only
+  casual: {
+    commands: ['beg', 'search', 'daily', 'weekly', 'monthly'],
+    deposit_threshold: 50000,
+    sell_threshold: 0.9,
+    gamble_enabled: false,
+  },
+
+  // Grinder: Run all commands ASAP, maximize earnings
+  grinder: {
+    commands: 'all',
+    deposit_threshold: 100000,
+    sell_threshold: 0.8,
+    gamble_enabled: true,
+    gamble_limit: 20,
+  },
+
+  // Smart: AI-driven prioritization based on cooldowns
+  smart: {
+    commands: 'all',
+    deposit_threshold: 100000,
+    sell_threshold: 0.85,
+    gamble_enabled: true,
+    gamble_limit: 10,
+    use_priority_queue: true,
+  },
+
+  // Sleep: Only run long cooldown commands
+  sleep: {
+    commands: ['daily', 'weekly', 'monthly', 'work'],
+    deposit_threshold: 200000,
+    sell_threshold: 0.95,
+    gamble_enabled: false,
+  },
+
+  // Safe: No gambling, conservative play
+  safe: {
+    commands: 'all',
+    deposit_threshold: 100000,
+    sell_threshold: 0.85,
+    gamble_enabled: false,
+  },
+};
+
+// ── Apply Preset ──────────────────────────────────────────────
+/**
+ * Apply an AFK preset to an account.
+ */
+function applyPreset(account, presetName) {
+  const preset = AFK_PRESETS[presetName];
+  if (!preset) return false;
+
+  // Set commands
+  if (preset.commands === 'all') {
+    // Enable all commands
+    account.cmd_beg = true;
+    account.cmd_search = true;
+    account.cmd_crime = true;
+    account.cmd_hunt = true;
+    account.cmd_dig = true;
+    account.cmd_fish = true;
+    account.cmd_farm = true;
+    account.cmd_work = true;
+    account.cmd_stream = true;
+    account.cmd_daily = true;
+    account.cmd_weekly = true;
+    account.cmd_monthly = true;
+    account.cmd_highlow = true;
+    account.cmd_blackjack = preset.gamble_enabled;
+    account.cmd_roulette = preset.gamble_enabled;
+    account.cmd_slots = preset.gamble_enabled;
+    account.cmd_snakeeyes = preset.gamble_enabled;
+    account.cmd_trivia = true;
+    account.cmd_scratch = true;
+    account.cmd_adventure = true;
+    account.cmd_postmemes = true;
+    account.cmd_tidy = true;
+    account.cmd_use = true;
+    account.cmd_deposit = true;
+  } else {
+    // Enable only specified commands
+    const cmdKeys = {
+      beg: 'cmd_beg', search: 'cmd_search', crime: 'cmd_crime',
+      hunt: 'cmd_hunt', dig: 'cmd_dig', fish: 'cmd_fish',
+      farm: 'cmd_farm', work: 'cmd_work', stream: 'cmd_stream',
+      daily: 'cmd_daily', weekly: 'cmd_weekly', monthly: 'cmd_monthly',
+      hl: 'cmd_highlow', blackjack: 'cmd_blackjack', roulette: 'cmd_roulette',
+      slots: 'cmd_slots', snakeeyes: 'cmd_snakeeyes', trivia: 'cmd_trivia',
+      scratch: 'cmd_scratch', adventure: 'cmd_adventure',
+      postmemes: 'cmd_postmemes', tidy: 'cmd_tidy',
+      use: 'cmd_use', deposit: 'cmd_deposit',
+    };
+
+    // Disable all first
+    Object.values(cmdKeys).forEach(key => { account[key] = false; });
+
+    // Enable selected
+    preset.commands.forEach(cmd => {
+      const key = cmdKeys[cmd];
+      if (key) account[key] = true;
+    });
+  }
+
+  // Set thresholds
+  account.afk_deposit_threshold = preset.deposit_threshold;
+  account.afk_sell_threshold = preset.sell_threshold;
+  account.afk_gamble_enabled = preset.gamble_enabled;
+  account.afk_gamble_limit = preset.gamble_limit || 10;
+
+  return true;
+}
+
+// ── Exports ───────────────────────────────────────────────────
+module.exports = {
+  // Main functions
+  buildSmartQueue,
+  calculateCommandPriority,
+  shouldAutoDeposit,
+  shouldAutoSell,
+  getItemsToSell,
+  isSleepMode,
+  applyPreset,
+
+  // Getters
+  getEnabledCommands,
+
+  // Constants
+  AFK_CONFIG,
+  AFK_PRESETS,
+};

package/lib/antiDetect.js

@@ -34,6 +34,16 @@ const CONFIG = Object.freeze({
 
   // Pattern randomization
   PATTERN_RESET_CHANCE: 0.2,   // 20% chance to reset timing pattern
+
+  // Session-based behavior (humans get tired/faster over time)
+  SESSION_TIRE_FACTOR: 0.001,  // Get 0.1% slower per action
+  SESSION_MAX_TIRED: 0.15,     // Max 15% slower when tired
+
+  // Time-of-day awareness (humans are slower at night)
+  TIME_DAWN: { hour: 6, multiplier: 0.9 },    // Faster in morning
+  TIME_DAY: { hour: 12, multiplier: 1.0 },    // Normal during day
+  TIME_EVENING: { hour: 18, multiplier: 1.05 }, // Slightly slower evening
+  TIME_NIGHT: { hour: 23, multiplier: 1.15 },  // Slower at night
 });
 
 // ── Session State ─────────────────────────────────────────────
@@ -42,7 +52,9 @@ const sessionState = {
   lastActionTime: 0,
   currentDrift: 0,
   patternSeed: Math.random(),
-  activityLevel: 1.0,  // Starts neutral
+  activityLevel: 1.0,      // Starts neutral
+  tiredness: 0,            // Increases with actions
+  sessionStart: Date.now(),
 };
 
 // ── Seeded Random for Reproducible Patterns ──────────────────
@@ -51,6 +63,30 @@ function seededRandom(seed) {
   return x - Math.floor(x);
 }
 
+// ── Time-of-Day Multiplier ────────────────────────────────────
+/**
+ * Get delay multiplier based on current hour.
+ * Humans are slower at night, faster in the morning.
+ */
+function getTimeOfDayMultiplier() {
+  const hour = new Date().getHours();
+
+  // Simple interpolation between time periods
+  if (hour >= 6 && hour < 12) {
+    // Morning: faster
+    return 0.9 + (hour - 6) * 0.016;  // 0.9 → 1.0
+  } else if (hour >= 12 && hour < 18) {
+    // Day: normal
+    return 1.0 + (hour - 12) * 0.008;  // 1.0 → 1.05
+  } else if (hour >= 18 && hour < 23) {
+    // Evening: slightly slower
+    return 1.05 + (hour - 18) * 0.02;  // 1.05 → 1.15
+  } else {
+    // Night: slowest
+    return 1.15;
+  }
+}
+
 // ── Adaptive Delay Calculation ────────────────────────────────
 /**
  * Calculate human-like delay based on context.
@@ -101,6 +137,14 @@ async function calcAdaptiveDelay(options = {}) {
   );
   multiplier *= (1 + sessionState.currentDrift);
 
+  // Apply tiredness factor (humans get slower over long sessions)
+  sessionState.tiredness += CONFIG.SESSION_TIRE_FACTOR;
+  sessionState.tiredness = Math.min(CONFIG.SESSION_MAX_TIRED, sessionState.tiredness);
+  multiplier *= (1 + sessionState.tiredness);
+
+  // Apply time-of-day multiplier
+  multiplier *= getTimeOfDayMultiplier();
+
   // Pattern reset for unpredictability
   if (Math.random() < CONFIG.PATTERN_RESET_CHANCE) {
     sessionState.patternSeed = Math.random();
@@ -146,14 +190,20 @@ function resetSession() {
   sessionState.currentDrift = 0;
   sessionState.patternSeed = Math.random();
   sessionState.activityLevel = 1.0;
+  sessionState.tiredness = 0;
+  sessionState.sessionStart = Date.now();
 }
 
 // ── Get Session Stats (for debugging) ─────────────────────────
 function getSessionStats() {
+  const elapsed = Date.now() - sessionState.sessionStart;
   return {
     actionCount: sessionState.actionCount,
     currentDrift: sessionState.currentDrift,
+    tiredness: sessionState.tiredness,
     timeSinceLast: Date.now() - sessionState.lastActionTime,
+    sessionDuration: Math.round(elapsed / 60000), // minutes
+    timeMultiplier: getTimeOfDayMultiplier(),
   };
 }
 

package/lib/grinder.js

@@ -605,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;
@@ -1139,7 +1184,9 @@ class AccountWorker {
             accountId: this.account.id,
             redis,
             onPageProgress: ({ page, total }) => {
-              this.log('info', `Inventory pages: ${page}/${total}`);
+              // Minimal progress update on same line
+              const erase = '\x1b[2K\r';
+              process.stdout.write(`${erase}${this.color}[inv] ${page}/${total}${c.reset}`);
             },
           });
 
@@ -1147,6 +1194,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`, {
@@ -1549,7 +1598,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;
@@ -1596,8 +1646,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);
 
@@ -2346,8 +2397,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();
       });
 
@@ -2472,47 +2523,62 @@ 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}`);
+  // Phase 2: Run inventory on ALL accounts in parallel (must complete before grinding)
+  log('info', `${c.dim}Checking inventory for ${workers.length} accounts...${c.reset}`);
+
+  // Parallel inventory checks with single-line progress
   let invDone = 0;
   let invFailed = 0;
+  const total = workers.length;
+
   await Promise.all(workers.map(async (w, 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}`);
+    const label = w?.username || w?.account?.label || 'account';
+
+    // Update progress on same line
+    const progress = `[inv] ${invDone + invFailed + 1}/${total}: ${label}`;
+    process.stdout.write(`\x1b[2K\r${c.dim}${progress}${c.reset}`);
+
     try {
       const invRes = await w.checkInventory({
         force: true,
-        startupProgress: { current: i + 1, total: workers.length },
+        startupProgress: { current: i + 1, total },
         requireComplete: true,
         maxAttempts: 3,
       });
@@ -2521,10 +2587,12 @@ 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}`);
   }));
 
+  // Final newline and summary
+  process.stdout.write('\n');
+  log('success', `Inventory: ${invDone}/${total} done${invFailed > 0 ? `, ${c.yellow}${invFailed} failed${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}`);
     return;
@@ -2541,6 +2609,8 @@ async function start(apiKey, apiUrl) {
   startTime = Date.now();
   dashboardStarted = true;
   setDashboardActive(true);
+  // Setup keyboard shortcuts
+  setupKeyboardShortcuts();
   // Clear entire screen so startup logs don't create ghost bars
   process.stdout.write('\x1b[2J\x1b[H');
   process.stdout.write(c.hide);
@@ -2684,4 +2754,76 @@ async function start(apiKey, apiUrl) {
   });
 }
 
-module.exports = { start };
+// ══════════════════════════════════════════════════════════════
+// ═  Keyboard Shortcuts (Quality of Life)
+// ══════════════════════════════════════════════════════════════
+// Single-key shortcuts for common actions
+function setupKeyboardShortcuts() {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    console.log(`\n  ${c.dim}Keyboard shortcuts: ${c.reset}p=pause/resume all ${c.dim}·${c.reset} r=resume all ${c.dim}·${c.reset} s=status ${c.dim}·${c.reset} q=quit ${c.dim}·${c.reset} 1-9=toggle account`);
+
+    process.stdin.on('data', (key) => {
+      const k = key.toString().toLowerCase();
+
+      // Ctrl+C or q = quit
+      if (k === '\u0003' || k === 'q') {
+        console.log(`\n\n  ${c.yellow}Shutting down gracefully...${c.reset}`);
+        process.emit('SIGINT');
+        return;
+      }
+
+      // p = pause all accounts
+      if (k === 'p') {
+        let paused = 0;
+        workers.forEach(w => { if (w.running && !w.paused) { w.paused = true; paused++; } });
+        console.log(`\n  ${c.yellow}Paused ${paused} accounts${c.reset}`);
+        return;
+      }
+
+      // r = resume all accounts
+      if (k === 'r') {
+        let resumed = 0;
+        workers.forEach(w => { if (w.paused) { w.paused = false; resumed++; } });
+        console.log(`\n  ${c.green}Resumed ${resumed} accounts${c.reset}`);
+        return;
+      }
+
+      // s = show status summary
+      if (k === 's') {
+        console.log(`\n  ${c.bold}Status Summary:${c.reset}`);
+        const active = workers.filter(w => w.running && !w.paused).length;
+        const paused = workers.filter(w => w.paused).length;
+        const offline = workers.filter(w => !w.running).length;
+        const recovering = workers.filter(w => w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()).length;
+        console.log(`  ${c.green}● ${active} active${c.reset}  ${c.yellow}⏸ ${paused} paused${c.reset}  ${c.red}○ ${offline} offline${c.reset}  ${c.yellow}↻ ${recovering} recovering${c.reset}`);
+        console.log(`  ${c.dim}Total earnings: ⏣ ${workers.reduce((s, w) => s + (w.stats.coins || 0), 0).toLocaleString()}${c.reset}`);
+        return;
+      }
+
+      // 1-9 = toggle specific account (for small account counts)
+      const num = parseInt(k, 10);
+      if (num >= 1 && num <= 9 && workers[num - 1]) {
+        const w = workers[num - 1];
+        w.paused = !w.paused;
+        console.log(`\n  ${w.color}${w.username}${c.reset} ${w.paused ? c.yellow + 'paused' : c.green + 'resumed'}${c.reset}`);
+        return;
+      }
+
+      // ? = show help
+      if (k === '?' || k === 'h') {
+        console.log(`\n  ${c.bold}Keyboard Shortcuts:${c.reset}`);
+        console.log(`  ${c.white}p${c.reset} Pause all accounts`);
+        console.log(`  ${c.white}r${c.reset} Resume all accounts`);
+        console.log(`  ${c.white}s${c.reset} Show status summary`);
+        console.log(`  ${c.white}q${c.reset} Quit gracefully`);
+        console.log(`  ${c.white}1-9${c.reset} Toggle account N`);
+        console.log(`  ${c.white}?${c.reset} Show this help`);
+        return;
+      }
+    });
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dankgrinder",
-  "version": "5.25.0",
+  "version": "5.281.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"
@@ -19,6 +19,10 @@
   ],
   "author": "DankGrinder",
   "license": "MIT",
+  "scripts": {
+    "start": "node bin/dankgrinder.js",
+    "test": "node --test test/**/*.test.js"
+  },
   "dependencies": {
     "debug": "^4.4.0",
     "discord.js-selfbot-v13": "3.5.0",