dankgrinder 4.6.0 → 4.8.1

package/bin/dankgrinder.js

@@ -46,6 +46,24 @@ for (let i = 0; i < args.length; i++) {
 apiUrl = apiUrl || process.env.DANKGRINDER_URL || DEFAULT_URL;
 if (redisUrl) process.env.REDIS_URL = redisUrl;
 
+// Keep process alive on transient discord interaction fetch failures.
+process.on('uncaughtException', (err) => {
+  const msg = String(err?.message || err || '');
+  const stack = String(err?.stack || '');
+  if (msg.toLowerCase().includes('fetch failed') && stack.includes('discord.js-selfbot-v13')) {
+    console.error(`\n  ${C.red}✗ Discord interaction fetch failed (transient). Continuing...${C.r}\n`);
+    return;
+  }
+  throw err;
+});
+process.on('unhandledRejection', (reason) => {
+  const msg = String(reason?.message || reason || '');
+  if (msg.toLowerCase().includes('fetch failed')) {
+    console.error(`\n  ${C.red}✗ Unhandled fetch failure (network/transient). Continuing...${C.r}\n`);
+    return;
+  }
+});
+
 if (!apiKey) {
   console.error(`\n  ${C.red}✗ Missing API key.${C.r}\n`);
   console.error(`  ${C.b}Usage:${C.r}  npx dankgrinder --key <YOUR_API_KEY>\n`);

package/lib/commands/adventure.js

@@ -34,11 +34,10 @@
  */
 
 const {
-  LOG, c, sleep, humanDelay, getFullText, parseCoins, parseBalance,
-  getAllButtons, getAllSelectMenus, findButton, findSelectMenuOption,
-  safeClickButton, isHoldTight, logMsg, dumpMessage, needsItem,
+  LOG, c, sleep, humanDelay, getFullText, parseCoins,
+  getAllButtons, getAllSelectMenus, findButton,
+  safeClickButton, isHoldTight, logMsg,
 } = require('./utils');
-const { buyItem } = require('./shop');
 
 // ── Adventure type rotation (cycle through all types each run) ────
 let lastAdventureIndex = -1;
@@ -63,8 +62,7 @@ async function clickAndRefetch(channel, msg, btn) {
     LOG.error(`[adventure] Click error: ${e.message}`);
     return null;
   }
-  // Dank Memer edits the message after a button click
-  await sleep(500);
+  await sleep(250);
   return await refetchMsg(channel, msg.id);
 }
 
@@ -172,7 +170,7 @@ async function playAdventureRounds(channel, msg) {
       const choice = pickSafeChoice(choices);
       if (choice) {
         LOG.info(`[adventure] → Choosing: "${choice.label}"`);
-        await sleep(200);
+        await sleep(100);
         const afterChoice = await clickAndRefetch(channel, current, choice);
         if (afterChoice) {
           current = afterChoice;
@@ -194,7 +192,7 @@ async function playAdventureRounds(channel, msg) {
     const nextBtnNow = getNextButton(current);
     if (nextBtnNow && !nextBtnNow.disabled) {
       LOG.debug(`[adventure] Clicking Next arrow...`);
-      await sleep(200);
+      await sleep(100);
       const afterNext = await clickAndRefetch(channel, current, nextBtnNow);
       if (afterNext) {
         current = afterNext;
@@ -206,7 +204,7 @@ async function playAdventureRounds(channel, msg) {
     } else if (nextBtnNow && nextBtnNow.disabled) {
       // Next is disabled but no choices found — might be loading
       LOG.debug(`[adventure] Next disabled, no choices — waiting...`);
-      await sleep(600);
+      await sleep(300);
       const refreshed = await refetchMsg(channel, current.id);
       if (refreshed) {
         current = refreshed;
@@ -219,8 +217,7 @@ async function playAdventureRounds(channel, msg) {
       // No next button at all
       LOG.debug(`[adventure] No Next button — checking if done`);
       if (isAdventureDone(current)) break;
-      // Wait and re-fetch as Dank Memer might still be editing
-      await sleep(1500);
+      await sleep(500);
       const refreshed = await refetchMsg(channel, current.id);
       if (refreshed) {
         current = refreshed;
@@ -314,42 +311,10 @@ async function runAdventure({ channel, waitForDankMemer, client }) {
     return { result: 'cooldown', coins: 0, nextCooldownSec: cooldownSec + 3 };
   }
 
-  // ── 4) If we need a ticket, try to buy one ─────────────────
+  // ── 4) If we need a ticket, skip (too expensive to auto-buy) ──
   if (needsTicket) {
-    LOG.warn(`[adventure] Need adventure ticket! Attempting to buy...`);
-
-    // Ticket costs 250,000 coins — check balance first to avoid wasting time in shop
-    const TICKET_COST = 250000;
-    let currentBalance = 0;
-    await channel.send('pls bal');
-    const balMsg = await waitForDankMemer(8000);
-    if (balMsg) {
-      currentBalance = parseBalance(balMsg);
-      LOG.info(`[adventure] Balance: ${c.yellow}⏣ ${currentBalance.toLocaleString()}${c.reset} (ticket costs ⏣ ${TICKET_COST.toLocaleString()})`);
-    }
-
-    if (currentBalance < TICKET_COST) {
-      LOG.warn(`[adventure] Not enough coins for ticket (⏣ ${currentBalance.toLocaleString()} < ⏣ ${TICKET_COST.toLocaleString()}). Grind more first.`);
-      return { result: `need ticket (⏣ ${currentBalance.toLocaleString()}/${TICKET_COST.toLocaleString()})`, coins: 0, nextCooldownSec: 120 };
-    }
-
-    const bought = await buyItem({
-      channel, waitForDankMemer, client,
-      itemName: 'Adventure Ticket', quantity: 1,
-    });
-
-    if (!bought) {
-      LOG.error('[adventure] Could not buy adventure ticket from shop.');
-      return { result: 'need ticket (buy failed)', coins: 0, nextCooldownSec: 120 };
-    }
-
-    LOG.success('[adventure] Tickets purchased! Re-running adventure...');
-    await sleep(1500);
-
-    await channel.send('pls adventure');
-    response = await waitForDankMemer(12000);
-    if (!response) return { result: 'no response after ticket buy', coins: 0, nextCooldownSec: null };
-    logMsg(response, 'adventure-after-buy');
+    LOG.warn(`[adventure] No ticket — skipping (too expensive to auto-buy)`);
+    return { result: 'no ticket', coins: 0, nextCooldownSec: 3600, skipReason: 'no_ticket' };
   }
 
   // ── Check if we're already mid-adventure (no select menu) ──

package/lib/commands/dig.js

@@ -45,7 +45,7 @@ async function runDig({ channel, waitForDankMemer, client }) {
     const bought = await buyItem({
       channel, waitForDankMemer, client,
       itemName: 'Shovel',
-      quantity: 3,
+      quantity: 1,
     });
 
     if (bought) {

package/lib/commands/gamble.js

@@ -1,6 +1,6 @@
 /**
- * Simple gambling command handlers.
- * Covers: coinflip, roulette, slots, snakeeyes
+ * Gambling command handlers.
+ * Covers: cointoss, roulette, slots, snakeeyes
  */
 
 const {
@@ -8,6 +8,29 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
 } = require('./utils');
 
+function parseGambleResult(text, cmdName) {
+  const net = parseNetCoins(text);
+  const lower = text.toLowerCase();
+
+  if (net > 0) {
+    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → +⏣ ${net.toLocaleString()}`, coins: net };
+  }
+  if (net < 0) {
+    LOG.warn(`[${cmdName}] ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → -⏣ ${Math.abs(net).toLocaleString()}`, coins: 0, lost: Math.abs(net) };
+  }
+  const coins = parseCoins(text);
+  if (coins > 0) {
+    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+  if (lower.includes('won') || lower.includes('beat')) return { result: `${cmdName} → won`, coins: 0 };
+  if (lower.includes('lost') || lower.includes('bust')) return { result: `${cmdName} → lost`, coins: 0, lost: coins };
+
+  return { result: `${cmdName} done`, coins: 0 };
+}
+
 async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
   LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
 
@@ -26,16 +49,29 @@ async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  // Check for min bet error
+  const initText = getFullText(response);
+  const initLower = initText.toLowerCase();
+  if (initLower.includes("can't bet less than") || initLower.includes('cannot bet less than') || initLower.includes('minimum bet')) {
+    const betMatch = initText.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || initText.match(/(\d[\d,]+)/);
+    if (betMatch) {
+      const minBet = parseInt(betMatch[1].replace(/,/g, ''));
+      if (minBet > 0) return { result: `min bet ${minBet}`, coins: 0, newMinBet: minBet };
+    }
+    return { result: 'min bet error', coins: 0 };
+  }
+
   logMsg(response, cmdName);
   const text = getFullText(response);
 
-  // Some gambles have buttons (coinflip: pick heads/tails)
+  // For cointoss/gambles with buttons: click a random non-disabled button
   const buttons = getAllButtons(response);
   if (buttons.length > 0) {
-    const btn = buttons.find(b => !b.disabled);
-    if (btn) {
-      LOG.info(`[${cmdName}] Clicking "${btn.label}"`);
-      await humanDelay();
+    const clickable = buttons.filter(b => !b.disabled);
+    if (clickable.length > 0) {
+      const btn = clickable[Math.floor(Math.random() * clickable.length)];
+      LOG.info(`[${cmdName}] Clicking "${btn.label || '?'}"`);
+      await humanDelay(50, 200);
       try {
         const followUp = await safeClickButton(response, btn);
         if (followUp) {
@@ -50,32 +86,11 @@ async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
   return parseGambleResult(text, cmdName);
 }
 
-function parseGambleResult(text, cmdName) {
-  const net = parseNetCoins(text);
-  const lower = text.toLowerCase();
-
-  if (net > 0) {
-    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
-    return { result: `${cmdName} → +⏣ ${net.toLocaleString()}`, coins: net };
-  }
-  if (net < 0) {
-    LOG.warn(`[${cmdName}] ${c.red}-⏣ ${Math.abs(net).toLocaleString()}${c.reset}`);
-    return { result: `${cmdName} → -⏣ ${Math.abs(net).toLocaleString()}`, coins: 0, lost: Math.abs(net) };
-  }
-  // Fallback to parseCoins
-  const coins = parseCoins(text);
-  if (coins > 0) {
-    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
-  }
-  if (lower.includes('won') || lower.includes('beat')) return { result: `${cmdName} → won`, coins: 0 };
-  if (lower.includes('lost') || lower.includes('bust')) return { result: `${cmdName} → lost`, coins: 0, lost: coins };
-
-  return { result: `${cmdName} done`, coins: 0 };
-}
-
-async function runCoinflip({ channel, waitForDankMemer, betAmount = 5000 }) {
-  return runGamble({ channel, waitForDankMemer, cmdName: 'coinflip', cmdString: `pls coinflip ${betAmount} heads` });
+/**
+ * Cointoss: send "pls cointoss <bet>", then click Heads or Tails randomly.
+ */
+async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
+  return runGamble({ channel, waitForDankMemer, cmdName: 'cointoss', cmdString: `pls cointoss ${betAmount}` });
 }
 
 async function runRoulette({ channel, waitForDankMemer, betAmount = 5000 }) {
@@ -90,4 +105,4 @@ async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 5000 }) {
   return runGamble({ channel, waitForDankMemer, cmdName: 'snakeeyes', cmdString: `pls snakeeyes ${betAmount}` });
 }
 
-module.exports = { runGamble, runCoinflip, runRoulette, runSlots, runSnakeeyes };
+module.exports = { runGamble, runCointoss, runRoulette, runSlots, runSnakeeyes };

package/lib/commands/generic.js

@@ -45,7 +45,7 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
   const missing = needsItem(text);
   if (missing) {
     LOG.warn(`[${cmdName}] Missing ${c.bold}${missing}${c.reset} — auto-buying...`);
-    const bought = await buyItem({ channel, waitForDankMemer, client, itemName: missing, quantity: 3 });
+    const bought = await buyItem({ channel, waitForDankMemer, client, itemName: missing, quantity: 1 });
     if (bought) {
       LOG.success(`[${cmdName}] Bought ${missing}, retrying command...`);
       await sleep(3000);
@@ -65,11 +65,12 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
     return { result: `need ${missing} (buy failed)`, coins: 0 };
   }
 
-  // Handle buttons if present
+  // Handle buttons if present — pick a random non-disabled button
   const buttons = getAllButtons(response);
   if (buttons.length > 0) {
-    const btn = buttons.find(b => !b.disabled) || buttons[0];
-    if (btn && !btn.disabled) {
+    const clickable = buttons.filter(b => !b.disabled);
+    const btn = clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+    if (btn) {
       LOG.info(`[${cmdName}] Clicking "${btn.label || '?'}"`);
       await humanDelay();
       try {

package/lib/commands/hunt.js

@@ -45,7 +45,7 @@ async function runHunt({ channel, waitForDankMemer, client }) {
       const bought = await buyItem({
         channel, waitForDankMemer, client,
         itemName: 'Hunting Rifle',
-        quantity: 3,
+        quantity: 1,
       });
 
       if (bought) {

package/lib/commands/index.js

@@ -16,7 +16,7 @@ const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
 const { runTrivia, triviaDB } = require('./trivia');
 const { runWorkShift } = require('./work');
-const { runCoinflip, runRoulette, runSlots, runSnakeeyes, runGamble } = require('./gamble');
+const { runCointoss, runRoulette, runSlots, runSnakeeyes, runGamble } = require('./gamble');
 const { runDeposit } = require('./deposit');
 const { runGeneric, runAlert } = require('./generic');
 const { runStream } = require('./stream');
@@ -39,7 +39,7 @@ module.exports = {
   runBlackjack,
   runTrivia,
   runWorkShift,
-  runCoinflip,
+  runCointoss,
   runRoulette,
   runSlots,
   runSnakeeyes,

package/lib/commands/shop.js

@@ -32,8 +32,12 @@ const ITEM_COSTS = {
  * @returns {Promise<boolean>} true if purchase succeeded
  */
 async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, client }) {
-  const MAX_RETRIES = 3;
-  const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '').replace('adventure ', '');
+  const MAX_RETRIES = 1;
+  const searchNames = [
+    itemName.toLowerCase(),
+    itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '').replace('adventure ', ''),
+    itemName.toLowerCase().split(' ').pop(),
+  ];
 
   for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
     LOG.buy(`Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset} (attempt ${attempt}/${MAX_RETRIES})`);
@@ -120,30 +124,17 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
     logMsg(response, 'shop-after-nav');
 
     // Step 3: Find the Buy button for our item
-    let buyBtn = getAllButtons(response).find(b => b.label && b.label.toLowerCase().includes(searchName));
+    let buyBtn = getAllButtons(response).find(b => {
+      if (!b.label) return false;
+      const label = b.label.toLowerCase();
+      return searchNames.some(s => label.includes(s) || s.includes(label));
+    });
 
     if (!buyBtn) {
-      LOG.warn(`No Buy button found for "${itemName}" (searched: "${searchName}")`);
-      // Log all available buttons for debugging
+      LOG.warn(`No Buy button found for "${itemName}"`);
       const allBtns = getAllButtons(response);
       if (allBtns.length > 0) {
-        LOG.debug(`Available buttons: ${allBtns.map(b => `"${b.label}"`).join(', ')}`);
-      }
-      // Maybe we need to scroll/paginate?
-      const nextBtn = findButton(response, 'next') || findButton(response, '▶') || findButton(response, '→');
-      if (nextBtn && !nextBtn.disabled) {
-        LOG.buy('Clicking next page to find item...');
-        try {
-          const nextPage = await safeClickButton(response, nextBtn);
-          if (nextPage) {
-            response = nextPage;
-            logMsg(response, 'shop-page2');
-            // Try finding button again
-            buyBtn = getAllButtons(response).find(b => b.label && b.label.toLowerCase().includes(searchName));
-          }
-        } catch (e) {
-          LOG.error(`Page nav failed: ${e.message}`);
-        }
+        LOG.debug(`Available: ${allBtns.map(b => `"${b.label}"`).join(', ')}`);
       }
 
       if (!buyBtn) {

package/lib/grinder.js

@@ -270,15 +270,32 @@ function log(type, msg, label) {
   }
 }
 
-async function fetchConfig() {
-  try {
-    const res = await fetch(`${API_URL}/api/grinder/config`, {
-      headers: { Authorization: `Bearer ${API_KEY}` },
-    });
-    const data = await res.json();
-    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; }
+async function fetchConfig(retries = 3, delayMs = 1500) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const t = setTimeout(() => controller.abort(), 10000);
+      const res = await fetch(`${API_URL}/api/grinder/config`, {
+        headers: { Authorization: `Bearer ${API_KEY}` },
+        signal: controller.signal,
+      });
+      clearTimeout(t);
+      const data = await res.json();
+      if (data.error) {
+        log('error', `Config fetch failed: ${data.error}`);
+        return null;
+      }
+      return data;
+    } catch (err) {
+      if (attempt < retries) {
+        log('warn', `API fetch failed (attempt ${attempt}/${retries}) — retrying...`);
+        await new Promise((r) => setTimeout(r, delayMs * attempt));
+      } else {
+        log('error', `Cannot reach API: ${err.message}`);
+      }
+    }
+  }
+  return null;
 }
 
 async function sendLog(accountName, command, response, status) {
@@ -509,6 +526,7 @@ class AccountWorker {
     this.globalCooldownUntil = 0;
     this.commandQueue = null;
     this.lastHealthCheck = Date.now();
+    this.doneToday = new Map(); // in-memory dedup: cmd → expiry timestamp
   }
 
   get tag() { return `${this.color}${c.bold}${this.username}${c.reset}`; }
@@ -616,8 +634,8 @@ class AccountWorker {
     return null;
   }
 
-  async buyItem(itemName, quantity = 10) {
-    const MAX_RETRIES = 3;
+  async buyItem(itemName, quantity = 1) {
+    const MAX_RETRIES = 1;
     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) {
@@ -671,12 +689,18 @@ class AccountWorker {
       }
       await humanDelay(1000, 2000);
 
-      // Find Buy button
+      // Find Buy button — match by full name or partial name
       let buyBtn = null;
-      const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '');
+      const searchNames = [
+        itemName.toLowerCase(),
+        itemName.toLowerCase().replace('hunting ', '').replace('fishing ', ''),
+        itemName.toLowerCase().split(' ')[0],
+      ];
       for (const row of response.components || []) {
         for (const comp of row.components || []) {
-          if (comp.type === 2 && comp.label && comp.label.toLowerCase().includes(searchName)) {
+          if (comp.type !== 2 || !comp.label) continue;
+          const label = comp.label.toLowerCase();
+          if (searchNames.some(s => label.includes(s) || s.includes(label))) {
             buyBtn = comp; break;
           }
         }
@@ -788,7 +812,7 @@ class AccountWorker {
       case 'dep max':     cmdString = `${prefix} dep max`; break;
       case 'with max':    cmdString = `${prefix} with max`; break;
       case 'blackjack':   cmdString = `${prefix} bj ${betAmount}`; break;
-      case 'coinflip':    cmdString = `${prefix} coinflip ${betAmount} heads`; break;
+      case 'cointoss':    cmdString = `${prefix} cointoss ${betAmount}`; break;
       case 'roulette':    cmdString = `${prefix} roulette ${betAmount} red`; break;
       case 'slots':       cmdString = `${prefix} slots ${betAmount}`; break;
       case 'snakeeyes':   cmdString = `${prefix} snakeeyes ${betAmount}`; break;
@@ -826,7 +850,7 @@ class AccountWorker {
         case 'blackjack':   cmdResult = await commands.runBlackjack(cmdOpts); break;
         case 'trivia':      cmdResult = await commands.runTrivia(cmdOpts); break;
         case 'work shift':  cmdResult = await commands.runWorkShift(cmdOpts); break;
-        case 'coinflip':    cmdResult = await commands.runCoinflip(cmdOpts); break;
+        case 'cointoss':    cmdResult = await commands.runCointoss(cmdOpts); break;
         case 'roulette':    cmdResult = await commands.runRoulette(cmdOpts); break;
         case 'slots':       cmdResult = await commands.runSlots(cmdOpts); break;
         case 'snakeeyes':   cmdResult = await commands.runSnakeeyes(cmdOpts); break;
@@ -878,18 +902,24 @@ class AccountWorker {
         return;
       }
 
-      // Min bet detection — raise bet amount
-      if (resultLower.includes('cannot bet less than') || resultLower.includes('minimum bet')) {
-        const betMatch = result.match(/⏣\s*([\d,]+)/);
+      // Min bet detection — "You can't bet less than 10,000" or "cannot bet less than ⏣ 5,000"
+      if (resultLower.includes("can't bet less than") || resultLower.includes('cannot bet less than') || resultLower.includes('minimum bet')) {
+        const betMatch = result.match(/less than\s*\*?\*?\s*[⏣o]?\s*([\d,]+)/i) || result.match(/(\d[\d,]+)/);
         if (betMatch) {
           const minBet = parseInt(betMatch[1].replace(/,/g, ''));
           if (minBet > 0) {
             this.account.bet_amount = minBet;
-            this.log('info', `${cmdName} min bet: ⏣ ${minBet.toLocaleString()}`);
+            this.log('info', `${cmdName} min bet raised → ⏣ ${minBet.toLocaleString()}`);
           }
         }
         return;
       }
+      // Also handle newMinBet from gamble handler
+      if (cmdResult.newMinBet && cmdResult.newMinBet > (this.account.bet_amount || 0)) {
+        this.account.bet_amount = cmdResult.newMinBet;
+        this.log('info', `${cmdName} min bet raised → ⏣ ${cmdResult.newMinBet.toLocaleString()}`);
+        return;
+      }
 
       // Premium-only command detection — disable for 24h
       if (resultLower.includes('only available on premium') || resultLower.includes('premium') ||
@@ -899,41 +929,50 @@ class AccountWorker {
         return;
       }
 
-      // Already claimed today (daily/weekly) — set long cooldown + mark in Redis
+      // Already claimed today (daily/weekly) — set long cooldown + mark done
       if (resultLower.includes('already got your daily') || resultLower.includes('try again <t:')) {
         this.log('info', `${cmdName} already claimed — waiting`);
         const timeMatch = result.match(/<t:(\d+):R>/);
+        let waitSec;
         if (timeMatch) {
           const nextAvail = parseInt(timeMatch[1]) * 1000;
-          const waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
-          await this.setCooldown(cmdName, waitSec);
-          if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', waitSec); } catch {}
+          waitSec = Math.max(60, Math.ceil((nextAvail - Date.now()) / 1000));
         } else {
-          const fallbackSec = cmdName === 'daily' ? 86400 : 604800;
-          await this.setCooldown(cmdName, fallbackSec);
-          if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', fallbackSec); } catch {}
+          waitSec = cmdName === 'daily' ? 86400 : 604800;
         }
+        await this.setCooldown(cmdName, waitSec);
+        this.doneToday.set(cmdName, Date.now() + waitSec * 1000);
+        if (redis) try { await redis.set(`dkg:done:${this.account.id}:${cmdName}`, '1', 'EX', waitSec); } catch {}
         return;
       }
 
-      // Scratch level-gate: if level too low, disable for 24h
+      // Skip reasons: level too low, no ticket, etc.
       if (cmdResult.skipReason === 'level') {
         this.log('warn', `${cmdName} level too low — retry in 24h`);
         await this.setCooldown(cmdName, 86400);
         return;
       }
+      if (cmdResult.skipReason === 'no_ticket') {
+        this.log('warn', `${cmdName} no ticket — retry in 1h`);
+        await this.setCooldown(cmdName, 3600);
+        return;
+      }
 
       const earned = Math.max(0, cmdResult.coins || 0);
       const spent = Math.max(0, cmdResult.lost || 0);
       if (earned > 0) this.stats.coins += earned;
       if (cmdResult.nextCooldownSec) await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
 
-      // Mark daily/drops as done in Redis so we don't re-run this session
-      if (redis && earned > 0 && cmdName === 'daily') {
-        try { await redis.set(`dkg:done:${this.account.id}:daily`, '1', 'EX', 86400); } catch {}
+      // Mark daily/drops as done so we don't re-run this session
+      if (cmdName === 'daily' && earned > 0) {
+        const expiry = Date.now() + 86400 * 1000;
+        this.doneToday.set('daily', expiry);
+        if (redis) try { await redis.set(`dkg:done:${this.account.id}:daily`, '1', 'EX', 86400); } catch {}
       }
-      if (redis && cmdName === 'drops') {
-        try { await redis.set(`dkg:done:${this.account.id}:drops`, '1', 'EX', 86400); } catch {}
+      if (cmdName === 'drops') {
+        const expiry = Date.now() + 86400 * 1000;
+        this.doneToday.set('drops', expiry);
+        if (redis) try { await redis.set(`dkg:done:${this.account.id}:drops`, '1', 'EX', 86400); } catch {}
       }
 
       if (cmdResult.holdTightReason) {
@@ -991,7 +1030,7 @@ class AccountWorker {
     { key: 'cmd_trivia', cmd: 'trivia', cdKey: 'cd_trivia', defaultCd: 10, priority: 2 },
     // Gambling (fast cycle)
     { 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_cointoss', cmd: 'cointoss', 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 },
@@ -1147,17 +1186,28 @@ class AccountWorker {
       return;
     }
 
-    // Skip daily/drops if already done today (Redis marker)
-    if (redis && (item.cmd === 'daily' || item.cmd === 'drops')) {
-      try {
-        const done = await redis.get(`dkg:done:${this.account.id}:${item.cmd}`);
-        if (done) {
-          item.nextRunAt = now + 86400 * 1000;
-          if (this.commandQueue) this.commandQueue.push(item);
-          this.tickTimeout = setTimeout(() => this.tick(), 100);
-          return;
-        }
-      } catch {}
+    // Skip daily/drops if already done today (in-memory + Redis)
+    if (item.cmd === 'daily' || item.cmd === 'drops') {
+      const memExpiry = this.doneToday.get(item.cmd);
+      if (memExpiry && Date.now() < memExpiry) {
+        item.nextRunAt = memExpiry;
+        if (this.commandQueue) this.commandQueue.push(item);
+        this.tickTimeout = setTimeout(() => this.tick(), 100);
+        return;
+      }
+      if (redis) {
+        try {
+          const done = await redis.get(`dkg:done:${this.account.id}:${item.cmd}`);
+          if (done) {
+            const expiry = now + 86400 * 1000;
+            this.doneToday.set(item.cmd, expiry);
+            item.nextRunAt = expiry;
+            if (this.commandQueue) this.commandQueue.push(item);
+            this.tickTimeout = setTimeout(() => this.tick(), 100);
+            return;
+          }
+        } catch {}
+      }
     }
 
     this.busy = true;
@@ -1167,10 +1217,11 @@ class AccountWorker {
 
     await this.setCooldown(item.cmd, totalWait);
 
+    // Inter-command delay: 1-3s random (human-like spacing)
     const timeSinceLastCmd = now - (this.lastCommandRun || 0);
-    const globalJitter = 500 + Math.random() * 1000;
-    if (timeSinceLastCmd < globalJitter) {
-      await new Promise(r => setTimeout(r, globalJitter - timeSinceLastCmd));
+    const minGap = 1000 + Math.random() * 2000; // 1-3s
+    if (timeSinceLastCmd < minGap) {
+      await new Promise(r => setTimeout(r, minGap - timeSinceLastCmd));
     }
 
     const prefix = this.account.use_slash ? '/' : 'pls';
@@ -1326,7 +1377,7 @@ class AccountWorker {
           { key: 'cmd_stream', l: 'stream' }, { key: 'cmd_scratch', l: 'scratch' },
           { key: 'cmd_adventure', l: 'adv' }, { key: 'cmd_farm', l: 'farm' },
           { key: 'cmd_tidy', l: 'tidy' }, { key: 'cmd_blackjack', l: 'bj' },
-          { key: 'cmd_cointoss', l: 'flip' }, { key: 'cmd_roulette', l: 'roul' },
+          { key: 'cmd_cointoss', l: 'toss' }, { key: 'cmd_roulette', l: 'roul' },
           { key: 'cmd_slots', l: 'slots' }, { key: 'cmd_snakeeyes', l: 'snake' },
           { key: 'cmd_trivia', l: 'trivia' }, { key: 'cmd_use', l: 'use' },
           { key: 'cmd_deposit', l: 'dep' },           { key: 'cmd_drops', l: 'drops' },
@@ -1377,7 +1428,7 @@ async function start(apiKey, apiUrl) {
 
   console.log(colorBanner());
   console.log(
-    `  ${rgb(139, 92, 246)}v4.6${c.reset}` +
+    `  ${rgb(139, 92, 246)}v4.8.1${c.reset}` +
     `  ${c.dim}·${c.reset}  ${c.white}30 Commands${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}Priority Queue${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}Redis Cooldowns${c.reset}` +
@@ -1392,17 +1443,18 @@ async function start(apiKey, apiUrl) {
 
   log('info', `${c.dim}Fetching accounts...${c.reset}`);
 
-  const data = await fetchConfig();
-  if (!data) {
+  let data = await fetchConfig(4, 2000);
+  while (!data) {
     log('error', `Cannot connect to API`);
-    log('error', `Check your API key or API URL and try again.`);
-    process.exit(1);
+    log('warn', `Will retry in 10s (check internet/API URL if this repeats).`);
+    await new Promise((r) => setTimeout(r, 10000));
+    data = await fetchConfig(4, 2000);
   }
 
   const { accounts } = data;
   if (!accounts || accounts.length === 0) {
     log('error', 'No active accounts. Add them in the dashboard.');
-    process.exit(1);
+    return;
   }
 
   checks.push(`${rgb(52, 211, 153)}✓${c.reset} ${c.white}${accounts.length} Account${accounts.length > 1 ? 's' : ''}${c.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dankgrinder",
-  "version": "4.6.0",
+  "version": "4.8.1",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"
@@ -21,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "debug": "^4.4.0",
-    "discord.js-selfbot-v13": "^3.6.1",
+    "discord.js-selfbot-v13": "3.5.0",
     "ioredis": "^5.10.1",
     "sharp": "^0.34.5"
   },