dankgrinder 4.0.0 → 4.1.0

package/lib/commands/fish.js

@@ -0,0 +1,615 @@
+/**
+ * Fish command handler (Dank Memer v2 fishing).
+ *
+ * The fishing minigame works as follows:
+ *   1. "pls fish catch" → fishing dashboard with "Go Fishing" button
+ *   2. Click "Go Fishing" → 3x3 grid image + 9 "Catch" buttons
+ *   3. Grid image shows mines (dark patches) and safe water
+ *   4. Click safe "Catch" buttons to catch fish, avoid mines
+ *   5. Result screen with "Fish Again" / "Go Back" buttons
+ *   6. Click "Fish Again" to loop without re-sending the command
+ *
+ * Image analysis uses sharp to detect dark pixel clusters (mines)
+ * in each grid cell. Safe cells have ~0% dark pixels; mine cells
+ * have >6% dark pixels with lower average brightness.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+const { downloadImage, extractImageUrl, findSafeCells } = require('./fishVision');
+
+const { DANK_MEMER_ID } = require('./utils');
+
+async function refetchMsg(channel, msgId) {
+  try { return await channel.messages.fetch(msgId); } catch { return null; }
+}
+
+/**
+ * Sell all fish from buckets via "pls fish buckets" → "Sell All Fish" button.
+ * The sell flow has a confirmation step with "Sell for X Coins" / "Sell for Y Tokens".
+ * Clicking "Sell All Fish" edits the message to show confirmation, then we click the token sell.
+ * @param {string} [sellFor='tokens'] - 'tokens' or 'coins'
+ * @returns {Promise<boolean>} true if sold successfully
+ */
+async function sellAllFish({ channel, waitForDankMemer, sellFor = 'tokens' }) {
+  LOG.info('[fish] Selling all fish from buckets...');
+  await channel.send('pls fish buckets');
+  let msg = await waitForDankMemer(8000);
+  if (!msg) { LOG.warn('[fish] No response to pls fish buckets'); return false; }
+  let fresh = await refetchMsg(channel, msg.id);
+  if (fresh) msg = fresh;
+
+  const sellAllBtn = getAllButtons(msg).find(b =>
+    !b.disabled && (b.customId || '').includes('fish-buckets-sell-all')
+  );
+  if (!sellAllBtn) {
+    LOG.info('[fish] No "Sell All Fish" button (bucket may be empty)');
+    return false;
+  }
+
+  // Click "Sell All Fish" — this edits the message to show confirmation
+  await humanDelay(80, 200);
+  try {
+    await safeClickButton(msg, sellAllBtn);
+  } catch (e) {
+    LOG.error(`[fish] Sell All Fish click error: ${e.message}`);
+    return false;
+  }
+
+  // Wait for confirmation screen (message update with "Sell for X Coins/Tokens")
+  await sleep(1500);
+  let confirmMsg = null;
+  // Check for update event first
+  for (let i = 0; i < 4; i++) {
+    const upd = await waitForDankMemer(3000);
+    if (!upd) break;
+    const btns = getAllButtons(upd);
+    if (btns.some(b => (b.label || '').toLowerCase().includes('sell for'))) {
+      confirmMsg = upd;
+      break;
+    }
+  }
+  // Fallback: refetch the message
+  if (!confirmMsg) {
+    confirmMsg = await refetchMsg(channel, msg.id);
+  }
+  if (!confirmMsg) { LOG.warn('[fish] No sell confirmation'); return false; }
+
+  // Find the sell confirmation button
+  const confirmBtns = getAllButtons(confirmMsg);
+  let sellBtn;
+  if (sellFor === 'tokens') {
+    // Prefer "Sell for X Tokens" button
+    sellBtn = confirmBtns.find(b =>
+      !b.disabled && (b.label || '').toLowerCase().includes('sell for') && (b.label || '').toLowerCase().includes('token')
+    );
+  }
+  if (!sellBtn) {
+    // Fallback: "Sell for X Coins"
+    sellBtn = confirmBtns.find(b =>
+      !b.disabled && (b.label || '').toLowerCase().includes('sell for') && (b.label || '').toLowerCase().includes('coin')
+    );
+  }
+  if (!sellBtn) {
+    // Last fallback: any green/primary sell button
+    sellBtn = confirmBtns.find(b =>
+      !b.disabled && (b.label || '').toLowerCase().includes('sell for')
+    );
+  }
+
+  if (!sellBtn) {
+    LOG.warn('[fish] No sell confirmation button found');
+    LOG.debug(`[fish] Buttons: ${confirmBtns.map(b => `"${b.label}"`).join(', ')}`);
+    return false;
+  }
+
+  LOG.info(`[fish] Confirming: "${sellBtn.label}"`);
+  await humanDelay(80, 200);
+  try {
+    await safeClickButton(confirmMsg, sellBtn);
+    await sleep(1500);
+    // Drain events from sell
+    for (let d = 0; d < 3; d++) {
+      const ev = await waitForDankMemer(2000);
+      if (!ev) break;
+    }
+    LOG.success('[fish] Sold all fish from buckets');
+    return true;
+  } catch (e) {
+    LOG.error(`[fish] Sell confirmation error: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Parse cooldown timestamp from text.
+ */
+function parseFishCooldown(text) {
+  const m = text.match(/<t:(\d+):R>/);
+  if (m) {
+    const diff = parseInt(m[1]) - Math.floor(Date.now() / 1000);
+    return diff > 0 ? diff : null;
+  }
+  return null;
+}
+
+/**
+ * Wait for the Catch grid OR a direct result (e.g. "nothing to catch").
+ * After clicking Go Fishing / Fish Again, the animation goes:
+ *   loading text (0 buttons) → EITHER Catch grid (9 btns) OR direct result (2 btns)
+ * Returns { type: 'grid', msg } or { type: 'result', msg } or null.
+ */
+async function waitForFishingOutcome({ channel, msgId, waitForDankMemer }) {
+  const hasCatch = (msg) => getAllButtons(msg).some(b => (b.label || '').toLowerCase() === 'catch');
+  const hasResult = (msg) => {
+    const btns = getAllButtons(msg);
+    return btns.some(b => (b.customId || '').includes('fish-catch-back')) ||
+           btns.some(b => (b.label || '').toLowerCase() === 'fish again');
+  };
+
+  for (let i = 0; i < 10; i++) {
+    const upd = await waitForDankMemer(2000);
+    if (upd) {
+      if (hasCatch(upd)) return { type: 'grid', msg: upd };
+      if (hasResult(upd)) return { type: 'result', msg: upd };
+    }
+    // Also check via refetch each iteration
+    const rf = await refetchMsg(channel, msgId);
+    if (rf) {
+      if (hasCatch(rf)) return { type: 'grid', msg: rf };
+      if (hasResult(rf)) return { type: 'result', msg: rf };
+    }
+  }
+  return null;
+}
+
+/**
+ * Wait for the result screen (Go Back / Fish Again buttons).
+ */
+async function waitForResult({ channel, msgId, waitForDankMemer }) {
+  for (let i = 0; i < 6; i++) {
+    const upd = await waitForDankMemer(5000);
+    if (!upd) {
+      const rf = await refetchMsg(channel, msgId);
+      if (rf) {
+        const btns = getAllButtons(rf);
+        const hasResult = btns.some(b => (b.customId || '').includes('fish-catch-back') || (b.label || '').toLowerCase() === 'fish again');
+        if (hasResult) return rf;
+      }
+      await sleep(2000);
+      return await refetchMsg(channel, msgId);
+    }
+    const btns = getAllButtons(upd);
+    const hasResult = btns.some(b => (b.customId || '').includes('fish-catch-back') || (b.label || '').toLowerCase() === 'fish again');
+    if (hasResult) return upd;
+  }
+  return await refetchMsg(channel, msgId);
+}
+
+/**
+ * Parse the result of a fishing round.
+ */
+function parseFishResult(text) {
+  const tl = text.toLowerCase();
+  const cd = parseFishCooldown(text);
+  const headerMatch = text.match(/###\s*(.+?)(?:\s*-#|$)/);
+  const header = headerMatch ? headerMatch[1].trim() : '';
+
+  if (tl.includes('nothing to catch') || tl.includes('no fish')) {
+    return { outcome: 'nothing', header, cd };
+  }
+  if (tl.includes('mine') || tl.includes('triggered')) {
+    return { outcome: 'mine', header, cd };
+  }
+  if (tl.includes('got away') || tl.includes('escaped')) {
+    return { outcome: 'got_away', header, cd };
+  }
+  if (tl.includes('caught')) {
+    const fishMatch = text.match(/caught\s+(?:a\s+)?(.+?)(?:\s*[!.]|$)/i);
+    return { outcome: 'caught', fish: fishMatch ? fishMatch[1].substring(0, 40) : 'a fish', header, cd };
+  }
+  return { outcome: 'unknown', header: header || text.substring(0, 60), cd };
+}
+
+/**
+ * Single fishing round: analyze grid, click safe cells, return result.
+ * @param {object} gameMsg - Message with MEDIA_GALLERY + Catch buttons
+ * @param {object} channel
+ * @param {string} msgId
+ * @param {function} waitForDankMemer
+ * @returns {Promise<{outcome, header, cd, clickedCount}>}
+ */
+async function playFishRound({ gameMsg, channel, msgId, waitForDankMemer }) {
+  // Extract and analyze the grid image
+  const imgUrl = extractImageUrl(gameMsg.components);
+  if (!imgUrl) {
+    LOG.warn('[fish] No grid image URL');
+    return { outcome: 'no_image', header: 'no image', cd: null, clickedCount: 0 };
+  }
+
+  let target = null;
+  try {
+    const imgBuf = await downloadImage(imgUrl);
+    const analysis = await findSafeCells(imgBuf);
+    const { fishCell, mineCells, allCells } = analysis;
+
+    // Log grid classification
+    const cellMap = allCells.map(c => `[${c.col},${c.row}]=${c.type}${c.type !== 'empty' ? `(fill=${c.fillRatio})` : ''}`);
+    LOG.info(`[fish] Grid: ${cellMap.filter(s => s.includes('fish')).length} fish, ${mineCells.length} mines`);
+    LOG.debug(`[fish] ${cellMap.join(' ')}`);
+
+    // Target the fish cell specifically for best catch rate
+    if (fishCell) {
+      target = { col: fishCell.col, row: fishCell.row };
+      LOG.info(`[fish] Fish detected at [${target.col},${target.row}]`);
+    } else {
+      // Fallback: pick a safe (non-mine) cell
+      const safe = allCells.filter(c => c.type !== 'mine');
+      target = safe.length > 0 ? { col: safe[0].col, row: safe[0].row } : null;
+      LOG.warn('[fish] No fish detected, picking safe cell');
+    }
+  } catch (e) {
+    LOG.error(`[fish] Image analysis failed: ${e.message}`);
+    // Fall back to clicking center cell
+    target = { col: 1, row: 1 };
+  }
+
+  if (!target) {
+    LOG.warn('[fish] No target cell found!');
+    return { outcome: 'no_target', header: 'no target', cd: null, clickedCount: 0 };
+  }
+
+  const catchBtns = getAllButtons(gameMsg).filter(b => (b.label || '').toLowerCase() === 'catch' && !b.disabled);
+  const btn = catchBtns.find(b => {
+    const m = (b.customId || '').match(/:(\d+):(\d+)$/);
+    return m && parseInt(m[1]) === target.col && parseInt(m[2]) === target.row;
+  });
+
+  if (!btn) {
+    LOG.warn(`[fish] Catch button [${target.col},${target.row}] not found`);
+    return { outcome: 'no_button', header: 'button not found', cd: null, clickedCount: 0 };
+  }
+
+  LOG.info(`[fish] Clicking safe cell [${target.col},${target.row}]`);
+  await humanDelay(80, 200);
+  try {
+    await safeClickButton(gameMsg, btn);
+  } catch (e) {
+    LOG.error(`[fish] Catch click error: ${e.message}`);
+    return { outcome: 'click_error', header: e.message, cd: null, clickedCount: 0 };
+  }
+
+  // Wait for result screen
+  const resultMsg = await waitForResult({ channel, msgId, waitForDankMemer });
+  if (!resultMsg) return { outcome: 'no_result', header: 'no result', cd: null, clickedCount: 1 };
+
+  logMsg(resultMsg, 'fish-result');
+  const text = getFullText(resultMsg);
+  const result = parseFishResult(text);
+  result.clickedCount = 1;
+  return result;
+}
+
+/**
+ * Main fish handler — single round (for grinder integration).
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @returns {Promise<{result: string, coins: number, nextCooldownSec?: number}>}
+ */
+async function runFish({ channel, waitForDankMemer }) {
+  LOG.cmd(`${c.white}${c.bold}pls fish catch${c.reset}`);
+
+  await channel.send('pls fish catch');
+  let response = await waitForDankMemer(10000);
+  if (!response) return { result: 'no response', coins: 0 };
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[fish] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'fish');
+  const text = getFullText(response);
+
+  // Check for cooldown
+  const cd = parseFishCooldown(text);
+  if (cd && (text.toLowerCase().includes('fish again') || text.toLowerCase().includes('can fish'))) {
+    LOG.info(`[fish] On cooldown — ${cd}s`);
+    return { result: `fish cooldown (${cd}s)`, coins: 0, nextCooldownSec: cd };
+  }
+
+  // Re-fetch for hydrated CV2 components
+  const msgId = response.id;
+  const fresh = await refetchMsg(channel, msgId);
+  if (fresh) response = fresh;
+
+  // Find "Go Fishing" button
+  const goFishBtn = getAllButtons(response).find(b =>
+    !b.disabled && ((b.customId || '').includes('fish-catch-fish') ||
+    (b.label || '').toLowerCase().includes('go fishing'))
+  );
+
+  if (!goFishBtn) {
+    LOG.warn('[fish] No "Go Fishing" button');
+    return { result: text.substring(0, 60) || 'no button', coins: 0 };
+  }
+
+  // Click "Go Fishing"
+  LOG.info('[fish] Clicking "Go Fishing"...');
+  await humanDelay();
+  try { await safeClickButton(response, goFishBtn); } catch (e) {
+    LOG.error(`[fish] Go Fishing click error: ${e.message}`);
+    return { result: 'click error', coins: 0 };
+  }
+
+  // Wait for Catch grid OR direct result
+  const outcome = await waitForFishingOutcome({ channel, msgId, waitForDankMemer });
+  if (!outcome) {
+    LOG.warn('[fish] No fishing outcome');
+    return { result: 'no outcome', coins: 0 };
+  }
+
+  let roundResult;
+  if (outcome.type === 'grid') {
+    roundResult = await playFishRound({ gameMsg: outcome.msg, channel, msgId, waitForDankMemer });
+  } else {
+    logMsg(outcome.msg, 'fish-result');
+    const resultText = getFullText(outcome.msg);
+    roundResult = parseFishResult(resultText);
+    roundResult.clickedCount = 0;
+  }
+  return formatRoundResult(roundResult);
+}
+
+/**
+ * Fish-only grinding loop — keeps fishing without re-sending the command.
+ * Clicks "Fish Again" after each round. Stops when bucket is full or cooldown.
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {number} [opts.maxRounds=50] - Max rounds per session
+ * @param {function} [opts.onRound] - Callback per round: (roundNum, result) => void
+ * @param {AbortSignal} [opts.signal] - Signal to stop early
+ * @returns {Promise<{totalRounds, totalCaught, totalMines, results: Array}>}
+ */
+async function runFishLoop({ channel, waitForDankMemer, maxRounds = 50, onRound, signal }) {
+  LOG.cmd(`${c.white}${c.bold}pls fish catch${c.reset} (loop mode, max ${maxRounds} rounds)`);
+
+  await channel.send('pls fish catch');
+  let response = await waitForDankMemer(10000);
+  if (!response) return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[fish] Hold Tight — waiting 30s`);
+    await sleep(30000);
+    return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+  }
+
+  // Refetch for hydrated components
+  let msgId = response.id;
+  const fresh = await refetchMsg(channel, msgId);
+  if (fresh) response = fresh;
+
+  // Check cooldown — wait for it instead of returning
+  const text = getFullText(response);
+  const cd = parseFishCooldown(text);
+  if (cd && cd > 0) {
+    LOG.info(`[fish] On cooldown — ${cd}s, waiting...`);
+    await sleep(cd * 1000 + 1000);
+    response = await refetchMsg(channel, msgId);
+    if (!response) return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+  }
+
+  // Click "Go Fishing" to start
+  const goFishBtn = getAllButtons(response).find(b =>
+    !b.disabled && ((b.customId || '').includes('fish-catch-fish') ||
+    (b.label || '').toLowerCase().includes('go fishing'))
+  );
+  if (!goFishBtn) {
+    LOG.warn('[fish] No Go Fishing button on dashboard');
+    return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+  }
+
+  // Sell all fish from buckets before starting to ensure space
+  LOG.info('[fish] Clearing bucket before starting...');
+  await sellAllFish({ channel, waitForDankMemer });
+
+  // Re-send command to get fresh dashboard after sell
+  await channel.send('pls fish catch');
+  let newDash = await waitForDankMemer(8000);
+  if (newDash) {
+    let freshDash = await refetchMsg(channel, newDash.id);
+    if (freshDash) newDash = freshDash;
+    msgId = newDash.id;
+    response = newDash;
+
+    // Wait for any cooldown on fresh dashboard
+    const newCd = parseFishCooldown(getFullText(response));
+    if (newCd && newCd > 0) {
+      LOG.info(`[fish] Cooldown after sell — ${newCd}s, waiting...`);
+      await sleep(newCd * 1000 + 1000);
+      response = await refetchMsg(channel, msgId);
+      if (!response) return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+    }
+  }
+
+  LOG.info('[fish] Starting fishing loop...');
+  await humanDelay();
+  const goFishBtn2 = getAllButtons(response).find(b =>
+    !b.disabled && ((b.customId || '').includes('fish-catch-fish') ||
+    (b.label || '').toLowerCase().includes('go fishing'))
+  );
+  if (!goFishBtn2) {
+    LOG.warn('[fish] No Go Fishing button after sell');
+    return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+  }
+  try { await safeClickButton(response, goFishBtn2); } catch (e) {
+    LOG.error(`[fish] Go Fishing click error: ${e.message}`);
+    return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
+  }
+
+  const results = [];
+  let totalCaught = 0, totalMines = 0;
+
+  for (let round = 0; round < maxRounds; round++) {
+    if (signal?.aborted) break;
+
+    // Wait for Catch grid OR direct result (e.g. "nothing to catch")
+    const outcome = await waitForFishingOutcome({ channel, msgId, waitForDankMemer });
+    if (!outcome) {
+      LOG.warn(`[fish] Round ${round + 1}: no fishing outcome`);
+      break;
+    }
+
+    let roundResult;
+    if (outcome.type === 'grid') {
+      // Normal: grid appeared, play the round
+      roundResult = await playFishRound({ gameMsg: outcome.msg, channel, msgId, waitForDankMemer });
+    } else {
+      // Direct result without grid (e.g. "nothing to catch", instant mine)
+      logMsg(outcome.msg, 'fish-result');
+      const text = getFullText(outcome.msg);
+      roundResult = parseFishResult(text);
+      roundResult.clickedCount = 0;
+      LOG.debug(`[fish] Direct result: ${roundResult.outcome}`);
+    }
+    results.push(roundResult);
+
+    if (roundResult.outcome === 'caught') totalCaught++;
+    if (roundResult.outcome === 'mine') totalMines++;
+
+    const formatted = formatRoundResult(roundResult);
+    LOG.info(`[fish] Round ${round + 1}: ${formatted.result}`);
+    if (onRound) onRound(round + 1, roundResult);
+
+    // Result screen has: Go Back, Open Buckets, Sell Creature (coins/tokens),
+    // and "Fish Again" (SECTION accessory button).
+    // NOTE: Sell Creature from result screen triggers EPHEMERAL confirmation
+    // which selfbots can't interact with. Use "pls fish buckets" → "Sell All Fish"
+    // instead (every N rounds or when bucket is full).
+
+    await sleep(500);
+
+    // Check if bucket is full — sell all from buckets to free space
+    const resultMsg = await refetchMsg(channel, msgId);
+    if (resultMsg) {
+      const resultText = getFullText(resultMsg).toLowerCase();
+      if (resultText.includes('no more bucket space')) {
+        LOG.warn('[fish] Bucket full — selling all from buckets');
+        await sellAllFish({ channel, waitForDankMemer });
+      }
+    }
+
+    // Wait for cooldown
+    if (roundResult.cd && roundResult.cd > 0) {
+      LOG.info(`[fish] Cooldown — ${roundResult.cd}s, waiting...`);
+      await sleep(roundResult.cd * 1000 + 1000);
+    }
+
+    // Click "Fish Again" — try multiple approaches
+    let fishAgainClicked = false;
+
+    // Drain stale events accumulated during cooldown/sell wait
+    for (let d = 0; d < 10; d++) {
+      const stale = await waitForDankMemer(300);
+      if (!stale) break;
+    }
+
+    // Approach 1: Refetch the catch result message and click Fish Again
+    for (let retry = 0; retry < 3 && !fishAgainClicked; retry++) {
+      const currentMsg = await refetchMsg(channel, msgId);
+      if (!currentMsg) break;
+      const fishAgainBtn = getAllButtons(currentMsg).find(b =>
+        !b.disabled && (b.customId || '').includes('fish-catch-fish')
+      );
+      if (fishAgainBtn) {
+        await humanDelay(80, 200);
+        try {
+          await safeClickButton(currentMsg, fishAgainBtn);
+          fishAgainClicked = true;
+        } catch (e) {
+          LOG.debug(`[fish] Fish Again attempt ${retry + 1} error: ${e.message}`);
+          await sleep(2000);
+        }
+      } else {
+        // Maybe still on CD — check and wait
+        const txt = getFullText(currentMsg);
+        const remainCd = parseFishCooldown(txt);
+        if (remainCd && remainCd > 0) {
+          LOG.debug(`[fish] Still on CD (${remainCd}s), waiting...`);
+          await sleep(remainCd * 1000 + 1000);
+        } else {
+          await sleep(2000);
+        }
+      }
+    }
+
+    // Approach 2: If Fish Again not found, re-send "pls fish catch" fresh
+    if (!fishAgainClicked) {
+      LOG.debug('[fish] Fish Again not found, re-sending pls fish catch');
+      await channel.send('pls fish catch');
+      let newResp = await waitForDankMemer(8000);
+      if (!newResp) { LOG.warn('[fish] No response to re-send'); break; }
+      let freshResp = await refetchMsg(channel, newResp.id);
+      if (freshResp) newResp = freshResp;
+      msgId = newResp.id;
+
+      // Wait for any remaining cooldown
+      const txt = getFullText(newResp);
+      const remainCd = parseFishCooldown(txt);
+      if (remainCd && remainCd > 0) {
+        await sleep(remainCd * 1000 + 1000);
+        newResp = await refetchMsg(channel, msgId);
+        if (!newResp) break;
+      }
+
+      const goFishBtn3 = getAllButtons(newResp).find(b =>
+        !b.disabled && (b.customId || '').includes('fish-catch-fish')
+      );
+      if (goFishBtn3) {
+        await humanDelay(80, 200);
+        try {
+          await safeClickButton(newResp, goFishBtn3);
+          fishAgainClicked = true;
+        } catch (e) {
+          LOG.debug(`[fish] Go Fishing re-send error: ${e.message}`);
+        }
+      }
+    }
+
+    if (!fishAgainClicked) {
+      LOG.info('[fish] Could not start next round — stopping loop');
+      break;
+    }
+  }
+
+  LOG.success(`[fish] Fishing loop done: ${results.length} rounds, ${totalCaught} caught, ${totalMines} mines`);
+  return { totalRounds: results.length, totalCaught, totalMines, results };
+}
+
+/**
+ * Format a round result into {result, coins, nextCooldownSec}.
+ */
+function formatRoundResult(r) {
+  const coins = 0; // Fish don't give coins directly; value is from selling
+  switch (r.outcome) {
+    case 'caught':
+      return { result: `fish → caught ${r.fish || 'a fish'}`, coins, nextCooldownSec: r.cd };
+    case 'mine':
+      return { result: 'fish → triggered mine', coins, nextCooldownSec: r.cd };
+    case 'nothing':
+      return { result: 'fish → nothing', coins, nextCooldownSec: r.cd };
+    case 'got_away':
+      return { result: 'fish → got away', coins, nextCooldownSec: r.cd };
+    default:
+      return { result: `fish → ${r.header || r.outcome}`, coins, nextCooldownSec: r.cd };
+  }
+}
+
+module.exports = { runFish, runFishLoop, sellAllFish };