dankgrinder 4.0.0 → 4.1.0

package/lib/commands/postmemes.js

@@ -0,0 +1,148 @@
+/**
+ * PostMemes command handler.
+ * Send "pls pm", select platform + meme type from dropdowns, click Post.
+ *
+ * Flow:
+ *   1. "pls pm" → response with 2 select menus (location + kind) + disabled Post button
+ *   2. Select a platform from location dropdown → message updates, Post still disabled
+ *   3. Select a meme type from kind dropdown → message updates, Post becomes enabled
+ *   4. Click Post → response with coins earned
+ *
+ * CRITICAL: After each selectMenu call, the returned object is the interaction response.
+ * We need to re-fetch the message to get the updated select menus and buttons.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
+  findButton, safeClickButton, logMsg, isHoldTight, getHoldTightReason,
+  sleep, humanDelay,
+} = require('./utils');
+
+/**
+ * Re-fetch a message to get updated state after an interaction.
+ */
+async function refetchMsg(channel, msgId) {
+  try { return await channel.messages.fetch(msgId); }
+  catch { return null; }
+}
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runPostMemes({ channel, waitForDankMemer }) {
+  LOG.cmd(`${c.white}${c.bold}pls pm${c.reset}`);
+
+  await channel.send('pls pm');
+  let response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[pm] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[pm] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'pm');
+
+  // Check for cooldown or direct text response (no select menus)
+  let selects = getAllSelectMenus(response);
+  if (selects.length === 0) {
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    if (coins > 0) {
+      LOG.coin(`[pm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+      return { result: `pm → +⏣ ${coins.toLocaleString()}`, coins };
+    }
+    LOG.info(`[pm] No menus: ${text.substring(0, 100).replace(/\n/g, ' ')}`);
+    return { result: text.substring(0, 60), coins: 0 };
+  }
+
+  const msgId = response.id;
+
+  // CRITICAL: The message from waitForDankMemer (messageCreate/Update event) may have
+  // incomplete component objects (missing minValues/maxValues). Re-fetch the message
+  // from the API to get fully-hydrated components before calling selectMenu().
+  response = await refetchMsg(channel, msgId) || response;
+
+  // Find row indices for our select menus
+  // Layout: Row 0 = platform select, Row 1 = kind select, Row 2 = Post button
+  let locRowIdx = -1, kindRowIdx = -1;
+  for (let i = 0; i < (response.components || []).length; i++) {
+    const row = response.components[i];
+    for (const comp of row.components || []) {
+      if ((comp.type === 'STRING_SELECT' || comp.type === 3) && !comp.disabled) {
+        const cid = (comp.customId || '').toLowerCase();
+        const ph = (comp.placeholder || '').toLowerCase();
+        if (cid.includes('location') || ph.includes('platform')) locRowIdx = i;
+        else if (cid.includes('kind') || ph.includes('meme type')) kindRowIdx = i;
+      }
+    }
+  }
+
+  LOG.debug(`[pm] locRowIdx=${locRowIdx}, kindRowIdx=${kindRowIdx}`);
+
+  // Step 1: Select platform
+  if (locRowIdx >= 0) {
+    const locMenu = response.components[locRowIdx].components[0];
+    const opt = locMenu.options[Math.floor(Math.random() * locMenu.options.length)];
+    LOG.info(`[pm] Platform: "${opt.label}"`);
+    try {
+      await response.selectMenu(locRowIdx, [opt.value]);
+    } catch (e) { LOG.error(`[pm] Platform select error: ${e.message}`); }
+    await sleep(600);
+    const updated = await refetchMsg(channel, msgId);
+    if (updated) { response = updated; logMsg(response, 'pm-after-platform'); }
+  }
+
+  // Step 2: Select meme type
+  if (kindRowIdx >= 0) {
+    const kindMenu = response.components[kindRowIdx].components[0];
+    const opt = kindMenu.options[Math.floor(Math.random() * kindMenu.options.length)];
+    LOG.info(`[pm] MemeType: "${opt.label}"`);
+    try {
+      await response.selectMenu(kindRowIdx, [opt.value]);
+    } catch (e) { LOG.error(`[pm] Kind select error: ${e.message}`); }
+    await sleep(600);
+    const updated = await refetchMsg(channel, msgId);
+    if (updated) { response = updated; logMsg(response, 'pm-after-kind'); }
+  }
+
+  // Step 3: Click Post button
+  const postBtn = getAllButtons(response).find(b =>
+    !b.disabled && (b.label || '').toLowerCase().includes('post')
+  );
+  if (postBtn) {
+    LOG.info(`[pm] Clicking "${postBtn.label}"...`);
+    try {
+      await safeClickButton(response, postBtn);
+      await sleep(600);
+      const final = await refetchMsg(channel, msgId);
+      if (final) {
+        logMsg(final, 'pm-result');
+        const text = getFullText(final);
+        const coins = parseCoins(text);
+        if (coins > 0) {
+          LOG.coin(`[pm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+          return { result: `pm → +⏣ ${coins.toLocaleString()}`, coins };
+        }
+        return { result: 'pm → posted', coins: 0 };
+      }
+    } catch (e) { LOG.error(`[pm] Post click error: ${e.message}`); }
+  } else {
+    LOG.warn('[pm] Post button disabled or not found after both selections');
+    const allBtns = getAllButtons(response);
+    for (const b of allBtns) LOG.debug(`[pm] btn: "${b.label}" disabled=${b.disabled}`);
+  }
+
+  return { result: 'pm done', coins: 0 };
+}
+
+module.exports = { runPostMemes };

