dankgrinder 5.24.0 → 5.260.0

package/lib/cooldownManager.js

@@ -0,0 +1,347 @@
+/**
+ * Advanced Cooldown Manager with Smart CD Calculations
+ *
+ * Features:
+ *   - EMA-based cooldown prediction (learns from history)
+ *   - Command chaining with optimal timing
+ *   - Priority queue for scheduling
+ *   - Redis-backed shared state (cluster mode)
+ *   - Predictive readiness estimation
+ */
+
+'use strict';
+
+const { LRUCache, MinHeap } = require('./structures');
+const { calcSmartCooldown } = require('./antiDetect');
+
+// ── Command Cooldown Config ───────────────────────────────────
+const COMMAND_CONFIG = Object.freeze({
+  // Base cooldowns in seconds
+  beg: { base: 120, priority: 3, category: 'income' },
+  crime: { base: 1200, priority: 2, category: 'income' },
+  search: { base: 150, priority: 3, category: 'income' },
+  work: { base: 3600, priority: 1, category: 'income' },
+  dig: { base: 600, priority: 2, category: 'income' },
+  fish: { base: 900, priority: 2, category: 'income' },
+  hunt: { base: 120, priority: 3, category: 'income' },
+  farm: { base: 300, priority: 2, category: 'income' },
+  stream: { base: 120, priority: 3, category: 'income' },
+  trivia: { base: 180, priority: 2, category: 'income' },
+  highlow: { base: 120, priority: 2, category: 'income' },
+  gamble: { base: 30, priority: 1, category: 'gambling' },
+  blackjack: { base: 30, priority: 1, category: 'gambling' },
+  roulette: { base: 30, priority: 1, category: 'gambling' },
+  slots: { base: 30, priority: 1, category: 'gambling' },
+  adventure: { base: 1800, priority: 1, category: 'special' },
+  postmeme: { base: 300, priority: 2, category: 'social' },
+  meme: { base: 300, priority: 2, category: 'social' },
+  vote: { base: 7200, priority: 1, category: 'special' },
+  daily: { base: 86400, priority: 1, category: 'special' },
+  weekly: { base: 604800, priority: 1, category: 'special' },
+  monthly: { base: 2592000, priority: 1, category: 'special' },
+});
+
+// ── EMA Calculator ────────────────────────────────────────────
+/**
+ * Exponential Moving Average for cooldown prediction.
+ * Gives more weight to recent observations.
+ */
+class EMACalculator {
+  constructor(alpha = 0.3) {
+    this.alpha = alpha;  // Smoothing factor (0-1)
+    this.ema = null;
+  }
+
+  update(value) {
+    if (this.ema === null) {
+      this.ema = value;
+    } else {
+      this.ema = this.alpha * value + (1 - this.alpha) * this.ema;
+    }
+    return this.ema;
+  }
+
+  getPrediction() {
+    return this.ema;
+  }
+
+  reset() {
+    this.ema = null;
+  }
+}
+
+// ── Cooldown Tracker ──────────────────────────────────────────
+class CooldownTracker {
+  constructor(userId, redis = null, clusterEnabled = false) {
+    this.userId = userId;
+    this.redis = redis;
+    this.clusterEnabled = clusterEnabled;
+
+    // Local caches
+    this.cooldowns = new Map();  // command -> readyAt (timestamp)
+    this.emaTrackers = new Map();  // command -> EMACalculator
+    this.historyCache = new LRUCache(50);  // Last 50 cooldown observations per command
+  }
+
+  /**
+   * Record a cooldown for a command.
+   * @param {string} command - Command name
+   * @param {number} cooldownSec - Observed cooldown in seconds
+   */
+  recordCooldown(command, cooldownSec) {
+    const now = Date.now();
+    const readyAt = now + (cooldownSec * 1000);
+
+    // Store in local map
+    this.cooldowns.set(command, readyAt);
+
+    // Update EMA prediction
+    if (!this.emaTrackers.has(command)) {
+      this.emaTrackers.set(command, new EMACalculator(0.3));
+    }
+    const ema = this.emaTrackers.get(command);
+    ema.update(cooldownSec);
+
+    // Store in Redis for cluster mode
+    if (this.redis && this.clusterEnabled) {
+      const key = `dkg:cd:${this.userId}:${command}`;
+      this.redis.setex(key, cooldownSec + 60, JSON.stringify({
+        readyAt,
+        ema: ema.getPrediction(),
+        recorded: now,
+      })).catch(() => {});
+    }
+
+    // Cache history
+    const history = this.historyCache.get(command) || [];
+    history.push({ cooldownSec, timestamp: now });
+    if (history.length > 50) history.shift();
+    this.historyCache.set(command, history);
+  }
+
+  /**
+   * Check if a command is ready.
+   * @param {string} command - Command name
+   * @returns {Object} - { ready: boolean, waitMs: number, predicted: number|null }
+   */
+  isReady(command) {
+    const readyAt = this.cooldowns.get(command);
+    if (!readyAt) {
+      return { ready: true, waitMs: 0, predicted: null };
+    }
+
+    const now = Date.now();
+    const waitMs = Math.max(0, readyAt - now);
+
+    // Add smart buffer
+    const config = COMMAND_CONFIG[command];
+    if (config) {
+      const buffered = calcSmartCooldown(waitMs / 1000, { addBuffer: true, addVariance: false });
+      return {
+        ready: waitMs <= 0,
+        waitMs: waitMs > 0 ? buffered * 1000 : 0,
+        predicted: this.emaTrackers.get(command)?.getPrediction() || null,
+      };
+    }
+
+    return {
+      ready: waitMs <= 0,
+      waitMs,
+      predicted: this.emaTrackers.get(command)?.getPrediction() || null,
+    };
+  }
+
+  /**
+   * Get predicted cooldown for a command.
+   * @param {string} command - Command name
+   * @returns {number|null} - Predicted cooldown in seconds
+   */
+  getPredictedCooldown(command) {
+    return this.emaTrackers.get(command)?.getPrediction() || null;
+  }
+
+  /**
+   * Get optimal command order based on cooldowns.
+   * @param {string[]} commands - List of commands to consider
+   * @returns {Array} - Sorted commands with timing info
+   */
+  getOptimalOrder(commands) {
+    const now = Date.now();
+    const order = commands.map(cmd => {
+      const config = COMMAND_CONFIG[cmd] || { priority: 5 };
+      const status = this.isReady(cmd);
+      return {
+        command: cmd,
+        ready: status.ready,
+        waitMs: status.waitMs,
+        priority: config.priority,
+        category: config.category,
+        predicted: status.predicted,
+      };
+    });
+
+    // Sort: ready commands first (by priority), then by wait time
+    order.sort((a, b) => {
+      if (a.ready && !b.ready) return -1;
+      if (!a.ready && b.ready) return 1;
+      if (a.ready && b.ready) return a.priority - b.priority;
+      return a.waitMs - b.waitMs;
+    });
+
+    return order;
+  }
+
+  /**
+   * Get all commands that will be ready within a time window.
+   * @param {number} windowMs - Time window in milliseconds
+   * @returns {Array} - Commands ready within window
+   */
+  getReadyInWindow(windowMs) {
+    const now = Date.now();
+    const ready = [];
+
+    for (const [command, readyAt] of this.cooldowns.entries()) {
+      const waitMs = readyAt - now;
+      if (waitMs <= windowMs) {
+        ready.push({
+          command,
+          waitMs: Math.max(0, waitMs),
+          readyAt,
+        });
+      }
+    }
+
+    ready.sort((a, b) => a.waitMs - b.waitMs);
+    return ready;
+  }
+
+  /**
+   * Clear cooldown for a command.
+   * @param {string} command - Command name
+   */
+  clearCooldown(command) {
+    this.cooldowns.delete(command);
+  }
+
+  /**
+   * Clear all cooldowns.
+   */
+  clearAll() {
+    this.cooldowns.clear();
+  }
+}
+
+// ── Command Scheduler (Priority Queue) ────────────────────────
+class CommandScheduler {
+  constructor(tracker) {
+    this.tracker = tracker;
+    this.queue = new MinHeap((a, b) => a.executeAt - b.executeAt);
+    this.pending = new Map();  // command -> node reference
+  }
+
+  /**
+   * Schedule a command for execution.
+   * @param {string} command - Command name
+   * @param {Function} executeFn - Function to execute
+   * @param {number} executeAt - Timestamp to execute at
+   */
+  schedule(command, executeFn, executeAt) {
+    // Remove existing scheduled command if any
+    this.unschedule(command);
+
+    const node = {
+      command,
+      executeFn,
+      executeAt,
+      added: Date.now(),
+    };
+
+    this.queue.push(node);
+    this.pending.set(command, node);
+
+    return node;
+  }
+
+  /**
+   * Cancel a scheduled command.
+   * @param {string} command - Command name
+   */
+  unschedule(command) {
+    const node = this.pending.get(command);
+    if (node) {
+      this.queue.remove(node);
+      this.pending.delete(command);
+    }
+  }
+
+  /**
+   * Get next command to execute.
+   * @returns {Object|null} - Next command node or null
+   */
+  peekNext() {
+    return this.queue.peek();
+  }
+
+  /**
+   * Execute next command if it's time.
+   * @returns {Object|null} - Executed command node or null
+   */
+  async executeNext() {
+    const node = this.queue.peek();
+    if (!node) return null;
+
+    const now = Date.now();
+    if (node.executeAt <= now) {
+      this.queue.pop();
+      this.pending.delete(node.command);
+
+      try {
+        await node.executeFn();
+        return node;
+      } catch (e) {
+        console.error(`[scheduler] Error executing ${node.command}:`, e);
+        throw e;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get queue size.
+   */
+  size() {
+    return this.queue.size();
+  }
+}
+
+// ── Factory Function ──────────────────────────────────────────
+/**
+ * Create a cooldown manager for a user.
+ * @param {string} userId - User ID
+ * @param {Object} options
+ * @param {Object} options.redis - Redis client (optional)
+ * @param {boolean} options.clusterEnabled - Cluster mode flag
+ * @returns {Object} - { tracker, scheduler, COMMAND_CONFIG }
+ */
+function createCooldownManager(userId, options = {}) {
+  const { redis = null, clusterEnabled = false } = options;
+
+  const tracker = new CooldownTracker(userId, redis, clusterEnabled);
+  const scheduler = new CommandScheduler(tracker);
+
+  return {
+    tracker,
+    scheduler,
+    COMMAND_CONFIG,
+  };
+}
+
+// ── Exports ───────────────────────────────────────────────────
+module.exports = {
+  EMACalculator,
+  CooldownTracker,
+  CommandScheduler,
+  createCooldownManager,
+  COMMAND_CONFIG,
+};