dankgrinder 6.8.2 → 6.16.0

package/lib/rawLogger.js

@@ -0,0 +1,550 @@
+/**
+ * Raw Gateway Logger — intercepts ALL Dank Memer messages and stores to Redis.
+ * Captures: CV2 components, embeds, buttons, text, edits, ephemeral, cooldowns.
+ *
+ * Redis Keys:
+ *   raw:msg:{msgId}              — full parsed message (latest version), TTL 24h
+ *   raw:msg:{msgId}:history      — list of all versions (create + updates), TTL 24h
+ *   raw:cmd:{command}:log        — list of recent message IDs for that command, TTL 7d
+ *   raw:account:{discordUserId}  — list of recent message IDs for that account, TTL 7d
+ *   raw:ephemeral:log            — list of all ephemeral messages, TTL 7d
+ *   raw:all:log                  — list of ALL message IDs (global), TTL 7d, capped at 10000
+ *
+ * Usage:
+ *   const rawLogger = require('./rawLogger');
+ *   await rawLogger.init('redis://...');
+ *   rawLogger.attachRawLogger(client);
+ *   const msg = await rawLogger.getMsg('123456');
+ *   const history = await rawLogger.getMsgHistory('123456');
+ *   const recent = await rawLogger.getRecentForCommand('cointoss', 20);
+ */
+
+const LRU_SIZE = 256;
+let redis = null;
+let redisReady = false;
+
+// ── In-memory LRU (always available, even without Redis) ──
+const memStore = new Map();
+const channelLast = new Map();
+const memRing = [];
+let memIdx = 0;
+
+// ── Redis init ──
+async function init(redisUrl) {
+  if (!redisUrl) return;
+  try {
+    const Redis = require('ioredis');
+    redis = new Redis(redisUrl, {
+      maxRetriesPerRequest: 2,
+      retryStrategy: (times) => times > 3 ? null : Math.min(times * 500, 3000),
+      lazyConnect: true,
+    });
+    await redis.connect();
+    redisReady = true;
+  } catch (e) {
+    console.error(`[rawLogger] Redis connect failed: ${e.message}`);
+    redis = null;
+    redisReady = false;
+  }
+}
+
+// ── CV2 component walkers ──
+function extractTexts(components, out = []) {
+  for (const c of (components || [])) {
+    if (c.type === 10 && c.content) out.push(c.content);
+    if (c.components) extractTexts(c.components, out);
+  }
+  return out;
+}
+
+function extractButtons(components, out = []) {
+  for (const c of (components || [])) {
+    if (c.type === 2) {
+      out.push({
+        type: 2,
+        label: c.label || '',
+        customId: c.custom_id || '',
+        style: c.style,
+        disabled: !!c.disabled,
+        emoji: c.emoji || null,
+      });
+    }
+    if (c.components) extractButtons(c.components, out);
+    if (c.accessory?.type === 2) {
+      const a = c.accessory;
+      out.push({ type: 2, label: a.label || '', customId: a.custom_id || '', style: a.style, disabled: !!a.disabled, emoji: a.emoji || null });
+    }
+  }
+  return out;
+}
+
+function extractSelectMenus(components, out = []) {
+  for (const c of (components || [])) {
+    if (c.type === 3) {
+      out.push({ type: 3, customId: c.custom_id || '', options: c.options || [], disabled: !!c.disabled });
+    }
+    if (c.components) extractSelectMenus(c.components, out);
+  }
+  return out;
+}
+
+function extractEmbedText(embeds) {
+  const parts = [];
+  for (const e of (embeds || [])) {
+    if (e.title) parts.push(e.title);
+    if (e.description) parts.push(e.description);
+    if (e.footer?.text) parts.push(e.footer.text);
+    if (e.author?.name) parts.push(e.author.name);
+    for (const f of (e.fields || [])) {
+      if (f.name) parts.push(f.name);
+      if (f.value) parts.push(f.value);
+    }
+  }
+  return parts.join('\n');
+}
+
+// ── Detect command from components/embeds ──
+function detectCommand(d) {
+  // Check button custom_ids
+  const walk = (items) => {
+    for (const c of (items || [])) {
+      const cid = c.custom_id || '';
+      // Gambling
+      if (cid.startsWith('cointoss')) return 'cointoss';
+      if (cid.startsWith('blackjack')) return 'blackjack';
+      if (cid.startsWith('roulette')) return 'roulette';
+      if (cid.startsWith('slots')) return 'slots';
+      if (cid.startsWith('snakeeyes')) return 'snakeeyes';
+      if (cid.includes(':low') || cid.includes(':high') || cid.includes(':jackpot')) return 'highlow';
+      if (cid.startsWith('scratch')) return 'scratch';
+      // Adventure / trivia
+      if (cid.startsWith('adventure') || cid.startsWith('adv')) return 'adventure';
+      if (cid.startsWith('trivia')) return 'trivia';
+      // Grind commands
+      if (cid.startsWith('fish')) return 'fish';
+      if (cid.startsWith('hunt')) return 'hunt';
+      if (cid.startsWith('dig')) return 'dig';
+      if (cid.startsWith('crime')) return 'crime';
+      if (cid.startsWith('search')) return 'search';
+      if (cid.startsWith('postmemes') || cid.startsWith('pm')) return 'postmemes';
+      // Stream
+      if (cid.startsWith('stream')) return 'stream';
+      // Shop
+      if (cid.startsWith('shop')) return 'shop';
+      // Farm
+      if (cid.startsWith('farm')) return 'farm';
+      if (c.components) { const r = walk(c.components); if (r) return r; }
+    }
+    return null;
+  };
+  const fromBtn = walk(d.components);
+  if (fromBtn) return fromBtn;
+
+  // Check CV2 text content
+  const cv2Text = extractTexts(d.components).join(' ').toLowerCase();
+  if (cv2Text.includes('coin toss')) return 'cointoss';
+  if (cv2Text.includes('blackjack')) return 'blackjack';
+  if (cv2Text.includes('roulette')) return 'roulette';
+  if (cv2Text.includes('slots')) return 'slots';
+  if (cv2Text.includes('snakeeyes') || cv2Text.includes('snake eyes')) return 'snakeeyes';
+  if (cv2Text.includes('cooldown') || cv2Text.includes('again <t:')) return 'cooldown';
+  // Non-gambling CV2
+  if (cv2Text.includes('fishing') || cv2Text.includes('fisherfolk')) return 'fish';
+  if (cv2Text.includes('deposit') || cv2Text.includes('bank account')) return 'deposit';
+  if (cv2Text.includes('begging') || cv2Text.includes('imagine begging')) return 'beg';
+  if (cv2Text.includes('weekly')) return 'weekly';
+  if (cv2Text.includes('daily')) return 'daily';
+  if (cv2Text.includes('inventory')) return 'inventory';
+  if (cv2Text.includes('profile') || cv2Text.includes('level:')) return 'profile';
+
+  // Check embed text
+  const embedText = extractEmbedText(d.embeds).toLowerCase();
+  // Gambling
+  if (embedText.includes('high') && embedText.includes('low') && embedText.includes('secret number')) return 'highlow';
+  if (embedText.includes('blackjack') || embedText.includes('dealer')) return 'blackjack';
+  if (embedText.includes('roulette')) return 'roulette';
+  if (embedText.includes('spinning') && embedText.includes('slots')) return 'slots';
+  if (embedText.includes('snakeeyes') || embedText.includes('snake eyes') || embedText.includes('dice')) return 'snakeeyes';
+  if (embedText.includes('scratch')) return 'scratch';
+  // Adventure
+  if (embedText.includes('adventure') || embedText.includes('choose an adventure')) return 'adventure';
+  // Crime / search
+  if (embedText.includes('what crime do you want')) return 'crime';
+  if (embedText.includes('where do you want to search')) return 'search';
+  if (embedText.includes('you searched') || embedText.includes('searched the')) return 'search';
+  if (embedText.includes('you committed') || embedText.includes('went outside')) return 'crime';
+  // Hunt / dig
+  if (embedText.includes('hunting') || embedText.includes('came back with') || embedText.includes('hunting rifle') || embedText.includes('dragon\'s fireball') || embedText.includes('dodge the')) return 'hunt';
+  if (embedText.includes('you dig') || embedText.includes('found a') && embedText.includes('digging') || embedText.includes('shovel')) return 'dig';
+  // Work
+  if (embedText.includes('work') && (embedText.includes('shift') || embedText.includes('mini-game') || embedText.includes('color') || embedText.includes('what color'))) return 'work';
+  if (embedText.includes('you were given') && embedText.includes('shift')) return 'work';
+  // Postmemes
+  if (embedText.includes('pick a meme') || embedText.includes('meme posting')) return 'postmemes';
+  // Stream
+  if (embedText.includes('stream manager') || embedText.includes('go live') || embedText.includes('what game do you want to stream')) return 'stream';
+  // Deposit
+  if (embedText.includes('deposited') && embedText.includes('bank balance')) return 'deposit';
+  // Trivia
+  if (embedText.includes('you have 10 seconds to answer') || embedText.includes('trivia')) return 'trivia';
+  // Profile / level
+  if (embedText.includes('level:') && embedText.includes('experience:')) return 'profile';
+  // Shop
+  if (embedText.includes('dank memer shop') || embedText.includes('successful purchase')) return 'shop';
+  // Farm
+  if (embedText.includes('farm') && (embedText.includes('harvest') || embedText.includes('plant') || embedText.includes('hoe') || embedText.includes('water'))) return 'farm';
+  // Beg
+  if (embedText.includes('begging')) return 'beg';
+  // Daily/weekly quest
+  if (embedText.includes('daily quest')) return 'daily';
+  // Fish
+  if (embedText.includes('fishing') || embedText.includes('fish')) return 'fish';
+  // Hold tight
+  if (embedText.includes('hold tight')) return 'holdtight';
+
+  return 'unknown';
+}
+
+// ── Parse raw gateway packet ──
+function parseRawPacket(d, event) {
+  const cv2Texts = extractTexts(d.components);
+  const buttons = extractButtons(d.components);
+  const selectMenus = extractSelectMenus(d.components);
+  const embedText = extractEmbedText(d.embeds);
+  const isCV2 = !!(d.flags & 32768);
+  const isEphemeral = !!(d.flags & 64);
+  const command = detectCommand(d);
+
+  return {
+    id: d.id,
+    channelId: d.channel_id,
+    guildId: d.guild_id || null,
+    authorId: d.author?.id,
+    authorTag: d.author?.username || d.author?.id,
+    flags: d.flags,
+    isCV2,
+    isEphemeral,
+    event,
+    command,
+    content: d.content || '',
+    embeds: d.embeds || [],
+    components: d.components || [],
+    cv2Text: cv2Texts.join('\n'),
+    allText: [d.content || '', ...cv2Texts, embedText].join('\n').trim(),
+    buttons,
+    clickableButtons: buttons.filter(b => !b.disabled && b.customId && !b.customId.includes('warning')),
+    selectMenus,
+    embedText,
+    timestamp: d.timestamp || null,
+    editedTimestamp: d.edited_timestamp || null,
+    _capturedAt: Date.now(),
+    _raw: d,
+  };
+}
+
+// ── Store to memory + Redis ──
+async function store(d, event) {
+  const parsed = parseRawPacket(d, event);
+
+  // Memory LRU
+  if (memRing.length >= LRU_SIZE) {
+    const old = memRing[memIdx];
+    if (old) memStore.delete(old);
+    memRing[memIdx] = d.id;
+  } else {
+    memRing.push(d.id);
+  }
+  memIdx = (memIdx + 1) % LRU_SIZE;
+  memStore.set(d.id, parsed);
+  channelLast.set(d.channel_id, d.id);
+
+  // Redis (non-blocking, fire-and-forget)
+  if (redisReady && redis) {
+    try {
+      const key = `raw:msg:${d.id}`;
+      const histKey = `raw:msg:${d.id}:history`;
+      const json = JSON.stringify(parsed, (k, v) => k === '_raw' ? undefined : v);
+
+      const MSG_TTL = 2592000;  // 30 days
+      const LOG_TTL = 2592000;  // 30 days
+
+      const pipe = redis.pipeline();
+      // Latest version
+      pipe.set(key, json, 'EX', MSG_TTL);
+      // History (all versions)
+      pipe.rpush(histKey, json);
+      pipe.expire(histKey, MSG_TTL);
+      // Per-command log
+      if (parsed.command && parsed.command !== 'unknown') {
+        const cmdKey = `raw:cmd:${parsed.command}:log`;
+        pipe.lpush(cmdKey, `${d.id}:${parsed._capturedAt}:${event}`);
+        pipe.ltrim(cmdKey, 0, 4999);
+        pipe.expire(cmdKey, LOG_TTL);
+      }
+      // Per-account log
+      if (parsed.authorId) {
+        const accKey = `raw:channel:${d.channel_id}:log`;
+        pipe.lpush(accKey, `${d.id}:${parsed._capturedAt}:${event}:${parsed.command}`);
+        pipe.ltrim(accKey, 0, 4999);
+        pipe.expire(accKey, LOG_TTL);
+      }
+      // Ephemeral log
+      if (parsed.isEphemeral || (d.flags & 32832)) {
+        pipe.lpush('raw:ephemeral:log', `${d.id}:${parsed._capturedAt}:${parsed.command}:${d.channel_id}`);
+        pipe.ltrim('raw:ephemeral:log', 0, 4999);
+        pipe.expire('raw:ephemeral:log', LOG_TTL);
+      }
+      // Global log
+      pipe.lpush('raw:all:log', `${d.id}:${parsed._capturedAt}:${event}:${parsed.command}:${d.channel_id}`);
+      pipe.ltrim('raw:all:log', 0, 49999);
+      pipe.expire('raw:all:log', LOG_TTL);
+
+      pipe.exec().catch(() => {}); // fire and forget
+    } catch {}
+  }
+
+  return parsed;
+}
+
+// ── Verbose console log ──
+let verboseMode = false;
+function setVerbose(v) { verboseMode = v; }
+
+function verboseLog(event, parsed) {
+  if (!verboseMode) return;
+  const tag = parsed.isCV2 ? 'CV2' : parsed.isEphemeral ? 'EPH' : 'STD';
+  console.log(`  [RAW ${event}] [${tag}] [${parsed.command}] id=${parsed.id} flags=${parsed.flags}`);
+  if (parsed.cv2Text) console.log(`    cv2: "${parsed.cv2Text.substring(0, 150)}"`);
+  if (parsed.embedText) console.log(`    embed: "${parsed.embedText.substring(0, 150)}"`);
+  for (const b of parsed.buttons) console.log(`    btn: [${b.label}] id="${b.customId}" disabled=${b.disabled}`);
+}
+
+// ── DM event listeners ──
+const dmListeners = [];
+function onDmEvent(fn) { dmListeners.push(fn); }
+
+/**
+ * Attach DM logger — monitors Dank Memer DMs for:
+ *   - Level ups: "You leveled up from level X to Y"
+ *   - Deaths: "Your lifesaver protected you!" / "you died"
+ *   - Lifesaver warnings: "you have 0 lifesavers"
+ *   - Robbery: "you were robbed"
+ *   - Trade notifications
+ *
+ * Stores to Redis under raw:dm:{channelId}:log
+ * Emits events via onDmEvent() callback
+ */
+function attachDmLogger(client, opts = {}) {
+  const targetAuthorId = opts.authorId || '270904126974590976'; // Dank Memer
+
+  client.on('raw', (packet) => {
+    if (packet.t !== 'MESSAGE_CREATE') return;
+    const d = packet.d;
+    if (!d?.id) return;
+    // DMs have no guild_id
+    if (d.guild_id) return;
+    if (targetAuthorId && d.author?.id !== targetAuthorId) return;
+
+    const content = d.content || '';
+    const embedText = extractEmbedText(d.embeds).toLowerCase();
+    const allText = (content + '\n' + embedText).toLowerCase();
+
+    // Detect event type
+    let dmEvent = null;
+    if (allText.includes('leveled up') || allText.includes('level up')) {
+      const m = allText.match(/level\s+(\d+)\s+to\s+(\d+)/i);
+      dmEvent = { type: 'levelup', from: m ? parseInt(m[1]) : 0, to: m ? parseInt(m[2]) : 0 };
+    } else if (allText.includes('lifesaver protected') || allText.includes('you died')) {
+      // Parse lifesaver count from button labels: "You have 0 Life Saver left"
+      let lsLeft = -1;
+      const btnText = extractButtons(d.components).map(b => (b.label || '').toLowerCase()).join(' ');
+      const btnMatch = btnText.match(/you have (\d+) life\s*saver/i);
+      if (btnMatch) lsLeft = parseInt(btnMatch[1]);
+      // Fallback to embed text
+      if (lsLeft === -1) {
+        const ls = allText.match(/(\d+)\s*life\s*saver/i);
+        if (ls) lsLeft = parseInt(ls[1]);
+      }
+      dmEvent = { type: 'death', lifesaversLeft: lsLeft };
+    } else if (allText.includes('you were robbed') || allText.includes('just robbed you')) {
+      const coins = allText.match(/[⏣]\s*([\d,]+)/);
+      dmEvent = { type: 'robbed', amount: coins ? parseInt(coins[1].replace(/,/g, '')) : 0 };
+    } else if (allText.includes('trade')) {
+      dmEvent = { type: 'trade' };
+    }
+
+    // Store in Redis
+    if (redisReady && redis && dmEvent) {
+      const json = JSON.stringify({
+        id: d.id,
+        channelId: d.channel_id,
+        event: dmEvent,
+        text: allText.substring(0, 500),
+        ts: Date.now(),
+      });
+      const pipe = redis.pipeline();
+      pipe.lpush(`raw:dm:${d.channel_id}:log`, json);
+      pipe.ltrim(`raw:dm:${d.channel_id}:log`, 0, 999);
+      pipe.expire(`raw:dm:${d.channel_id}:log`, 2592000); // 30 days
+      // Also log globally
+      pipe.lpush('raw:dm:all:log', `${d.id}:${Date.now()}:${dmEvent.type}:${d.channel_id}`);
+      pipe.ltrim('raw:dm:all:log', 0, 4999);
+      pipe.expire('raw:dm:all:log', 2592000);
+      // If death with 0 lifesavers — store alert
+      if (dmEvent.type === 'death' && dmEvent.lifesaversLeft === 0) {
+        pipe.set(`raw:alert:no-lifesaver:${d.channel_id}`, '1', 'EX', 86400);
+      }
+      // If level up — update cached level
+      if (dmEvent.type === 'levelup' && dmEvent.to > 0) {
+        pipe.set(`dkg:level:dm:${d.channel_id}`, String(dmEvent.to), 'EX', 2592000);
+      }
+      pipe.exec().catch(() => {});
+    }
+
+    // Emit to listeners
+    if (dmEvent) {
+      for (const fn of dmListeners) {
+        try { fn(dmEvent, d); } catch {}
+      }
+    }
+  });
+}
+
+async function getDmLog(channelId, count = 50) {
+  if (!redisReady || !redis) return [];
+  try {
+    const items = await redis.lrange(`raw:dm:${channelId}:log`, 0, count - 1);
+    return items.map(i => { try { return JSON.parse(i); } catch { return null; } }).filter(Boolean);
+  } catch { return []; }
+}
+
+async function hasNoLifesaverAlert(channelId) {
+  if (!redisReady || !redis) return false;
+  try { return await redis.get(`raw:alert:no-lifesaver:${channelId}`) === '1'; } catch { return false; }
+}
+
+// ── Attach to discord.js-selfbot-v13 client ──
+function attachRawLogger(client, opts = {}) {
+  const targetAuthorId = opts.authorId || '270904126974590976'; // Dank Memer
+  const targetChannelId = opts.channelId || null;
+
+  client.on('raw', (packet) => {
+    if (packet.t !== 'MESSAGE_CREATE' && packet.t !== 'MESSAGE_UPDATE') return;
+    const d = packet.d;
+    if (!d?.id) return;
+    if (targetAuthorId && d.author?.id !== targetAuthorId) return;
+    if (targetChannelId && d.channel_id !== targetChannelId) return;
+
+    const event = packet.t === 'MESSAGE_CREATE' ? 'CREATE' : 'UPDATE';
+    const parsed = store(d, event); // async but we don't await (fire-and-forget)
+    if (parsed.then) parsed.then(p => verboseLog(event, p)).catch(() => {});
+    else verboseLog(event, parsed);
+  });
+}
+
+// ── Read API (memory) ──
+function getRawMessage(msgId) { return memStore.get(msgId) || null; }
+function getLastRaw(channelId) {
+  const id = channelLast.get(channelId);
+  return id ? memStore.get(id) || null : null;
+}
+
+// ── Read API (Redis) ──
+async function getMsg(msgId) {
+  // Memory first
+  const mem = memStore.get(msgId);
+  if (mem) return mem;
+  // Redis fallback
+  if (!redisReady || !redis) return null;
+  try {
+    const json = await redis.get(`raw:msg:${msgId}`);
+    return json ? JSON.parse(json) : null;
+  } catch { return null; }
+}
+
+async function getMsgHistory(msgId) {
+  if (!redisReady || !redis) return [];
+  try {
+    const items = await redis.lrange(`raw:msg:${msgId}:history`, 0, -1);
+    return items.map(i => { try { return JSON.parse(i); } catch { return null; } }).filter(Boolean);
+  } catch { return []; }
+}
+
+async function getRecentForCommand(command, count = 20) {
+  if (!redisReady || !redis) return [];
+  try {
+    const entries = await redis.lrange(`raw:cmd:${command}:log`, 0, count - 1);
+    const results = [];
+    for (const entry of entries) {
+      const msgId = entry.split(':')[0];
+      const msg = await getMsg(msgId);
+      if (msg) results.push(msg);
+    }
+    return results;
+  } catch { return []; }
+}
+
+async function getRecentAll(count = 50) {
+  if (!redisReady || !redis) return [];
+  try {
+    return await redis.lrange('raw:all:log', 0, count - 1);
+  } catch { return []; }
+}
+
+async function getRecentEphemeral(count = 50) {
+  if (!redisReady || !redis) return [];
+  try {
+    return await redis.lrange('raw:ephemeral:log', 0, count - 1);
+  } catch { return []; }
+}
+
+async function getRecentForChannel(channelId, count = 50) {
+  if (!redisReady || !redis) return [];
+  try {
+    return await redis.lrange(`raw:channel:${channelId}:log`, 0, count - 1);
+  } catch { return []; }
+}
+
+async function getStats() {
+  if (!redisReady || !redis) return { redis: false };
+  try {
+    const pipe = redis.pipeline();
+    pipe.llen('raw:all:log');
+    pipe.llen('raw:ephemeral:log');
+    const cmds = ['cointoss', 'blackjack', 'highlow', 'roulette', 'slots', 'snakeeyes', 'cooldown', 'unknown'];
+    for (const cmd of cmds) pipe.llen(`raw:cmd:${cmd}:log`);
+    const results = await pipe.exec();
+    const stats = { redis: true, total: results[0][1], ephemeral: results[1][1], commands: {} };
+    cmds.forEach((cmd, i) => { stats.commands[cmd] = results[i + 2][1]; });
+    return stats;
+  } catch { return { redis: true, error: true }; }
+}
+
+module.exports = {
+  init,
+  attachRawLogger,
+  attachDmLogger,
+  onDmEvent,
+  setVerbose,
+  // Memory reads
+  getRawMessage,
+  getLastRaw,
+  // Redis reads
+  getMsg,
+  getMsgHistory,
+  getRecentForCommand,
+  getRecentAll,
+  getRecentEphemeral,
+  getRecentForChannel,
+  getStats,
+  // DM reads
+  getDmLog,
+  hasNoLifesaverAlert,
+  // Component helpers
+  extractTexts,
+  extractButtons,
+  extractSelectMenus,
+  extractEmbedText,
+  parseRawPacket,
+  detectCommand,
+};

package/package.json

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