dankgrinder 5.14.0 → 5.19.0

package/lib/commands/shop.js

@@ -15,7 +15,7 @@
 
 const {
   LOG, c, sleep, humanDelay, getFullText,
-  getAllButtons, findSelectMenuOption,
+  getAllButtons, findSelectMenuOption, getAllSelectMenus, safeClickButton,
   logMsg, isHoldTight, isCV2, ensureCV2, stripAnsi,
 } = require('./utils');
 const { LRUCache, Trie } = require('../structures');
@@ -29,6 +29,13 @@ const ITEM_COSTS = Object.freeze({
   'adventure ticket': 250000,
   'keyboard': 10000,
   'mouse': 10000,
+  'hoe': 25000,
+  'watering can': 25000,
+  'water can': 25000,
+  'water bucket': 100000,
+  'seeds': 5000,
+  'seed': 5000,
+  'corn seeds': 5000,
 });
 
 const ITEM_SEARCH_TERM = Object.freeze({
@@ -39,6 +46,13 @@ const ITEM_SEARCH_TERM = Object.freeze({
   'adventure ticket': 'ticket',
   'keyboard': 'keyboard',
   'mouse': 'mouse',
+  'hoe': 'hoe',
+  'watering can': 'water can',
+  'water can': 'water can',
+  'water bucket': 'water bucket',
+  'seeds': 'seeds',
+  'seed': 'seed',
+  'corn seeds': 'corn seeds',
 });
 
 const ITEM_SHOP_TAB = Object.freeze({
@@ -49,6 +63,13 @@ const ITEM_SHOP_TAB = Object.freeze({
   'adventure ticket': 'Coin Shop',
   'keyboard': 'Coin Shop',
   'mouse': 'Coin Shop',
+  'hoe': 'Coin Shop',
+  'watering can': 'Coin Shop',
+  'water can': 'Coin Shop',
+  'water bucket': 'Coin Shop',
+  'seeds': 'Coin Shop',
+  'seed': 'Coin Shop',
+  'corn seeds': 'Coin Shop',
 });
 
 // Trie for item button label matching — O(k) vs O(n) linear scan
@@ -80,50 +101,56 @@ function isBuyFailText(text) {
     || lower.includes('missing items');
 }
 
-/**
- * Buy an item from the Dank Memer shop.
- *
- * @param {object} opts
- * @param {object} opts.channel
- * @param {function} opts.waitForDankMemer
- * @param {string} opts.itemName - e.g. 'Hunting Rifle', 'Shovel'
- * @param {number} [opts.quantity=1]
- * @param {object} [opts.client] - Discord client
- * @returns {Promise<boolean>} true if purchase succeeded
- */
-async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, client }) {
-  const key = itemName.toLowerCase();
-  const searchTerm = ITEM_SEARCH_TERM[key] || key.split(' ').pop();
-  const targetTab = ITEM_SHOP_TAB[key] || 'Coin Shop';
+function findBuyButtonInMessage(msg, searchTerm, key) {
+  const allBtns = getAllButtons(msg);
+  const normalizedSearch = String(searchTerm || '').toLowerCase().replace(/\s+/g, '');
+  const normalizedKey = String(key || '').toLowerCase().replace(/\s+/g, '');
+  return allBtns.find(b => {
+    const label = String(b.label || '').toLowerCase();
+    const id = String(b.customId || b.custom_id || '').toLowerCase().replace(/\s+/g, '');
+    return label.includes(searchTerm)
+      || (normalizedSearch && id.includes(normalizedSearch))
+      || (normalizedKey && id.includes(normalizedKey));
+  }) || null;
+}
 
-  // LRU dedup: skip if we bought this item in the last 10 seconds
-  const lastBuy = recentPurchases.get(key);
-  if (lastBuy && Date.now() - lastBuy < 10000) {
-    LOG.info(`[shop] Skipping ${itemName} — just purchased ${Math.round((Date.now() - lastBuy) / 1000)}s ago`);
-    return true;
-  }
+function findNextShopPageButton(msg) {
+  const btns = getAllButtons(msg).filter(b => !b.disabled);
+  return btns.find(b => {
+    const id = String(b.customId || b.custom_id || '').toLowerCase();
+    if (!id.includes('shop-view')) return false;
+    return id.endsWith(':1') || id.includes(':1:');
+  }) || null;
+}
 
-  LOG.buy(`Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset}`);
+function normalizeShopRequest(itemName, quantity = 1) {
+  const key = String(itemName || '').toLowerCase();
+  return {
+    itemName,
+    quantity,
+    key,
+    searchTerm: ITEM_SEARCH_TERM[key] || key.split(' ').pop(),
+    targetTab: ITEM_SHOP_TAB[key] || 'Coin Shop',
+  };
+}
 
-  // Step 1: Open shop
+async function openShopView({ channel, waitForDankMemer }) {
   await channel.send('pls shop view');
   let response = await waitForDankMemer(10000);
 
-  if (!response) {
-    LOG.warn('[shop] No response to pls shop view');
-    return false;
-  }
+  if (!response) return { ok: false, reason: 'no-response', response: null };
   if (isHoldTight(response)) {
     LOG.warn('[shop] Hold tight — waiting 30s');
     await sleep(30000);
-    return false;
+    return { ok: false, reason: 'hold-tight', response: null };
   }
 
   if (isCV2(response)) await ensureCV2(response);
-
   logMsg(response, 'shop');
+  return { ok: true, reason: 'ok', response };
+}
 
-  // Step 2: Switch shop tab if needed (e.g. Fishing Shop for fishing pole)
+async function ensureShopTab({ response, waitForDankMemer, targetTab }) {
   const selectInfo = findSelectMenuOption(response, targetTab);
   if (selectInfo) {
     const isAlreadySelected = (selectInfo.component.options || [])
@@ -137,7 +164,7 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
           const row = response.components[i];
           for (const comp of row?.components || []) {
             if ((comp.type === 'STRING_SELECT' || comp.type === 3) &&
-                comp.customId === selectInfo.menuCustomId) {
+                (comp.customId || comp.custom_id) === selectInfo.menuCustomId) {
               menuRowIdx = i;
               break;
             }
@@ -148,46 +175,62 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
           menuRowIdx >= 0 ? menuRowIdx : selectInfo.menuCustomId,
           [selectInfo.option.value]
         );
-        if (result) {
-          response = result;
-          if (isCV2(response)) await ensureCV2(response);
-          LOG.success(`Switched to ${targetTab}`);
-        }
+        response = result || (await waitForDankMemer(6000)) || response;
+        if (isCV2(response)) await ensureCV2(response);
+        LOG.success(`Switched to ${targetTab}`);
         await sleep(300);
       } catch (e) {
         LOG.error(`[shop] Tab switch failed: ${e.message}`);
-        return false;
+      }
+    }
+  } else {
+    const menus = getAllSelectMenus(response);
+    const menu = menus.find(m => (m.options || []).length > 0);
+    if (menu) {
+      const desired = (menu.options || []).find(o => (o.label || '').toLowerCase().includes(targetTab.toLowerCase()));
+      if (desired) {
+        try {
+          await response.selectMenu(menu.customId || menu.custom_id, [desired.value]);
+          const maybeUpdated = await waitForDankMemer(6000);
+          if (maybeUpdated) {
+            response = maybeUpdated;
+            if (isCV2(response)) await ensureCV2(response);
+            LOG.success(`Switched to ${targetTab}`);
+          }
+        } catch {}
       }
     }
   }
+  return response;
+}
 
-  // Step 3: Find the Buy button for our item
-  const allBtns = getAllButtons(response);
-  const normalizedSearch = String(searchTerm || '').toLowerCase().replace(/\s+/g, '');
-  const normalizedKey = String(key || '').toLowerCase().replace(/\s+/g, '');
-  const buyBtn = allBtns.find(b => {
-    const label = String(b.label || '').toLowerCase();
-    const id = String(b.customId || b.custom_id || '').toLowerCase().replace(/\s+/g, '');
-    return label.includes(searchTerm)
-      || (normalizedSearch && id.includes(normalizedSearch))
-      || (normalizedKey && id.includes(normalizedKey));
-  });
+async function findBuyButtonPaged({ response, waitForDankMemer, searchTerm, key }) {
+  let buyBtn = null;
+  for (let page = 0; page < 10; page++) {
+    buyBtn = findBuyButtonInMessage(response, searchTerm, key);
+    if (buyBtn) break;
 
-  if (!buyBtn) {
-    LOG.warn(`[shop] No button for "${itemName}" (search: "${searchTerm}")`);
-    const named = allBtns.filter(b => b.label);
-    if (named.length > 0) {
-      LOG.debug(`[shop] Available: ${named.map(b => `"${b.label}"(${b.disabled ? 'DIS' : 'EN'})`).join(', ')}`);
+    const nextPageBtn = findNextShopPageButton(response);
+    if (!nextPageBtn) break;
+    try {
+      const moved = await safeClickButton(response, nextPageBtn);
+      response = moved || (await waitForDankMemer(5000)) || response;
+      if (isCV2(response)) await ensureCV2(response);
+      await sleep(200);
+    } catch {
+      break;
     }
-    return false;
   }
+  return { response, buyBtn };
+}
 
+async function performBuyFromButton({ response, buyBtn, waitForDankMemer, itemName, quantity, key }) {
+  if (!buyBtn) return { ok: false, reason: 'not-found', response };
   if (buyBtn.disabled) {
     LOG.warn(`[shop] "${buyBtn.label}" is DISABLED — not enough coins for ${itemName}`);
-    return false;
+    return { ok: false, reason: 'disabled', response };
   }
 
-  // Step 4: Click the Buy button → Modal with quantity input
   LOG.buy(`Clicking "${buyBtn.label}"...`);
   const btnId = buyBtn.customId || buyBtn.custom_id;
   let clickResult;
@@ -195,11 +238,9 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
     clickResult = await response.clickButton(btnId);
   } catch (e) {
     LOG.error(`[shop] Button click failed: ${e.message}`);
-    return false;
+    return { ok: false, reason: 'click-failed', response };
   }
 
-  // Some shop buttons buy immediately (no quantity modal).
-  // If we received a message-like response, parse it directly.
   if (clickResult && !clickResult.components?.[0]?.components?.[0]?.setValue) {
     if (isCV2(clickResult)) await ensureCV2(clickResult);
     const directText = getFullText(clickResult);
@@ -207,14 +248,13 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
     if (isBuySuccessText(directText)) {
       LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
       recentPurchases.set(key, Date.now());
-      return true;
+      return { ok: true, reason: 'direct-success', response: clickResult };
     }
     if (isBuyFailText(directText)) {
       LOG.warn(`[shop] Direct buy failed for ${itemName}: ${directText.substring(0, 120)}`);
-      return false;
+      return { ok: false, reason: 'direct-failed', response: clickResult };
     }
 
-    // Fallback: wait one follow-up message for purchase outcome text.
     const follow = await waitForDankMemer(6000);
     if (follow) {
       if (isCV2(follow)) await ensureCV2(follow);
@@ -223,27 +263,26 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
       if (isBuySuccessText(fText)) {
         LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
         recentPurchases.set(key, Date.now());
-        return true;
+        return { ok: true, reason: 'followup-success', response: follow };
       }
       if (isBuyFailText(fText)) {
         LOG.warn(`[shop] Buy failed for ${itemName}: ${fText.substring(0, 120)}`);
-        return false;
+        return { ok: false, reason: 'followup-failed', response: follow };
       }
+      return { ok: true, reason: 'followup-unknown', response: follow };
     }
 
     LOG.success(`Buy click sent for ${itemName} (no modal path)`);
     recentPurchases.set(key, Date.now());
-    return true;
+    return { ok: true, reason: 'direct-unknown', response: clickResult };
   }
 
   const modal = clickResult;
-
   if (!modal || !modal.components) {
     LOG.warn('[shop] No modal returned from button click');
-    return false;
+    return { ok: false, reason: 'no-modal', response };
   }
 
-  // Step 5: Set quantity and submit the modal
   LOG.buy(`Modal "${modal.title}" — qty=${quantity}`);
   try {
     modal.components[0].components[0].setValue(String(quantity));
@@ -256,20 +295,129 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
       if (isBuySuccessText(text)) {
         LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
         recentPurchases.set(key, Date.now());
-        return true;
+        return { ok: true, reason: 'modal-success', response: result };
       }
       if (isBuyFailText(text)) {
         LOG.warn(`Not enough coins to buy ${itemName}`);
-        return false;
+        return { ok: false, reason: 'modal-failed', response: result };
       }
+      return { ok: true, reason: 'modal-unknown', response: result };
     }
 
     LOG.success(`Modal submitted for ${quantity}x ${itemName} (assuming success)`);
-    return true;
+    return { ok: true, reason: 'modal-submitted', response };
   } catch (e) {
     LOG.error(`[shop] Modal submit failed: ${e.message}`);
+    return { ok: false, reason: 'modal-submit-failed', response };
+  }
+}
+
+/**
+ * Buy an item from the Dank Memer shop.
+ *
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} opts.itemName - e.g. 'Hunting Rifle', 'Shovel'
+ * @param {number} [opts.quantity=1]
+ * @param {object} [opts.client] - Discord client
+ * @returns {Promise<boolean>} true if purchase succeeded
+ */
+async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, client }) {
+  const { key, searchTerm, targetTab } = normalizeShopRequest(itemName, quantity);
+
+  // LRU dedup: skip if we bought this item in the last 10 seconds
+  const lastBuy = recentPurchases.get(key);
+  if (lastBuy && Date.now() - lastBuy < 10000) {
+    LOG.info(`[shop] Skipping ${itemName} — just purchased ${Math.round((Date.now() - lastBuy) / 1000)}s ago`);
+    return true;
+  }
+
+  LOG.buy(`Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset}`);
+
+  // Step 1: Open shop
+  const opened = await openShopView({ channel, waitForDankMemer });
+  if (!opened.ok) {
+    LOG.warn('[shop] No response to pls shop view');
     return false;
   }
+  let response = opened.response;
+
+  // Step 2: Switch shop tab if needed
+  response = await ensureShopTab({ response, waitForDankMemer, targetTab });
+
+  // Step 3: Find the Buy button for our item (scan pages in current tab)
+  const located = await findBuyButtonPaged({ response, waitForDankMemer, searchTerm, key });
+  response = located.response;
+  const buyBtn = located.buyBtn;
+
+  if (!buyBtn) {
+    LOG.warn(`[shop] No button for "${itemName}" (search: "${searchTerm}")`);
+    const named = getAllButtons(response).filter(b => b.label);
+    if (named.length > 0) {
+      LOG.debug(`[shop] Available: ${named.map(b => `"${b.label}"(${b.disabled ? 'DIS' : 'EN'})`).join(', ')}`);
+    }
+    return false;
+  }
+
+  if (buyBtn.disabled) {
+    LOG.warn(`[shop] "${buyBtn.label}" is DISABLED — not enough coins for ${itemName}`);
+    return false;
+  }
+
+  // Step 4/5: purchase
+  const bought = await performBuyFromButton({ response, buyBtn, waitForDankMemer, itemName, quantity, key });
+  return !!bought.ok;
+}
+
+async function buyItemsBatch({ channel, waitForDankMemer, client, items = [] }) {
+  const requests = items
+    .map(i => normalizeShopRequest(i.itemName || i.item || '', i.quantity || i.qty || 1))
+    .filter(r => r.itemName && r.quantity > 0);
+
+  if (requests.length === 0) return { ok: true, results: [] };
+
+  const opened = await openShopView({ channel, waitForDankMemer });
+  if (!opened.ok) return { ok: false, results: requests.map(r => ({ itemName: r.itemName, success: false, reason: opened.reason })) };
+
+  let response = opened.response;
+  const results = [];
+
+  for (const req of requests) {
+    const lastBuy = recentPurchases.get(req.key);
+    if (lastBuy && Date.now() - lastBuy < 10000) {
+      results.push({ itemName: req.itemName, success: true, reason: 'recent' });
+      continue;
+    }
+
+    response = await ensureShopTab({ response, waitForDankMemer, targetTab: req.targetTab });
+    const located = await findBuyButtonPaged({ response, waitForDankMemer, searchTerm: req.searchTerm, key: req.key });
+    response = located.response;
+
+    if (!located.buyBtn) {
+      const named = getAllButtons(response).filter(b => b.label);
+      if (named.length > 0) {
+        LOG.debug(`[shop] Available: ${named.map(b => `"${b.label}"(${b.disabled ? 'DIS' : 'EN'})`).join(', ')}`);
+      }
+      results.push({ itemName: req.itemName, success: false, reason: 'not-found' });
+      continue;
+    }
+
+    const bought = await performBuyFromButton({
+      response,
+      buyBtn: located.buyBtn,
+      waitForDankMemer,
+      itemName: req.itemName,
+      quantity: req.quantity,
+      key: req.key,
+    });
+    response = bought.response || response;
+    results.push({ itemName: req.itemName, success: !!bought.ok, reason: bought.reason });
+
+    await sleep(300);
+  }
+
+  return { ok: results.every(r => r.success), results };
 }
 
