dankgrinder 5.21.0 → 5.23.0

package/lib/commands/inventory.js

@@ -194,7 +194,7 @@ async function enrichItems(items) {
 /**
  * Check inventory for all pages and return full item list.
  */
-async function runInventory({ channel, waitForDankMemer, client, accountId, redis }) {
+async function runInventory({ channel, waitForDankMemer, client, accountId, redis, onPageProgress }) {
   LOG.cmd(`${c.white}${c.bold}pls inv${c.reset}`);
 
   await channel.send('pls inv');
@@ -202,14 +202,21 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
 
   if (!response) {
     LOG.warn('[inv] No response');
-    return { result: 'no response', items: [] };
+    return { result: 'no response', items: [], complete: false, pagesVisited: 0, pagesTotal: 0 };
   }
 
   if (isHoldTight(response)) {
     const reason = getHoldTightReason(response);
     LOG.warn(`[inv] Hold Tight${reason ? ` (reason: ${reason})` : ''}`);
     await sleep(30000);
-    return { result: `hold tight (${reason || 'unknown'})`, items: [], holdTightReason: reason };
+    return {
+      result: `hold tight (${reason || 'unknown'})`,
+      items: [],
+      holdTightReason: reason,
+      complete: false,
+      pagesVisited: 0,
+      pagesTotal: 0,
+    };
   }
 
   if (isCV2(response)) await ensureCV2(response);
@@ -218,6 +225,9 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   const allItems = [];
   let { page, total } = parsePageInfo(response);
   LOG.info(`[inv] Page ${page}/${total}`);
+  if (typeof onPageProgress === 'function') {
+    try { onPageProgress({ page, total }); } catch {}
+  }
   const visitedPages = new Set([page]);
 
   allItems.push(...parseInventoryPage(response));
@@ -316,6 +326,9 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
         visitedPages.add(page);
         pageChanged = true;
         LOG.info(`[inv] Page ${page}/${total}`);
+        if (typeof onPageProgress === 'function') {
+          try { onPageProgress({ page, total }); } catch {}
+        }
         break;
       }
       // Clear CV2 cache again for next retry
@@ -340,13 +353,19 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   }
 
   const items = Object.values(itemMap);
-  LOG.success(`[inv] Found ${items.length} unique items across ${visitedPages.size}/${total} pages`);
+  const pagesVisited = visitedPages.size;
+  const pagesTotal = Math.max(total || 1, 1);
+  const complete = page >= total || pagesVisited >= pagesTotal;
+  LOG.success(`[inv] Found ${items.length} unique items across ${pagesVisited}/${pagesTotal} pages`);
+  if (!complete) {
+    LOG.warn(`[inv] Incomplete pagination detected: stopped at page ${page}/${pagesTotal}`);
+  }
 
   const { totalValue, totalMarket } = await enrichItems(items);
   LOG.info(`[inv] Net value: ${c.bold}${c.green}⏣ ${totalValue.toLocaleString()}${c.reset}  Market: ${c.bold}⏣ ${totalMarket.toLocaleString()}${c.reset}`);
 
   // Store in Redis — NO EXPIRY (permanent until next update)
-  if (redis && accountId) {
+  if (complete && redis && accountId) {
     try {
       const payload = {
         items,
@@ -360,6 +379,8 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
     } catch (e) {
       LOG.error(`[inv] Redis store failed: ${e.message}`);
     }
+  } else if (!complete) {
+    LOG.warn('[inv] Skipping Redis store for incomplete inventory scan');
   }
 
   return {
@@ -368,6 +389,9 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
     totalValue,
     totalMarket,
     coins: 0,
+    complete,
+    pagesVisited,
+    pagesTotal,
   };
 }
 

package/lib/grinder.js

@@ -1085,39 +1085,78 @@ class AccountWorker {
 
   // ── Check Balance ───────────────────────────────────────────
   async checkInventory(options = {}) {
-    const { force = false, startupProgress = null } = options;
-    if (this._invRunning) return;
-    if (!force && this._lastInvCheck && Date.now() - this._lastInvCheck < 300_000) return;
+    const {
+      force = false,
+      startupProgress = null,
+      requireComplete = false,
+      maxAttempts = 1,
+    } = options;
+    if (this._invRunning) return { ok: false, skipped: 'busy' };
+    if (!force && this._lastInvCheck && Date.now() - this._lastInvCheck < 300_000) return { ok: false, skipped: 'recent' };
     this._invRunning = true;
     this._lastInvCheck = Date.now();
     this.busy = true;
     try {
-      if (startupProgress && Number.isInteger(startupProgress.current) && Number.isInteger(startupProgress.total)) {
-        this.log('info', `Checking inventory... (${startupProgress.current}/${startupProgress.total})`);
-      } else {
-        this.log('info', 'Checking inventory...');
-      }
-      const result = await commands.runInventory({
-        channel: this.channel,
-        waitForDankMemer: (timeout) => this.waitForDankMemer(timeout),
-        client: this.client,
-        accountId: this.account.id,
-        redis,
-      });
-      this.log('success', `Inventory: ${result.items?.length || 0} items, ⏣ ${(result.totalValue || 0).toLocaleString()} net`);
-      try {
-        await fetch(`${API_URL}/api/grinder/inventory`, {
-          method: 'POST',
-          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            account_id: this.account.id,
-            items: result.items || [],
-            totalValue: result.totalValue || 0,
-          }),
-        });
-      } catch {}
+      const tries = Math.max(1, Number.isFinite(maxAttempts) ? maxAttempts : 1);
+      let lastErr = null;
+      for (let attempt = 1; attempt <= tries; attempt++) {
+        if (startupProgress && Number.isInteger(startupProgress.current) && Number.isInteger(startupProgress.total)) {
+          this.log('info', `Checking inventory... (${startupProgress.current}/${startupProgress.total}) [try ${attempt}/${tries}]`);
+        } else {
+          this.log('info', `Checking inventory...${tries > 1 ? ` [try ${attempt}/${tries}]` : ''}`);
+        }
+
+        try {
+          const result = await commands.runInventory({
+            channel: this.channel,
+            waitForDankMemer: (timeout) => this.waitForDankMemer(timeout),
+            client: this.client,
+            accountId: this.account.id,
+            redis,
+            onPageProgress: ({ page, total }) => {
+              this.log('info', `Inventory pages: ${page}/${total}`);
+            },
+          });
+
+          if (requireComplete && !result.complete) {
+            throw new Error(`incomplete pages (${result.pagesVisited || 0}/${result.pagesTotal || 0})`);
+          }
+
+          this.log('success', `Inventory: ${result.items?.length || 0} items, ⏣ ${(result.totalValue || 0).toLocaleString()} net`);
+          try {
+            await fetch(`${API_URL}/api/grinder/inventory`, {
+              method: 'POST',
+              headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                account_id: this.account.id,
+                items: result.items || [],
+                totalValue: result.totalValue || 0,
+              }),
+            });
+          } catch {}
+
+          return {
+            ok: true,
+            complete: !!result.complete,
+            pagesVisited: result.pagesVisited || 0,
+            pagesTotal: result.pagesTotal || 0,
+            attempts: attempt,
+            result,
+          };
+        } catch (e) {
+          lastErr = e;
+          if (attempt < tries) {
+            this.log('warn', `Inventory attempt ${attempt}/${tries} failed (${e.message}). Retrying...`);
+            await sleep(1500 + Math.floor(Math.random() * 1500));
+            continue;
+          }
+        }
+      }
+
+      throw lastErr || new Error('inventory check failed');
     } catch (e) {
       this.log('error', `Inventory check failed: ${e.message}`);
+      return { ok: false, error: e.message };
     } finally {
       this._invRunning = false;
       this.busy = false;
@@ -2418,36 +2457,30 @@ async function start(apiKey, apiUrl) {
   log('info', `${c.dim}Checking inventory for all ${workers.length} accounts...${c.reset}`);
   let invDone = 0;
   let invFailed = 0;
-  const parsedInvConcurrency = Number.parseInt(String(process.env.INV_STARTUP_CONCURRENCY || ''), 10);
-  const invConcurrency = Math.max(1, Math.min(
-    workers.length,
-    Number.isFinite(parsedInvConcurrency) && parsedInvConcurrency > 0
-      ? parsedInvConcurrency
-      : Math.min(10, Math.max(3, Math.ceil(workers.length / 8)))
-  ));
-  log('info', `${c.dim}[inv-startup] parallel workers: ${invConcurrency}${c.reset}`);
-
-  let invCursor = 0;
-  const runInventoryWorker = async (slot) => {
-    while (!shutdownCalled) {
-      const i = invCursor++;
-      if (i >= workers.length) break;
-      const w = workers[i];
-      const label = w?.username || w?.account?.label || w?.account?.id || `account-${i + 1}`;
-      log('info', `${c.dim}[inv-startup] ${i + 1}/${workers.length} ${label} ${c.dim}(runner ${slot})${c.reset}`);
-      try {
-        await w.checkInventory({ force: true, startupProgress: { current: i + 1, total: workers.length } });
-        invDone++;
-      } catch {
-        invFailed++;
-      }
-      const invComplete = invDone + invFailed;
-      log('info', `${c.dim}[inv-startup-progress] ${invComplete}/${workers.length} complete (${invDone} ok, ${invFailed} failed)${c.reset}`);
-      await new Promise(r => setTimeout(r, 200 + Math.floor(Math.random() * 400)));
+  await Promise.all(workers.map(async (w, i) => {
+    const label = w?.username || w?.account?.label || w?.account?.id || `account-${i + 1}`;
+    log('info', `${c.dim}[inv-startup] ${i + 1}/${workers.length} ${label}${c.reset}`);
+    try {
+      const invRes = await w.checkInventory({
+        force: true,
+        startupProgress: { current: i + 1, total: workers.length },
+        requireComplete: true,
+        maxAttempts: 3,
+      });
+      if (invRes?.ok) invDone++;
+      else invFailed++;
+    } catch {
+      invFailed++;
     }
-  };
+    const invComplete = invDone + invFailed;
+    log('info', `${c.dim}[inv-startup-progress] ${invComplete}/${workers.length} complete (${invDone} ok, ${invFailed} failed)${c.reset}`);
+  }));
+
+  if (invFailed > 0) {
+    log('error', `${c.red}Inventory phase incomplete: ${invDone}/${workers.length} complete, ${invFailed} failed/incomplete. Not starting grind loops.${c.reset}`);
+    return;
+  }
 
-  await Promise.all(Array.from({ length: invConcurrency }, (_, idx) => runInventoryWorker(idx + 1)));
   const invSummaryColor = invFailed > 0 ? c.yellow : c.green;
   log('success', `${c.dim}Inventory phase complete: ${invSummaryColor}${invDone}/${workers.length}${c.reset}${c.dim} done${invFailed > 0 ? `, ${c.yellow}${invFailed} failed${c.reset}${c.dim}` : ''}. Starting grind loops...${c.reset}`);
 

package/package.json

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