dankgrinder 1.0.1 → 3.0.0

package/lib/grinder.js

@@ -1,35 +1,48 @@
 const { Client } = require('discord.js-selfbot-v13');
 
+// ── Terminal Colors ──────────────────────────────────────────
 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',
 };
 
-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 = '';
 const workers = [];
 
 function log(type, msg, label) {
-  const time = new Date().toLocaleTimeString();
-  const prefix = {
-    info: `${c.cyan}ℹ${c.reset}`,
+  const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  const icons = {
+    info: `${c.cyan}│${c.reset}`,
     success: `${c.green}✓${c.reset}`,
     error: `${c.red}✗${c.reset}`,
-    warn: `${c.yellow}⚠${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}`,
   };
-  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} ` : '';
+  console.log(`  ${c.dim}${time}${c.reset}  ${icons[type] || icons.info}  ${tag}${msg}`);
 }
 
 async function fetchConfig() {
@@ -38,178 +51,362 @@ 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) {
   try {
     await fetch(`${API_URL}/api/grinder/log`, {
       method: 'POST',
-      headers: {
-        Authorization: `Bearer ${API_KEY}`,
-        'Content-Type': 'application/json',
-      },
+      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ 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;
+  // Match patterns like "⏣ 1,250" or "+1,250 coins" or "**1,250**"
+  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,
+  ];
+  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;
+}
+
+// ── Smart Button Picker ──────────────────────────────────────
+function pickSafeButton(buttons, safeList) {
+  if (!buttons || buttons.length === 0) return null;
+
+  // First check user-configured safe answers
+  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;
+    }
+  }
+
+  // Then check built-in safe list
+  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;
+  }
+
+  // Fallback: pick random
+  const clickable = buttons.filter((b) => !b.disabled);
+  return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+}
+
+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;
 }
 
-// ── Worker: one per Discord account ──────────────────────────────
+// ══════════════════════════════════════════════════════════════
+// ═  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.username = account.label || `Account ${idx + 1}`;
+
+    // Session stats
+    this.stats = { coins: 0, commands: 0, successes: 0, errors: 0, balance: 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); }
+
   waitForDankMemer(timeout = 15000) {
     return new Promise((resolve) => {
       const timer = setTimeout(() => {
         this.client.removeListener('messageCreate', handler);
         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);
           resolve(msg);
         }
       }
-
       this.client.on('messageCreate', handler);
     });
   }
 
-  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;
-                  }
-                }
-              }
-            }
-          }
+  // ── Needs Item Detection ────────────────────────────────────
+  needsItem(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("don't have a shovel") || lower.includes('need to go buy') && lower.includes('shovel'))
+      return 'shovel';
+    if (lower.includes("don't have a fishing") || lower.includes('need a fishing'))
+      return 'fishing pole';
+    if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle'))
+      return 'hunting rifle';
+    return null;
+  }
 
-          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;
-            }
-          }
+  async buyItem(itemName) {
+    this.log('buy', `Buying ${c.bold}${itemName}${c.reset}...`);
+    await this.channel.send(`pls buy ${itemName}`);
+    const response = await this.waitForDankMemer(10000);
+    if (response) {
+      const text = getFullText(response);
+      // Sometimes Dank Memer asks for confirmation
+      const buttons = getAllButtons(response);
+      if (buttons.length > 0) {
+        const confirm = buttons.find((b) => {
+          const label = (b.label || '').toLowerCase();
+          return label.includes('yes') || label.includes('confirm') || label.includes('buy');
+        });
+        if (confirm) {
+          await humanDelay();
+          try { await confirm.click(); } catch {}
+          await this.waitForDankMemer(5000);
         }
       }
+      if (text.toLowerCase().includes('bought') || text.toLowerCase().includes('purchased')) {
+        this.log('success', `Bought ${c.bold}${itemName}${c.reset}!`);
+        return true;
+      }
     }
+    this.log('warn', `Could not buy ${itemName}`);
+    return false;
+  }
 
-    return msg.content?.substring(0, 100) || 'Response received';
+  // ── Check Balance ───────────────────────────────────────────
+  async checkBalance() {
+    await this.channel.send('pls bal');
+    const response = await this.waitForDankMemer(10000);
+    if (response) {
+      const text = getFullText(response);
+      // Try to parse wallet balance
+      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}`);
+      }
+    }
   }
 
-  async handleHighLow(msg) {
-    if (!msg) return null;
-
-    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);
-              }
-            }
+  // ── Command Handlers ────────────────────────────────────────
+
+  async handleSearch(response) {
+    if (!response) return null;
+    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';
+  }
 
