dankgrinder 3.0.0 → 4.1.0

package/lib/commands/fishVision.js

@@ -0,0 +1,141 @@
+/**
+ * Fish Vision Module — analyze fishing minigame grid images.
+ * Detects mines (dark patches) vs safe/fish cells using pixel analysis.
+ *
+ * Mine cells have significantly higher percentage of dark pixels (< 60 brightness).
+ * Safe cells: dark% ≈ 0, avgBrightness ≈ 83
+ * Mine cells: dark% > 8, avgBrightness < 80
+ */
+
+const sharp = require('sharp');
+const https = require('https');
+const http = require('http');
+
+/**
+ * Download an image from a URL and return as Buffer.
+ */
+function downloadImage(url) {
+  return new Promise((resolve, reject) => {
+    const proto = url.startsWith('https') ? https : http;
+    const req = proto.get(url, res => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return downloadImage(res.headers.location).then(resolve, reject);
+      }
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+      res.on('error', reject);
+    });
+    req.on('error', reject);
+    req.setTimeout(10000, () => { req.destroy(); reject(new Error('download timeout')); });
+  });
+}
+
+/**
+ * Extract image URL from MEDIA_GALLERY inside CV2 components.
+ */
+function extractImageUrl(components) {
+  for (const item of components || []) {
+    if (item.data?.items) {
+      for (const g of item.data.items) {
+        if (g.media?.url) return g.media.url;
+      }
+    }
+    if (item.components) {
+      const found = extractImageUrl(item.components);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+/**
+ * Analyze a fishing grid image — classify each cell as empty, fish, or mine.
+ *
+ * Grid layout: 3x3 = 9 cells. Each round has exactly:
+ *   - 1 fish cell  (dark silhouette, higher fill ratio ~0.32, darkPct ~10)
+ *   - 2 mine cells (dark silhouette, lower fill ratio ~0.15, darkPct ~6)
+ *   - 6 empty cells (uniform blue water, darkPct ≈ 0)
+ *
+ * Classification features (from empirical data across many rounds):
+ *   FISH:  darkPct≥8, fillRatio>0.25, aspect<1, spread<0.7
+ *   MINE:  darkPct≥4, fillRatio<0.2, aspect≥1, spread≥0.9
+ *   EMPTY: darkPct<4
+ *
+ * @param {Buffer} imgBuffer - The image data
+ * @param {number} gridCols - Number of columns (default 3)
+ * @param {number} gridRows - Number of rows (default 3)
+ * @returns {Promise<Array<{col, row, type, darkPct, fillRatio}>>}
+ */
+async function analyzeGrid(imgBuffer, gridCols = 3, gridRows = 3) {
+  const { data, info } = await sharp(imgBuffer).raw().toBuffer({ resolveWithObject: true });
+  const { width, height, channels } = info;
+  const cellW = Math.floor(width / gridCols);
+  const cellH = Math.floor(height / gridRows);
+
+  const cells = [];
+  for (let row = 0; row < gridRows; row++) {
+    for (let col = 0; col < gridCols; col++) {
+      const startX = col * cellW, startY = row * cellH;
+      const endX = Math.min(startX + cellW, width);
+      const endY = Math.min(startY + cellH, height);
+
+      // Collect dark pixels (brightness < 50)
+      const darkPixels = [];
+      let totalPixels = 0;
+      for (let y = startY; y < endY; y++) {
+        for (let x = startX; x < endX; x++) {
+          totalPixels++;
+          const idx = (y * width + x) * channels;
+          const r = data[idx], g = data[idx + 1], b = data[idx + 2];
+          if ((r + g + b) / 3 < 50) darkPixels.push({ x: x - startX, y: y - startY });
+        }
+      }
+
+      const darkPct = Math.round(darkPixels.length / totalPixels * 100);
+
+      if (darkPixels.length < 10 || darkPct < 4) {
+        cells.push({ col, row, type: 'empty', darkPct, fillRatio: 0 });
+        continue;
+      }
+
+      // Compute bounding box and fill ratio
+      let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+      for (const p of darkPixels) {
+        minX = Math.min(minX, p.x); maxX = Math.max(maxX, p.x);
+        minY = Math.min(minY, p.y); maxY = Math.max(maxY, p.y);
+      }
+      const bboxW = maxX - minX + 1, bboxH = maxY - minY + 1;
+      const fillRatio = darkPixels.length / (bboxW * bboxH);
+
+      // Classify: fish has higher fill ratio (~0.32) vs mine (~0.15)
+      let type;
+      if (fillRatio > 0.22) {
+        type = 'fish';
+      } else {
+        type = 'mine';
+      }
+
+      cells.push({ col, row, type, darkPct, fillRatio: +fillRatio.toFixed(3) });
+    }
+  }
+
+  return cells;
+}
+
+/**
+ * Find fish cell and mine cells from a fishing grid image.
+ * @param {Buffer} imgBuffer
+ * @returns {Promise<{fishCell: {col, row}|null, mineCells: Array<{col, row}>, emptyCells: Array<{col, row}>, allCells: Array}>}
+ */
+async function findSafeCells(imgBuffer) {
+  const allCells = await analyzeGrid(imgBuffer);
+  const fishCell = allCells.find(c => c.type === 'fish') || null;
+  const mineCells = allCells.filter(c => c.type === 'mine').map(c => ({ col: c.col, row: c.row }));
+  const emptyCells = allCells.filter(c => c.type === 'empty').map(c => ({ col: c.col, row: c.row }));
+  // safeCells = fish + empty (everything except mines)
+  const safeCells = allCells.filter(c => c.type !== 'mine').map(c => ({ col: c.col, row: c.row }));
+  return { fishCell, mineCells, emptyCells, safeCells, allCells };
+}
+
+module.exports = { downloadImage, extractImageUrl, analyzeGrid, findSafeCells };

package/lib/commands/gamble.js

@@ -0,0 +1,96 @@
+/**
+ * Simple gambling command handlers.
+ * Covers: coinflip, roulette, slots, snakeeyes
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+/**
+ * Generic gamble handler — works for coinflip, roulette, slots, snakeeyes.
+ * 
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} opts.cmdName - e.g. 'coinflip', 'roulette', 'slots', 'snakeeyes'
+ * @param {string} opts.cmdString - Full command string e.g. 'pls coinflip 1000 heads'
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
+  LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
+
+  await channel.send(cmdString);
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn(`[${cmdName}] No response`);
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[${cmdName}] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, cmdName);
+  const text = getFullText(response);
+  const coins = parseCoins(text);
+
+  // Some gambles have buttons (e.g. pick heads/tails)
+  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();
+      try {
+        const followUp = await safeClickButton(response, btn);
+        if (followUp) {
+          logMsg(followUp, `${cmdName}-result`);
+          const fText = getFullText(followUp);
+          const fCoins = parseCoins(fText);
+          if (fCoins > 0) {
+            LOG.coin(`[${cmdName}] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
+            return { result: `${cmdName} → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
+          }
+          if (fText.toLowerCase().includes('won')) return { result: `${cmdName} → ${c.green}won${c.reset}`, coins: 0 };
+          if (fText.toLowerCase().includes('lost')) return { result: `${cmdName} → ${c.red}lost${c.reset}`, coins: 0 };
+        }
+      } catch (e) { LOG.error(`[${cmdName}] Click error: ${e.message}`); }
+    }
+  }
+
+  if (coins > 0) {
+    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  const lower = text.toLowerCase();
+  if (lower.includes('won')) return { result: `${cmdName} → ${c.green}won${c.reset}`, coins: 0 };
+  if (lower.includes('lost')) return { result: `${cmdName} → ${c.red}lost${c.reset}`, coins: 0 };
+
+  return { result: `${cmdName} done`, coins: 0 };
+}
+
+// Convenience wrappers
+async function runCoinflip({ channel, waitForDankMemer, betAmount = 1000 }) {
+  return runGamble({ channel, waitForDankMemer, cmdName: 'coinflip', cmdString: `pls coinflip ${betAmount} heads` });
+}
+
+async function runRoulette({ channel, waitForDankMemer, betAmount = 1000 }) {
+  return runGamble({ channel, waitForDankMemer, cmdName: 'roulette', cmdString: `pls roulette ${betAmount} red` });
+}
+
+async function runSlots({ channel, waitForDankMemer, betAmount = 1000 }) {
+  return runGamble({ channel, waitForDankMemer, cmdName: 'slots', cmdString: `pls slots ${betAmount}` });
+}
+
+async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 1000 }) {
+  return runGamble({ channel, waitForDankMemer, cmdName: 'snakeeyes', cmdString: `pls snakeeyes ${betAmount}` });
+}
+
+module.exports = { runGamble, runCoinflip, runRoulette, runSlots, runSnakeeyes };

package/lib/commands/generic.js

@@ -0,0 +1,181 @@
+/**
+ * Generic command handler.
+ * Handles simple commands like: beg, farm, tidy, daily, weekly, monthly, stream, drops, use, alert.
+ * Detects missing items and auto-buys. Handles buttons and select menus.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
+  safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
+} = require('./utils');
+const { buyItem } = require('./shop');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} opts.cmdString - Full command string e.g. 'pls farm'
+ * @param {string} opts.cmdName - Short name e.g. 'farm'
+ * @param {object} [opts.client]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, client }) {
+  LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
+
+  await channel.send(cmdString);
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn(`[${cmdName}] No response`);
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[${cmdName}] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, cmdName);
+  const text = getFullText(response);
+  const coins = parseCoins(text);
+
+  // Check if we need an item
+  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 });
+    if (bought) {
+      LOG.success(`[${cmdName}] Bought ${missing}, retrying command...`);
+      await sleep(3000);
+      await channel.send(cmdString);
+      const r2 = await waitForDankMemer(10000);
+      if (r2) {
+        logMsg(r2, `${cmdName}-retry`);
+        const t2 = getFullText(r2);
+        const c2 = parseCoins(t2);
+        if (c2 > 0) {
+          LOG.coin(`[${cmdName}] ${c.green}+⏣ ${c2.toLocaleString()}${c.reset}`);
+          return { result: `auto-bought ${missing} → +⏣ ${c2.toLocaleString()}`, coins: c2 };
+        }
+        return { result: `auto-bought ${missing}`, coins: 0 };
+      }
+    }
+    return { result: `need ${missing} (buy failed)`, coins: 0 };
+  }
+
+  // Handle buttons if present
+  const buttons = getAllButtons(response);
+  if (buttons.length > 0) {
+    const btn = buttons.find(b => !b.disabled) || buttons[0];
+    if (btn && !btn.disabled) {
+      LOG.info(`[${cmdName}] Clicking "${btn.label || '?'}"`);
+      await humanDelay();
+      try {
+        const followUp = await safeClickButton(response, btn);
+        if (followUp) {
+          logMsg(followUp, `${cmdName}-followup`);
+          const fText = getFullText(followUp);
+          const fCoins = parseCoins(fText);
+          if (fCoins > 0) {
+            LOG.coin(`[${cmdName}] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
+            return { result: `+⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
+          }
+          // Multi-step: click next button too
+          const nextButtons = getAllButtons(followUp);
+          if (nextButtons.length > 0) {
+            const nextBtn = nextButtons.find(b => !b.disabled);
+            if (nextBtn) {
+              await humanDelay();
+              try { await safeClickButton(followUp, nextBtn); } catch {}
+            }
+          }
+        }
+      } catch (e) { LOG.error(`[${cmdName}] Click error: ${e.message}`); }
+    }
+  }
+
+  // Handle select menus
+  const menus = getAllSelectMenus(response);
+  if (menus.length > 0) {
+    // Re-fetch for hydrated components (minValues/maxValues)
+    const freshMsg = await channel.messages.fetch(response.id).catch(() => null);
+    if (freshMsg) response = freshMsg;
+    // Find row index of first select menu
+    let menuRowIdx = -1;
+    for (let i = 0; i < (response.components || []).length; i++) {
+      for (const comp of response.components[i].components || []) {
+        if (comp.type === 'STRING_SELECT' || comp.type === 3) { menuRowIdx = i; break; }
+      }
+      if (menuRowIdx >= 0) break;
+    }
+    const menu = menuRowIdx >= 0 ? response.components[menuRowIdx].components[0] : null;
+    const options = menu?.options || [];
+    if (options.length > 0 && menuRowIdx >= 0) {
+      const opt = options[Math.floor(Math.random() * options.length)];
+      LOG.info(`[${cmdName}] Selecting: "${opt.label}"`);
+      try {
+        await response.selectMenu(menuRowIdx, [opt.value]);
+        const followUp = await waitForDankMemer(8000);
+        if (followUp) {
+          const fText = getFullText(followUp);
+          const fCoins = parseCoins(fText);
+          if (fCoins > 0) {
+            LOG.coin(`[${cmdName}] ${opt.label} → ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
+            return { result: `${opt.label} → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
+          }
+        }
+      } catch (e) { LOG.error(`[${cmdName}] Select error: ${e.message}`); }
+    }
+  }
+
+  if (coins > 0) {
+    LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `+⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: text.substring(0, 60) || 'done', coins: 0 };
+}
+
+/**
+ * Alert handler — click dismiss/accept/ok button.
+ */
+async function runAlert({ channel, waitForDankMemer }) {
+  LOG.cmd(`${c.white}${c.bold}pls alert${c.reset}`);
+
+  await channel.send('pls alert');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) return { result: 'no response', coins: 0 };
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[alert] Hold Tight${reason ? ` (reason: /${reason})` : ''}`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'alert');
+  const buttons = getAllButtons(response);
+  const dismissLabels = ['ok', 'dismiss', 'accept', 'got it', 'continue'];
+  const btn = buttons.find(b => !b.disabled && dismissLabels.some(s => (b.label || '').toLowerCase().includes(s)));
+
+  if (btn) {
+    await humanDelay();
+    try { await safeClickButton(response, btn); } catch {}
+    LOG.info('[alert] Dismissed');
+    return { result: 'alert dismissed', coins: 0 };
+  }
+
+  if (buttons.length > 0) {
+    const first = buttons.find(b => !b.disabled);
+    if (first) {
+      await humanDelay();
+      try { await safeClickButton(response, first); } catch {}
+    }
+  }
+
+  return { result: 'alert handled', coins: 0 };
+}
+
+module.exports = { runGeneric, runAlert };

package/lib/commands/highlow.js

@@ -0,0 +1,112 @@
+/**
+ * HighLow command handler.
+ * Send "pls hl", parse the hint number, pick higher/lower/jackpot.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+/**
+ * Recursively handle highlow rounds (multi-round game).
+ */
+async function playHighLow(response, depth = 0) {
+  if (!response || depth > 5) return { result: 'done', coins: 0 };
+
+  const text = getFullText(response);
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const coins = parseCoins(text);
+    return { result: coins > 0 ? `+⏣ ${coins.toLocaleString()}` : 'done', coins };
+  }
+
+  // Parse the hint number
+  const match = text.match(/number.*?(\d+)/i) || text.match(/(\d+)/);
+  let targetBtn;
+
+  if (match && buttons.length >= 2) {
+    const num = parseInt(match[1]);
+    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)];
+    }
+    LOG.info(`[hl] Number: ${num} → picking "${targetBtn.label}"`);
+  } else {
+    targetBtn = buttons.find(b => !b.disabled) || buttons[0];
+    LOG.info(`[hl] No hint, picking "${targetBtn.label}"`);
+  }
+
+  if (!targetBtn || targetBtn.disabled) {
+    const coins = parseCoins(text);
+    return { result: 'buttons disabled', coins };
+  }
+
+  await humanDelay(500, 1200);
+
+  try {
+    const followUp = await safeClickButton(response, targetBtn);
+    if (followUp) {
+      logMsg(followUp, `hl-round-${depth}`);
+      const fText = getFullText(followUp);
+      const fCoins = parseCoins(fText);
+
+      // Check for more rounds
+      const moreButtons = getAllButtons(followUp);
+      if (moreButtons.length >= 2 && !moreButtons.every(b => b.disabled)) {
+        const deeper = await playHighLow(followUp, depth + 1);
+        return { result: deeper.result, coins: fCoins + deeper.coins };
+      }
+
+      if (fCoins > 0) {
+        return { result: `${targetBtn.label} → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins };
+      }
+      return { result: `${targetBtn.label}`, coins: 0 };
+    }
+  } catch (e) {
+    LOG.error(`[hl] Click error: ${e.message}`);
+  }
+
+  return { result: 'done', coins: 0 };
+}
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runHighLow({ channel, waitForDankMemer }) {
+  LOG.cmd(`${c.white}${c.bold}pls hl${c.reset}`);
+
+  await channel.send('pls hl');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[hl] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[hl] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'hl');
+  const { result, coins } = await playHighLow(response);
+
+  if (coins > 0) {
+    LOG.coin(`[hl] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+  }
+
+  return { result: `hl → ${result}`, coins };
+}
+
+module.exports = { runHighLow };

package/lib/commands/hunt.js

@@ -0,0 +1,85 @@
+/**
+ * Hunt command handler.
+ * Send "pls hunt", detect if rifle is missing, auto-buy if needed.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
+} = require('./utils');
+const { buyItem } = require('./shop');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {object} [opts.client] - Discord client for modal handling
+ * @returns {Promise<{result: string, coins: number, needsRifle: boolean}>}
+ */
+async function runHunt({ channel, waitForDankMemer, client }) {
+  LOG.cmd(`${c.white}${c.bold}pls hunt${c.reset}`);
+
+  await channel.send('pls hunt');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[hunt] No response');
+    return { result: 'no response', coins: 0, needsRifle: false };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[hunt] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, needsRifle: false, holdTightReason: reason };
+  }
+
+  logMsg(response, 'hunt');
+  const text = getFullText(response);
+  const textLower = text.toLowerCase();
+
+  // Check if we need a rifle
+  if (textLower.includes("don't have") || textLower.includes('need a') || textLower.includes('hunting rifle')) {
+    if (textLower.includes('rifle') || textLower.includes('hunt')) {
+      LOG.warn('[hunt] No rifle! Attempting to buy...');
+
+      const bought = await buyItem({
+        channel, waitForDankMemer, client,
+        itemName: 'Hunting Rifle',
+        quantity: 3,
+      });
+
+      if (bought) {
+        LOG.success('[hunt] Rifle purchased! Re-running hunt...');
+        // Drain stale shop messages
+        while (await waitForDankMemer(1500)) { /* drain */ }
+        await sleep(1000);
+
+        await channel.send('pls hunt');
+        const r2 = await waitForDankMemer(10000);
+        if (r2) {
+          logMsg(r2, 'hunt-retry');
+          const t2 = getFullText(r2);
+          const coins = parseCoins(t2);
+          if (coins > 0) {
+            LOG.coin(`[hunt] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+            return { result: `hunt → +⏣ ${coins.toLocaleString()}`, coins, needsRifle: false };
+          }
+          return { result: t2.substring(0, 60), coins: 0, needsRifle: false };
+        }
+        return { result: 'no response after rifle buy', coins: 0, needsRifle: false };
+      }
+
+      return { result: 'need rifle (buy failed)', coins: 0, needsRifle: true };
+    }
+  }
+
+  const coins = parseCoins(text);
+  if (coins > 0) {
+    LOG.coin(`[hunt] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `hunt → +⏣ ${coins.toLocaleString()}`, coins, needsRifle: false };
+  }
+
+  return { result: text.substring(0, 60) || 'done', coins: 0, needsRifle: false };
+}
+
+module.exports = { runHunt };

package/lib/commands/index.js

@@ -0,0 +1,59 @@
+/**
+ * Central export for all command handlers.
+ * Each command lives in its own file — import from here.
+ */
+
+const { runAdventure } = require('./adventure');
+const { runBeg } = require('./beg');
+const { runSearch, SAFE_SEARCH_LOCATIONS } = require('./search');
+const { runCrime, SAFE_CRIME_OPTIONS } = require('./crime');
+const { runHighLow } = require('./highlow');
+const { runHunt } = require('./hunt');
+const { runDig } = require('./dig');
+const { runFish } = require('./fish');
+const { runPostMemes } = require('./postmemes');
+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 { runDeposit } = require('./deposit');
+const { runGeneric, runAlert } = require('./generic');
+const { buyItem, ITEM_COSTS } = require('./shop');
+const { getPlayerLevel, meetsLevelRequirement } = require('./profile');
+
+module.exports = {
+  // Individual commands
+  runAdventure,
+  runBeg,
+  runSearch,
+  runCrime,
+  runHighLow,
+  runHunt,
+  runDig,
+  runFish,
+  runPostMemes,
+  runScratch,
+  runBlackjack,
+  runTrivia,
+  runWorkShift,
+  runCoinflip,
+  runRoulette,
+  runSlots,
+  runSnakeeyes,
+  runGamble,
+  runDeposit,
+  runGeneric,
+  runAlert,
+  buyItem,
+
+  // Profile / Level
+  getPlayerLevel,
+  meetsLevelRequirement,
+
+  // Constants
+  SAFE_SEARCH_LOCATIONS,
+  SAFE_CRIME_OPTIONS,
+  ITEM_COSTS,
+  triviaDB,
+};