package/lib/commands/profile.js

@@ -0,0 +1,99 @@
+/**
+ * Profile level checker.
+ * Send "pls profile", parse level, cache in Redis.
+ * Used to gate commands like scratch (requires level 25).
+ */
+
+const {
+  LOG, c, getFullText, logMsg, isHoldTight, sleep,
+} = require('./utils');
+
+// In-memory cache: { accountId: { level: number, checkedAt: timestamp } }
+const levelCache = {};
+const CACHE_TTL = 10 * 60 * 1000; // 10 minutes
+
+/**
+ * Parse level from profile response text.
+ * Looks for patterns like "Level 25", "Lvl 25", "level: 25"
+ */
+function parseLevelFromText(text) {
+  // Pattern: "Level XX" or "Lvl XX" or "level XX"
+  const match = text.match(/(?:level|lvl)\s*:?\s*(\d+)/i);
+  if (match) return parseInt(match[1]);
+  // Fallback: "Prestige X Level Y" pattern
+  const presMatch = text.match(/prestige\s+\d+\s+level\s+(\d+)/i);
+  if (presMatch) return parseInt(presMatch[1]);
+  return null;
+}
+
+/**
+ * Check player level. Returns cached value if fresh, otherwise sends "pls profile".
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} [opts.accountId] - for cache key
+ * @param {object} [opts.redis] - Redis client for persistent cache
+ * @returns {Promise<number|null>} Level number or null if can't determine
+ */
+async function getPlayerLevel({ channel, waitForDankMemer, accountId = 'default', redis }) {
+  // Check in-memory cache first
+  const cached = levelCache[accountId];
+  if (cached && (Date.now() - cached.checkedAt) < CACHE_TTL) {
+    return cached.level;
+  }
+
+  // Check Redis cache
+  if (redis) {
+    try {
+      const redisLevel = await redis.get(`dkg:level:${accountId}`);
+      if (redisLevel) {
+        const level = parseInt(redisLevel);
+        levelCache[accountId] = { level, checkedAt: Date.now() };
+        return level;
+      }
+    } catch {}
+  }
+
+  // Fetch from Discord
+  LOG.debug('[profile] Checking level...');
+  await channel.send('pls profile');
+  const response = await waitForDankMemer(8000);
+
+  if (!response) {
+    LOG.warn('[profile] No response');
+    return null;
+  }
+
+  if (isHoldTight(response)) {
+    await sleep(5000);
+    return null;
+  }
+
+  logMsg(response, 'profile');
+  const text = getFullText(response);
+  const level = parseLevelFromText(text);
+
+  if (level !== null) {
+    LOG.info(`[profile] Level: ${c.bold}${level}${c.reset}`);
+    levelCache[accountId] = { level, checkedAt: Date.now() };
+    // Persist to Redis for 10 min
+    if (redis) {
+      try { await redis.set(`dkg:level:${accountId}`, String(level), 'EX', 600); } catch {}
+    }
+  } else {
+    LOG.warn(`[profile] Could not parse level from: ${text.substring(0, 100)}`);
+  }
+
+  return level;
+}
+
+/**
+ * Check if player meets minimum level requirement.
+ */
+async function meetsLevelRequirement(opts, minLevel) {
+  const level = await getPlayerLevel(opts);
+  if (level === null) return false; // can't determine, skip
+  return level >= minLevel;
+}
+
+module.exports = { getPlayerLevel, meetsLevelRequirement, parseLevelFromText };