-        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)];
+  async handleCrime(response) {
+    if (!response) return null;
+    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;
+    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 {
+        // Jackpot hint
+        const jackpot = buttons.find((b) => (b.label || '').toLowerCase().includes('jackpot'));
+        targetBtn = jackpot || buttons[Math.floor(Math.random() * 2)];
+      }
 
-          try {
-            await targetBtn.click();
-            return `HL: number was ${num}, clicked ${targetBtn.label}`;
-          } catch {
-            return null;
+      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}`;
+          }
+          // Multi-round: keep playing
+          const moreButtons = getAllButtons(followUp);
+          if (moreButtons.length >= 2) {
+            return await this.handleHighLow(followUp);
           }
+          return `${num} → ${targetBtn.label}`;
         }
-      }
+        return `${num} → ${targetBtn.label}`;
+      } catch { return null; }
     }
 
+    // Fallback: click random
+    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;
   }
 
+  async handleGenericCommand(response) {
+    if (!response) return null;
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+
+    // Check if we need to buy something
+    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
+    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}`; }
+          }
+        } catch {}
+      }
+    }
+
+    if (coins > 0) {
+      this.stats.coins += coins;
+      return `${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`;
+    }
+
+    return text.substring(0, 60) || 'done';
+  }
+
+  // ── Run Single Command ──────────────────────────────────────
   async runCommand(cmdName, prefix) {
     const cmdString = `${prefix} ${cmdName}`;
-    this.log('cmd', `${c.white}${cmdString}${c.reset}`);
+    this.log('cmd', `${c.white}${c.bold}${cmdString}${c.reset}`);
+    this.stats.commands++;
 
     try {
       await this.channel.send(cmdString);
@@ -217,53 +414,78 @@ class AccountWorker {
 
       if (!response) {
         this.log('warn', `No response for ${cmdString}`);
-        await sendLog(cmdString, 'No response (timeout)', 'timeout');
+        this.stats.errors++;
+        await sendLog(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);
-        }
+      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;
+        default:       result = await this.handleGenericCommand(response); break;
       }
 
-      this.log('success', `${cmdString} ${c.dim}→${c.reset} ${c.green}${result || 'done'}${c.reset}`);
+      this.stats.successes++;
+      this.log('success', `${c.dim}${cmdString}${c.reset} → ${result || 'done'}`);
       await sendLog(cmdString, result || 'done', 'success');
     } catch (err) {
+      this.stats.errors++;
       this.log('error', `${cmdString} failed: ${err.message}`);
       await sendLog(cmdString, err.message, 'error');
     }
   }
 
