dankgrinder 5.11.0 → 5.13.0

package/lib/commands/shop.js

@@ -16,7 +16,7 @@
 const {
   LOG, c, sleep, humanDelay, getFullText,
   getAllButtons, findSelectMenuOption,
-  logMsg, isHoldTight, isCV2, ensureCV2,
+  logMsg, isHoldTight, isCV2, ensureCV2, stripAnsi,
 } = require('./utils');
 const { LRUCache, Trie } = require('../structures');
 
@@ -61,6 +61,25 @@ for (const [item, searchTerm] of Object.entries(ITEM_SEARCH_TERM)) {
 // commands both detect "need shovel" within seconds of each other)
 const recentPurchases = new LRUCache(16);
 
+function isBuySuccessText(text) {
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+  return lower.includes('success')
+    || lower.includes('successful purchase')
+    || lower.includes('bought')
+    || lower.includes('purchased')
+    || (lower.includes('you bought') && lower.includes('for'));
+}
+
+function isBuyFailText(text) {
+  const lower = String(stripAnsi(text || '')).toLowerCase();
+  return lower.includes('not enough')
+    || lower.includes("can't afford")
+    || lower.includes('insufficient')
+    || lower.includes('you need')
+    || lower.includes('missing item')
+    || lower.includes('missing items');
+}
+
 /**
  * Buy an item from the Dank Memer shop.
  *
@@ -171,14 +190,54 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
   // Step 4: Click the Buy button → Modal with quantity input
   LOG.buy(`Clicking "${buyBtn.label}"...`);
   const btnId = buyBtn.customId || buyBtn.custom_id;
-  let modal;
+  let clickResult;
   try {
-    modal = await response.clickButton(btnId);
+    clickResult = await response.clickButton(btnId);
   } catch (e) {
     LOG.error(`[shop] Button click failed: ${e.message}`);
     return false;
   }
 
+  // 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);
+    logMsg(clickResult, 'buy-direct-result');
+    if (isBuySuccessText(directText)) {
+      LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
+      recentPurchases.set(key, Date.now());
+      return true;
+    }
+    if (isBuyFailText(directText)) {
+      LOG.warn(`[shop] Direct buy failed for ${itemName}: ${directText.substring(0, 120)}`);
+      return false;
+    }
+
+    // Fallback: wait one follow-up message for purchase outcome text.
+    const follow = await waitForDankMemer(6000);
+    if (follow) {
+      if (isCV2(follow)) await ensureCV2(follow);
+      const fText = getFullText(follow);
+      logMsg(follow, 'buy-direct-followup');
+      if (isBuySuccessText(fText)) {
+        LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
+        recentPurchases.set(key, Date.now());
+        return true;
+      }
+      if (isBuyFailText(fText)) {
+        LOG.warn(`[shop] Buy failed for ${itemName}: ${fText.substring(0, 120)}`);
+        return false;
+      }
+    }
+
+    LOG.success(`Buy click sent for ${itemName} (no modal path)`);
+    recentPurchases.set(key, Date.now());
+    return true;
+  }
+
+  const modal = clickResult;
+
   if (!modal || !modal.components) {
     LOG.warn('[shop] No modal returned from button click');
     return false;
@@ -194,12 +253,12 @@ async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, clie
       const text = getFullText(result);
       logMsg(result, 'buy-result');
 
-      if (text.toLowerCase().includes('success') || text.toLowerCase().includes('bought') || text.toLowerCase().includes('purchased')) {
+      if (isBuySuccessText(text)) {
         LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
         recentPurchases.set(key, Date.now());
         return true;
       }
-      if (text.toLowerCase().includes('not enough') || text.toLowerCase().includes("can't afford") || text.toLowerCase().includes('insufficient')) {
+      if (isBuyFailText(text)) {
         LOG.warn(`Not enough coins to buy ${itemName}`);
         return false;
       }

package/lib/commands/stream.js

@@ -1,10 +1,97 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
+  isCV2, ensureCV2, stripAnsi,
 } = 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']);
+
+function normalizeLower(text) {
+  return String(text || '')
+    .normalize('NFKC')
+    .replace(/[’‘`´]/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+async function hydrate(msg) {
+  if (isCV2(msg)) await ensureCV2(msg);
+  return msg;
+}
+
+async function refetchMsg(channel, msgId) {
+  try { return await channel.messages.fetch(msgId); } catch { return null; }
+}
+
+function getGoLiveButton(msg) {
+  const buttons = getAllButtons(msg);
+  return buttons.find(b => !b.disabled && (b.label || '').toLowerCase().includes('go live')) || null;
+}
+
+function getLiveActionButtons(msg) {
+  const buttons = getAllButtons(msg).filter(b => !b.disabled && b.label);
+  return buttons.filter(b => STREAM_ACTION_LABELS.some(lbl => (b.label || '').toLowerCase().includes(lbl)));
+}
+
+function isLiveDashboard(msg, lowerText) {
+  if (lowerText.includes('your stream can last') || lowerText.includes('you can interact with your stream every')) return true;
+  const labels = getAllButtons(msg).map(b => (b.label || '').toLowerCase());
+  return labels.some(l => l.includes('end stream')) && labels.some(l => STREAM_ACTION_LABELS.some(a => l.includes(a)));
+}
+
+function isStreamManagerScreen(lowerText) {
+  return lowerText.includes('stream manager')
+    || lowerText.includes('what game do you want to stream')
+    || lowerText.includes('view setup')
+    || lowerText.includes('go live');
+}
+
+function isActionResultText(lowerText) {
+  return lowerText.includes('you ran an ad')
+    || lowerText.includes('read chat')
+    || lowerText.includes('collect')
+    || lowerText.includes('donation')
+    || lowerText.includes('received');
+}
+
+async function selectRandomStreamOption(msg) {
+  const menus = getAllSelectMenus(msg);
+  if (menus.length === 0) return false;
+
+  const menu = menus[0];
+  const options = (menu.options || []).filter(o => !o.default);
+  if (options.length === 0) return false;
+
+  const pick = pickRandom(options);
+  LOG.info(`[stream] Selecting option: "${pick.label}"`);
+
+  let menuRowIdx = -1;
+  for (let i = 0; i < (msg.components || []).length; i++) {
+    for (const comp of (msg.components[i]?.components || [])) {
+      if ((comp.type === 'STRING_SELECT' || comp.type === 3) &&
+          ((comp.customId || comp.custom_id) === (menu.customId || menu.custom_id))) {
+        menuRowIdx = i;
+        break;
+      }
+    }
+    if (menuRowIdx >= 0) break;
+  }
+
+  try {
+    await msg.selectMenu(menuRowIdx >= 0 ? menuRowIdx : (menu.customId || menu.custom_id), [pick.value]);
+    return true;
+  } catch (e) {
+    LOG.error(`[stream] Select option failed: ${e.message}`);
+    return false;
+  }
+}
 
 async function runStream({ channel, waitForDankMemer, client }) {
   LOG.cmd(`${c.white}${c.bold}pls stream${c.reset}`);
@@ -22,16 +109,21 @@ async function runStream({ channel, waitForDankMemer, client }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  await hydrate(response);
   logMsg(response, 'stream');
   let text = getFullText(response);
-  let lower = text.toLowerCase();
+  let lower = normalizeLower(stripAnsi(text));
 
   // Missing items — buy keyboard + mouse
-  if (lower.includes('missing items') || lower.includes('need following items') ||
+  const missing = needsItem(lower);
+  if (missing === 'keyboard' || missing === 'mouse' ||
+      lower.includes('missing items') || lower.includes('need following items') ||
+      lower.includes('need the following items') ||
       lower.includes('need a keyboard') || lower.includes('need a mouse')) {
     const itemsToBuy = [];
     if (lower.includes('keyboard')) itemsToBuy.push('keyboard');
     if (lower.includes('mouse')) itemsToBuy.push('mouse');
+    if ((missing === 'keyboard' || missing === 'mouse') && !itemsToBuy.includes(missing)) itemsToBuy.push(missing);
     if (itemsToBuy.length === 0) itemsToBuy.push(...STREAM_ITEMS);
 
     for (const item of itemsToBuy) {
@@ -44,108 +136,121 @@ async function runStream({ channel, waitForDankMemer, client }) {
     await channel.send('pls stream');
     response = await waitForDankMemer(12000);
     if (!response) return { result: 'no response after buy', coins: 0 };
+    await hydrate(response);
     logMsg(response, 'stream-retry');
     text = getFullText(response);
-    lower = text.toLowerCase();
+    lower = normalizeLower(stripAnsi(text));
   }
 
-  // Stream Manager — select a game from dropdown, then click "Go Live"
-  if (lower.includes('stream manager') || lower.includes('what game do you want to stream')) {
-    const menus = getAllSelectMenus(response);
-    if (menus.length > 0) {
-      const menu = menus[0];
-      const options = menu.options || [];
-      if (options.length > 0) {
-        // Pick a random game (variety is better for Dank Memer)
-        const pick = options[Math.floor(Math.random() * options.length)];
-        LOG.info(`[stream] Selecting game: "${pick.label}"`);
-
-        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;
-        }
+  // Setup flow: manager -> option select (game/platform) -> Go Live -> live dashboard
+  for (let step = 0; step < 6; step++) {
+    text = getFullText(response);
+    lower = normalizeLower(stripAnsi(text));
 
-        if (menuRowIdx >= 0) {
-          try {
-            const selectResult = await response.selectMenu(menuRowIdx, [pick.value]);
-            if (selectResult) {
-              response = selectResult;
-              logMsg(response, 'stream-game-selected');
-            }
-          } catch (e) {
-            LOG.error(`[stream] Select game failed: ${e.message}`);
-          }
-          await humanDelay(200, 500);
-        }
+    if (isLiveDashboard(response, lower)) break;
+    if (!isStreamManagerScreen(lower)) break;
+
+    const selected = await selectRandomStreamOption(response);
+    if (selected) {
+      await humanDelay(150, 350);
+      const updatedAfterSelect = (await waitForDankMemer(5000)) || (await refetchMsg(channel, response.id));
+      if (updatedAfterSelect) {
+        response = updatedAfterSelect;
+        await hydrate(response);
+        logMsg(response, `stream-selected-${step}`);
       }
     }
 
-    // Click "Go Live" button
-    const buttons = getAllButtons(response);
-    const goLiveBtn = buttons.find(b => !b.disabled && b.label && b.label.toLowerCase().includes('go live'));
-    if (goLiveBtn) {
-      LOG.info('[stream] Clicking "Go Live"');
-      await humanDelay(100, 300);
-      try {
-        const liveResult = await safeClickButton(response, goLiveBtn);
-        if (liveResult) {
-          response = liveResult;
-          logMsg(response, 'stream-live');
-          text = getFullText(response);
-          lower = text.toLowerCase();
-        }
-      } catch (e) {
-        LOG.error(`[stream] Go Live click failed: ${e.message}`);
-      }
-    } else {
-      const anyBtn = buttons.find(b => !b.disabled && b.label && !b.label.toLowerCase().includes('back'));
-      if (anyBtn) {
-        try { await safeClickButton(response, anyBtn); } catch {}
+    const goLiveBtn = getGoLiveButton(response);
+    if (!goLiveBtn) {
+      await sleep(300);
+      const fresh = await refetchMsg(channel, response.id);
+      if (fresh) {
+        response = fresh;
+        await hydrate(response);
+        continue;
       }
+      break;
     }
-  }
 
-  // After going live, there might be interactive stream events
-  // Keep clicking non-end buttons for up to 5 rounds
-  for (let round = 0; round < 5; round++) {
-    const followUp = await waitForDankMemer(15000);
-    if (!followUp) break;
-
-    logMsg(followUp, `stream-round-${round}`);
-    const fText = getFullText(followUp);
-    const fLower = fText.toLowerCase();
-    const fCoins = parseCoins(fText);
-
-    if (fLower.includes('stream ended') || fLower.includes('stream is over') || fLower.includes('you earned')) {
-      if (fCoins > 0) {
-        LOG.coin(`[stream] ${c.green}+⏣ ${fCoins.toLocaleString()}${c.reset}`);
-        return { result: `stream → +⏣ ${fCoins.toLocaleString()}`, coins: fCoins, nextCooldownSec: 600 };
+    LOG.info('[stream] Clicking "Go Live"');
+    await humanDelay(100, 250);
+    try {
+      const liveResult = await safeClickButton(response, goLiveBtn);
+      const next = liveResult || (await waitForDankMemer(7000)) || (await refetchMsg(channel, response.id));
+      if (next) {
+        response = next;
+        await hydrate(response);
+        logMsg(response, `stream-go-live-${step}`);
+        continue;
       }
-      return { result: 'stream ended', coins: 0, nextCooldownSec: 600 };
+    } catch (e) {
+      LOG.error(`[stream] Go Live click failed: ${e.message}`);
     }
+    break;
+  }
 
-    const btns = getAllButtons(followUp);
-    const actionBtn = btns.find(b => !b.disabled && b.label &&
-      !b.label.toLowerCase().includes('end') && !b.label.toLowerCase().includes('stop') && !b.label.toLowerCase().includes('back'));
-    if (actionBtn) {
-      LOG.info(`[stream] Clicking "${actionBtn.label}"`);
-      await humanDelay(100, 300);
-      try { await safeClickButton(followUp, actionBtn); } catch {}
-    } else if (btns.length > 0) {
-      const first = btns.find(b => !b.disabled);
-      if (first) { try { await safeClickButton(followUp, first); } catch {} }
+  // Live phase: click exactly one random interaction button every run.
+  // Scheduler uses nextCooldownSec=600, so this executes every 10 minutes.
+  text = getFullText(response);
+  lower = normalizeLower(stripAnsi(text));
+
+  if (isLiveDashboard(response, lower)) {
+    const actions = getLiveActionButtons(response);
+    if (actions.length > 0) {
+      const action = pickRandom(actions);
+      LOG.info(`[stream] Live action: "${action.label}"`);
+      await humanDelay(120, 320);
+      try {
+        const clicked = await safeClickButton(response, action);
+        let updated = clicked || (await waitForDankMemer(6000)) || (await refetchMsg(channel, response.id));
+        if (updated) {
+          response = updated;
+          await hydrate(response);
+          logMsg(response, 'stream-action');
+          text = getFullText(response);
+          lower = normalizeLower(stripAnsi(text));
+
+          // Action payouts may appear as a second follow-up message.
+          // Keep checking briefly so earnings are not missed.
+          let bestText = text;
+          let bestCoins = parseCoins(bestText);
+          for (let i = 0; i < 2; i++) {
+            const nextMsg = await waitForDankMemer(5000);
+            if (!nextMsg) break;
+            await hydrate(nextMsg);
+            logMsg(nextMsg, `stream-action-followup-${i}`);
+            const nextText = getFullText(nextMsg);
+            const nextLower = normalizeLower(stripAnsi(nextText));
+            const nextCoins = parseCoins(nextText);
+            if (nextCoins > bestCoins || (bestCoins === 0 && isActionResultText(nextLower))) {
+              bestText = nextText;
+              bestCoins = nextCoins;
+              response = nextMsg;
+            }
+          }
+          text = bestText;
+          lower = normalizeLower(stripAnsi(text));
+        }
+      } catch (e) {
+        LOG.error(`[stream] Action click failed: ${e.message}`);
+      }
     } else {
-      break;
+      LOG.info('[stream] Live dashboard found but no action buttons available yet');
     }
   }
 
+  const ended = lower.includes('stream ended') || lower.includes('stream is over') || lower.includes('you earned');
   const coins = parseCoins(text);
-  if (coins > 0) return { result: `stream → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: 600 };
+  if (coins > 0) {
+    LOG.coin(`[stream] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `stream → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: 600 };
+  }
+
+  if (ended) return { result: 'stream ended', coins: 0, nextCooldownSec: 600 };
 
-  return { result: text.substring(0, 50) || 'streamed', coins: 0, nextCooldownSec: 600 };
+  const short = normalizeLower(stripAnsi(text)).substring(0, 60);
+  return { result: short || 'streamed', coins: 0, nextCooldownSec: 600 };
 }
 
 module.exports = { runStream };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dankgrinder",
-  "version": "5.11.0",
+  "version": "5.13.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"