package/lib/commands/scratch.js

@@ -0,0 +1,83 @@
+/**
+ * Scratch command handler.
+ * Send "pls scratch", click through scratch card buttons.
+ * Requires level 25 — checks profile level before running.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+const { meetsLevelRequirement } = require('./profile');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string} [opts.accountId]
+ * @param {object} [opts.redis]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runScratch({ channel, waitForDankMemer, accountId, redis }) {
+  // Check level 25 requirement before wasting a command
+  const canRun = await meetsLevelRequirement({ channel, waitForDankMemer, accountId, redis }, 25);
+  if (!canRun) {
+    LOG.warn(`[scratch] Skipped — need level 25`);
+    return { result: 'skipped (need level 25)', coins: 0, skipReason: 'level' };
+  }
+  LOG.cmd(`${c.white}${c.bold}pls scratch${c.reset}`);
+
+  await channel.send('pls scratch');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[scratch] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[scratch] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'scratch');
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const text = getFullText(response);
+    const coins = parseCoins(text);
+    if (coins > 0) {
+      LOG.coin(`[scratch] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+      return { result: `scratch → +⏣ ${coins.toLocaleString()}`, coins };
+    }
+    return { result: text.substring(0, 60) || 'done', coins: 0 };
+  }
+
+  // Click through all scratch card cells
+  let lastResponse = response;
+  let clickCount = 0;
+  for (let i = 0; i < Math.min(buttons.length, 9); i++) {
+    const btn = buttons[i];
+    if (btn && !btn.disabled) {
+      await humanDelay(300, 700);
+      try {
+        const followUp = await safeClickButton(lastResponse, btn);
+        if (followUp) { lastResponse = followUp; clickCount++; }
+      } catch { break; }
+    }
+  }
+
+  const finalText = getFullText(lastResponse);
+  const coins = parseCoins(finalText);
+
+  if (coins > 0) {
+    LOG.coin(`[scratch] ${clickCount} clicks → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `scratch (${clickCount} clicks) → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: `scratch done (${clickCount} clicks)`, coins: 0 };
+}
+
+module.exports = { runScratch };

package/lib/commands/search.js

@@ -0,0 +1,102 @@
+/**
+ * Search command handler.
+ * Send "pls search", pick a safe button, click it, parse coins.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+const SAFE_SEARCH_LOCATIONS = [
+  'sofa', 'mailbox', 'dog', 'car', 'dresser', 'laundromat', 'bed',
+  'couch', 'pantry', 'fridge', 'kitchen', 'bathroom', 'attic',
+  'closet', 'shoe', 'vacuum', 'toilet', 'sink', 'shower',
+  'tree', 'grass', 'bushes', 'garden', 'park', 'backyard',
+];
+
+function pickSafeButton(buttons, customSafe) {
+  if (!buttons || buttons.length === 0) return null;
+  // Try custom safe list first
+  if (customSafe && customSafe.length > 0) {
+    for (const btn of buttons) {
+      const label = (btn.label || '').toLowerCase();
+      if (customSafe.some(s => label.includes(s.toLowerCase()))) return btn;
+    }
+  }
+  // Try built-in safe list
+  for (const btn of buttons) {
+    const label = (btn.label || '').toLowerCase();
+    if (SAFE_SEARCH_LOCATIONS.some(s => label.includes(s))) return btn;
+  }
+  // Fallback: random non-disabled
+  const clickable = buttons.filter(b => !b.disabled);
+  return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+}
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string[]} [opts.safeAnswers] - Custom safe search locations
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runSearch({ channel, waitForDankMemer, safeAnswers }) {
+  LOG.cmd(`${c.white}${c.bold}pls search${c.reset}`);
+
+  await channel.send('pls search');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[search] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[search] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'search');
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const text = getFullText(response);
+    LOG.info(`[search] No buttons: ${text.substring(0, 80)}`);
+    return { result: text.substring(0, 60), coins: 0 };
+  }
+
+  const btn = pickSafeButton(buttons, safeAnswers);
+  if (!btn) {
+    LOG.warn('[search] No safe button found');
+    return { result: 'no safe option', coins: 0 };
+  }
+
+  LOG.info(`[search] Picking: "${btn.label}"`);
+  await humanDelay();
+
+  try {
+    const followUp = await safeClickButton(response, btn);
+    if (followUp) {
+      logMsg(followUp, 'search-result');
+      const text = getFullText(followUp);
+      const coins = parseCoins(text);
+      if (coins > 0) {
+        LOG.coin(`[search] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+        return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };
+      }
+      if (text.toLowerCase().includes('nothing')) {
+        return { result: `${btn.label} → found nothing`, coins: 0 };
+      }
+      return { result: `${btn.label} → done`, coins: 0 };
+    }
+    return { result: `clicked: ${btn.label}`, coins: 0 };
+  } catch (e) {
+    LOG.error(`[search] Click error: ${e.message}`);
+    return { result: `error: ${e.message}`, coins: 0 };
+  }
+}
+
+module.exports = { runSearch, SAFE_SEARCH_LOCATIONS };

package/lib/commands/shop.js

@@ -0,0 +1,262 @@
+/**
+ * Shop / Buy Item command handler.
+ * Handles opening the shop, navigating to Coin Shop, clicking buy, and submitting modal.
+ */
+
+const {
+  LOG, c, sleep, humanDelay, getFullText, parseCoins,
+  getAllButtons, findButton, findSelectMenuOption, safeClickButton,
+  logMsg, dumpMessage, isHoldTight, DANK_MEMER_ID,
+} = require('./utils');
+
+// Known items and their approximate costs
+const ITEM_COSTS = {
+  'rifle': 50000,
+  'hunting rifle': 50000,
+  'shovel': 25000,
+  'fishing pole': 25000,
+  'adventure ticket': 250000,
+};
+
+/**
+ * Buy an item from the Dank Memer shop.
+ * 
+ * @param {object} opts
+ * @param {object} opts.channel - Discord channel to send commands in
+ * @param {function} opts.waitForDankMemer - Function that returns a promise resolving to Dank Memer's response
+ * @param {string} opts.itemName - Name of the item to buy (e.g. 'Rifle', 'Shovel', 'Adventure Ticket')
+ * @param {number} [opts.quantity=1] - How many to buy
+ * @param {object} [opts.client] - Discord client (needed for modal via interactionModalCreate)
+ * @returns {Promise<boolean>} true if purchase succeeded
+ */
+async function buyItem({ channel, waitForDankMemer, itemName, quantity = 1, client }) {
+  const MAX_RETRIES = 3;
+  const searchName = itemName.toLowerCase().replace('hunting ', '').replace('fishing ', '').replace('adventure ', '');
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    LOG.buy(`Opening shop to buy ${c.bold}${quantity}x ${itemName}${c.reset} (attempt ${attempt}/${MAX_RETRIES})`);
+
+    // Step 1: Open shop
+    await channel.send('pls shop view');
+    let response = await waitForDankMemer(10000);
+
+    if (!response) {
+      LOG.warn('No response to shop view command.');
+      if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+      return false;
+    }
+
+    // Check for Hold Tight
+    if (isHoldTight(response)) {
+      LOG.warn('Hold Tight detected — waiting 30s...');
+      await sleep(30000);
+      if (attempt < MAX_RETRIES) continue;
+      return false;
+    }
+
+    logMsg(response, 'shop');
+
+    const responseText = getFullText(response).toLowerCase();
+
+    // Check if we got an event/lucky response instead of shop
+    const allBtnsCheck = getAllButtons(response);
+    const hasShopComponents = allBtnsCheck.some(b => b.label && b.label.toLowerCase().includes('buy')) ||
+                              allBtnsCheck.some(b => b.label && b.label.toLowerCase().includes('ticket'));
+
+    if (!hasShopComponents && (responseText.includes('lucky') || responseText.includes('event'))) {
+      LOG.warn('Got event response instead of shop. Retrying...');
+      await humanDelay(3000, 5000);
+      continue;
+    }
+
+    // If we got a shop text but no components, wait for the full shop UI
+    if (!hasShopComponents && responseText.includes('shop')) {
+      LOG.debug('Waiting for shop UI to fully load...');
+      const shopUI = await waitForDankMemer(8000);
+      if (shopUI) response = shopUI;
+    }
+
+    // Step 2: Navigate to Coin Shop tab
+    // Re-fetch message to get hydrated components (minValues/maxValues for selectMenu)
+    const freshShopMsg = await channel.messages.fetch(response.id).catch(() => null);
+    if (freshShopMsg) response = freshShopMsg;
+
+    const csInfo = findSelectMenuOption(response, 'Coin Shop');
+    if (csInfo) {
+      const alreadySelected = csInfo.component.options.find(o => o.value === csInfo.option.value)?.default === true;
+      if (!alreadySelected) {
+        LOG.buy('Switching to Coin Shop tab...');
+        // Find row index for the select menu
+        let shopMenuRowIdx = -1;
+        for (let i = 0; i < (response.components || []).length; i++) {
+          const row = response.components[i];
+          for (const comp of row.components || []) {
+            if ((comp.type === 'STRING_SELECT' || comp.type === 3) && comp.customId === csInfo.menuCustomId) {
+              shopMenuRowIdx = i; break;
+            }
+          }
+          if (shopMenuRowIdx >= 0) break;
+        }
+        try {
+          const result = await response.selectMenu(shopMenuRowIdx >= 0 ? shopMenuRowIdx : csInfo.menuCustomId, [csInfo.option.value]);
+          if (result) { response = result; LOG.success('Switched to Coin Shop'); }
+        } catch (e) {
+          LOG.error(`Failed to switch to Coin Shop: ${e.message}`);
+          if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+          return false;
+        }
+        await sleep(600);
+      } else {
+        LOG.debug('Already in Coin Shop');
+      }
+    }
+
+    logMsg(response, 'shop-after-nav');
+
+    // Step 3: Find the Buy button for our item
+    let buyBtn = getAllButtons(response).find(b => b.label && b.label.toLowerCase().includes(searchName));
+
+    if (!buyBtn) {
+      LOG.warn(`No Buy button found for "${itemName}" (searched: "${searchName}")`);
+      // Log all available buttons for debugging
+      const allBtns = getAllButtons(response);
+      if (allBtns.length > 0) {
+        LOG.debug(`Available buttons: ${allBtns.map(b => `"${b.label}"`).join(', ')}`);
+      }
+      // Maybe we need to scroll/paginate?
+      const nextBtn = findButton(response, 'next') || findButton(response, '▶') || findButton(response, '→');
+      if (nextBtn && !nextBtn.disabled) {
+        LOG.buy('Clicking next page to find item...');
+        try {
+          const nextPage = await safeClickButton(response, nextBtn);
+          if (nextPage) {
+            response = nextPage;
+            logMsg(response, 'shop-page2');
+            // Try finding button again
+            buyBtn = getAllButtons(response).find(b => b.label && b.label.toLowerCase().includes(searchName));
+          }
+        } catch (e) {
+          LOG.error(`Page nav failed: ${e.message}`);
+        }
+      }
+
+      if (!buyBtn) {
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+    }
+
+    if (buyBtn.disabled) {
+      LOG.warn(`"${buyBtn.label}" button is DISABLED — not enough coins to buy ${itemName}`);
+      return false;
+    }
+
+    // Step 4: Click the Buy button
+    LOG.buy(`Clicking "${buyBtn.label}"...`);
+    let clickResult;
+    try {
+      clickResult = await safeClickButton(response, buyBtn);
+    } catch (e) {
+      LOG.error(`Buy click failed: ${e.message}`);
+      if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+      return false;
+    }
+
+    // Step 5: Handle Modal (quantity input)
+    // Try two approaches: direct modal from clickResult, or listen for interactionModalCreate
+    let modalHandled = false;
+
+    // Approach A: clickResult is a Modal
+    if (clickResult && (clickResult.isMessage === false || clickResult.constructor?.name === 'Modal')) {
+      const modal = clickResult;
+      LOG.buy(`Modal appeared: "${modal.title || modal.customId}"`);
+      try {
+        modal.components[0].components[0].setValue(String(quantity));
+        LOG.buy(`Submitting modal (qty: ${quantity})...`);
+        const submitResult = await modal.reply();
+        LOG.success('Modal submitted!');
+        if (submitResult) {
+          const text = getFullText(submitResult);
+          logMsg(submitResult, 'buy-result');
+          if (text.toLowerCase().includes('success') || text.toLowerCase().includes('bought') || text.toLowerCase().includes('purchased')) {
+            LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
+            return true;
+          }
+        }
+        modalHandled = true;
+      } catch (e) {
+        LOG.error(`Modal submit failed: ${e.message}`);
+        if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+        return false;
+      }
+    }
+
+    // Approach B: Listen for interactionModalCreate event on client
+    if (!modalHandled && client) {
+      const modal = await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), 8000);
+        const handler = (m) => {
+          clearTimeout(timer);
+          client.removeListener('interactionModalCreate', handler);
+          resolve(m);
+        };
+        client.on('interactionModalCreate', handler);
+      });
+
+      if (modal) {
+        LOG.buy(`Modal (event): "${modal.title || modal.customId}"`);
+        try {
+          const quantityInputId = modal.components[0].components[0].customId;
+          await fetch('https://discord.com/api/v9/interactions', {
+            method: 'POST',
+            headers: { 'Authorization': client.token, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              type: 5, application_id: modal.applicationId,
+              channel_id: channel.id, guild_id: channel.guild?.id,
+              data: {
+                id: modal.id, custom_id: modal.customId,
+                components: [{ type: 1, components: [{ type: 4, custom_id: quantityInputId, value: String(quantity) }] }]
+              },
+              session_id: client.sessionId || "dummy_session",
+              nonce: Date.now().toString()
+            })
+          });
+          LOG.success('Modal submitted via API!');
+          modalHandled = true;
+        } catch (e) {
+          LOG.error(`Modal API submit failed: ${e.message}`);
+          if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+          return false;
+        }
+      }
+    }
+
+    // Step 6: Wait for confirmation message from Dank Memer
+    const confirmMsg = await waitForDankMemer(8000);
+    if (confirmMsg) {
+      const text = getFullText(confirmMsg).toLowerCase();
+      logMsg(confirmMsg, 'buy-confirm');
+      if (text.includes('bought') || text.includes('purchased') || text.includes('success')) {
+        LOG.success(`${c.green}${c.bold}Purchased ${quantity}x ${itemName}!${c.reset}`);
+        return true;
+      }
+      if (text.includes('not enough') || text.includes("can't afford") || text.includes('insufficient')) {
+        LOG.warn(`Not enough coins to buy ${itemName}.`);
+        return false;
+      }
+    }
+
+    if (modalHandled) {
+      LOG.success(`Submitted purchase for ${quantity}x ${itemName} (result unclear but modal was submitted)`);
+      return true;
+    }
+
+    LOG.warn(`Purchase result unclear (attempt ${attempt})`);
+    if (attempt < MAX_RETRIES) { await humanDelay(2000, 4000); continue; }
+  }
+
+  LOG.error(`Failed to buy ${itemName} after ${MAX_RETRIES} attempts.`);
+  return false;
+}
+
+module.exports = { buyItem, ITEM_COSTS };