+  // ── Print Session Stats ─────────────────────────────────────
+  printStats() {
+    const rate = this.stats.commands > 0 ? ((this.stats.successes / this.stats.commands) * 100).toFixed(0) : 0;
+    this.log('info', `${c.dim}──────────────────────────────────────${c.reset}`);
+    this.log('coin', `Session: ${c.bold}${c.green}⏣ ${this.stats.coins.toLocaleString()}${c.reset} earned  ${c.dim}│${c.reset}  ${c.white}${this.stats.commands}${c.reset} cmds  ${c.dim}│${c.reset}  ${c.green}${rate}%${c.reset} success`);
+    if (this.stats.balance > 0) {
+      this.log('bal', `Wallet: ${c.bold}⏣ ${this.stats.balance.toLocaleString()}${c.reset}`);
+    }
+    this.log('info', `${c.dim}──────────────────────────────────────${c.reset}`);
+  }
+
+  // ── Main Grind Loop ─────────────────────────────────────────
   async grindLoop() {
     if (this.running) return;
     this.running = true;
 
     const commandMap = {
-      cmd_hunt: 'hunt',
-      cmd_dig: 'dig',
-      cmd_beg: 'beg',
-      cmd_search: 'search',
-      cmd_hl: 'hl',
-      cmd_crime: 'crime',
-      cmd_pm: 'pm',
+      cmd_hunt: { cmd: 'hunt', cdKey: 'cd_hunt', defaultCd: 20 },
+      cmd_dig: { cmd: 'dig', cdKey: 'cd_dig', defaultCd: 20 },
+      cmd_beg: { cmd: 'beg', cdKey: 'cd_beg', defaultCd: 20 },
+      cmd_search: { cmd: 'search', cdKey: 'cd_search', defaultCd: 20 },
+      cmd_hl: { cmd: 'hl', cdKey: 'cd_hl', defaultCd: 20 },
+      cmd_crime: { cmd: 'crime', cdKey: 'cd_crime', defaultCd: 40 },
+      cmd_pm: { cmd: 'pm', cdKey: 'cd_pm', defaultCd: 20 },
     };
 
+    let cycleCount = 0;
+
     while (this.running) {
+      // Re-fetch config from API every cycle for live dashboard control
+      if (cycleCount > 0 && cycleCount % 3 === 0) {
+        await this.refreshConfig();
+        if (!this.account.active) {
+          this.log('warn', 'Account deactivated from dashboard. Pausing...');
+          while (!this.account.active && this.running) {
+            await new Promise((r) => setTimeout(r, 10000));
+            await this.refreshConfig();
+          }
+          if (!this.running) break;
+          this.log('success', 'Account re-activated! Resuming...');
+        }
+      }
+
       const acc = this.account;
       const prefix = acc.use_slash ? '/' : 'pls';
-      const minCD = acc.cooldown_min || 3;
-      const maxCD = acc.cooldown_max || 8;
 
       const enabledCommands = Object.entries(commandMap)
         .filter(([key]) => acc[key] === true || acc[key] === 1)
-        .map(([, cmd]) => cmd);
+        .map(([, val]) => val);
 
       if (enabledCommands.length === 0) {
         this.log('warn', 'No commands enabled. Waiting 30s...');
@@ -271,50 +493,95 @@ class AccountWorker {
         continue;
       }
 
-      for (const cmd of enabledCommands) {
+      for (const { cmd, cdKey, defaultCd } of enabledCommands) {
         if (!this.running) break;
         await this.runCommand(cmd, prefix);
-        await randomDelay(minCD, maxCD);
+
+        // Per-command cooldown with jitter
+        const cd = (acc[cdKey] || defaultCd);
+        const jitter = 1 + Math.random() * 3; // 1-4s random jitter for safety
+        const totalWait = cd + jitter;
+        this.log('info', `${c.dim}⏳ cd ${cd}s + ${jitter.toFixed(1)}s jitter = ${totalWait.toFixed(1)}s${c.reset}`);
+        await new Promise((r) => setTimeout(r, totalWait * 1000));
+      }
+
+      cycleCount++;
+
+      // Every 5 cycles: print stats + check balance
+      if (cycleCount % 5 === 0) {
+        this.printStats();
+        await humanDelay(500, 1500);
+        await this.checkBalance();
+        await humanDelay(2000, 4000);
       }
 
       const cycleDelay = 2 + Math.random() * 3;
-      this.log('info', `${c.dim}Cycle done. Next in ${cycleDelay.toFixed(1)}s${c.reset}`);
+      this.log('info', `${c.dim}Cycle ${cycleCount} done. Next in ${cycleDelay.toFixed(1)}s${c.reset}`);
       await new Promise((r) => setTimeout(r, cycleDelay * 1000));
     }
   }
 
+  // ── Re-fetch Config from API ─────────────────────────────────
+  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 */ }
+  }
+
+  // ── Start Worker ────────────────────────────────────────────
   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}`);
-
+        // Use the actual Discord username
+        this.username = this.client.user.tag || this.username;
+
+        // Report username back to API
+        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}`);
+        // Show per-command cooldowns
+        const cmdInfo = [
+          { key: 'cmd_hunt', cd: 'cd_hunt', label: 'hunt' },
+          { key: 'cmd_dig', cd: 'cd_dig', label: 'dig' },
+          { key: 'cmd_beg', cd: 'cd_beg', label: 'beg' },
+          { key: 'cmd_search', cd: 'cd_search', label: 'search' },
+          { key: 'cmd_hl', cd: 'cd_hl', label: 'hl' },
+          { key: 'cmd_crime', cd: 'cd_crime', label: 'crime' },
+          { key: 'cmd_pm', cd: 'cd_pm', label: 'pm' },
+        ].filter((ci) => this.account[ci.key] === true || this.account[ci.key] === 1);
+
+        const cmdStr = cmdInfo.map((ci) => `${ci.label}(${this.account[ci.cd] || 20}s)`).join(', ');
+        this.log('info', `Commands: ${c.white}${cmdStr || 'none'}${c.reset}`);
+
+        // Initial balance check
+        await this.checkBalance();
         console.log('');
 
         this.grindLoop();
@@ -331,55 +598,54 @@ class AccountWorker {
   }
 }
 
-// ── Main Entry ──────────────────────────────────
+// ══════════════════════════════════════════════════════════════
+// ═  Main Entry
+// ══════════════════════════════════════════════════════════════
 
 async function start(apiKey, apiUrl) {
   API_KEY = apiKey;
   API_URL = apiUrl;
 
   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}`);
+  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}v3.0${c.reset}                    ${c.magenta}${c.bold}│${c.reset}`);
+  console.log(`  ${c.magenta}${c.bold}│${c.reset}   ${c.dim}Per-Cmd CD • Live Control • Smart${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}`);
   console.log('');
 
   log('info', `API: ${c.dim}${API_URL}${c.reset}`);
-  log('info', 'Fetching config & accounts...');
+  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}`);
+  log('info', `${c.bold}All workers running.${c.reset} ${c.dim}Ctrl+C to stop.${c.reset}`);
   console.log('');
 
   process.on('SIGINT', () => {
     console.log('');
-    log('warn', 'Shutting down all workers...');
-    for (const w of workers) w.stop();
+    log('warn', 'Shutting down...');
+    for (const w of workers) {
+      w.printStats();
+      w.stop();
+    }
     setTimeout(() => process.exit(0), 2000);
   });
 }

package/package.json

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