dankgrinder 6.37.0 → 6.39.0

package/lib/commands/farm.js

@@ -68,11 +68,30 @@ function parseFarmCooldownSec(text) {
   const hasCooldownContext = /easy tiger|slow it down|already farmed|farm again|cooldown|can be used again|on cooldown/.test(lower);
   if (!hasCooldownContext) return null;
 
-  const ts = clean.match(RE_TS);
-  if (ts) {
-    const diff = parseInt(ts[1], 10) - Math.floor(Date.now() / 1000);
-    if (diff > 0) return diff;
+  // Handle all Discord timestamp formats: :R, :f, :F, :T, :t, :d, :D
+  // :R = relative seconds from now (already seconds since epoch difference)
+  // :f/:F = absolute datetime → diff from now
+  // :T/:t/:d/:D = not useful for cooldowns (no time component)
+  const RE_TS_ALL = /<t:(\d+):([tTdDfFR])>/g;
+  const now = Math.floor(Date.now() / 1000);
+  let best = null;
+  for (const m of clean.matchAll(RE_TS_ALL)) {
+    const ts = parseInt(m[1], 10);
+    const fmt = m[2];
+    if (!Number.isFinite(ts)) continue;
+    let diff;
+    if (fmt === 'R') {
+      diff = ts - now; // :R is already relative seconds
+    } else if (fmt === 'f' || fmt === 'F' || fmt === 'T') {
+      diff = ts - now; // :f/:F/:T are absolute → diff gives seconds remaining
+    } else {
+      // :t/:d/:D don't have enough info for cooldown calc — skip
+      continue;
+    }
+    if (diff > 0 && (best === null || diff < best)) best = diff;
   }
+  if (best !== null) return Math.max(5, best);
+
   const mm = clean.match(RE_MIN);
   if (mm) return parseInt(mm[1], 10) * 60;
   const hh = clean.match(RE_HR);
@@ -1589,16 +1608,23 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     LOG.coin(`[farm] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
     // After a harvest, Dank Memer auto-plants new crops. Record harvest time
     // in Redis so the next run knows when crops should be ready.
-    // Also: if the farm shows "empty" or "manage" state (no grow timestamp),
-    // set a short re-check window instead of trusting a potentially stale grow queue.
+    // Only force a short 30s re-check if there is NO known grow queue timer.
+    // If growReadyEnd is set (e.g. "ready in 26m"), that takes priority.
     const afterHarvestState = analyzeFarmState({ msg: cycleResponse, text });
     const farmIsHarvested = afterHarvestState.stage === 'overview'
       || /seems? pretty empty|empty\.{0,3}|hoe|water|plant|harvest/i.test(text);
     if (farmIsHarvested) {
-      // Farm was harvested and is back to manage/empty state.
-      // Re-check in 30s to start the next cycle (hoe→water→plant→harvest).
-      nextCd = Math.min(nextCd, 30);
-      LOG.info(`[farm] harvest complete (+⏣ ${coins.toLocaleString()}), farm is ${afterHarvestState.stage} — re-checking in 30s`);
+      const hasGrowTimer = Number.isFinite(growReadyEnd) && growReadyEnd > 0;
+      if (hasGrowTimer) {
+        // Crops were planted and a grow queue timer exists (e.g. "ready in 26m").
+        // Respect that timer — the 30s cap should NOT override it.
+        LOG.info(`[farm] harvest complete (+⏣ ${coins.toLocaleString()}), farm is ${afterHarvestState.stage}, grow in ${Math.ceil(growReadyEnd / 60)}m — waiting for grow queue`);
+      } else {
+        // No grow queue timer visible (farm is truly empty or manage menu without timestamp).
+        // Short re-check to start the next hoe→water→plant→harvest cycle.
+        nextCd = Math.min(nextCd, 30);
+        LOG.info(`[farm] harvest complete (+⏣ ${coins.toLocaleString()}), farm is ${afterHarvestState.stage} — re-checking in 30s`);
+      }
     }
     // Record in Redis for cross-instance awareness
     let growDurMs = null;

package/lib/commands/stream.js

@@ -206,7 +206,7 @@ async function runStream({ channel, waitForDankMemer, client }) {
 
   if (isHoldTight(response)) {
     const reason = getHoldTightReason(response);
-    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason, nextCooldownSec: 30 };
   }
 
   await hydrate(response);

package/lib/commands/work.js

@@ -418,7 +418,7 @@ async function runWorkShift({ channel, waitForDankMemer }) {
     const reason = getHoldTightReason(current);
     LOG.warn(`[work] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
     await sleep(30000);
-    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason, nextCooldownSec: 30 };
   }
 
   if (isCV2(current)) await ensureCV2(current);

package/lib/grinder.js

@@ -94,6 +94,8 @@ const c = {
 };
 
 const WORKER_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+// Unique marker written to stdout so we can query cursor position via DSR response
+const MARKER = '\x1b[6n\x1b[@@MARKER@@';
 const DANK_MEMER_ID = '270904126974590976';
 
 // ── Safe options for search/crime ──────────────────────────
@@ -1110,6 +1112,11 @@ class AccountWorker {
     this.commandQueue = null;
     this.lastHealthCheck = Date.now();
     this.doneToday = new Map();
+
+    // Dynamic cooldown learning: tracks actual parsed cooldowns per command.
+    // Persisted in Redis hash `dkg:cd:learned:{accountId}` for cross-restart persistence.
+    // Used as adaptive floor when command parsers don't return exact cooldowns.
+    this._learnedCooldowns = new Map();
     this._fishRoundsSinceSell = 0;
     this._autoDepositThreshold = account.auto_deposit_threshold || 500000;
 
@@ -1995,6 +2002,11 @@ class AccountWorker {
       if (cmdResult.nextCooldownSec) {
         await this.setCooldown(cmdName, cmdResult.nextCooldownSec);
         this._lastCooldownOverride = cmdResult.nextCooldownSec;
+        // Learn: record this cooldown as the known value for future fallback use
+        this._learnedCooldowns.set(cmdName, cmdResult.nextCooldownSec);
+        if (redis) {
+          await redis.hset(`dkg:cd:learned:${this.account.id}`, cmdName, String(cmdResult.nextCooldownSec));
+        }
       }
 
       // Smart gambling loss tracker
@@ -2115,6 +2127,25 @@ class AccountWorker {
     }
   }
 
+  // Load previously learned cooldowns from Redis so floors adapt across restarts.
+  async _loadLearnedCooldowns() {
+    if (!redis) return;
+    try {
+      const learned = await redis.hgetall(`dkg:cd:learned:${this.account.id}`);
+      for (const [cmd, val] of Object.entries(learned)) {
+        const n = parseFloat(val);
+        if (Number.isFinite(n) && n > 0) {
+          this._learnedCooldowns.set(cmd, n);
+        }
+      }
+      if (this._learnedCooldowns.size > 0) {
+        this.log('info', `Loaded ${this._learnedCooldowns.size} learned cooldowns from Redis`);
+      }
+    } catch (e) {
+      this.log('warn', `Failed to load learned cooldowns: ${e.message}`);
+    }
+  }
+
   printStats() {
     // Stats are shown in the live dashboard, no-op here
   }
@@ -2166,7 +2197,7 @@ class AccountWorker {
     // Alert is NOT scheduled — it's reactive (listener-based, see grindLoop)
   ].map(Object.freeze);
 
-  buildCommandQueue() {
+  async buildCommandQueue() {
     const heap = new MinHeap();
     const now = Date.now();
     let enabled = AccountWorker.COMMAND_MAP.filter(
@@ -2180,8 +2211,33 @@ class AccountWorker {
       enabled = AccountWorker.COMMAND_MAP.filter(ci => Boolean(this.account[ci.key]));
     }
 
+    // Restore cooldown state from Redis so commands don't re-run immediately
+    // after restart. We use TTL to calculate remaining cooldown time.
+    const accountId = this.account.id;
+    const cmdKeys = enabled.map(info => `dkg:cd:${accountId}:${info.cmd}`);
+    let ttlMap = new Map();
+    if (redis) {
+      const pipeline = redis.pipeline();
+      for (const k of cmdKeys) pipeline.ttl(k);
+      const results = await pipeline.exec();
+      for (let i = 0; i < cmdKeys.length; i++) {
+        const [err, val] = results[i];
+        if (!err && Number.isFinite(val) && val > 0) {
+          ttlMap.set(cmdKeys[i], val);
+        }
+      }
+    }
+
     for (const info of enabled) {
-      heap.push({ cmd: info.cmd, nextRunAt: now, priority: info.priority, info });
+      let nextRunAt = now;
+      const key = `dkg:cd:${accountId}:${info.cmd}`;
+      const ttlVal = ttlMap.get(key);
+      if (Number.isFinite(ttlVal) && ttlVal > 0) {
+        nextRunAt = now + ttlVal * 1000;
+        this._cooldownBloom.add(key);
+        this.log('info', `Restored cooldown for ${info.cmd}: ${ttlVal}s remaining`);
+      }
+      heap.push({ cmd: info.cmd, nextRunAt, priority: info.priority, info });
     }
     return heap;
   }
@@ -2309,7 +2365,7 @@ class AccountWorker {
 
         // Resume grind loop if it was running
         if (!this.commandQueue || this.commandQueue.size === 0) {
-          this.commandQueue = this.buildCommandQueue();
+          this.commandQueue = await this.buildCommandQueue();
         }
       } else {
         this.log('error', 'Recovered connection but channel not found — retrying');
@@ -2407,7 +2463,7 @@ class AccountWorker {
     }
 
     if (!this.commandQueue || this.commandQueue.size === 0) {
-      this.commandQueue = this.buildCommandQueue();
+      this.commandQueue = await this.buildCommandQueue();
     }
     if (!this.commandQueue || this.commandQueue.size === 0) {
       this.tickTimeout = setTimeout(() => this.tick(), 15000);
@@ -2558,22 +2614,33 @@ class AccountWorker {
 
     if (this.commandQueue && this.running && !shutdownCalled) {
       const hasOverride = Number.isFinite(this._lastCooldownOverride) && this._lastCooldownOverride > 0;
-      let effectiveWait = hasOverride ? this._lastCooldownOverride : totalWait;
       this._lastCooldownOverride = null;
 
-      // Smart fallback floors for long/interactive commands when parser misses exact cooldown.
-      if (!hasOverride) {
-        const floor = AccountWorker.SMART_CD_FLOORS[item.cmd];
-        if (Number.isFinite(floor) && floor > 0) {
-          effectiveWait = Math.max(effectiveWait, floor);
+      let scheduledWaitSec;
+      if (hasOverride) {
+        // Exact cooldown returned by command parser — use it without jitter or backoff.
+        // This ensures work (1h), adventure (5h), stream (10m), farm (varies) are honored exactly.
+        scheduledWaitSec = Math.max(1, this._lastCooldownOverride);
+      } else {
+        // Jitter-based cooldown for commands without a parsed override.
+        let effectiveWait = totalWait;
+
+        // Smart fallback floors: static floor OR dynamically learned cooldown (whichever is higher).
+        // Learned cooldowns come from actual parsed responses and persist across restarts via Redis.
+        const staticFloor = AccountWorker.SMART_CD_FLOORS[item.cmd] || 0;
+        const learnedCd = this._learnedCooldowns.get(item.cmd) || 0;
+        const adaptiveFloor = Math.max(staticFloor, learnedCd);
+        if (adaptiveFloor > 0) {
+          effectiveWait = Math.max(effectiveWait, adaptiveFloor);
         }
-      }
 
-      if (earned <= 0 && !noFailCmds.includes(item.cmd) && effectiveWait < MIN_FAIL_COOLDOWN) {
-        effectiveWait = MIN_FAIL_COOLDOWN;
+        if (earned <= 0 && !noFailCmds.includes(item.cmd) && effectiveWait < MIN_FAIL_COOLDOWN) {
+          effectiveWait = MIN_FAIL_COOLDOWN;
+        }
+
+        scheduledWaitSec = Math.max(1, effectiveWait * backoffMultiplier);
       }
 
-      const scheduledWaitSec = Math.max(1, effectiveWait * backoffMultiplier);
       await this.setCooldown(item.cmd, scheduledWaitSec);
       item.nextRunAt = Date.now() + scheduledWaitSec * 1000;
       this.commandQueue.push(item);
@@ -2611,7 +2678,8 @@ class AccountWorker {
     this.failStreak = 0;
     this.cycleCount = 0;
     this.lastCommandRun = 0;
-    this.commandQueue = this.buildCommandQueue();
+    await this._loadLearnedCooldowns();
+    this.commandQueue = await this.buildCommandQueue();
     this.lastHealthCheck = Date.now();
 
     // Reactive alert listener: run `pls alert` only when Dank Memer
@@ -3048,9 +3116,30 @@ async function start(apiKey, apiUrl) {
   }
   loginLines.push(`  ${'─'.repeat(loginVis)}`);
   for (const l of loginLines) console.log(l);
-  loginLines = null;
+
+  // Dynamically capture the starting row of the login table via DSR
+  let loginBaseRow = 1;
+  const captureLoginRow = () => new Promise(resolve => {
+    process.stdout.write(MARKER);
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        loginBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    setTimeout(resolve, 50);
+  });
+  await captureLoginRow();
 
   let loginPending = new Array(accounts.length).fill(true);
+  const moveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
+
   const drawLoginSpinners = () => {
     for (let i = 0; i < loginPending.length; i++) {
       if (!loginPending[i]) continue;
@@ -3059,8 +3148,13 @@ async function start(apiKey, apiUrl) {
       const name = loginStates[i].name.substring(0, colName).padEnd(colName);
       const guild = c.dim + 'logging in...'.substring(0, colGuild) + c.reset;
       const cmds = c.dim + '···'.padEnd(colCmds) + c.reset;
-      process.stdout.write(`\r\x1b[2K  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
+      const row = loginBaseRow + 1 + i; // +1 skips the top border line
+      moveToRow(row);
+      process.stdout.write(`  ${num}  ${rgb(139, 92, 246)}${spin}${c.reset}  ${name}  ${guild}  ${cmds}\x1b[K`);
     }
+    // Move cursor back to bottom to avoid overwriting the bottom border
+    const lastRow = loginBaseRow + 1 + accounts.length + 1;
+    moveToRow(lastRow);
   };
   const loginSpinnerInterval = setInterval(drawLoginSpinners, 80);
 
@@ -3089,7 +3183,9 @@ async function start(apiKey, apiUrl) {
       guild = 'timeout'.padEnd(colGuild);
       cmds = '···'.padEnd(colCmds);
     }
-    process.stdout.write(`\r\x1b[2K  ${num}  ${sts}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}${cmds}${c.reset}\x1b[K`);
+    const row = loginBaseRow + 1 + idx; // +1 skips the top border line
+    moveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${c.dim}${guild}${c.reset}  ${c.dim}${cmds}${c.reset}\x1b[K`);
   };
 
   const parsedGapMin = Number.parseInt(String(process.env.LOGIN_GAP_MIN_MS || '50'), 10);
@@ -3137,6 +3233,28 @@ async function start(apiKey, apiUrl) {
   const iColVal = 16;
   const invVis = 7 + iColNum + iColName + iColItems + iColVal + 12;
 
+  // Print a unique marker, query its position, then overwrite it with the table
+  process.stdout.write(MARKER);
+  let invBaseRow = 1;
+  const captureRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        invBaseRow = parseInt(m[1], 10) + 1; // +1: first account row is after marker
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    setTimeout(resolve, 50);
+  });
+  await captureRow();
+
+  // Now print the inventory table starting at invBaseRow
+  const invMoveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
   console.log(`  ${'─'.repeat(invVis)}`);
   for (let i = 0; i < activeWorkers.length; i++) {
     const w = activeWorkers[i];
@@ -3155,7 +3273,8 @@ async function start(apiKey, apiUrl) {
     const filled = Math.round(pct * barW);
     const bar = rgb(34, 211, 238) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(barW - filled) + c.reset;
     const pctStr = `${Math.round(pct * 100)}%`;
-    process.stdout.write(`\r\x1b[2K  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - invPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  `);
+    invMoveToRow(invBaseRow);
+    process.stdout.write(`  ${rgb(34, 211, 238)}${spin}${c.reset}  ${c.dim}Inventory...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - invPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  ${c.dim}${pctStr}${c.reset}  \x1b[K`);
   };
   const invSpinnerInterval = setInterval(drawInvProgress, 80);
 
@@ -3171,7 +3290,9 @@ async function start(apiKey, apiUrl) {
     const sts = invRes?.ok ? `${rgb(52, 211, 153)}✓${c.reset}` : `${rgb(239, 68, 68)}✗${c.reset}`;
     const itemStr = `${items}`.padEnd(iColItems);
     const valStr = invRes?.ok ? `${c.green}⏣${val.toLocaleString()}${c.reset}` : `${c.dim}···${c.reset}`;
-    process.stdout.write(`\r\x1b[2K  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
+    const row = invBaseRow + 1 + i;
+    invMoveToRow(row);
+    process.stdout.write(`  ${num}  ${sts}  ${name}  ${itemStr}  ${valStr.padEnd(iColVal + 5)}\x1b[K`);
     if (invRes?.ok) invDone++; else invFailed++;
   }));
 
@@ -3195,6 +3316,27 @@ async function start(apiKey, apiUrl) {
   const bColLs = 4;
   const balVis = 7 + bColNum + bColName + bColWallet + bColBank + bColTotal + bColLs + 14;
 
+  // Capture starting row for balance phase
+  process.stdout.write(MARKER);
+  let balBaseRow = 1;
+  const balCaptureRow = () => new Promise(resolve => {
+    const chunks = [];
+    const handler = (chunk) => {
+      chunks.push(chunk);
+      const raw = chunks.join('');
+      const m = raw.match(/\x1b\[(\d+);\d+R/);
+      if (m) {
+        process.stdin.removeListener('data', handler);
+        balBaseRow = parseInt(m[1], 10) + 1;
+        resolve();
+      }
+    };
+    process.stdin.on('data', handler);
+    setTimeout(resolve, 50);
+  });
+  await balCaptureRow();
+
+  const balMoveToRow = (row) => process.stdout.write(`\x1b[${row};1H`);
   console.log(`  ${'─'.repeat(balVis)}`);
   for (let i = 0; i < activeWorkers.length; i++) {
     const w = activeWorkers[i];
@@ -3212,7 +3354,8 @@ async function start(apiKey, apiUrl) {
     const barW = Math.min(20, startupTw - 40);
     const filled = Math.round(pct * barW);
     const bar = rgb(251, 191, 36) + '█'.repeat(filled) + rgb(50, 50, 70) + '░'.repeat(barW - filled) + c.reset;
-    process.stdout.write(`\r\x1b[2K  ${rgb(251, 191, 36)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - balPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  `);
+    balMoveToRow(balBaseRow);
+    process.stdout.write(`  ${rgb(251, 191, 36)}${spin}${c.reset}  ${c.dim}Balance...${c.reset}  ${bar}  ${c.bold}${rgb(52, 211, 153)}${activeWorkers.length - balPending}${c.reset}${c.dim}/${c.reset}${c.white}${activeWorkers.length}${c.reset}  \x1b[K`);
   };
   const balSpinnerInterval = setInterval(drawBalProgress, 80);
 
@@ -3228,7 +3371,9 @@ async function start(apiKey, apiUrl) {
     const walletStr = `${c.green}⏣${wallet.toLocaleString()}${c.reset}`;
     const bankStr = `${c.cyan}⏣${bank.toLocaleString()}${c.reset}`;
     const totalStr = `${c.bold}⏣${(wallet + bank).toLocaleString()}${c.reset}`;
-    process.stdout.write(`\r\x1b[2K  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}\x1b[K`);
+    const row = balBaseRow + 1 + i;
+    balMoveToRow(row);
+    process.stdout.write(`  ${num}  ${rgb(52, 211, 153)}✓${c.reset}  ${name}  ${walletStr.padEnd(bColWallet + 4)}  ${bankStr.padEnd(bColBank + 4)}  ${totalStr.padEnd(bColTotal + 3)}  ${lsColor}♥${ls}${c.reset}\x1b[K`);
     balDone++;
   }));
 

package/package.json

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