dankgrinder 5.10.0 → 5.12.0

package/lib/commands/stream.js

@@ -1,10 +1,89 @@
 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');
+}
+
+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 +101,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 +128,100 @@ 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 (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}`);
+      }
+    }
 
-        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);
-        }
+    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;
+    }
+
+    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;
       }
+    } catch (e) {
+      LOG.error(`[stream] Go Live click failed: ${e.message}`);
     }
+    break;
+  }
 
-    // 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);
+  // 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 liveResult = await safeClickButton(response, goLiveBtn);
-        if (liveResult) {
-          response = liveResult;
-          logMsg(response, 'stream-live');
+        const clicked = await safeClickButton(response, action);
+        const 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 = text.toLowerCase();
+          lower = normalizeLower(stripAnsi(text));
         }
       } catch (e) {
-        LOG.error(`[stream] Go Live click failed: ${e.message}`);
+        LOG.error(`[stream] Action 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 {}
-      }
+      LOG.info('[stream] Live dashboard found but no action buttons available yet');
     }
   }
 
-  // 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 };
-      }
-      return { result: 'stream ended', coins: 0, nextCooldownSec: 600 };
-    }
-
-    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 {} }
-    } else {
-      break;
-    }
+  const ended = lower.includes('stream ended') || lower.includes('stream is over') || lower.includes('you earned');
+  const coins = parseCoins(text);
+  if (coins > 0) {
+    LOG.coin(`[stream] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `stream → +⏣ ${coins.toLocaleString()}`, coins, nextCooldownSec: 600 };
   }
 
-  const coins = parseCoins(text);
-  if (coins > 0) 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/lib/commands/work.js

@@ -18,6 +18,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  isCV2, ensureCV2, stripAnsi,
 } = require('./utils');
 
 const RE_MEMORY_BACKTICK_CHUNK = /`([^`]+)`/g;
@@ -26,6 +27,24 @@ const RE_WORK_COOLDOWN_TS = /<t:(\d+):R>/;
 const RE_WORK_COOLDOWN_MINUTES = /(\d+)\s*minute/i;
 const RE_WORK_COOLDOWN_HOURS = /(\d+)\s*hour/i;
 
+function normalizeLower(text) {
+  return String(text || '')
+    .normalize('NFKC')
+    .replace(/[’‘`´]/g, "'")
+    .replace(/\bdon'?t\b/gi, "don't")
+    .toLowerCase();
+}
+
+function isNoJobText(text) {
+  const t = normalizeLower(stripAnsi(text)).replace(/\s+/g, ' ').trim();
+  return t.includes("don't currently have a job")
+    || t.includes("don't have a job")
+    || t.includes('no job to work at')
+    || t.includes('you need a job')
+    || t.includes('/work list')
+    || (t.includes('work list') && t.includes('available jobs'));
+}
+
 // Job progression list (order matters — first is easiest to get)
 const JOBS = Object.freeze([
   'babysitter', 'dog walker', 'fast food worker', 'youtuber',
@@ -114,14 +133,15 @@ async function resignFromJob({ channel, waitForDankMemer }) {
 async function autoApplyForJob({ channel, waitForDankMemer }) {
   LOG.info('[work] No job! Applying for Babysitter...');
   await channel.send('pls work apply babysitter');
-  const response = await waitForDankMemer(8000);
+  const response = await waitForDankMemer(10000);
   if (!response) {
     LOG.warn('[work] No response to apply');
     return { applied: false };
   }
+  if (isCV2(response)) await ensureCV2(response);
   logMsg(response, 'work-apply');
   const text = getFullText(response);
-  const tl = text.toLowerCase();
+  const tl = normalizeLower(stripAnsi(text)).replace(/\s+/g, ' ').trim();
   if (tl.includes('congratulations') || tl.includes('now working')) {
     LOG.success('[work] Applied for Babysitter!');
     return { applied: true };
@@ -301,6 +321,8 @@ async function runWorkShift({ channel, waitForDankMemer }) {
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  if (isCV2(current)) await ensureCV2(current);
+
   logMsg(current, 'work');
   let text = getFullText(current);
 
@@ -314,11 +336,10 @@ async function runWorkShift({ channel, waitForDankMemer }) {
     return { result: `work cooldown (${Math.ceil(cooldownSec / 60)}m)`, coins: 0, nextCooldownSec: cooldownSec };
   }
 
-  const textLower = text.toLowerCase();
+  const textLower = normalizeLower(stripAnsi(text)).replace(/\s+/g, ' ').trim();
 
   // ── No job? Auto-apply ─────────────────────────────────────
-  if (textLower.includes("don't currently have a job") || textLower.includes('don\'t have a job') ||
-      textLower.includes('you need a job') || textLower.includes('work list')) {
+  if (isNoJobText(textLower)) {
     const applyResult = await autoApplyForJob({ channel, waitForDankMemer });
     if (!applyResult.applied) {
       return { result: 'no job (apply failed)', coins: 0, nextCooldownSec: applyResult.cooldownSec || 600 };
@@ -331,6 +352,7 @@ async function runWorkShift({ channel, waitForDankMemer }) {
     await channel.send('pls work shift');
     current = await waitForDankMemer(10000);
     if (!current) return { result: 'no response after apply', coins: 0 };
+    if (isCV2(current)) await ensureCV2(current);
     logMsg(current, 'work-after-apply');
     text = getFullText(current);
   }

package/package.json

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