dankgrinder 1.0.1 → 4.0.0

package/lib/grinder.js

@@ -1,35 +1,175 @@
 const { Client } = require('discord.js-selfbot-v13');
+const Redis = require('ioredis');
 
+// ── Terminal Colors & ANSI ───────────────────────────────────
 const c = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  magenta: '\x1b[35m',
-  dim: '\x1b[2m',
-  bold: '\x1b[1m',
-  white: '\x1b[37m',
-  blue: '\x1b[34m',
+  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`,
+  hide: '\x1b[?25l',
+  show: '\x1b[?25h',
+  saveCursor: '\x1b7',
+  restoreCursor: '\x1b8',
 };
 
-const ACCOUNT_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+const WORKER_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+const DANK_MEMER_ID = '270904126974590976';
+
+// ── Safe options for search/crime ──────────────────────────
+const SAFE_SEARCH_LOCATIONS = [
+  'sofa', 'mailbox', 'dog', 'car', 'dresser', 'laundromat', 'bed',
+  'couch', 'pantry', 'fridge', 'kitchen', 'bathroom', 'attic',
+  'closet', 'shoe', 'vacuum', 'toilet', 'sink', 'shower',
+  'tree', 'grass', 'bushes', 'garden', 'park', 'backyard',
+];
+
+const SAFE_CRIME_OPTIONS = [
+  'tax evasion', 'fraud', 'cybercrime', 'hacking', 'identity theft',
+  'money laundering', 'tax fraud', 'insurance fraud', 'scam',
+];
 
 let API_KEY = '';
 let API_URL = '';
+let REDIS_URL = process.env.REDIS_URL || 'redis://default:qXcezFjDHlCDtakRUZJmvsEzHoBgdLHi@shortline.proxy.rlwy.net:32007';
+let redis = null;
 const workers = [];
 
+function initRedis() {
+  if (!redis) {
+    try {
+      redis = new Redis(REDIS_URL, { maxRetriesPerRequest: null, lazyConnect: true });
+      redis.connect().catch(() => {});
+    } catch (e) {
+      console.error('Redis connection failed', e);
+    }
+  }
+}
+
+// ── Live Dashboard State ─────────────────────────────────────
+let dashboardLines = 0;
+let dashboardStarted = false;
+let totalBalance = 0;
+let totalCoins = 0;
+let totalCommands = 0;
+let startTime = Date.now();
+const recentLogs = []; // Ring buffer of last N log entries
+const MAX_LOGS = 6;
+
+const BANNER = `
+${c.magenta}${c.bold}    ██████╗  █████╗ ███╗   ██╗██╗  ██╗${c.reset}
+${c.magenta}${c.bold}    ██╔══██╗██╔══██╗████╗  ██║██║ ██╔╝${c.reset}
+${c.magenta}${c.bold}    ██║  ██║███████║██╔██╗ ██║█████╔╝ ${c.reset}
+${c.magenta}${c.bold}    ██║  ██║██╔══██║██║╚██╗██║██╔═██╗ ${c.reset}
+${c.magenta}${c.bold}    ██████╔╝██║  ██║██║ ╚████║██║  ██╗${c.reset}
+${c.magenta}${c.bold}    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝${c.reset}
+${c.cyan}${c.bold}     ██████╗ ██████╗ ██╗███╗   ██╗██████╗ ███████╗██████╗${c.reset}
+${c.cyan}${c.bold}    ██╔════╝ ██╔══██╗██║████╗  ██║██╔══██╗██╔════╝██╔══██╗${c.reset}
+${c.cyan}${c.bold}    ██║  ███╗██████╔╝██║██╔██╗ ██║██║  ██║█████╗  ██████╔╝${c.reset}
+${c.cyan}${c.bold}    ██║   ██║██╔══██╗██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗${c.reset}
+${c.cyan}${c.bold}    ╚██████╔╝██║  ██║██║██║ ╚████║██████╔╝███████╗██║  ██║${c.reset}
+${c.cyan}${c.bold}     ╚═════╝ ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝${c.reset}
+`;
+
+function formatUptime() {
+  const s = Math.floor((Date.now() - startTime) / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  return `${h}h ${m}m ${sec}s`;
+}
+
+function formatCoins(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toLocaleString();
+}
+
+function renderDashboard() {
+  if (!dashboardStarted || workers.length === 0) return;
+
+  // Compute totals
+  totalBalance = 0; totalCoins = 0; totalCommands = 0;
+  for (const w of workers) {
+    totalBalance += w.stats.balance || 0;
+    totalCoins += w.stats.coins || 0;
+    totalCommands += w.stats.commands || 0;
+  }
+
+  const lines = [];
+  const width = Math.min(process.stdout.columns || 80, 90);
+  const sep = c.dim + '─'.repeat(width) + c.reset;
+
+  // Header bar
+  lines.push(sep);
+  lines.push(
+    `  ${c.yellow}${c.bold}⏣ ${formatCoins(totalBalance)}${c.reset}` +
+    `  ${c.dim}│${c.reset}  ${c.green}+⏣ ${formatCoins(totalCoins)}${c.reset} earned` +
+    `  ${c.dim}│${c.reset}  ${c.white}${totalCommands}${c.reset} cmds` +
+    `  ${c.dim}│${c.reset}  ${c.dim}⏱ ${formatUptime()}${c.reset}`
+  );
+  lines.push(sep);
+
+  // Per-account rows
+  for (const w of workers) {
+    const status = w.lastStatus || 'idle';
+    const statusColor = w.running ? (w.busy ? c.yellow : c.green) : c.red;
+    const dot = w.running ? (w.busy ? '◉' : '●') : '○';
+    const bal = w.stats.balance > 0 ? `${c.dim}⏣${c.reset} ${c.white}${formatCoins(w.stats.balance)}${c.reset}` : `${c.dim}⏣ ---${c.reset}`;
+    const earned = w.stats.coins > 0 ? `${c.green}+${formatCoins(w.stats.coins)}${c.reset}` : `${c.dim}+0${c.reset}`;
+    const cmds = `${c.dim}${w.stats.commands}cmd${c.reset}`;
+    const name = `${w.color}${c.bold}${(w.username || 'Account').substring(0, 14).padEnd(14)}${c.reset}`;
+
+    lines.push(
+      `  ${statusColor}${dot}${c.reset} ${name} ${bal}  ${earned}  ${cmds}  ${c.dim}→${c.reset} ${status.substring(0, 35)}`
+    );
+  }
+  lines.push(sep);
+
+  // Scrolling log section (last 6 events)
+  for (const entry of recentLogs) {
+    lines.push(`  ${c.dim}${entry}${c.reset}`);
+  }
+  if (recentLogs.length > 0) lines.push(sep);
+
+  // Move cursor up to overwrite previous dashboard
+  if (dashboardLines > 0) {
+    process.stdout.write(c.cursorUp(dashboardLines));
+  }
+  for (const line of lines) {
+    process.stdout.write(c.clearLine + '\r' + line + '\n');
+  }
+  dashboardLines = lines.length;
+}
+
 function log(type, msg, label) {
-  const time = new Date().toLocaleTimeString();
-  const prefix = {
-    info: `${c.cyan}ℹ${c.reset}`,
-    success: `${c.green}✓${c.reset}`,
-    error: `${c.red}✗${c.reset}`,
-    warn: `${c.yellow}⚠${c.reset}`,
-    cmd: `${c.magenta}▸${c.reset}`,
+  const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  const icons = {
+    info: `│`, success: `✓`, error: `✗`, warn: `!`,
+    cmd: `▸`, coin: `$`, buy: `♦`, bal: `◈`, debug: `⊙`,
   };
-  const tag = label ? `${c.bold}[${label}]${c.reset} ` : '';
-  console.log(`  ${c.dim}${time}${c.reset}  ${prefix[type] || prefix.info}  ${tag}${msg}`);
+  const tag = label ? `${label} ` : '';
+  const stripped = msg.replace(/\x1b\[[0-9;]*m/g, ''); // Strip ANSI for log buffer
+  if (dashboardStarted) {
+    // Add to scrolling log buffer
+    recentLogs.push(`${time}  ${icons[type] || '│'}  ${tag}${stripped}`.substring(0, 80));
+    while (recentLogs.length > MAX_LOGS) recentLogs.shift();
+    renderDashboard();
+  } else {
+    const colorIcons = {
+      info: `${c.cyan}│${c.reset}`, success: `${c.green}✓${c.reset}`,
+      error: `${c.red}✗${c.reset}`, warn: `${c.yellow}!${c.reset}`,
+      cmd: `${c.magenta}▸${c.reset}`, coin: `${c.yellow}$${c.reset}`,
+      buy: `${c.blue}♦${c.reset}`, bal: `${c.green}◈${c.reset}`,
+      debug: `${c.dim}⊙${c.reset}`,
+    };
+    console.log(`  ${c.dim}${time}${c.reset}  ${colorIcons[type] || colorIcons.info}  ${tag}${msg}`);
+  }
 }
 
 async function fetchConfig() {
@@ -38,178 +178,778 @@ async function fetchConfig() {
       headers: { Authorization: `Bearer ${API_KEY}` },
     });
     const data = await res.json();
-    if (data.error) {
-      log('error', `Config fetch failed: ${data.error}`);
-      return null;
-    }
+    if (data.error) { log('error', `Config fetch failed: ${data.error}`); return null; }
     return data;
-  } catch (err) {
-    log('error', `Cannot reach API: ${err.message}`);
-    return null;
-  }
+  } catch (err) { log('error', `Cannot reach API: ${err.message}`); return null; }
 }
 
-async function sendLog(command, response, status) {
+async function sendLog(accountName, command, response, status) {
   try {
     await fetch(`${API_URL}/api/grinder/log`, {
       method: 'POST',
-      headers: {
-        Authorization: `Bearer ${API_KEY}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ command, response, status }),
+      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ account_name: accountName, command, response, status }),
     });
