dankgrinder 5.0.0 → 5.0.2

package/lib/commands/utils.js

@@ -12,6 +12,20 @@
 const https = require('https');
 const { AhoCorasick, LRUCache, StringPool, ObjectPool } = require('../structures');
 
+// ── HTTPS Keep-Alive Agent ───────────────────────────────────
+// At 10K accounts, every CV2 fetch without keep-alive creates a new
+// TCP+TLS handshake (~150ms). With keep-alive, connections are reused.
+// maxSockets=150 prevents file descriptor exhaustion; scheduling='fifo'
+// distributes load evenly across connections.
+const httpsAgent = new https.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 30000,
+  maxSockets: 150,
+  maxFreeSockets: 30,
+  timeout: 30000,
+  scheduling: 'fifo',
+});
+
 // ── String Interning ─────────────────────────────────────────
 // Discord sends repeated IDs millions of times. Intern them to share references.
 const strings = new StringPool();
@@ -62,6 +76,25 @@ const LOG = {
   debug:   (msg) => log(`${c.dim}⊙${c.reset}`, msg),
 };
 
+// ── Pre-compiled Regex (avoid recompilation in hot paths) ────
+// V8 recompiles inline /regex/ on every call site. Module-level
+// compilation runs once and shares the compiled automaton.
+const RE_ANSI = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+const RE_NET_COINS = /Net:\s*\*{0,2}\s*[⏣o]\s*\*{0,2}([+-]?[\d,]+)/i;
+const RE_WINNINGS = /Winnings:\s*\*{0,2}\s*[⏣o]\s*\*{0,2}([\d,]+)/i;
+const RE_RECEIVED = /you\s+received\s*:\s*[\s\S]{0,80}?([\d,]+)/i;
+const RE_COIN_EMOJI = /<a?:Coin:\d+>\s*([\d,]+)/gi;
+const RE_WALLET_PLACED = /⏣\s*([\d,]+)\s*was placed/i;
+const RE_COINS_PLAIN = /⏣\s*([\d,]+)/g;
+const RE_WALLET_TEXT = /wallet[:\s]*[⏣💰]?\s*([\d,]+)/i;
+const RE_BANK_TEXT = /bank[:\s]*[⏣💰]?\s*([\d,]+)/i;
+const RE_BANK_EMOJI = /<a?:Bank:\d+>\s*([\d,]+)/i;
+const RE_BANK_SLASH = /[\d,]+\s*\/\s*[\d,]+/g;
+const RE_LARGE_NUM = /([\d,]{2,})/;
+const RE_NET_SIGNED = /Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i;
+const RE_WIN_SIGNED = /Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i;
+const RE_HOLD_TIGHT_REASON = /Reason:\s*\/(\w+)/i;
+
 // ── Sleep ────────────────────────────────────────────────────
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
@@ -72,76 +105,83 @@ function humanDelay(min = 50, max = 200) {
 // ── Message Parsing ──────────────────────────────────────────
 function getFullText(msg) {
   if (!msg) return '';
-  // If CV2 text was pre-fetched via ensureCV2(), use it
   if (msg._cv2text) return msg._cv2text;
-  let text = msg.content || '';
-  for (const embed of msg.embeds || []) {
-    if (embed.title) text += ' ' + embed.title;
-    if (embed.description) text += ' ' + embed.description;
-    for (const f of embed.fields || []) text += ' ' + (f.name || '') + ' ' + (f.value || '');
-    if (embed.footer?.text) text += ' ' + embed.footer.text;
+  // Array-join pattern: O(n) vs O(n²) from repeated string concatenation.
+  // At 10K accounts processing messages concurrently, this avoids
+  // creating intermediate string copies on every += operation.
+  const parts = [msg.content || ''];
+  const embeds = msg.embeds;
+  if (embeds) {
+    for (let i = 0; i < embeds.length; i++) {
+      const e = embeds[i];
+      if (e.title) parts.push(e.title);
+      if (e.description) parts.push(e.description);
+      const fields = e.fields;
+      if (fields) for (let j = 0; j < fields.length; j++) {
+        parts.push(fields[j].name || '', fields[j].value || '');
+      }
+      if (e.footer?.text) parts.push(e.footer.text);
+    }
   }
-  function extractText(components) {
-    for (const comp of components || []) {
+  const _extract = (components) => {
+    if (!components) return;
+    for (let i = 0; i < components.length; i++) {
+      const comp = components[i];
       if (!comp) continue;
-      if (comp.content) text += ' ' + comp.content;
-      if (comp.components) extractText(comp.components);
+      if (comp.content) parts.push(comp.content);
+      if (comp.components) _extract(comp.components);
     }
-  }
-  extractText(msg.components);
-  return text;
+  };
+  _extract(msg.components);
+  return parts.join(' ');
 }
 
 function stripAnsi(text) {
   if (!text) return '';
-  return String(text).replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+  return String(text).replace(RE_ANSI, '');
 }
 
 function parseCoins(text) {
   if (!text) return 0;
   const cleanText = stripAnsi(text);
-  // Prefer "Net:" if present (accurate earned/lost from Dank Memer)
-  const netMatch = cleanText.match(/Net:\s*\*{0,2}\s*[⏣o]\s*\*{0,2}([+-]?[\d,]+)/i);
+  RE_NET_COINS.lastIndex = 0;
+  const netMatch = cleanText.match(RE_NET_COINS);
   if (netMatch) {
     const net = parseInt(netMatch[1].replace(/,/g, ''));
     return net > 0 ? net : 0;
   }
-  const winMatch = cleanText.match(/Winnings:\s*\*{0,2}\s*[⏣o]\s*\*{0,2}([\d,]+)/i);
+  RE_WINNINGS.lastIndex = 0;
+  const winMatch = cleanText.match(RE_WINNINGS);
   if (winMatch) {
     const w = parseInt(winMatch[1].replace(/,/g, ''));
     if (w > 0) return w;
   }
-
-  // Tidy/CV2 reward blocks often use "You received:" with non-⏣ symbols.
-  const receivedMatch = cleanText.match(/you\s+received\s*:\s*[\s\S]{0,80}?([\d,]+)/i);
+  const receivedMatch = cleanText.match(RE_RECEIVED);
   if (receivedMatch) {
     const r = parseInt(receivedMatch[1].replace(/,/g, ''), 10);
     if (r > 0) return r;
   }
-
-  // CV2 pattern: <:Coin:ID> NUMBER
-  const coinEmojiMatches = [...cleanText.matchAll(/<a?:Coin:\d+>\s*([\d,]+)/gi)];
+  RE_COIN_EMOJI.lastIndex = 0;
+  const coinEmojiMatches = [...cleanText.matchAll(RE_COIN_EMOJI)];
   if (coinEmojiMatches.length > 0) {
     let best = 0;
-    for (const m of coinEmojiMatches) {
-      const v = parseInt((m[1] || '0').replace(/,/g, ''), 10) || 0;
+    for (let i = 0; i < coinEmojiMatches.length; i++) {
+      const v = parseInt((coinEmojiMatches[i][1] || '0').replace(/,/g, ''), 10) || 0;
       if (v > best) best = v;
     }
     if (best > 0) return best;
   }
-
-  // Prefer "placed in your wallet" pattern (daily, beg, etc.)
-  const walletMatch = cleanText.match(/⏣\s*([\d,]+)\s*was placed/i);
+  const walletMatch = cleanText.match(RE_WALLET_PLACED);
   if (walletMatch) return parseInt(walletMatch[1].replace(/,/g, ''));
-  // Fallback: max ⏣ number
-  const matches = cleanText.match(/⏣\s*([\d,]+)/g);
+  RE_COINS_PLAIN.lastIndex = 0;
+  const matches = cleanText.match(RE_COINS_PLAIN);
   if (!matches) return 0;
   let best = 0;
-  for (const m of matches) {
-    const numStr = m.replace(/[^\d]/g, '');
+  for (let i = 0; i < matches.length; i++) {
+    const numStr = matches[i].replace(/[^\d]/g, '');
     if (numStr) {
       const val = parseInt(numStr);
-      if (val > 0 && val < 1_000_000_000) best = Math.max(best, val);
+      if (val > 0 && val < 1_000_000_000 && val > best) best = val;
     }
   }
   return best;
@@ -149,11 +189,9 @@ function parseCoins(text) {
 
 function parseNetCoins(text) {
   if (!text) return 0;
-  // "Net: **⏣ -5,000**" or "Net: **⏣ +0**" (draw)
-  const netMatch = text.match(/Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i);
+  const netMatch = text.match(RE_NET_SIGNED);
   if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
-  // Snakeeyes: "Winnings: **⏣ -10,000**", CV2: "Winnings: ⏣ **10,000**"
-  const winMatch = text.match(/Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i);
+  const winMatch = text.match(RE_WIN_SIGNED);
   if (winMatch) {
     const v = parseInt(winMatch[1].replace(/,/g, ''));
     if (v !== 0) return v;
@@ -169,27 +207,19 @@ function parseNetCoins(text) {
 function parseBalance(msg) {
   if (!msg) return 0;
   const text = stripAnsi(getFullText(msg));
-
-  // Try standard embed wallet pattern
-  const walletMatch = text.match(/wallet[:\s]*[⏣💰]?\s*([\d,]+)/i);
+  const walletMatch = text.match(RE_WALLET_TEXT);
   if (walletMatch) return parseInt(walletMatch[1].replace(/,/g, ''));
-
-  // CV2 pattern: <:Coin:ID> NUMBER (first number after Coin emoji = wallet)
-  const coinEmojiMatch = text.match(/<a?:Coin:\d+>\s*([\d,]+)/i);
+  RE_COIN_EMOJI.lastIndex = 0;
+  const coinEmojiMatch = text.match(RE_COIN_EMOJI);
   if (coinEmojiMatch) return parseInt(coinEmojiMatch[1].replace(/,/g, ''));
-
-  const bankEmojiMatch = text.match(/<a?:Bank:\d+>\s*([\d,]+)/i);
+  const bankEmojiMatch = text.match(RE_BANK_EMOJI);
   if (bankEmojiMatch) return parseInt(bankEmojiMatch[1].replace(/,/g, ''));
-
-  // Fallback: ⏣ prefixed
   const coins = parseCoins(text);
   if (coins > 0) return coins;
-
-  // Last resort: first large number not in "X / Y" bank pattern
-  const cleaned = text.replace(/[\d,]+\s*\/\s*[\d,]+/g, '');
-  const numMatch = cleaned.match(/([\d,]{2,})/);
+  RE_BANK_SLASH.lastIndex = 0;
+  const cleaned = text.replace(RE_BANK_SLASH, '');
+  const numMatch = cleaned.match(RE_LARGE_NUM);
   if (numMatch) return parseInt(numMatch[1].replace(/,/g, ''));
-
   return 0;
 }
 
@@ -252,7 +282,9 @@ function findSelectMenuOption(msg, label) {
   return null;
 }
 
-// Safe button click — tries library methods first, falls back to raw HTTP for CV2
+// Safe button click — tries library methods first, falls back to raw HTTP for CV2.
+// When CV2 fallback is used, waits for the message to update so callers always
+// get the updated message back (instead of null, which broke multi-round games).
 async function safeClickButton(msg, button) {
   if (typeof button.click === 'function') {
     return button.click();
@@ -265,9 +297,29 @@ async function safeClickButton(msg, button) {
       // Fall through to CV2 raw interaction fallback.
     }
   }
-  // CV2 fallback: send interaction via raw HTTP
+  // CV2 fallback: send interaction via raw HTTP, then wait for the message
+  // to update so we can return the updated message to the caller.
   if (id) {
     await clickCV2Button(msg, id);
+    // Wait for Dank Memer to process the interaction and update the message
+    const updatedMsg = await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        msg.client?.removeListener?.('messageUpdate', handler);
+        resolve(null);
+      }, 8000);
+      const handler = (_, newMsg) => {
+        if (newMsg.id === msg.id) {
+          clearTimeout(timeout);
+          msg.client?.removeListener?.('messageUpdate', handler);
+          resolve(newMsg);
+        }
+      };
+      msg.client?.on?.('messageUpdate', handler);
+    });
+    if (updatedMsg) {
+      await ensureCV2(updatedMsg);
+      return updatedMsg;
+    }
     return null;
   }
   throw new Error('No click method available on button');
@@ -288,7 +340,7 @@ function isHoldTight(msg) {
 function getHoldTightReason(msg) {
   if (!msg) return null;
   const text = getFullText(msg);
-  const match = text.match(/Reason:\s*\/(\w+)/i);
+  const match = text.match(RE_HOLD_TIGHT_REASON);
   return match ? match[1].toLowerCase() : null;
 }
 
@@ -359,10 +411,13 @@ function dumpMessage(msg, label) {
 
 function _httpGet(url, headers) {
   return new Promise((resolve, reject) => {
-    https.get(url, { headers }, res => {
-      let d = '';
-      res.on('data', c => d += c);
-      res.on('end', () => { try { resolve(JSON.parse(d)); } catch (e) { reject(e); } });
+    https.get(url, { headers, agent: httpsAgent }, res => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => {
+        const d = chunks.join('');
+        try { resolve(JSON.parse(d)); } catch (e) { reject(e); }
+      });
     }).on('error', reject);
   });
 }
@@ -371,11 +426,11 @@ function _httpPost(url, headers, body) {
   return new Promise((resolve, reject) => {
     const u = new URL(url);
     const req = https.request({
-      hostname: u.hostname, path: u.pathname, method: 'POST', headers,
+      hostname: u.hostname, path: u.pathname, method: 'POST', headers, agent: httpsAgent,
     }, res => {
-      let d = '';
-      res.on('data', c => d += c);
-      res.on('end', () => resolve({ status: res.statusCode, body: d }));
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve({ status: res.statusCode, body: chunks.join('') }));
     });
     req.on('error', reject);
     req.write(body);
@@ -564,8 +619,12 @@ module.exports = {
   isCV2,
   ensureCV2,
   clickCV2Button,
-  // Expose shared structures for other command files
+  // Shared structures and optimized constants
   strings,
   cv2Cache,
   itemDetector,
+  httpsAgent,
+  RE_NET_SIGNED,
+  RE_WIN_SIGNED,
+  RE_COIN_EMOJI,
 };

package/lib/commands/work.js

@@ -20,14 +20,20 @@ const {
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
 } = require('./utils');
 
+const RE_MEMORY_BACKTICK_CHUNK = /`([^`]+)`/g;
+const RE_BACKTICK_STRIP = /`/g;
+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;
+
 // Job progression list (order matters — first is easiest to get)
-const JOBS = [
+const JOBS = Object.freeze([
   'babysitter', 'dog walker', 'fast food worker', 'youtuber',
   'twitch streamer', 'professional fisherman', 'robber',
   'veterinarian', 'musician', 'manager', 'politician',
   'detective', 'santa claus', 'discord mod', 'professional hunter',
   'scientist', 'pro gamer', 'ghost',
-];
+]);
 
 /**
  * Re-fetch a message to get updated state.
@@ -41,9 +47,9 @@ async function refetchMsg(channel, msgId) {
  * Looks for backtick-wrapped words: `word1` `word2` `word3`
  */
 function parseMemoryOrder(text) {
-  const matches = text.match(/`([^`]+)`/g);
+  const matches = text.match(RE_MEMORY_BACKTICK_CHUNK);
   if (matches && matches.length > 0) {
-    return matches.map(m => m.replace(/`/g, '').trim().toLowerCase());
+    return matches.map(m => m.replace(RE_BACKTICK_STRIP, '').trim().toLowerCase());
   }
   return [];
 }
@@ -54,7 +60,7 @@ function parseMemoryOrder(text) {
  */
 function parseWorkCooldown(text) {
   // Unix timestamp pattern: <t:TIMESTAMP:R>
-  const tsMatch = text.match(/<t:(\d+):R>/);
+  const tsMatch = text.match(RE_WORK_COOLDOWN_TS);
   if (tsMatch) {
     const ts = parseInt(tsMatch[1]);
     const now = Math.floor(Date.now() / 1000);
@@ -62,9 +68,9 @@ function parseWorkCooldown(text) {
     return diff > 0 ? diff : 3600;
   }
   // "X minutes" / "X hours" pattern
-  const minMatch = text.match(/(\d+)\s*minute/i);
+  const minMatch = text.match(RE_WORK_COOLDOWN_MINUTES);
   if (minMatch) return parseInt(minMatch[1]) * 60;
-  const hrMatch = text.match(/(\d+)\s*hour/i);
+  const hrMatch = text.match(RE_WORK_COOLDOWN_HOURS);
   if (hrMatch) return parseInt(hrMatch[1]) * 3600;
   return null;
 }
@@ -214,7 +220,10 @@ async function handleWordMemory({ channel, current, wordOrder, waitForDankMemer
 async function handleRepeatWord({ current, wordOrder }) {
   // Find which word appears more than once
   const counts = {};
-  for (const w of wordOrder) counts[w] = (counts[w] || 0) + 1;
+  for (let wi = 0; wi < wordOrder.length; wi++) {
+    const w = wordOrder[wi];
+    counts[w] = (counts[w] || 0) + 1;
+  }
   const repeated = Object.entries(counts).find(([, count]) => count > 1);
   if (repeated) {
     const [word] = repeated;