-module.exports = { buyItem, ITEM_COSTS };
+module.exports = { buyItem, buyItemsBatch, ITEM_COSTS };

package/lib/commands/stream.js

@@ -1,12 +1,13 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
-  isCV2, ensureCV2, stripAnsi,
+  isCV2, ensureCV2, stripAnsi, clickCV2Button,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
 const STREAM_ITEMS = Object.freeze(['keyboard', 'mouse']);
 const STREAM_ACTION_LABELS = Object.freeze(['run ad', 'read chat', 'collect donations']);
+const RE_STREAM_INTERACT_MIN = /interact\s+with\s+your\s+stream\s+every\s+`?(\d+)`?\s*minutes?/i;
 
 function normalizeLower(text) {
   return String(text || '')
@@ -30,6 +31,27 @@ async function refetchMsg(channel, msgId) {
   try { return await channel.messages.fetch(msgId); } catch { return null; }
 }
 
+async function waitForMessageEditById(client, msgId, channelId, timeoutMs = 6000) {
+  if (!client?.on) return null;
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      try { client.removeListener('messageUpdate', onUpdate); } catch {}
+      resolve(null);
+    }, timeoutMs);
+
+    function onUpdate(_oldMsg, newMsg) {
+      if (!newMsg) return;
+      if (newMsg.id !== msgId) return;
+      if (channelId && newMsg.channel?.id !== channelId && newMsg.channelId !== channelId) return;
+      clearTimeout(timer);
+      try { client.removeListener('messageUpdate', onUpdate); } catch {}
+      resolve(newMsg);
+    }
+
+    client.on('messageUpdate', onUpdate);
+  });
+}
+
 function messageStateSignature(msg) {
   const text = normalizeLower(stripAnsi(getFullText(msg))).slice(0, 220);
   const btnSig = getAllButtons(msg)
@@ -40,10 +62,16 @@ function messageStateSignature(msg) {
   return `${text}||${btnSig}`;
 }
 
-async function waitForStreamTransition({ channel, waitForDankMemer, prevMsg, timeoutMs = 12000 }) {
+async function waitForStreamTransition({ channel, waitForDankMemer, prevMsg, client, timeoutMs = 12000 }) {
   const start = Date.now();
   const prevSig = messageStateSignature(prevMsg);
   while (Date.now() - start < timeoutMs) {
+    const byIdUpdate = await waitForMessageEditById(client, prevMsg.id, prevMsg.channel?.id || prevMsg.channelId, 1800);
+    if (byIdUpdate) {
+      await hydrate(byIdUpdate);
+      if (messageStateSignature(byIdUpdate) !== prevSig) return byIdUpdate;
+    }
+
     const evt = await waitForDankMemer(1500);
     if (evt) {
       await hydrate(evt);
@@ -75,11 +103,14 @@ function isLiveDashboard(msg, lowerText) {
   return labels.some(l => l.includes('end stream')) && labels.some(l => STREAM_ACTION_LABELS.some(a => l.includes(a)));
 }
 
-function isStreamManagerScreen(lowerText) {
+function isStreamManagerScreen(msg, lowerText) {
+  const labels = getAllButtons(msg).map(b => (b.label || '').toLowerCase());
+  const hasManagerButtons = labels.some(l => l.includes('go live')) || labels.some(l => l.includes('view setup'));
   return lowerText.includes('stream manager')
     || lowerText.includes('what game do you want to stream')
     || lowerText.includes('view setup')
-    || lowerText.includes('go live');
+    || lowerText.includes('go live')
+    || hasManagerButtons;
 }
 
 function isActionResultText(lowerText) {
@@ -90,6 +121,16 @@ function isActionResultText(lowerText) {
     || lowerText.includes('received');
 }
 
+function parseStreamInteractCooldownSec(text) {
+  const clean = String(stripAnsi(text || '')).replace(/\s+/g, ' ').trim();
+  const mm = clean.match(RE_STREAM_INTERACT_MIN);
+  if (mm) {
+    const mins = parseInt(mm[1], 10);
+    if (Number.isFinite(mins) && mins > 0) return mins * 60;
+  }
+  return 600;
+}
+
 async function selectRandomStreamOption(msg) {
   const menus = getAllSelectMenus(msg);
   if (menus.length === 0) return false;
@@ -142,6 +183,7 @@ async function runStream({ channel, waitForDankMemer, client }) {
   logMsg(response, 'stream');
   let text = getFullText(response);
   let lower = normalizeLower(stripAnsi(text));
+  let nextCooldownSec = parseStreamInteractCooldownSec(text);
 
   // Missing items — buy keyboard + mouse
   const missing = needsItem(lower);
@@ -169,15 +211,18 @@ async function runStream({ channel, waitForDankMemer, client }) {
     logMsg(response, 'stream-retry');
     text = getFullText(response);
     lower = normalizeLower(stripAnsi(text));
+    nextCooldownSec = parseStreamInteractCooldownSec(text);
   }
 
   // Setup flow: manager -> option select (game/platform) -> Go Live -> live dashboard
+  let lastGoLiveCustomId = null;
   for (let step = 0; step < 6; step++) {
     text = getFullText(response);
     lower = normalizeLower(stripAnsi(text));
+  nextCooldownSec = parseStreamInteractCooldownSec(text);
 
-    if (isLiveDashboard(response, lower)) break;
-    if (!isStreamManagerScreen(lower)) break;
+  if (isLiveDashboard(response, lower)) break;
+  if (!isStreamManagerScreen(response, lower)) break;
 
     const selected = await selectRandomStreamOption(response);
     if (selected) {
@@ -191,7 +236,34 @@ async function runStream({ channel, waitForDankMemer, client }) {
     }
 
     const goLiveBtn = getGoLiveButton(response);
+    if (goLiveBtn?.customId || goLiveBtn?.custom_id) {
+      lastGoLiveCustomId = goLiveBtn.customId || goLiveBtn.custom_id;
+    }
     if (!goLiveBtn) {
+      // Parser fallback: game prompt text detected but buttons/selects may be hidden by library.
+      // Use previously known stream-game custom_id directly against current message.
+      if (lower.includes('what game do you want to stream') && lastGoLiveCustomId) {
+        LOG.info('[stream] Go Live button not visible; trying raw stream-game fallback');
+        try {
+          await clickCV2Button(response, lastGoLiveCustomId);
+          const transitioned = await waitForStreamTransition({
+            channel,
+            waitForDankMemer,
+            client,
+            prevMsg: response,
+            timeoutMs: 12000,
+          });
+          if (transitioned) {
+            response = transitioned;
+            await hydrate(response);
+            logMsg(response, `stream-go-live-raw-${step}`);
+            continue;
+          }
+        } catch (e) {
+          LOG.error(`[stream] Raw Go Live fallback failed: ${e.message}`);
+        }
+      }
+
       await sleep(300);
       const fresh = await refetchMsg(channel, response.id);
       if (fresh) {
@@ -207,12 +279,22 @@ async function runStream({ channel, waitForDankMemer, client }) {
     try {
       const before = response;
       const liveResult = await safeClickButton(response, goLiveBtn);
-      const next = liveResult || (await waitForStreamTransition({
-        channel,
-        waitForDankMemer,
-        prevMsg: before,
-        timeoutMs: 12000,
-      }));
+      const liveLooksLikeMessage = Boolean(liveResult?.id && (liveResult?.channel?.id || liveResult?.channelId));
+      let next = liveLooksLikeMessage ? liveResult : null;
+      if (!next) {
+        next = await waitForStreamTransition({
+          channel,
+          waitForDankMemer,
+          client,
+          prevMsg: before,
+          timeoutMs: 12000,
+        });
+      }
+      if (!next) {
+        // Last fallback: explicit refetch of the original message after click.
+        const fetched = await refetchMsg(channel, before.id);
+        if (fetched) next = fetched;
+      }
       if (next) {
         response = next;
         await hydrate(response);
@@ -234,6 +316,7 @@ async function runStream({ channel, waitForDankMemer, client }) {
           const afterFallback = fallbackRes || (await waitForStreamTransition({
             channel,
             waitForDankMemer,
+            client,
             prevMsg: before,
             timeoutMs: 8000,
           }));
@@ -255,11 +338,13 @@ async function runStream({ channel, waitForDankMemer, client }) {
   // Scheduler uses nextCooldownSec=600, so this executes every 10 minutes.
   text = getFullText(response);
   lower = normalizeLower(stripAnsi(text));
+  nextCooldownSec = parseStreamInteractCooldownSec(text);
 
   if (isLiveDashboard(response, lower)) {
     const actions = getLiveActionButtons(response);
     if (actions.length > 0) {
       const action = pickRandom(actions);
+      const actionAt = new Date();
       LOG.info(`[stream] Live action: "${action.label}"`);
       await humanDelay(120, 320);
       try {
@@ -292,10 +377,12 @@ async function runStream({ channel, waitForDankMemer, client }) {
           }
           text = bestText;
           lower = normalizeLower(stripAnsi(text));
+          nextCooldownSec = parseStreamInteractCooldownSec(text);
         }
       } catch (e) {
         LOG.error(`[stream] Action click failed: ${e.message}`);
       }
+      LOG.info(`[stream] Action timestamp: ${actionAt.toISOString()} | next interaction in ${Math.ceil(nextCooldownSec / 60)}m`);
     } else {
       LOG.info('[stream] Live dashboard found but no action buttons available yet');
     }
@@ -305,13 +392,13 @@ async function runStream({ channel, waitForDankMemer, client }) {
   const coins = parseCoins(text);
   if (coins > 0) {
     LOG.coin(`[stream] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
-    return { result: `stream → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: 600 };
+    return { result: `stream → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec };
   }
 
-  if (ended) return { result: 'stream ended', coins: 0, nextCooldownSec: 600 };
+  if (ended) return { result: 'stream ended', coins: 0, nextCooldownSec };
 
   const short = normalizeLower(stripAnsi(text)).substring(0, 60);
-  return { result: short || 'streamed', coins: 0, nextCooldownSec: 600 };
+  return { result: short || 'streamed', coins: 0, nextCooldownSec };
 }
 
 module.exports = { runStream };