-  } catch {
-    // silent fail for logging
-  }
+  } catch { /* silent */ }
 }
 
 function randomDelay(min, max) {
-  const ms = (Math.random() * (max - min) + min) * 1000;
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((r) => setTimeout(r, (Math.random() * (max - min) + min) * 1000));
+}
+function humanDelay(min = 300, max = 800) {
+  return new Promise((r) => setTimeout(r, min + Math.random() * (max - min)));
+}
+function safeParseJSON(str, fallback = []) {
+  try { return JSON.parse(str || '[]'); } catch { return fallback; }
 }
 
-function humanDelay() {
-  return new Promise((resolve) => setTimeout(resolve, 200 + Math.random() * 600));
+// ── Coin Parser ──────────────────────────────────────────────
+function parseCoins(text) {
+  if (!text) return 0;
+  const patterns = [
+    /[⏣💰]\s*[\d,]+/g,
+    /\+\s*[\d,]+\s*coins?/gi,
+    /\*\*([\d,]+)\*\*/g,
+    /take\s*[⏣💰]?\s*([\d,]+)/gi,
+    /earned\s*[⏣💰]?\s*([\d,]+)/gi,
+    /found\s*[⏣💰]?\s*([\d,]+)/gi,
+    /got\s*[⏣💰]?\s*([\d,]+)/gi,
+    /won\s*[⏣💰]?\s*([\d,]+)/gi,
+    /gained\s*[⏣💰]?\s*([\d,]+)/gi,
+  ];
+  let total = 0;
+  for (const pat of patterns) {
+    const matches = text.match(pat);
+    if (matches) {
+      for (const m of matches) {
+        const numStr = m.replace(/[^\d]/g, '');
+        if (numStr) total = Math.max(total, parseInt(numStr));
+      }
+    }
+  }
+  return total;
 }
 
-function safeParseJSON(str, fallback) {
-  try {
-    return JSON.parse(str || '[]');
-  } catch {
-    return fallback;
+function getFullText(msg) {
+  let text = msg.content || '';
+  if (msg.embeds) {
+    for (const embed of msg.embeds) {
+      if (embed.title) text += ' ' + embed.title;
+      if (embed.description) text += ' ' + embed.description;
+      if (embed.fields) {
+        for (const f of embed.fields) {
+          text += ' ' + (f.name || '') + ' ' + (f.value || '');
+        }
+      }
+      if (embed.footer?.text) text += ' ' + embed.footer.text;
+    }
   }
+  return text;
 }
 
-// ── Worker: one per Discord account ──────────────────────────────
+function getAllButtons(msg) {
+  const buttons = [];
+  if (msg.components) {
+    for (const row of msg.components) {
+      if (row.components) {
+        for (const comp of row.components) {
+          if (comp.type === 2) buttons.push(comp);
+        }
+      }
+    }
+  }
+  return buttons;
+}
+
+function getAllSelectMenus(msg) {
+  const menus = [];
+  if (msg.components) {
+    for (const row of msg.components) {
+      if (row.components) {
+        for (const comp of row.components) {
+          if (comp.type === 3) menus.push(comp);
+        }
+      }
+    }
+  }
+  return menus;
+}
+
+function pickSafeButton(buttons, safeList) {
+  if (!buttons || buttons.length === 0) return null;
+  if (safeList && safeList.length > 0) {
+    for (const btn of buttons) {
+      const label = (btn.label || '').toLowerCase();
+      if (safeList.some((s) => label.includes(s.toLowerCase()))) return btn;
+    }
+  }
+  for (const btn of buttons) {
+    const label = (btn.label || '').toLowerCase();
+    if (SAFE_SEARCH_LOCATIONS.some((s) => label.includes(s))) return btn;
+    if (SAFE_CRIME_OPTIONS.some((s) => label.includes(s))) return btn;
+  }
+  const clickable = buttons.filter((b) => !b.disabled);
+  return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+}
+
+// Debug: log all embed/component data for a message
+function debugMessage(msg, label) {
+  if (!msg) return;
+  const text = getFullText(msg);
+  log('debug', `${label || 'MSG'}: ${c.dim}${text.substring(0, 120)}${c.reset}`);
+  const buttons = getAllButtons(msg);
+  if (buttons.length > 0) {
+    log('debug', `  Buttons: ${buttons.map(b => `[${b.label || b.emoji?.name || '?'}${b.disabled ? ' (disabled)' : ''}]`).join(' ')}`);
+  }
+  const menus = getAllSelectMenus(msg);
+  if (menus.length > 0) {
+    for (const m of menus) {
+      log('debug', `  SelectMenu: ${(m.options || []).map(o => o.label).join(', ')}`);
+    }
+  }
+}
+
+// ══════════════════════════════════════════════════════════════
+// ═  Worker: one per Discord account
+// ══════════════════════════════════════════════════════════════
 
 class AccountWorker {
   constructor(account, idx) {
     this.account = account;
-    this.label = account.label || `Account ${idx + 1}`;
-    this.color = ACCOUNT_COLORS[idx % ACCOUNT_COLORS.length];
+    this.idx = idx;
+    this.color = WORKER_COLORS[idx % WORKER_COLORS.length];
     this.client = new Client();
     this.channel = null;
     this.running = false;
+    this.busy = false;
+    this.username = account.label || `Account ${idx + 1}`;
+    this.tickTimeout = null;
+    this.stats = { coins: 0, commands: 0, successes: 0, errors: 0, balance: 0 };
+    this.lastRunTime = {};
+    this.cycleCount = 0;
+    this.lastCommandRun = 0;
   }
 
-  log(type, msg) {
-    log(type, msg, `${this.color}${this.label}${c.reset}`);
+  get tag() { return `${this.color}${c.bold}${this.username}${c.reset}`; }
+  log(type, msg) { log(type, msg, this.tag); }
+
+  // Update the live dashboard status for this worker
+  setStatus(text) {
+    this.lastStatus = text;
+    renderDashboard();
   }
 
   waitForDankMemer(timeout = 15000) {
     return new Promise((resolve) => {
       const timer = setTimeout(() => {
         this.client.removeListener('messageCreate', handler);
+        this.client.removeListener('messageUpdate', updateHandler);
         resolve(null);
       }, timeout);
-
       const self = this;
       function handler(msg) {
-        if (msg.author.id === '270904126974590976' && msg.channel.id === self.channel.id) {
+        if (msg.author.id === DANK_MEMER_ID && msg.channel.id === self.channel.id) {
           clearTimeout(timer);
           self.client.removeListener('messageCreate', handler);
+          self.client.removeListener('messageUpdate', updateHandler);
           resolve(msg);
         }
       }
-
+      function updateHandler(oldMsg, newMsg) {
+        if (newMsg.author?.id === DANK_MEMER_ID && newMsg.channel?.id === self.channel.id) {
+          clearTimeout(timer);
+          self.client.removeListener('messageCreate', handler);
+          self.client.removeListener('messageUpdate', updateHandler);
+          resolve(newMsg);
+        }
+      }
       this.client.on('messageCreate', handler);
+      this.client.on('messageUpdate', updateHandler);
     });
   }
 
-  async handleInteraction(msg) {
-    if (!msg) return null;
-
-    if (msg.components && msg.components.length > 0) {
-      for (const row of msg.components) {
-        if (row.components) {
-          for (const component of row.components) {
-            if (component.type === 2) {
-              const label = component.label?.toLowerCase() || '';
-              const searchAnswers = safeParseJSON(this.account.search_answers, []);
-              const crimeAnswers = safeParseJSON(this.account.crime_answers, []);
-              const allSafe = [...searchAnswers, ...crimeAnswers];
-
-              if (allSafe.length > 0) {
-                const match = allSafe.find((a) => label.includes(a.toLowerCase()));
-                if (match) {
-                  await humanDelay();
-                  try {
-                    await component.click();
-                    return `Clicked: ${label}`;
-                  } catch {
-                    return null;
-                  }
-                }
-              }
-            }
+  // Wait specifically for message edits (Dank Memer often edits messages)
+  waitForMessageUpdate(msgId, timeout = 10000) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.client.removeListener('messageUpdate', handler);
+        resolve(null);
+      }, timeout);
+      const self = this;
+      function handler(oldMsg, newMsg) {
+        if (newMsg.id === msgId && newMsg.channel?.id === self.channel.id) {
+          clearTimeout(timer);
+          self.client.removeListener('messageUpdate', handler);
+          resolve(newMsg);
+        }
+      }
+      this.client.on('messageUpdate', handler);
+    });
+  }
+
+  // ── Needs Item Detection ────────────────────────────────────
+  needsItem(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("don't have a shovel") || (lower.includes('need') && lower.includes('shovel')) || lower.includes('you need a shovel'))
+      return 'shovel';
+    if (lower.includes("don't have a fishing") || lower.includes('need a fishing') || lower.includes('you need a fishing pole'))
+      return 'fishing pole';
+    if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle') || lower.includes('you need a rifle'))
+      return 'hunting rifle';
+    return null;
+  }
+
+  async buyItem(itemName, quantity = 10) {
+    const MAX_RETRIES = 3;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      this.log('buy', `Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset}... (attempt ${attempt}/${MAX_RETRIES})`);
+      if (this.account.use_slash) {
+        await this.channel.sendSlash(DANK_MEMER_ID, 'shop', 'view').catch(() => this.channel.send('pls shop view'));
+      } else {
+        await this.channel.send('pls shop view');
+      }
+      let response = await this.waitForDankMemer(10000);
+      if (!response) {
+        this.log('warn', 'No response to shop view command.');
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      const responseText = getFullText(response).toLowerCase();
+      const hasShopComponents = (response.components || []).some(row =>
+        (row.components || []).some(comp => comp.type === 3 || (comp.type === 2 && comp.label && comp.label.toLowerCase().includes('buy')))
+      );
+
+      if (!hasShopComponents && (responseText.includes('lucky') || responseText.includes('event') || responseText.includes('for the rest of the day'))) {
+        this.log('warn', 'Got event response instead of shop. Retrying...');
+        await humanDelay(3000, 5000);
+        continue;
+      }
+      if (!hasShopComponents && responseText.includes('shop')) {
+        const shopUI = await this.waitForDankMemer(8000);
+        if (shopUI) response = shopUI;
+      }
+
+      // Navigate to Coin Shop
+      let coinShopMenuId = null;
+      let coinShopOption = null;
+      for (const row of response.components || []) {
+        for (const comp of row.components || []) {
+          if (comp.type === 3) {
+            const opt = (comp.options || []).find(o => o.label && o.label.includes('Coin Shop'));
+            if (opt) { coinShopMenuId = comp.customId; coinShopOption = opt; }
           }
+        }
+      }
 
-          const buttons = row.components.filter((comp) => comp.type === 2 && !comp.disabled);
-          if (buttons.length > 0) {
-            const btn = buttons[Math.floor(Math.random() * buttons.length)];
-            await humanDelay();
-            try {
-              await btn.click();
-              return `Clicked: ${btn.label || 'button'}`;
-            } catch {
-              return null;
-            }
+      if (coinShopMenuId && coinShopOption) {
+        this.log('buy', 'Navigating to Coin Shop...');
+        try {
+          await response.selectMenu(coinShopMenuId, [coinShopOption.value]);
+          const updatedMsg = await this.waitForDankMemer(8000);
+          if (updatedMsg) response = updatedMsg;
+        } catch (e) {
+          this.log('error', `Failed to open Coin Shop: ${e.message}`);
+        }
+      }
+      await humanDelay(1000, 2000);
+
+      // Find Buy button
+      let buyBtn = null;
+      const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '');
+      for (const row of response.components || []) {
+        for (const comp of row.components || []) {
+          if (comp.type === 2 && comp.label && comp.label.toLowerCase().includes(searchName)) {
+            buyBtn = comp; break;
           }
         }
+        if (buyBtn) break;
+      }
+
+      if (!buyBtn) {
+        this.log('warn', `Could not find Buy button for ${itemName} (attempt ${attempt})`);
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      this.log('buy', `Clicking Buy ${itemName}...`);
+      try { await buyBtn.click(); } catch (e) {
+        this.log('error', `Buy click failed: ${e.message}`);
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      // Handle Modal
+      const modal = await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), 8000);
+        const handler = (m) => {
+          clearTimeout(timer);
+          this.client.removeListener('interactionModalCreate', handler);
+          resolve(m);
+        };
+        this.client.on('interactionModalCreate', handler);
+      });
+
+      if (modal) {
+        this.log('buy', `Submitting quantity ${c.bold}${quantity}${c.reset} in modal...`);
+        try {
+          const quantityInputId = modal.components[0].components[0].customId;
+          await fetch('https://discord.com/api/v9/interactions', {
+            method: 'POST',
+            headers: { 'Authorization': this.client.token, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              type: 5, application_id: modal.applicationId,
+              channel_id: this.channel.id, guild_id: this.channel.guild?.id,
+              data: {
+                id: modal.id, custom_id: modal.customId,
+                components: [{ type: 1, components: [{ type: 4, custom_id: quantityInputId, value: String(quantity) }] }]
+              },
+              session_id: this.client.sessionId || "dummy_session",
+              nonce: Date.now().toString()
+            })
+          });
+        } catch (e) {
+          this.log('error', `Modal submit failed: ${e.message}`);
+          if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+          return false;
+        }
+      } else {
+        this.log('warn', 'No modal appeared after clicking buy.');
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+
+      const confirmMsg = await this.waitForDankMemer(8000);
+      if (confirmMsg) {
+        const text = getFullText(confirmMsg).toLowerCase();
+        if (text.includes('bought') || text.includes('purchased') || text.includes('success')) {
+          this.log('success', `Bought ${c.bold}${quantity}x ${itemName}${c.reset}!`);
+          return true;
+        }
+        if (text.includes('not enough') || text.includes("can't afford") || text.includes('insufficient')) {
+          this.log('warn', `Not enough coins to buy ${itemName}.`);
+          return false;
+        }
+      }
+      this.log('success', `Submitted purchase for ${quantity}x ${itemName}.`);
+      return true;
+    }
+    this.log('error', `Failed to buy ${itemName} after ${MAX_RETRIES} attempts.`);
+    return false;
+  }
+
+  // ── Check Balance ───────────────────────────────────────────
+  async checkBalance() {
+    const prefix = this.account.use_slash ? '/' : 'pls';
+    await this.channel.send(`${prefix} bal`);
+    const response = await this.waitForDankMemer(10000);
+    if (response) {
+      const text = getFullText(response);
+      const walletMatch = text.match(/wallet[:\s]*[⏣💰]?\s*([\d,]+)/i);
+      if (walletMatch) {
+        this.stats.balance = parseInt(walletMatch[1].replace(/,/g, ''));
+        this.log('bal', `Wallet: ${c.bold}${c.green}⏣ ${this.stats.balance.toLocaleString()}${c.reset}`);
+        try {
+          await fetch(`${API_URL}/api/grinder/status`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, balance: this.stats.balance }),
+          });
+        } catch { /* silent */ }
+      }
+    }
+  }
+
+  // ══════════════════════════════════════════════════════════════
+  // ═  COMMAND HANDLERS
+  // ══════════════════════════════════════════════════════════════
+
+  async handleSearch(response) {
+    if (!response) return null;
+    debugMessage(response, 'SEARCH');
+    const buttons = getAllButtons(response);
+    if (buttons.length === 0) return getFullText(response).substring(0, 80);
+    const userSafe = safeParseJSON(this.account.search_answers, []);
+    const btn = pickSafeButton(buttons, userSafe);
+    if (btn) {
+      await humanDelay();
+      try {
+        await btn.click();
+        const followUp = await this.waitForDankMemer(10000);
+        if (followUp) {
+          const text = getFullText(followUp);
+          const coins = parseCoins(text);
+          if (coins > 0) { this.stats.coins += coins; return `${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+          if (text.toLowerCase().includes('nothing')) return `${btn.label} → found nothing`;
+          return `${btn.label} → done`;
+        }
+        return `Clicked: ${btn.label}`;
+      } catch { return null; }
+    }
+    return 'No safe option found';
+  }
+
+  async handleCrime(response) {
+    if (!response) return null;
+    debugMessage(response, 'CRIME');
+    const buttons = getAllButtons(response);
+    if (buttons.length === 0) return getFullText(response).substring(0, 80);
+    const userSafe = safeParseJSON(this.account.crime_answers, []);
+    const btn = pickSafeButton(buttons, userSafe);
+    if (btn) {
+      await humanDelay();
+      try {
+        await btn.click();
+        const followUp = await this.waitForDankMemer(10000);
+        if (followUp) {
+          const text = getFullText(followUp);
+          const coins = parseCoins(text);
+          if (coins > 0) { this.stats.coins += coins; return `${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+          return `${btn.label} → done`;
+        }
+        return `Clicked: ${btn.label}`;
+      } catch { return null; }
+    }
+    return 'No safe option found';
+  }
+
+  async handleHighLow(response) {
+    if (!response) return null;
+    debugMessage(response, 'HIGHLOW');
+    const text = getFullText(response);
+    const match = text.match(/number.*?(\d+)/i) || text.match(/(\d+)/);
+    const buttons = getAllButtons(response);
+    if (match && buttons.length >= 2) {
+      const num = parseInt(match[1]);
+      await humanDelay();
+      let targetBtn;
+      if (num > 50) targetBtn = buttons.find((b) => (b.label || '').toLowerCase().includes('lower')) || buttons[1];
+      else if (num < 50) targetBtn = buttons.find((b) => (b.label || '').toLowerCase().includes('higher')) || buttons[0];
+      else {
+        const jackpot = buttons.find((b) => (b.label || '').toLowerCase().includes('jackpot'));
+        targetBtn = jackpot || buttons[Math.floor(Math.random() * 2)];
       }
+      try {
+        await targetBtn.click();
+        const followUp = await this.waitForDankMemer(10000);
+        if (followUp) {
+          const ftText = getFullText(followUp);
+          const coins = parseCoins(ftText);
+          if (coins > 0) { this.stats.coins += coins; return `${num} → ${targetBtn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+          const moreButtons = getAllButtons(followUp);
+          if (moreButtons.length >= 2) return await this.handleHighLow(followUp);
+          return `${num} → ${targetBtn.label}`;
+        }
+        return `${num} → ${targetBtn.label}`;
+      } catch { return null; }
     }
+    if (buttons.length > 0) {
+      const btn = buttons[Math.floor(Math.random() * buttons.length)];
+      await humanDelay();
+      try { await btn.click(); } catch {}
+      return `Clicked: ${btn.label || 'button'}`;
+    }
+    return null;
+  }
 
-    return msg.content?.substring(0, 100) || 'Response received';
+  async handleScratch(response) {
+    if (!response) return null;
+    debugMessage(response, 'SCRATCH');
+    const buttons = getAllButtons(response);
+    if (buttons.length === 0) {
+      const text = getFullText(response);
+      const coins = parseCoins(text);
+      if (coins > 0) { this.stats.coins += coins; return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+      return text.substring(0, 60) || 'done';
+    }
+    let lastResponse = response;
+    for (let i = 0; i < Math.min(buttons.length, 9); i++) {
+      const btn = buttons[i];
+      if (btn && !btn.disabled) {
+        await humanDelay(300, 700);
+        try {
+          await btn.click();
+          const followUp = await this.waitForDankMemer(5000);
+          if (followUp) lastResponse = followUp;
+        } catch { break; }
+      }
+    }
+    const finalText = getFullText(lastResponse);
+    const coins = parseCoins(finalText);
+    if (coins > 0) { this.stats.coins += coins; return `scratch → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+    return 'scratch done';
   }
 
-  async handleHighLow(msg) {
-    if (!msg) return null;
+  async handleAdventure(response) {
+    if (!response) return null;
+    debugMessage(response, 'ADVENTURE');
+    let current = response;
+    let rounds = 0;
+    const MAX_ROUNDS = 15;
+    while (current && rounds < MAX_ROUNDS) {
+      const buttons = getAllButtons(current);
+      if (buttons.length === 0) break;
+      const safeButtons = buttons.filter((b) => !b.disabled && b.style !== 4);
+      const btn = safeButtons.length > 0 ? safeButtons[Math.floor(Math.random() * safeButtons.length)] : buttons.find((b) => !b.disabled);
+      if (!btn) break;
+      await humanDelay(500, 1500);
+      try {
+        await btn.click();
+        const followUp = await this.waitForDankMemer(10000);
+        if (followUp) { current = followUp; rounds++; } else break;
+      } catch { break; }
+    }
+    const finalText = getFullText(current);
+    // Parse next adventure time from footer
+    const nextMatch = finalText.match(/next adventure.*?(\d+)/i);
+    if (nextMatch) {
+      const nextSec = parseInt(nextMatch[1]) * 60;
+      this.log('info', `Next adventure in ${c.yellow}${nextMatch[1]}m${c.reset}`);
+      await this.setCooldown('adventure', nextSec);
+    }
+    const coins = parseCoins(finalText);
+    if (coins > 0) { this.stats.coins += coins; return `adventure (${rounds} rounds) → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+    return `adventure done (${rounds} rounds)`;
+  }
 
-    if (msg.embeds && msg.embeds.length > 0) {
-      const embed = msg.embeds[0];
-      const desc = embed.description || '';
-      const match = desc.match(/(\d+)/);
-      if (match) {
-        const num = parseInt(match[1]);
-        const buttons = [];
-        if (msg.components) {
-          for (const row of msg.components) {
-            if (row.components) {
-              for (const comp of row.components) {
-                if (comp.type === 2) buttons.push(comp);
+  // ── BlackJack Handler ─────────────────────────────────────
+  async handleBlackjack(response) {
+    if (!response) return null;
+    debugMessage(response, 'BLACKJACK');
+    let current = response;
+    const MAX_ROUNDS = 10;
+    for (let i = 0; i < MAX_ROUNDS; i++) {
+      const text = getFullText(current);
+      const buttons = getAllButtons(current);
+      if (buttons.length === 0) break;
+      // Parse player total from embed - look for patterns like "Total: 15" or "Value: **15**"
+      const totalMatch = text.match(/total[:\s]*\**(\d+)\**/i) || text.match(/value[:\s]*\**(\d+)\**/i);
+      const playerTotal = totalMatch ? parseInt(totalMatch[1]) : 0;
+      let targetBtn;
+      if (playerTotal >= 17 || playerTotal === 0) {
+        targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
+      } else {
+        targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('hit')) || buttons[0];
+      }
+      if (!targetBtn || targetBtn.disabled) break;
+      await humanDelay(500, 1200);
+      try {
+        await targetBtn.click();
+        const followUp = await this.waitForDankMemer(8000);
+        if (followUp) {
+          current = followUp;
+          const fButtons = getAllButtons(current);
+          if (fButtons.length === 0 || fButtons.every(b => b.disabled)) break;
+        } else break;
+      } catch { break; }
+    }
+    const finalText = getFullText(current);
+    const coins = parseCoins(finalText);
+    if (coins > 0) { this.stats.coins += coins; return `blackjack → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+    if (finalText.toLowerCase().includes('won')) return 'blackjack → won';
+    if (finalText.toLowerCase().includes('lost') || finalText.toLowerCase().includes('bust')) return 'blackjack → lost';
+    return 'blackjack done';
+  }
+
+  // ── Trivia Handler ────────────────────────────────────────
+  async handleTrivia(response) {
+    if (!response) return null;
+    debugMessage(response, 'TRIVIA');
+    const buttons = getAllButtons(response);
+    if (buttons.length === 0) return getFullText(response).substring(0, 80);
+    // Pick a random answer (we don't have a trivia DB - random has ~25% chance)
+    const clickable = buttons.filter(b => !b.disabled);
+    const btn = clickable[Math.floor(Math.random() * clickable.length)];
+    if (btn) {
+      await humanDelay(1000, 3000);
+      try {
+        await btn.click();
+        const followUp = await this.waitForDankMemer(8000);
+        if (followUp) {
+          const text = getFullText(followUp);
+          const coins = parseCoins(text);
+          if (coins > 0) { this.stats.coins += coins; return `trivia → ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+          if (text.toLowerCase().includes('correct')) return `trivia → ${btn.label} → correct`;
+          return `trivia → ${btn.label} → wrong`;
+        }
+      } catch {}
+    }
+    return 'trivia done';
+  }
+
+  // ── Work Shift Handler ────────────────────────────────────
+  async handleWorkShift(response) {
+    if (!response) return null;
+    debugMessage(response, 'WORK');
+    let current = response;
+    const MAX_ROUNDS = 5;
+    for (let i = 0; i < MAX_ROUNDS; i++) {
+      const buttons = getAllButtons(current);
+      const text = getFullText(current);
+      // Work shift mini-games: word scramble, memory, typing, etc.
+      // Try to click any available non-disabled button
+      if (buttons.length === 0) break;
+      const clickable = buttons.filter(b => !b.disabled);
+      if (clickable.length === 0) break;
+      // For word-type games, look for the correct button
+      const btn = clickable[0]; // Just pick first available
+      await humanDelay(500, 1500);
+      try {
+        await btn.click();
+        const followUp = await this.waitForDankMemer(8000);
+        if (followUp) { current = followUp; } else break;
+      } catch { break; }
+    }
+    const finalText = getFullText(current);
+    const coins = parseCoins(finalText);
+    if (coins > 0) { this.stats.coins += coins; return `work → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+    return 'work done';
+  }
+
+  // ── Generic Command Handler (beg, hunt, dig, farm, tidy, etc.) ──
+  async handleGenericCommand(response) {
+    if (!response) return null;
+    debugMessage(response, 'GENERIC');
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    const neededItem = this.needsItem(text);
+    if (neededItem) {
+      this.log('warn', `Missing ${c.bold}${neededItem}${c.reset} — auto-buying...`);
+      const bought = await this.buyItem(neededItem);
+      if (bought) return `auto-bought ${neededItem}`;
+      return `need ${neededItem} (couldn't buy)`;
+    }
+    // Handle buttons if present (e.g., postmemes, farm choices)
+    const buttons = getAllButtons(response);
+    if (buttons.length > 0) {
+      const btn = buttons.find((b) => !b.disabled) || buttons[0];
+      if (btn) {
+        await humanDelay();
+        try {
+          await btn.click();
+          const followUp = await this.waitForDankMemer(8000);
+          if (followUp) {
+            const fText = getFullText(followUp);
+            const fCoins = parseCoins(fText);
+            if (fCoins > 0) { this.stats.coins += fCoins; return `${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`; }
+            // Check if followUp also has buttons (multi-step)
+            const nextButtons = getAllButtons(followUp);
+            if (nextButtons.length > 0) {
+              const nextBtn = nextButtons.find(b => !b.disabled);
+              if (nextBtn) {
+                await humanDelay();
+                try { await nextBtn.click(); } catch {}
               }
             }
           }
-        }
-
-        if (buttons.length >= 2) {
-          await humanDelay();
-          let targetBtn;
-          if (num > 50) {
-            targetBtn = buttons.find((b) => b.label?.toLowerCase().includes('lower')) || buttons[1];
-          } else if (num < 50) {
-            targetBtn = buttons.find((b) => b.label?.toLowerCase().includes('higher')) || buttons[0];
-          } else {
-            targetBtn = buttons[Math.floor(Math.random() * 2)];
+        } catch {}
+      }
+    }
+    // Handle select menus (some commands use dropdowns)
+    const menus = getAllSelectMenus(response);
+    if (menus.length > 0) {
+      const menu = menus[0];
+      const options = menu.options || [];
+      if (options.length > 0) {
+        const opt = options[Math.floor(Math.random() * options.length)];
+        try {
+          await response.selectMenu(menu.customId, [opt.value]);
+          const followUp = await this.waitForDankMemer(8000);
+          if (followUp) {
+            const fText = getFullText(followUp);
+            const fCoins = parseCoins(fText);
+            if (fCoins > 0) { this.stats.coins += fCoins; return `${opt.label} → ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`; }
           }
+        } catch {}
+      }
+    }
+    if (coins > 0) { this.stats.coins += coins; return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+    return text.substring(0, 60) || 'done';
+  }
 
-          try {
-            await targetBtn.click();
-            return `HL: number was ${num}, clicked ${targetBtn.label}`;
-          } catch {
-            return null;
+  // ── Simple Gambling (cointoss, roulette, slots, snakeeyes) ──
+  async handleSimpleGamble(response) {
+    if (!response) return null;
+    debugMessage(response, 'GAMBLE');
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    // Check buttons (some gambling has buttons)
+    const buttons = getAllButtons(response);
+    if (buttons.length > 0) {
+      const btn = buttons.find(b => !b.disabled);
+      if (btn) {
+        await humanDelay();
+        try {
+          await btn.click();
+          const followUp = await this.waitForDankMemer(8000);
+          if (followUp) {
+            const fText = getFullText(followUp);
+            const fCoins = parseCoins(fText);
+            if (fCoins > 0) { this.stats.coins += fCoins; return `${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`; }
+            if (fText.toLowerCase().includes('won')) return `${c.green}won${c.reset}`;
+            if (fText.toLowerCase().includes('lost')) return `${c.red}lost${c.reset}`;
           }
-        }
+        } catch {}
       }
     }
+    if (coins > 0) { this.stats.coins += coins; return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`; }
+    if (text.toLowerCase().includes('won')) return `${c.green}won${c.reset}`;
+    if (text.toLowerCase().includes('lost')) return `${c.red}lost${c.reset}`;
+    return text.substring(0, 60) || 'done';
+  }
 
-    return null;
+  // ── Deposit Handler ────────────────────────────────────────
+  async handleDeposit(response) {
+    if (!response) return null;
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    if (text.toLowerCase().includes('deposited')) {
+      return `deposited ${c.green}⏣ ${coins.toLocaleString()}${c.reset}`;
+    }
+    return text.substring(0, 60) || 'deposit done';
   }
 
+  // ── Alert Handler ─────────────────────────────────────────
+  async handleAlert(response) {
+    if (!response) return null;
+    debugMessage(response, 'ALERT');
+    const buttons = getAllButtons(response);
+    // Click any dismiss/accept/ok button
+    const btn = buttons.find(b => !b.disabled && ['ok', 'dismiss', 'accept', 'got it', 'continue'].some(s => (b.label || '').toLowerCase().includes(s)));
+    if (btn) {
+      await humanDelay();
+      try { await btn.click(); } catch {}
+      return `alert dismissed`;
+    }
+    if (buttons.length > 0) {
+      const first = buttons.find(b => !b.disabled);
+      if (first) {
+        await humanDelay();
+        try { await first.click(); } catch {}
+      }
+    }
+    return 'alert handled';
+  }
+
+  // ── Run Single Command ──────────────────────────────────────
   async runCommand(cmdName, prefix) {
-    const cmdString = `${prefix} ${cmdName}`;
-    this.log('cmd', `${c.white}${cmdString}${c.reset}`);
+    let cmdString;
+    const betAmount = this.account.bet_amount || 1000;
+
+    // Build the command string
+    switch (cmdName) {
+      case 'dep max':     cmdString = `${prefix} dep max`; break;
+      case 'blackjack':   cmdString = `${prefix} bj ${betAmount}`; break;
+      case 'coinflip':    cmdString = `${prefix} coinflip ${betAmount} heads`; break;
+      case 'roulette':    cmdString = `${prefix} roulette ${betAmount} red`; break;
+      case 'slots':       cmdString = `${prefix} slots ${betAmount}`; break;
+      case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${betAmount}`; break;
+      case 'work shift':  cmdString = `${prefix} work shift`; break;
+      default:            cmdString = `${prefix} ${cmdName}`;
+    }
+
+    this.log('cmd', `${c.white}${c.bold}${cmdString}${c.reset}`);
+    this.stats.commands++;
 
     try {
       await this.channel.send(cmdString);
@@ -217,106 +957,272 @@ class AccountWorker {
 
       if (!response) {
         this.log('warn', `No response for ${cmdString}`);
-        await sendLog(cmdString, 'No response (timeout)', 'timeout');
+        this.stats.errors++;
+        await sendLog(this.username, cmdString, 'timeout', 'timeout');
         return;
       }
 
-      let result;
-      if (cmdName === 'hl') {
-        result = await this.handleHighLow(response);
-      } else if (['search', 'crime'].includes(cmdName)) {
-        result = await this.handleInteraction(response);
-      } else {
-        result = response.content?.substring(0, 100) || 'Embed response';
-        if (response.components && response.components.length > 0) {
-          result = await this.handleInteraction(response);
+      // Check for cooldown messages
+      const responseText = getFullText(response).toLowerCase();
+      if (responseText.includes('already claimed') || 
+          (responseText.includes('wait') && responseText.includes('before')) ||
+          responseText.includes('cooldown') || responseText.includes('slow down') || 
+          responseText.includes('come back') || responseText.includes('already used') ||
+          responseText.includes('try again in')) {
+        this.log('warn', `${cmdName} on cooldown`);
+        // Try to parse remaining cooldown from text
+        const timeMatch = responseText.match(/(\d+)\s*(second|minute|hour|day)/i);
+        if (timeMatch) {
+          let secs = parseInt(timeMatch[1]);
+          const unit = timeMatch[2].toLowerCase();
+          if (unit.startsWith('minute')) secs *= 60;
+          if (unit.startsWith('hour')) secs *= 3600;
+          if (unit.startsWith('day')) secs *= 86400;
+          await this.setCooldown(cmdName, secs + 5);
+          this.log('info', `Set cooldown for ${cmdName}: ${secs}s`);
         }
+        await sendLog(this.username, cmdString, 'on cooldown', 'cooldown');
+        return;
       }
 
-      this.log('success', `${cmdString} ${c.dim}→${c.reset} ${c.green}${result || 'done'}${c.reset}`);
-      await sendLog(cmdString, result || 'done', 'success');
+      let result;
+      switch (cmdName) {
+        case 'search':      result = await this.handleSearch(response); break;
+        case 'crime':       result = await this.handleCrime(response); break;
+        case 'hl':          result = await this.handleHighLow(response); break;
+        case 'scratch':     result = await this.handleScratch(response); break;
+        case 'adventure':   result = await this.handleAdventure(response); break;
+        case 'blackjack':   result = await this.handleBlackjack(response); break;
+        case 'trivia':      result = await this.handleTrivia(response); break;
+        case 'work shift':  result = await this.handleWorkShift(response); break;
+        case 'coinflip':
+        case 'roulette':
+        case 'slots':
+        case 'snakeeyes':   result = await this.handleSimpleGamble(response); break;
+        case 'dep max':     result = await this.handleDeposit(response); break;
+        case 'alert':       result = await this.handleAlert(response); break;
+        default:            result = await this.handleGenericCommand(response); break;
+      }
+
+      this.stats.successes++;
+      this.log('success', `${c.dim}${cmdString}${c.reset} → ${result || 'done'}`);
+      await sendLog(this.username, cmdString, result || 'done', 'success');
     } catch (err) {
+      this.stats.errors++;
       this.log('error', `${cmdString} failed: ${err.message}`);
-      await sendLog(cmdString, err.message, 'error');
+      await sendLog(this.username, cmdString, err.message, 'error');
     }
   }
 
-  async grindLoop() {
-    if (this.running) return;
-    this.running = true;
+  // ── Redis Cooldown Management ───────────────────────────────
+  async setCooldown(cmdName, durationSeconds) {
+    if (!redis) return;
+    const key = `dkg:cd:${this.account.id}:${cmdName}`;
+    await redis.set(key, '1', 'EX', Math.ceil(durationSeconds));
+  }
 
-    const commandMap = {
-      cmd_hunt: 'hunt',
-      cmd_dig: 'dig',
-      cmd_beg: 'beg',
-      cmd_search: 'search',
-      cmd_hl: 'hl',
-      cmd_crime: 'crime',
-      cmd_pm: 'pm',
-    };
+  async isCooldownReady(cmdName) {
+    if (!redis) return true;
+    const key = `dkg:cd:${this.account.id}:${cmdName}`;
+    const val = await redis.get(key);
+    return !val;
+  }
 
-    while (this.running) {
-      const acc = this.account;
-      const prefix = acc.use_slash ? '/' : 'pls';
-      const minCD = acc.cooldown_min || 3;
-      const maxCD = acc.cooldown_max || 8;
+  printStats() {
+    // Stats are shown in the live dashboard, no-op here
+  }
 
-      const enabledCommands = Object.entries(commandMap)
-        .filter(([key]) => acc[key] === true || acc[key] === 1)
-        .map(([, cmd]) => cmd);
+  // ── Main Non-Blocking Grind Scheduler ───────────────────────
+  async tick() {
+    if (!this.running) return;
+    if (this.busy) {
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
+      return;
+    }
 
-      if (enabledCommands.length === 0) {
-        this.log('warn', 'No commands enabled. Waiting 30s...');
-        await new Promise((r) => setTimeout(r, 30000));
-        continue;
+    const commandMap = [
+      // Grinding commands (high frequency)
+      { key: 'cmd_beg', cmd: 'beg', cdKey: 'cd_beg', defaultCd: 40, priority: 5 },
+      { key: 'cmd_search', cmd: 'search', cdKey: 'cd_search', defaultCd: 25, priority: 4 },
+      { key: 'cmd_hl', cmd: 'hl', cdKey: 'cd_hl', defaultCd: 10, priority: 3 },
+      { key: 'cmd_pm', cmd: 'pm', cdKey: 'cd_pm', defaultCd: 20, priority: 3 },
+      { key: 'cmd_crime', cmd: 'crime', cdKey: 'cd_crime', defaultCd: 40, priority: 2 },
+      { key: 'cmd_hunt', cmd: 'hunt', cdKey: 'cd_hunt', defaultCd: 20, priority: 1 },
+      { key: 'cmd_dig', cmd: 'dig', cdKey: 'cd_dig', defaultCd: 20, priority: 1 },
+      { key: 'cmd_fish', cmd: 'fish', cdKey: 'cd_fish', defaultCd: 20, priority: 1 },
+      { key: 'cmd_farm', cmd: 'farm', cdKey: 'cd_farm', defaultCd: 10, priority: 2 },
+      { key: 'cmd_tidy', cmd: 'tidy', cdKey: 'cd_tidy', defaultCd: 40, priority: 1 },
+      // Gambling
+      { key: 'cmd_blackjack', cmd: 'blackjack', cdKey: 'cd_blackjack', defaultCd: 3, priority: 3 },
+      { key: 'cmd_cointoss', cmd: 'coinflip', cdKey: 'cd_cointoss', defaultCd: 2, priority: 3 },
+      { key: 'cmd_roulette', cmd: 'roulette', cdKey: 'cd_roulette', defaultCd: 3, priority: 3 },
+      { key: 'cmd_slots', cmd: 'slots', cdKey: 'cd_slots', defaultCd: 3, priority: 3 },
+      { key: 'cmd_snakeeyes', cmd: 'snakeeyes', cdKey: 'cd_snakeeyes', defaultCd: 3, priority: 3 },
+      // Medium cooldown
+      { key: 'cmd_trivia', cmd: 'trivia', cdKey: 'cd_trivia', defaultCd: 10, priority: 2 },
+      { key: 'cmd_use', cmd: 'use', cdKey: 'cd_use', defaultCd: 10, priority: 1 },
+      { key: 'cmd_drops', cmd: 'drops', cdKey: 'cd_drops', defaultCd: 60, priority: 2 },
+      { key: 'cmd_stream', cmd: 'stream', cdKey: 'cd_stream', defaultCd: 600, priority: 8 },
+      // Economy
+      { key: 'cmd_deposit', cmd: 'dep max', cdKey: 'cd_deposit', defaultCd: 60, priority: 7 },
+      // Long cooldown / special
+      { key: 'cmd_daily', cmd: 'daily', cdKey: 'cd_daily', defaultCd: 86400, priority: 10 },
+      { key: 'cmd_weekly', cmd: 'weekly', cdKey: 'cd_weekly', defaultCd: 604800, priority: 10 },
+      { key: 'cmd_monthly', cmd: 'monthly', cdKey: 'cd_monthly', defaultCd: 2592000, priority: 10 },
+      { key: 'cmd_work', cmd: 'work shift', cdKey: 'cd_work', defaultCd: 3600, priority: 8 },
+      { key: 'cmd_scratch', cmd: 'scratch', cdKey: 'cd_scratch', defaultCd: 3600, priority: 6 },
+      { key: 'cmd_adventure', cmd: 'adventure', cdKey: 'cd_adventure', defaultCd: 300, priority: 6 },
+      // System
+      { key: 'cmd_alert', cmd: 'alert', cdKey: 'cd_alert', defaultCd: 300, priority: 9 },
+    ];
+
+    const enabledCommands = commandMap.filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
+    
+    if (enabledCommands.length === 0) {
+      this.tickTimeout = setTimeout(() => this.tick(), 15000);
+      return;
+    }
+
+    let nextCmdToRun = null;
+    let highestPriority = -1;
+
+    for (const info of enabledCommands) {
+      const ready = await this.isCooldownReady(info.cmd);
+      if (ready && info.priority > highestPriority) {
+        nextCmdToRun = info;
+        highestPriority = info.priority;
       }
+    }
+
+    if (nextCmdToRun) {
+      this.busy = true;
+      const cd = (this.account[nextCmdToRun.cdKey] || nextCmdToRun.defaultCd);
+      const jitter = 1 + Math.random() * 3; 
+      const totalWait = cd + jitter;
+      
+      // Optimistic lock via Redis
+      await this.setCooldown(nextCmdToRun.cmd, totalWait); 
+      
+      // Global Jitter between commands
+      const now = Date.now();
+      const timeSinceLastCmd = now - (this.lastCommandRun || 0);
+      const globalJitter = 1500 + Math.random() * 1500;
+      if (timeSinceLastCmd < globalJitter) {
+        await new Promise(r => setTimeout(r, globalJitter - timeSinceLastCmd));
+      }
+
+      const prefix = this.account.use_slash ? '/' : 'pls';
+      this.setStatus(`${c.white}pls ${nextCmdToRun.cmd}${c.reset}`);
+      await this.runCommand(nextCmdToRun.cmd, prefix);
+      
+      this.lastCommandRun = Date.now();
+      // Re-apply cooldown based on actual finish time
+      await this.setCooldown(nextCmdToRun.cmd, totalWait);
+      
+      this.busy = false;
+      this.cycleCount++;
 
-      for (const cmd of enabledCommands) {
-        if (!this.running) break;
-        await this.runCommand(cmd, prefix);
-        await randomDelay(minCD, maxCD);
+      if (this.cycleCount > 0 && this.cycleCount % 10 === 0) this.printStats();
+      if (this.cycleCount > 0 && this.cycleCount % 20 === 0) {
+        this.busy = true;
+        await this.checkBalance();
+        this.busy = false;
       }
 
-      const cycleDelay = 2 + Math.random() * 3;
-      this.log('info', `${c.dim}Cycle done. Next in ${cycleDelay.toFixed(1)}s${c.reset}`);
-      await new Promise((r) => setTimeout(r, cycleDelay * 1000));
+      this.tickTimeout = setTimeout(() => this.tick(), 100);
+    } else {
+      this.setStatus(`${c.dim}waiting for cooldowns...${c.reset}`);
+      this.tickTimeout = setTimeout(() => this.tick(), 1000);
     }
   }
 
+  async grindLoop() {
+    if (this.running) return;
+    this.running = true;
+    this.busy = false;
+    this.cycleCount = 0;
+    this.lastCommandRun = 0;
+
+    this.configInterval = setInterval(async () => {
+      if (!this.running) return;
+      await this.refreshConfig();
+      if (!this.account.active && !this.busy) {
+        this.log('warn', 'Account deactivated from dashboard. Pausing...');
+        this.busy = true;
+      } else if (this.account.active && this.busy) {
+        this.log('success', 'Account re-activated! Resuming...');
+        this.busy = false;
+      }
+    }, 15000);
+
+    this.tick();
+  }
+
+  async refreshConfig() {
+    try {
+      const res = await fetch(`${API_URL}/api/grinder/status`, {
+        headers: { Authorization: `Bearer ${API_KEY}` },
+      });
+      const data = await res.json();
+      if (data.accounts) {
+        const updated = data.accounts.find((a) => a.id === this.account.id);
+        if (updated) this.account = updated;
+      }
+    } catch { /* silent */ }
+  }
+
   async start() {
-    if (!this.account.discord_token) {
-      this.log('error', 'No Discord token configured.');
-      return;
-    }
-    if (!this.account.channel_id) {
-      this.log('error', 'No channel ID configured.');
-      return;
-    }
+    if (!this.account.discord_token) { this.log('error', 'No Discord token.'); return; }
+    if (!this.account.channel_id) { this.log('error', 'No channel ID.'); return; }
 
-    this.log('info', 'Connecting to Discord...');
+    this.log('info', 'Connecting...');
 
     return new Promise((resolve) => {
       this.client.on('ready', async () => {
-        this.log('success', `Logged in as ${c.bold}${this.client.user.tag}${c.reset}`);
-        this.log('info', `Servers: ${c.white}${this.client.guilds.cache.size}${c.reset}`);
+        this.username = this.client.user.tag || this.username;
+        try {
+          await fetch(`${API_URL}/api/grinder/status`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, discord_username: this.username }),
+          });
+        } catch { /* silent */ }
 
+        this.log('success', `Logged in! ${c.dim}(${this.client.guilds.cache.size} servers)${c.reset}`);
         this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
 
         if (!this.channel) {
-          this.log('error', `Cannot find channel ${this.account.channel_id}`);
-          resolve();
-          return;
+          this.log('error', `Channel ${this.account.channel_id} not found`);
+          resolve(); return;
         }
 
         this.log('info', `Channel: ${c.white}#${this.channel.name || this.account.channel_id}${c.reset}`);
 
-        const enabled = Object.keys({ cmd_hunt: 1, cmd_dig: 1, cmd_beg: 1, cmd_search: 1, cmd_hl: 1, cmd_crime: 1, cmd_pm: 1 })
-          .filter((k) => this.account[k] === true || this.account[k] === 1)
-          .map((k) => k.replace('cmd_', ''));
-        this.log('info', `Commands: ${c.white}${enabled.join(', ') || 'none'}${c.reset}`);
-        this.log('info', `Cooldown: ${c.white}${this.account.cooldown_min || 3}-${this.account.cooldown_max || 8}s${c.reset}`);
-        console.log('');
+        const ALL_CMDS = [
+          { key: 'cmd_hunt', label: 'hunt' }, { key: 'cmd_dig', label: 'dig' },
+          { key: 'cmd_fish', label: 'fish' }, { key: 'cmd_beg', label: 'beg' },
+          { key: 'cmd_search', label: 'search' }, { key: 'cmd_hl', label: 'hl' },
+          { key: 'cmd_crime', label: 'crime' }, { key: 'cmd_pm', label: 'pm' },
+          { key: 'cmd_daily', label: 'daily' }, { key: 'cmd_weekly', label: 'weekly' },
+          { key: 'cmd_monthly', label: 'monthly' }, { key: 'cmd_work', label: 'work' },
+          { key: 'cmd_stream', label: 'stream' }, { key: 'cmd_scratch', label: 'scratch' },
+          { key: 'cmd_adventure', label: 'adventure' }, { key: 'cmd_farm', label: 'farm' },
+          { key: 'cmd_tidy', label: 'tidy' }, { key: 'cmd_blackjack', label: 'bj' },
+          { key: 'cmd_cointoss', label: 'coinflip' }, { key: 'cmd_roulette', label: 'roulette' },
+          { key: 'cmd_slots', label: 'slots' }, { key: 'cmd_snakeeyes', label: 'snakeeyes' },
+          { key: 'cmd_trivia', label: 'trivia' }, { key: 'cmd_use', label: 'use' },
+          { key: 'cmd_deposit', label: 'deposit' }, { key: 'cmd_drops', label: 'drops' },
+          { key: 'cmd_alert', label: 'alert' },
+        ].filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
 
+        const cmdStr = ALL_CMDS.map(ci => ci.label).join(', ');
+        this.log('info', `Commands: ${c.white}${cmdStr || 'none'}${c.reset}`);
+        if (this.account.bet_amount) {
+          this.log('info', `Bet amount: ${c.yellow}⏣ ${this.account.bet_amount.toLocaleString()}${c.reset}`);
+        }
+
+        await this.checkBalance();
+        console.log('');
         this.grindLoop();
         resolve();
       });
@@ -327,59 +1233,73 @@ class AccountWorker {
 
   stop() {
     this.running = false;
+    if (this.tickTimeout) clearTimeout(this.tickTimeout);
+    if (this.configInterval) clearInterval(this.configInterval);
     try { this.client.destroy(); } catch {}
   }
 }
 
-// ── Main Entry ──────────────────────────────────
+// ══════════════════════════════════════════════════════════════
+// ═  Main Entry
+// ══════════════════════════════════════════════════════════════
 
 async function start(apiKey, apiUrl) {
   API_KEY = apiKey;
   API_URL = apiUrl;
+  initRedis();
 
-  console.log('');
-  console.log(`  ${c.magenta}${c.bold}╔══════════════════════════════════════════╗${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}║${c.reset}                                          ${c.magenta}${c.bold}║${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}║${c.reset}   ${c.white}${c.bold}DankGrinder${c.reset} ${c.dim}v2.0${c.reset}                      ${c.magenta}${c.bold}║${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}║${c.reset}   ${c.dim}Multi-Account Automation Engine${c.reset}        ${c.magenta}${c.bold}║${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}║${c.reset}                                          ${c.magenta}${c.bold}║${c.reset}`);
-  console.log(`  ${c.magenta}${c.bold}╚══════════════════════════════════════════╝${c.reset}`);
+  // Clear screen & show big banner
+  process.stdout.write('\x1b[2J\x1b[H');
+  console.log(BANNER);
+  console.log(`  ${c.dim}v4.0${c.reset}  ${c.dim}•${c.reset}  ${c.white}30 Commands${c.reset}  ${c.dim}•${c.reset}  ${c.cyan}Redis Cooldowns${c.reset}  ${c.dim}•${c.reset}  ${c.green}Smart AI${c.reset}`);
   console.log('');
 
   log('info', `API: ${c.dim}${API_URL}${c.reset}`);
-  log('info', 'Fetching config & accounts...');
+  log('info', `Redis: ${c.dim}${REDIS_URL.replace(/:[^:]+@/, ':***@')}${c.reset}`);
+  log('info', 'Fetching accounts...');
 
   const data = await fetchConfig();
-
-  if (!data) {
-    log('error', 'Failed to fetch config. Check your API key and server.');
-    process.exit(1);
-  }
+  if (!data) { log('error', 'Failed to fetch config.'); process.exit(1); }
 
   const { accounts } = data;
-
   if (!accounts || accounts.length === 0) {
-    log('error', 'No active accounts found. Add accounts in the dashboard.');
+    log('error', 'No active accounts. Add them in the dashboard.');
     process.exit(1);
   }
 
-  log('success', `Found ${c.bold}${accounts.length}${c.reset} active account(s)`);
+  log('success', `${c.bold}${accounts.length}${c.reset} active account(s) found`);
   console.log('');
 
-  // Spawn a worker per account
   for (let i = 0; i < accounts.length; i++) {
     const worker = new AccountWorker(accounts[i], i);
     workers.push(worker);
     await worker.start();
   }
 
-  log('info', `${c.bold}All workers running. Press Ctrl+C to stop.${c.reset}`);
   console.log('');
+  startTime = Date.now();
+  dashboardStarted = true;
+  process.stdout.write(c.hide); // Hide cursor for clean UI
+
+  // Start the live dashboard refresh loop
+  setInterval(() => renderDashboard(), 1000);
+  renderDashboard(); // Initial render
 
   process.on('SIGINT', () => {
+    process.stdout.write(c.show); // Show cursor again
+    dashboardStarted = false;
+    console.log('');
+    console.log('');
+    log('warn', 'Shutting down...');
+    console.log('');
+    for (const w of workers) {
+      const rate = w.stats.commands > 0 ? ((w.stats.successes / w.stats.commands) * 100).toFixed(0) : 0;
+      console.log(`  ${w.color}${c.bold}${w.username}${c.reset}  ${c.green}⏣ ${w.stats.coins.toLocaleString()}${c.reset} earned  ${c.dim}│${c.reset}  ${w.stats.commands} cmds  ${c.dim}│${c.reset}  ${rate}% success`);
+      w.stop();
+    }
+    console.log('');
+    console.log(`  ${c.yellow}${c.bold}Total: ⏣ ${totalCoins.toLocaleString()}${c.reset} earned in ${formatUptime()}`);
     console.log('');
-    log('warn', 'Shutting down all workers...');
-    for (const w of workers) w.stop();
     setTimeout(() => process.exit(0), 2000);
   });
 }