dankgrinder 4.0.0 → 4.1.0

package/README.md

@@ -1,16 +1,16 @@
 # DankGrinder CLI
 
-Dank Memer automation engine — grind coins while you sleep.
+Dank Memer automation engine — multi-account grinding with live TUI dashboard.
 
 ## Installation & Usage
 
 ```bash
 # Run directly (no install needed)
-npx dankgrinder --key dkg_your_api_key
+npx dankgrinder --key dkg_your_api_key --url https://your-dashboard.com
 
 # Or install globally
 npm install -g dankgrinder
-dankgrinder --key dkg_your_api_key
+dankgrinder --key dkg_your_api_key --url https://your-dashboard.com
 ```
 
 ## Options
@@ -18,30 +18,39 @@ dankgrinder --key dkg_your_api_key
 | Flag | Description | Default |
 |------|-------------|---------|
 | `--key <key>` | Your DankGrinder API key (required) | — |
-| `--url <url>` | API server URL | `http://localhost:3000` |
+| `--url <url>` | API server URL (required) | — |
 | `--help` | Show help | — |
 | `--version` | Show version | — |
 
 ## Setup
 
 1. Sign up at your DankGrinder dashboard
-2. Go to **Config** → set your Discord token and channel ID
-3. Enable the commands you want to automate
+2. Go to **Accounts** → add your Discord account(s) with token and channel ID
+3. Enable the commands you want to automate per account
 4. Go to **API Keys** → create a new key
-5. Run: `npx dankgrinder --key dkg_your_key`
+5. Run: `npx dankgrinder --key dkg_your_key --url https://your-dashboard.com`
 
-## Supported Commands
+## Supported Commands (30)
 
-- `pls hunt` — Hunt animals for coins
-- `pls dig` — Dig for treasure
-- `pls beg` — Beg for coins
-- `pls search` — Search locations
-- `pls hl` — Play highlow
-- `pls crime` — Commit crime
-- `pls pm` — Post memes
+| Category | Commands |
+|----------|----------|
+| **Grinding** | hunt, dig, fish, beg, search, crime, postmemes |
+| **Games** | highlow, blackjack, coinflip, roulette, slots, snakeeyes, trivia, scratch |
+| **Economy** | daily, weekly, monthly, work shift, stream, adventure, deposit |
+| **Utility** | farm, tidy, use, drops, alert |
+
+## Features
+
+- Multi-account support with per-account config
+- Redis-backed cooldowns per command per account
+- Live TUI dashboard with real-time stats
+- Auto-buy tools (shovel, fishing pole, rifle) when missing
+- Smart button/interaction handling for all mini-games
+- Hold Tight detection with automatic cooldown management
 
 ## Requirements
 
 - Node.js 18+
 - A DankGrinder account with API key
-- Discord token configured in dashboard
+- Discord token(s) configured in dashboard
+- Redis (optional, for persistent cooldowns via `REDIS_URL` env var)

package/bin/dankgrinder.js

@@ -6,30 +6,20 @@ const args = process.argv.slice(2);
 
 if (args.includes('--help') || args.includes('-h')) {
   console.log(`
-\x1b[35m╔══════════════════════════════════════╗
-║       \x1b[1mDankGrinder CLI v2.0\x1b[0m\x1b[35m           ║
-║   Multi-Account Automation Engine    ║
-╚══════════════════════════════════════╝\x1b[0m
-
-\x1b[1mUsage:\x1b[0m
-  npx dankgrinder --key <API_KEY> [options]
-
-\x1b[1mOptions:\x1b[0m
-  --key <key>    Your DankGrinder API key (required)
-  --url <url>    API server URL (default: http://localhost:3000)
-  --help, -h     Show this help message
-  --version, -v  Show version
-
-\x1b[1mExamples:\x1b[0m
-  npx dankgrinder --key dkg_abc123def456
-  npx dankgrinder --key dkg_abc123def456 --url https://myserver.com
-
-\x1b[1mSetup:\x1b[0m
-  1. Sign up at your DankGrinder dashboard
-  2. Go to the Accounts page and add your Discord accounts
-  3. Configure per-account commands and cooldowns
-  4. Generate an API key from Auth Tokens
-  5. Run this CLI — it spawns one worker per active account
+  \x1b[1m\x1b[35mDANK\x1b[36mGRINDER\x1b[0m \x1b[2mv4.0\x1b[0m
+
+  \x1b[1mUsage:\x1b[0m
+    npx dankgrinder --key <API_KEY> --url <DASHBOARD_URL>
+
+  \x1b[1mOptions:\x1b[0m
+    --key <key>    API key from dashboard (or env DANKGRINDER_KEY)
+    --url <url>    Dashboard URL (or env DANKGRINDER_URL)
+    --help, -h     Show this help
+    --version, -v  Show version
+
+  \x1b[1mExamples:\x1b[0m
+    npx dankgrinder --key dkg_abc123 --url https://myapp.up.railway.app
+    DANKGRINDER_KEY=dkg_abc123 DANKGRINDER_URL=https://... npx dankgrinder
 `);
   process.exit(0);
 }
@@ -40,8 +30,8 @@ if (args.includes('--version') || args.includes('-v')) {
   process.exit(0);
 }
 
-let apiKey = '';
-let apiUrl = 'http://localhost:3000';
+let apiKey = process.env.DANKGRINDER_KEY || '';
+let apiUrl = process.env.DANKGRINDER_URL || '';
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--key' && args[i + 1]) apiKey = args[i + 1];
@@ -51,9 +41,9 @@ for (let i = 0; i < args.length; i++) {
 if (!apiKey) {
   console.error('\x1b[31m✗ Missing API key.\x1b[0m');
   console.error('');
-  console.error('  Usage: npx dankgrinder --key <YOUR_API_KEY>');
+  console.error('  Usage: npx dankgrinder --key <YOUR_API_KEY> --url <DASHBOARD_URL>');
   console.error('');
-  console.error('  Get your API key from the DankGrinder dashboard.');
+  console.error('  Or set env vars: DANKGRINDER_KEY, DANKGRINDER_URL');
   console.error('  Run \x1b[36mnpx dankgrinder --help\x1b[0m for more info.');
   process.exit(1);
 }

package/lib/commands/adventure.js

@@ -0,0 +1,502 @@
+/**
+ * Adventure command handler.
+ * 
+ * Confirmed flow from live debugging:
+ * ─────────────────────────────────────────────────────────────
+ * 1. "pls adventure"
+ *    → SELECT_MENU: adventure types (space, west, halloween, museum, brazil, etc.)
+ *    → "Start" BUTTON  (customId: adventure-backpack:ID:TYPE, style=SUCCESS)
+ *    → If no ticket: Start is disabled
+ *
+ * 2. Click Start
+ *    → Equip screen: item grid buttons (null labels, emojis) + "Start" + "Equip All" + "Cancel"
+ *    → Click "Equip All" then "Start"
+ *
+ * 3. Adventure rounds (5 interactions shown in footer like "🚀 - ⦾ - ⦾ - ⦾ - ⦾"):
+ *    Each round has:
+ *      • Embed with event description + footer showing progress
+ *      • Backpack btn (emoji=Backpack, customId=adventure-progress:ID) — view-only
+ *      • ArrowRightui btn (customId=adventure-next:ID) — advance to next interaction
+ *      • Sometimes: choice buttons (customId=adventure-option:ID:N:M) like "Reach for it" / "Flee"
+ *
+ *    When choices are present → ArrowRightui is DISABLED until a choice is made.
+ *    After choosing → ArrowRightui becomes enabled. Click it to advance.
+ *    When no choices → ArrowRightui is enabled. Click it to advance directly.
+ *
+ * 4. After last interaction:
+ *    → "Adventure Progress" embed with Backpack, Rewards, Interactions fields
+ *    → No clickable buttons → adventure is done
+ *
+ * CRITICAL: safeClickButton()/clickButton() returns an interaction object,
+ * NOT the updated message. Must re-fetch via channel.messages.fetch(msg.id)
+ * to see the updated state after each click.
+ * ─────────────────────────────────────────────────────────────
+ */
+
+const {
+  LOG, c, sleep, humanDelay, getFullText, parseCoins, parseBalance,
+  getAllButtons, getAllSelectMenus, findButton, findSelectMenuOption,
+  safeClickButton, isHoldTight, logMsg, dumpMessage, needsItem,
+} = require('./utils');
+const { buyItem } = require('./shop');
+
+// ── Adventure type rotation (cycle through all types each run) ────
+let lastAdventureIndex = -1;
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+/** Re-fetch a message to get its current state after an interaction edit */
+async function refetchMsg(channel, msgId) {
+  try {
+    return await channel.messages.fetch(msgId);
+  } catch (e) {
+    LOG.error(`[adventure] Re-fetch failed: ${e.message}`);
+    return null;
+  }
+}
+
+/** Click a button on msg, then re-fetch msg to get updated state */
+async function clickAndRefetch(channel, msg, btn) {
+  try {
+    await safeClickButton(msg, btn);
+  } catch (e) {
+    LOG.error(`[adventure] Click error: ${e.message}`);
+    return null;
+  }
+  // Dank Memer edits the message after a button click
+  await sleep(500);
+  return await refetchMsg(channel, msg.id);
+}
+
+/** Parse footer progress like "🚀 - ⦾ - ⦾ - ⦾ - ⦾" → { current: 1, total: 5 } */
+function parseProgress(msg) {
+  const footer = msg.embeds?.[0]?.footer?.text || '';
+  // Count total markers and find the rocket position
+  const markers = footer.split(' - ');
+  if (markers.length < 2) return null;
+  const current = markers.findIndex(m => m.includes('🚀')) + 1;
+  return { current, total: markers.length };
+}
+
+/** Get all choice buttons (adventure-option) that are clickable */
+function getChoiceButtons(msg) {
+  return getAllButtons(msg).filter(b =>
+    !b.disabled && (b.customId || '').includes('adventure-option')
+  );
+}
+
+/** Get the "next" arrow button */
+function getNextButton(msg) {
+  return getAllButtons(msg).find(b =>
+    (b.customId || '').includes('adventure-next')
+  );
+}
+
+/** Check if msg is the final "Adventure Progress" summary */
+function isAdventureDone(msg) {
+  const text = getFullText(msg).toLowerCase();
+  const title = msg.embeds?.[0]?.title || '';
+  if (title === 'Adventure Progress') return true;
+  // Also done if no clickable buttons at all
+  const clickable = getAllButtons(msg).filter(b => !b.disabled);
+  if (clickable.length === 0) return true;
+  return false;
+}
+
+// ── Safe choices: prefer non-destructive options ─────────────────
+const SAFE_KEYWORDS = ['flee', 'run', 'hide', 'avoid', 'ignore', 'leave', 'walk away', 'back away', 'retreat', 'skip'];
+const RISKY_KEYWORDS = ['reach', 'grab', 'fight', 'attack', 'steal', 'open', 'touch', 'eat', 'drink'];
+
+function pickSafeChoice(choices) {
+  if (choices.length === 0) return null;
+  if (choices.length === 1) return choices[0];
+
+  // Check labels for safe/risky keywords
+  const labels = choices.map(b => (b.label || '').toLowerCase());
+
+  // Prefer safe keywords
+  for (let i = 0; i < labels.length; i++) {
+    for (const kw of SAFE_KEYWORDS) {
+      if (labels[i].includes(kw)) {
+        LOG.info(`[adventure] Picking safe option: "${choices[i].label}" (matched: ${kw})`);
+        return choices[i];
+      }
+    }
+  }
+
+  // Avoid risky keywords
+  const nonRisky = choices.filter((b, i) => {
+    return !RISKY_KEYWORDS.some(kw => labels[i].includes(kw));
+  });
+  if (nonRisky.length > 0) {
+    const pick = nonRisky[Math.floor(Math.random() * nonRisky.length)];
+    LOG.info(`[adventure] Picking non-risky option: "${pick.label}"`);
+    return pick;
+  }
+
+  // Fallback: random
+  const pick = choices[Math.floor(Math.random() * choices.length)];
+  LOG.info(`[adventure] Picking random option: "${pick.label}"`);
+  return pick;
+}
+
+// ── Play through all adventure rounds ────────────────────────────
+async function playAdventureRounds(channel, msg) {
+  let current = msg;
+  let interactions = 0;
+  const MAX_INTERACTIONS = 30;
+
+  while (interactions < MAX_INTERACTIONS) {
+    interactions++;
+
+    const progress = parseProgress(current);
+    const fullText = getFullText(current);
+    const choices = getChoiceButtons(current);
+    const nextBtn = getNextButton(current);
+    const done = isAdventureDone(current);
+
+    if (progress) {
+      LOG.info(`[adventure] Interaction ${progress.current}/${progress.total}: "${fullText.substring(0, 80).trim()}"`);
+    } else {
+      LOG.info(`[adventure] Step ${interactions}: "${fullText.substring(0, 80).trim()}"`);
+    }
+
+    if (done) {
+      LOG.success(`[adventure] Adventure finished after ${interactions} steps`);
+      break;
+    }
+
+    // ── If there are choices, pick one first ─────────────────
+    if (choices.length > 0) {
+      LOG.info(`[adventure] ${choices.length} choices: [${choices.map(b => `"${b.label}"`).join(', ')}]`);
+      const choice = pickSafeChoice(choices);
+      if (choice) {
+        LOG.info(`[adventure] → Choosing: "${choice.label}"`);
+        await sleep(200);
+        const afterChoice = await clickAndRefetch(channel, current, choice);
+        if (afterChoice) {
+          current = afterChoice;
+          logMsg(current, `adv-choice-${interactions}`);
+
+          // Check if adventure ended after this choice
+          if (isAdventureDone(current)) {
+            LOG.success(`[adventure] Adventure ended after choice at step ${interactions}`);
+            break;
+          }
+        } else {
+          LOG.warn(`[adventure] No response after choice click`);
+          break;
+        }
+      }
+    }
+
+    // ── Click "Next" arrow to advance ────────────────────────
+    const nextBtnNow = getNextButton(current);
+    if (nextBtnNow && !nextBtnNow.disabled) {
+      LOG.debug(`[adventure] Clicking Next arrow...`);
+      await sleep(200);
+      const afterNext = await clickAndRefetch(channel, current, nextBtnNow);
+      if (afterNext) {
+        current = afterNext;
+        logMsg(current, `adv-round-${interactions}`);
+      } else {
+        LOG.warn(`[adventure] No response after Next click`);
+        break;
+      }
+    } 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);
+      const refreshed = await refetchMsg(channel, current.id);
+      if (refreshed) {
+        current = refreshed;
+        // Don't increment interactions, just retry
+        interactions--;
+      } else {
+        break;
+      }
+    } else {
+      // 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);
+      const refreshed = await refetchMsg(channel, current.id);
+      if (refreshed) {
+        current = refreshed;
+        if (isAdventureDone(current)) break;
+        interactions--;
+      } else {
+        break;
+      }
+    }
+  }
+
+  // Parse final results
+  const finalText = getFullText(current);
+  const coins = parseCoins(finalText);
+
+  // Parse rewards from Adventure Progress embed
+  let rewards = '-';
+  for (const e of current.embeds || []) {
+    for (const f of e.fields || []) {
+      if (f.name === 'Rewards') rewards = f.value;
+    }
+  }
+  LOG.info(`[adventure] Rewards: ${rewards}`);
+
+  return { text: finalText, coins, interactions, rewards, finalMsg: current };
+}
+
+// ── Main: runAdventure ───────────────────────────────────────────
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel - Discord channel
+ * @param {function} opts.waitForDankMemer - Waits for Dank Memer response
+ * @param {object} [opts.client] - Discord client (for modal handling in shop)
+ * @returns {Promise<{result: string, coins: number, nextCooldownSec: number|null}>}
+ */
+async function runAdventure({ channel, waitForDankMemer, client }) {
+  LOG.cmd(`${c.white}${c.bold}pls adventure${c.reset}`);
+
+  // Step 1: Send the command
+  await channel.send('pls adventure');
+  let response = await waitForDankMemer(12000);
+
+  if (!response) {
+    LOG.warn('[adventure] No response from Dank Memer');
+    return { result: 'no response', coins: 0, nextCooldownSec: null };
+  }
+
+  // Check for Hold Tight
+  if (isHoldTight(response)) {
+    LOG.warn('[adventure] Hold Tight — waiting 30s');
+    await sleep(30000);
+    return { result: 'hold tight', coins: 0, nextCooldownSec: 35 };
+  }
+
+  logMsg(response, 'adventure-initial');
+
+  const text = getFullText(response);
+  const textLower = text.toLowerCase();
+  const allButtons = getAllButtons(response);
+
+  // ── 1) Check cooldown via Unix timestamp <t:UNIX:t> ────────
+  //    Format: "You can start another adventure at <t:1774415487:t> (<t:1774415487:R>)"
+  let cooldownSec = 0;
+  const tsMatch = text.match(/<t:(\d+)(?::[tTdDfFR])?>/);
+  if (tsMatch) {
+    const unixTarget = parseInt(tsMatch[1]);
+    const nowUnix = Math.floor(Date.now() / 1000);
+    cooldownSec = Math.max(0, unixTarget - nowUnix);
+    if (cooldownSec > 0) {
+      LOG.warn(`[adventure] On cooldown — next at ${new Date(unixTarget * 1000).toLocaleTimeString()} (${cooldownSec}s / ${Math.ceil(cooldownSec / 60)}min)`);
+    }
+  }
+
+  // ── 2) Check ticket need from button label ─────────────────
+  //    Button: "Start (1 Adventure Ticket)" with emoji=AdventureTicket
+  //    Footer: "You need adventure tickets to start the adventure!"
+  const startBtn = allButtons.find(b => (b.customId || '').includes('adventure-backpack'));
+  const startLabel = (startBtn?.label || '').toLowerCase();
+  const needsTicket = textLower.includes('you need adventure tickets') ||
+                      (startLabel.includes('ticket') && startBtn?.disabled);
+
+  LOG.debug(`[adventure] startBtn="${startBtn?.label}" disabled=${startBtn?.disabled}, needsTicket=${needsTicket}, cooldown=${cooldownSec}s`);
+
+  // ── 3) If on cooldown, return with exact seconds ───────────
+  if (cooldownSec > 5) {
+    // Even if we also need a ticket, cooldown takes priority — we can buy ticket later
+    if (needsTicket) {
+      LOG.info(`[adventure] Need ticket + on cooldown. Will buy ticket after cooldown.`);
+    }
+    return { result: 'cooldown', coins: 0, nextCooldownSec: cooldownSec + 3 };
+  }
+
+  // ── 4) If we need a ticket, try to buy one ─────────────────
+  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');
+  }
+
+  // ── Check if we're already mid-adventure (no select menu) ──
+  const menus = getAllSelectMenus(response);
+  const hasNextBtn = allButtons.some(b => (b.customId || '').includes('adventure-next'));
+
+  if (hasNextBtn && menus.length === 0) {
+    // Already mid-adventure from a previous run — jump straight to rounds
+    LOG.info('[adventure] Resuming mid-adventure...');
+    const { text: finalText, coins, interactions, rewards, finalMsg } = await playAdventureRounds(channel, response);
+    return buildResult(finalText, coins, interactions, rewards, finalMsg);
+  }
+
+  // ── Select adventure type from dropdown ─────────────────────
+  if (menus.length > 0) {
+    // Re-fetch message to get hydrated components (minValues/maxValues)
+    const freshMsg = await channel.messages.fetch(response.id).catch(() => null);
+    if (freshMsg) response = freshMsg;
+
+    // Find the select menu row index
+    let menuRowIdx = -1;
+    for (let i = 0; i < (response.components || []).length; i++) {
+      const row = response.components[i];
+      for (const comp of row.components || []) {
+        if (comp.type === 'STRING_SELECT' || comp.type === 3) { menuRowIdx = i; break; }
+      }
+      if (menuRowIdx >= 0) break;
+    }
+
+    const menu = response.components[menuRowIdx]?.components[0];
+    const options = menu?.options || [];
+    if (options.length > 0 && menuRowIdx >= 0) {
+      lastAdventureIndex = (lastAdventureIndex + 1) % options.length;
+      const opt = options[lastAdventureIndex];
+      LOG.info(`[adventure] Selecting [${lastAdventureIndex + 1}/${options.length}]: "${opt.label}"`);
+      try {
+        const selectResult = await response.selectMenu(menuRowIdx, [opt.value]);
+        if (selectResult) {
+          response = selectResult;
+          logMsg(response, 'adventure-selected');
+        }
+      } catch (e) {
+        LOG.error(`[adventure] Select error: ${e.message}`);
+      }
+      await sleep(300);
+    }
+  }
+
+  // ── Click "Start" button ───────────────────────────────────
+  let updatedButtons = getAllButtons(response);
+  let startButton = updatedButtons.find(b =>
+    (b.label || '').toLowerCase() === 'start' ||
+    (b.customId || '').includes('adventure-backpack')
+  );
+
+  if (startButton && !startButton.disabled) {
+    LOG.info(`[adventure] Clicking "Start"...`);
+    const afterStart = await clickAndRefetch(channel, response, startButton);
+    if (afterStart) {
+      response = afterStart;
+      logMsg(response, 'adventure-after-start');
+    }
+  } else if (startButton && startButton.disabled) {
+    LOG.warn('[adventure] Start button disabled (no ticket?)');
+    return { result: 'start disabled (no ticket)', coins: 0, nextCooldownSec: 60 };
+  }
+
+  // ── Handle equip screen ────────────────────────────────────
+  updatedButtons = getAllButtons(response);
+  const equipAllBtn = updatedButtons.find(b => !b.disabled && (b.label || '').toLowerCase() === 'equip all');
+  const equipStartBtn = updatedButtons.find(b => !b.disabled && (b.label || '').toLowerCase() === 'start');
+  const hasCancelBtn = updatedButtons.some(b => !b.disabled && (b.label || '').toLowerCase() === 'cancel');
+
+  if (equipStartBtn && (equipAllBtn || hasCancelBtn)) {
+    LOG.info('[adventure] Equip screen detected');
+
+    if (equipAllBtn) {
+      LOG.info('[adventure] Equipping all items...');
+      const afterEquip = await clickAndRefetch(channel, response, equipAllBtn);
+      if (afterEquip) {
+        response = afterEquip;
+        logMsg(response, 'adventure-after-equip');
+      }
+    }
+
+    // Click Start to begin the actual adventure
+    const newStart = getAllButtons(response).find(b =>
+      !b.disabled && (b.label || '').toLowerCase() === 'start'
+    );
+    if (newStart) {
+      LOG.info('[adventure] Starting adventure...');
+      const afterStart2 = await clickAndRefetch(channel, response, newStart);
+      if (afterStart2) {
+        response = afterStart2;
+        logMsg(response, 'adventure-started');
+      }
+    }
+  }
+
+  // ── Play through all adventure rounds ──────────────────────
+  const { text: finalText, coins, interactions, rewards, finalMsg } = await playAdventureRounds(channel, response);
+  return buildResult(finalText, coins, interactions, rewards, finalMsg);
+}
+
+// ── Build result object with cooldown parsing ────────────────────
+function buildResult(finalText, coins, interactions, rewards, msg) {
+  let nextCooldownSec = null;
+
+  // 1) Best: Unix timestamp <t:UNIX:t> in final text or embed
+  const allText = msg ? getFullText(msg) : finalText;
+  const tsMatch = allText.match(/<t:(\d+)(?::[tTdDfFR])?>/);
+  if (tsMatch) {
+    const unixTarget = parseInt(tsMatch[1]);
+    const nowUnix = Math.floor(Date.now() / 1000);
+    nextCooldownSec = Math.max(5, unixTarget - nowUnix);
+    LOG.info(`[adventure] Next at ${new Date(unixTarget * 1000).toLocaleTimeString()} (${c.yellow}${nextCooldownSec}s${c.reset})`);
+  }
+
+  // 2) Fallback: "Adventure again in X minutes" button label
+  if (!nextCooldownSec && msg) {
+    for (const row of msg.components || []) {
+      for (const comp of row.components || []) {
+        const label = (comp.label || '').toLowerCase();
+        const btnMatch = label.match(/adventure again in (\d+)\s*(minute|min|hour|second)/);
+        if (btnMatch) {
+          nextCooldownSec = parseInt(btnMatch[1]);
+          const unit = btnMatch[2].toLowerCase();
+          if (unit.startsWith('min')) nextCooldownSec *= 60;
+          if (unit.startsWith('hour')) nextCooldownSec *= 3600;
+          LOG.info(`[adventure] Next in ${c.yellow}${btnMatch[1]} ${btnMatch[2]}s${c.reset} (from button)`);
+        }
+      }
+    }
+  }
+
+  if (!nextCooldownSec) nextCooldownSec = 300;
+
+  let result;
+  if (coins > 0) {
+    result = `adventure (${interactions} interactions) → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset} | Rewards: ${rewards}`;
+    LOG.coin(`[adventure] Earned ${c.green}${c.bold}⏣ ${coins.toLocaleString()}${c.reset}`);
+  } else {
+    result = `adventure done (${interactions} interactions) | Rewards: ${rewards}`;
+    LOG.info(`[adventure] Completed ${interactions} interactions`);
+  }
+
+  return { result, coins, nextCooldownSec };
+}
+
+module.exports = { runAdventure };

package/lib/commands/beg.js

@@ -0,0 +1,45 @@
+/**
+ * Beg command handler.
+ * Simple command: send "pls beg", parse coins from response.
+ */
+
+const { LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep } = require('./utils');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runBeg({ channel, waitForDankMemer }) {
+  LOG.cmd(`${c.white}${c.bold}pls beg${c.reset}`);
+
+  await channel.send('pls beg');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[beg] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[beg] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'beg');
+  const text = getFullText(response);
+  const coins = parseCoins(text);
+
+  if (coins > 0) {
+    LOG.coin(`[beg] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `beg → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`, coins };
+  }
+
+  LOG.info(`[beg] ${text.substring(0, 80).replace(/\n/g, ' ')}`);
+  return { result: text.substring(0, 60) || 'done', coins: 0 };
+}
+
+module.exports = { runBeg };