dankgrinder 7.12.0 → 7.60.0

package/bin/dankgrinder.js

@@ -15,13 +15,18 @@ if (args.includes('--help') || args.includes('-h')) {
   console.log(`
   ${C.b}${C.mag}DANK${C.cyn}GRINDER${C.r} ${C.d}v${pkg.version}${C.r}
 
-  ${C.b}Usage:${C.r}
-    npx dankgrinder --key <API_KEY>
+  ${C.b}Local usage:${C.r}
+    npx dankgrinder --key <YOUR_API_KEY>
+
+  ${C.b}Cloud mode (admin):${C.r}
+    npx dankgrinder --cloud --key <CLOUD_ADMIN_KEY>
 
   ${C.b}Options:${C.r}
-    --key <key>       API key from dashboard (required)
+    --key <key>       API key (required)
     --url <url>       Override dashboard URL (default: ${DEFAULT_URL})
     --redis <url>     Redis URL for cooldowns & trivia DB
+    --cloud           Cloud mode: fetch ALL cloud-enabled accounts from ALL users
+                      Requires CLOUD_ADMIN_KEY env var and admin API endpoint
     --help, -h        Show this help
     --version, -v     Show version
 `);
@@ -36,11 +41,13 @@ if (args.includes('--version') || args.includes('-v')) {
 let apiKey = process.env.DANKGRINDER_KEY || process.env.GRINDER_API_KEY || '';
 let apiUrl = '';
 let redisUrl = '';
+let cloudMode = false;
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--key' && args[i + 1]) apiKey = args[i + 1];
   if (args[i] === '--url' && args[i + 1]) apiUrl = args[i + 1];
   if (args[i] === '--redis' && args[i + 1]) redisUrl = args[i + 1];
+  if (args[i] === '--cloud') cloudMode = true;
 }
 
 apiUrl = apiUrl || process.env.DANKGRINDER_URL || process.env.GRINDER_URL || DEFAULT_URL;
@@ -71,4 +78,4 @@ if (!apiKey) {
   process.exit(1);
 }
 
-start(apiKey, apiUrl);
+start(apiKey, apiUrl, { cloud: cloudMode });

package/lib/commands/index.js

@@ -25,6 +25,7 @@ const { runDrops } = require('./drops');
 const { buyItem, ITEM_COSTS } = require('./shop');
 const { getPlayerLevel, meetsLevelRequirement, runProfile } = require('./profile');
 const { runInventory, fetchItemValues, enrichItems, getCachedInventory, getAllInventories, updateInventoryItem, deleteInventoryItem } = require('./inventory');
+const { runMarketPost } = require('./market');
 
 module.exports = {
   // Individual commands
@@ -56,6 +57,7 @@ module.exports = {
 
   // Inventory
   runInventory,
+  runMarketPost,
   fetchItemValues,
   enrichItems,
   getCachedInventory,

package/lib/commands/market.js

@@ -0,0 +1,151 @@
+/**
+ * Market command handler.
+ * Posts an item to Dank Memer's marketplace.
+ * Handles sell listings with optional partial sales and privacy settings.
+ *
+ * Dank Memer market post format:
+ *   pls market post for_coins <listing_type> <qty> <item> <price> <days> <allow_partial> <is_private> <partial_min>
+ *
+ * listing_type: "sell" | "auction"
+ * allow_partial: "true" | "false"
+ * is_private: "true" | "false"
+ * partial_min: only meaningful when allow_partial is true
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, logMsg, isHoldTight,
+  getHoldTightReason, sleep, humanDelay, getAllButtons, safeClickButton,
+  findSelectMenuOption,
+} = require('./utils');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {number} opts.quantity
+ * @param {string} opts.itemName
+ * @param {number} opts.pricePerItem
+ * @param {number} [opts.days=1]
+ * @param {boolean} [opts.allowPartial=false]
+ * @param {boolean} [opts.isPrivate=false]
+ * @param {number} [opts.partialMin=1]
+ * @param {string} [opts.priceType="per_item"]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runMarketPost({
+  channel,
+  waitForDankMemer,
+  quantity = 1,
+  itemName,
+  pricePerItem = 0,
+  days = 1,
+  allowPartial = false,
+  isPrivate = false,
+  partialMin = 1,
+  priceType = 'per_item',
+}) {
+  if (!itemName) {
+    return { result: 'no item specified', coins: 0 };
+  }
+
+  const cmdParts = [
+    'pls', 'market', 'post',
+    'for_coins',                   // price type: "for_coins" fixed price
+    'sell',                        // listing type: "sell" | "auction"
+    String(quantity),              // quantity
+    itemName,                      // item name
+    String(pricePerItem * quantity), // TOTAL price (price per item × quantity)
+    String(days),                  // days (1-7)
+    allowPartial ? 'true' : 'false', // allow partial
+    isPrivate ? 'true' : 'false', // is private
+    String(allowPartial ? partialMin : 0), // partial minimum (only meaningful when allowPartial is true)
+  ];
+
+  const cmdString = cmdParts.join(' ');
+  LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
+
+  await channel.send(cmdString);
+  const response = await waitForDankMemer(12000);
+
+  if (!response) {
+    LOG.warn('[market] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[market] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'market');
+  const text = getFullText(response);
+
+  // Check for common errors
+  const lowerText = text.toLowerCase();
+  if (lowerText.includes('you don\'t have') || lowerText.includes('not enough') || lowerText.includes('invalid item') || lowerText.includes('partial minimum can\'t') || lowerText.includes('set allow_partial')) {
+    return { result: text.substring(0, 80) || 'error listing item', coins: 0 };
+  }
+
+  if (lowerText.includes('listed') || lowerText.includes('posted') || lowerText.includes('now selling') || lowerText.includes('auction created') || lowerText.includes('now listed') || lowerText.includes('successfully listed')) {
+    const earned = parseCoins(text);
+    LOG.success(`[market] Listed ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea (total ⏣ ${(pricePerItem * quantity).toLocaleString()})${earned > 0 ? ` → earned ⏣ ${earned.toLocaleString()}` : ''}`);
+    return { result: `listed ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea`, coins: earned };
+  }
+
+  // Handle confirmation buttons (e.g. "Confirm" for expensive listings)
+  const buttons = getAllButtons(response);
+  if (buttons.length > 0) {
+    // Handle fee payment dropdown first (select "coins" option)
+    const coinsOpt = findSelectMenuOption(response, 'coin');
+    if (coinsOpt) {
+      try {
+        await humanDelay();
+        await response.selectMenu(coinsOpt.menuCustomId, [coinsOpt.option.value]);
+        LOG.info(`[market] Selected fee payment: ${coinsOpt.option.label}`);
+        await sleep(500);
+        // Re-fetch message to get updated state after select
+        const msgId = response.id;
+        const updated = await channel.messages.fetch(msgId).catch(() => null);
+        if (updated) response = updated;
+      } catch (e) {
+        LOG.warn(`[market] Select menu error: ${e.message}`);
+      }
+    }
+
+    const confirmBtn = buttons.find(b =>
+      !b.disabled &&
+      (b.label?.toLowerCase().includes('confirm') ||
+       b.label?.toLowerCase().includes('post') ||
+       b.label?.toLowerCase().includes('list'))
+    );
+    if (confirmBtn) {
+      await humanDelay();
+      try {
+        const updatedMsg = await safeClickButton(response, confirmBtn);
+        // If the listing posted, Dank Memer usually sends a confirmation.
+        // But sometimes it posts silently — treat as success either way.
+        if (updatedMsg) {
+          logMsg(updatedMsg, 'market-confirm');
+          const fText = getFullText(updatedMsg);
+          const lowerF = fText.toLowerCase();
+          if (lowerF.includes('listed') || lowerF.includes('posted') || lowerF.includes('now selling') || lowerF.includes('now listed') || lowerF.includes('successfully listed') || lowerF.includes('offer to sell')) {
+            const earned = parseCoins(fText);
+            LOG.success(`[market] Listed ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea → earned ⏣ ${earned.toLocaleString()}`);
+            return { result: `listed ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea`, coins: earned };
+          }
+        }
+        // Silent post — assume it worked
+        LOG.success(`[market] Listed ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea (confirmation received)`);
+        return { result: `listed ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea`, coins: 0 };
+      } catch (e) {
+        LOG.error(`[market] Click error: ${e.message}`);
+      }
+    }
+  }
+
+  return { result: text.substring(0, 80) || 'market post sent', coins: 0 };
+}
+
+module.exports = { runMarketPost };

package/lib/grinder.js

@@ -114,6 +114,7 @@ const SAFE_CRIME_OPTIONS = Object.freeze([
 ]);
 
 let API_KEY = '';
+let CLOUD_ADMIN_KEY = '';
 let API_URL = '';
 let REDIS_URL = process.env.REDIS_URL || '';
 let redis = null;
@@ -467,7 +468,7 @@ function renderDashboard() {
   const invalidCount = workers.filter(w => w._tokenInvalid).length;
   const pausedCount = workers.filter(w => w.paused || w.dashboardPaused).length;
   const recovCount = workers.filter(w => w._recoveryAttempts > 0 && w._errorCooldownUntil > Date.now()).length;
-  const mode = CLUSTER_ENABLED ? `${Cy}CLUSTER${c.reset}` : `${D}Standalone${c.reset}`;
+  const mode = CLOUD_MODE ? `${Cy}CLOUD${c.reset}` : (CLUSTER_ENABLED ? `${Cy}CLUSTER${c.reset}` : `${D}Standalone${c.reset}`);
   const cmdCount = AccountWorker.COMMAND_MAP.length;
 
   const netQ = workers.length > 0
@@ -585,7 +586,7 @@ function renderDashboard() {
 
   for (const wk of visibleWorkers) {
     const origNum = (wk.idx + 1).toString().padStart(colNum);
-    const rawStat = (wk.lastStatus || 'idle').replace(RE, '');
+    const rawStat = (wk.lastStatus || 'ready').replace(RE, '');
     const activityText = rawStat.substring(0, colActivity);
 
     // ── Status icon ──
@@ -770,21 +771,42 @@ function log(type, msg, label) {
   }
 }
 
-async function fetchConfig(retries = 3, delayMs = 1500) {
+async function fetchConfig(retries = 3, delayMs = 1500, opts = {}) {
+  const isCloudMode = opts.cloud === true;
+  // Cloud mode uses admin endpoint + CLOUD_ADMIN_KEY
+  const url = isCloudMode
+    ? `${API_URL}/api/cloud/grinders`
+    : `${API_URL}/api/grinder/config`;
+  const authKey = isCloudMode ? (CLOUD_ADMIN_KEY || API_KEY) : API_KEY;
+
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
       const controller = new AbortController();
       const t = setTimeout(() => controller.abort(), 10000);
-      const res = await fetch(`${API_URL}/api/grinder/config`, {
-        headers: { Authorization: `Bearer ${API_KEY}` },
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${authKey}` },
         signal: controller.signal,
       });
       clearTimeout(t);
+      if (res.status === 403) {
+        const data = await res.json();
+        log('error', data.error || 'Forbidden');
+        return { error: data.error };
+      }
+      if (res.status === 401) {
+        const data = await res.json();
+        log('error', data.error || 'Unauthorized');
+        return { error: data.error };
+      }
       const data = await res.json();
       if (data.error) {
         log('error', `Config fetch failed: ${data.error}`);
         return null;
       }
+      // Mark cloud accounts so workers know their userId for SSE routing
+      if (isCloudMode && data.accounts) {
+        data.accounts = data.accounts.map(acc => ({ ...acc, _cloud: true }));
+      }
       return data;
     } catch (err) {
       if (attempt < retries) {
@@ -804,7 +826,7 @@ async function sendLog(accountName, command, response, status) {
     const safeResponse = stripAnsi(String(response || '')).replace(/\s+/g, ' ').trim();
     await fetch(`${API_URL}/api/grinder/log`, {
       method: 'POST',
-      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ account_name: accountName, command: safeCommand, response: safeResponse, status }),
     });
   } catch { /* silent */ }
@@ -818,7 +840,7 @@ const earningsBatch = new AsyncBatchQueue(async (batch) => {
   try {
     await fetch(`${API_URL}/api/grinder/earnings-batch`, {
       method: 'POST',
-      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ items: batch }),
     });
   } catch {
@@ -827,7 +849,7 @@ const earningsBatch = new AsyncBatchQueue(async (batch) => {
       try {
         await fetch(`${API_URL}/api/grinder/earnings`, {
           method: 'POST',
-          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+          headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
           body: JSON.stringify(item),
         });
       } catch {}
@@ -850,7 +872,7 @@ async function reportCommandFeed(accountId, accountName, data) {
   try {
     await fetch(`${API_URL}/api/grinder/command-feed`, {
       method: 'POST',
-      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ account_id: accountId, account_name: accountName, ...normalized }),
     });
   } catch { /* silent — dashboard just won't see this update */ }
@@ -1103,14 +1125,18 @@ class AccountWorker {
     this.channel = null;
     this.running = false;
     this.busy = false;
+    // Per-account API key (cloud mode) falls back to global key (local mode)
+    this.apiKey = account.api_key || API_KEY;
     this.username = account.label || `Account ${idx + 1}`;
     this.tickTimeout = null;
     this.stats = { coins: 0, commands: 0, successes: 0, errors: 0, balance: 0 };
     this.lastRunTime = {};
     this.cycleCount = 0;
     this.lastCommandRun = 0;
+    this.lastStatus = 'ready';
     this.paused = false;
     this.dashboardPaused = false;
+    this._sellRunning = false;
     this.failStreak = 0;
     this.globalCooldownUntil = 0;
     this.commandQueue = null;
@@ -1487,7 +1513,7 @@ class AccountWorker {
           try {
             await fetch(`${API_URL}/api/grinder/inventory`, {
               method: 'POST',
-              headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+              headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
               body: JSON.stringify({
                 account_id: this.account.id,
                 items: result.items || [],
@@ -1551,7 +1577,7 @@ class AccountWorker {
       try {
         await fetch(`${API_URL}/api/grinder/profile`, {
           method: 'POST',
-          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+          headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({
             account_id: this.account.id,
             level: result.level,
@@ -1580,6 +1606,44 @@ class AccountWorker {
     }
   }
 
+  // ── Market Sell ──────────────────────────────────────────────
+  // Pauses the grind loop, posts item to Dank Memer marketplace, resumes.
+  async sellItem({ itemName, quantity, pricePerItem, days = 1, allowPartial = false, isPrivate = false, partialMin = 1, priceType = 'per_item' }) {
+    if (!this.channel || !this.running) {
+      this.log('warn', '[sell] Cannot sell — account not running');
+      return { result: 'account not running', coins: 0 };
+    }
+
+    this._sellRunning = true;
+    this.log('info', `[sell] Posting ${quantity}x ${itemName} at ⏣ ${pricePerItem.toLocaleString()}/ea on market`);
+
+    try {
+      const result = await commands.runMarketPost({
+        channel: this.channel,
+        waitForDankMemer: (t) => this.waitForDankMemer(t),
+        quantity,
+        itemName,
+        pricePerItem,
+        days,
+        allowPartial,
+        isPrivate,
+        partialMin,
+        priceType,
+      });
+
+      if (result.result) {
+        this.log('info', `[sell] Result: ${result.result} · earned ⏣ ${result.coins.toLocaleString()}`);
+      }
+
+      return result;
+    } catch (e) {
+      this.log('error', `[sell] Error: ${e.message}`);
+      return { result: e.message, coins: 0 };
+    } finally {
+      this._sellRunning = false;
+    }
+  }
+
   async checkBalance(silent = false) {
     const prefix = this.account.use_slash ? '/' : 'pls';
     const sentAt = Date.now();
@@ -1688,13 +1752,14 @@ class AccountWorker {
     try {
       await fetch(`${API_URL}/api/grinder/status`, {
         method: 'POST',
-        headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+        headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
         body: JSON.stringify({
           account_id: this.account.id,
           balance: wallet,
           bank_balance: bank,
           total_balance: wallet + bank,
           lifesavers: this._lifesavers ?? null,
+          userId: this.account.userId,
         }),
       });
     } catch { /* silent */ }
@@ -1951,8 +2016,8 @@ class AccountWorker {
         try {
           await fetch(`${API_URL}/api/grinder/status`, {
             method: 'POST',
-            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ account_id: this.account.id, active: false }),
+            headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, active: false, userId: this.account.userId }),
           });
         } catch {}
         await sendLog(this.username, cmdString, 'VERIFICATION — account deactivated', 'error');
@@ -2506,7 +2571,7 @@ class AccountWorker {
       this.tickTimeout = setTimeout(() => this.tick(), 5000);
       return;
     }
-    if (this.busy || this._invRunning) {
+    if (this.busy || this._invRunning || this._sellRunning) {
       this.tickTimeout = setTimeout(() => this.tick(), 2000);
       return;
     }
@@ -2824,7 +2889,7 @@ class AccountWorker {
   async refreshConfig() {
     try {
       const res = await fetch(`${API_URL}/api/grinder/status`, {
-        headers: { Authorization: `Bearer ${API_KEY}` },
+        headers: { Authorization: `Bearer ${this.apiKey}` },
       });
       const data = await res.json();
       if (data.accounts) {
@@ -2840,7 +2905,7 @@ class AccountWorker {
             try {
               await fetch(`${API_URL}/api/grinder/actions`, {
                 method: 'DELETE',
-                headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+                headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
                 body: JSON.stringify({ action_id: action.id }),
               });
             } catch {}
@@ -2851,7 +2916,30 @@ class AccountWorker {
             try {
               await fetch(`${API_URL}/api/grinder/actions`, {
                 method: 'DELETE',
-                headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+                headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action_id: action.id }),
+              });
+            } catch {}
+          }
+          if (action.action === 'sell_item' && !this.busy && !this._sellRunning && action.data) {
+            const { itemName, quantity, pricePerItem, days, allowPartial, isPrivate, partialMin, priceType, accountId } = action.data;
+            // Only process if this action targets this specific account, or has no accountId (legacy/global)
+            if (accountId != null && accountId !== this.account.id) {
+              try {
+                await fetch(`${API_URL}/api/grinder/actions`, {
+                  method: 'DELETE',
+                  headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ action_id: action.id }),
+                });
+              } catch {}
+              return;
+            }
+            this.log('info', `Dashboard requested sell: ${quantity}x ${itemName}`);
+            await this.sellItem({ itemName, quantity, pricePerItem, days, allowPartial, isPrivate, partialMin, priceType }).catch(() => {});
+            try {
+              await fetch(`${API_URL}/api/grinder/actions`, {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
                 body: JSON.stringify({ action_id: action.id }),
               });
             } catch {}
@@ -2893,8 +2981,8 @@ class AccountWorker {
         // Report status non-blocking
         fetch(`${API_URL}/api/grinder/status`, {
           method: 'POST',
-          headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ account_id: this.account.id, discord_username: this.username, avatar_url: this.avatarUrl }),
+          headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ account_id: this.account.id, discord_username: this.username, avatar_url: this.avatarUrl, userId: this.account.userId }),
         }).catch(() => {});
 
         this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
@@ -2959,8 +3047,8 @@ class AccountWorker {
           // Report invalid status to API
           fetch(`${API_URL}/api/grinder/status`, {
             method: 'POST',
-            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ account_id: this.account.id, active: false, status: 'token_invalid' }),
+            headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, active: false, status: 'token_invalid', userId: this.account.userId }),
           }).catch(() => {});
           sendWebhook('Token Invalid', `**${this.account.label || this.account.id}** has an invalid Discord token.`, 0xef4444);
         } else {
@@ -2996,8 +3084,8 @@ class AccountWorker {
           this.stats.bankBalance = bank;
           await fetch(`${API_URL}/api/grinder/status`, {
             method: 'POST',
-            headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ account_id: this.account.id, balance: wallet, bank_balance: bank, total_balance: wallet + bank }),
+            headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ account_id: this.account.id, balance: wallet, bank_balance: bank, total_balance: wallet + bank, userId: this.account.userId }),
           }).catch(() => {});
         }
       }
@@ -3030,6 +3118,7 @@ class AccountWorker {
     this.paused = false;
     this.dashboardPaused = false;
     this.busy = false;
+    this._sellRunning = false;
     if (this.tickTimeout) { clearTimeout(this.tickTimeout); this.tickTimeout = null; }
     if (this.configInterval) { clearInterval(this.configInterval); this.configInterval = null; }
     if (this._alertHandler) {
@@ -3071,9 +3160,17 @@ captchaDetector.build();
 // ═  Main Entry
 // ══════════════════════════════════════════════════════════════
 
-async function start(apiKey, apiUrl) {
+async function start(apiKey, apiUrl, opts = {}) {
+  CLOUD_ADMIN_KEY = process.env.CLOUD_ADMIN_KEY || '';
   API_KEY = apiKey;
   API_URL = apiUrl || process.env.DANKGRINDER_URL || 'http://localhost:3000';
+  const CLOUD_MODE = opts.cloud === true;
+
+  if (CLOUD_MODE) {
+    // In cloud mode, API_KEY is the CLOUD_ADMIN_KEY — not used for user auth.
+    // Per-account keys are fetched per-account from /api/cloud/grinders.
+    console.log('🌥️  Starting in CLOUD MODE — grinding all cloud-enabled accounts');
+  }
   REDIS_URL = process.env.REDIS_URL || '';
   WEBHOOK_URL = process.env.WEBHOOK_URL || '';
 
@@ -3089,7 +3186,7 @@ async function start(apiKey, apiUrl) {
   console.log(
     `  ${rgb(139, 92, 246)}v${PKG_VERSION}${c.reset}` +
     `  ${c.dim}·${c.reset}  ${c.white}${AccountWorker.COMMAND_MAP.length} Commands${c.reset}` +
-    `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}${CLUSTER_ENABLED ? 'Cluster Mode' : 'Standalone'}${c.reset}` +
+    `  ${c.dim}·${c.reset}  ${rgb(34, 211, 238)}${CLOUD_MODE ? 'Cloud Mode' : (CLUSTER_ENABLED ? 'Cluster Mode' : 'Standalone')}${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(52, 211, 153)}Auto-Recovery${c.reset}` +
     `  ${c.dim}·${c.reset}  ${rgb(251, 191, 36)}Loss Limiter${c.reset}`
   );
@@ -3097,12 +3194,38 @@ async function start(apiKey, apiUrl) {
 
   log('info', `${c.dim}Fetching accounts...${c.reset}`);
 
-  let data = await fetchConfig(4, 2000);
+  const fetchOpts = CLOUD_MODE ? { cloud: true } : {};
+  let data = await fetchConfig(4, 2000, fetchOpts);
   while (!data) {
     log('error', `Cannot connect to API`);
     log('warn', `Will retry in 10s (check internet/API URL if this repeats).`);
     await new Promise((r) => setTimeout(r, 10000));
-    data = await fetchConfig(4, 2000);
+    data = await fetchConfig(4, 2000, fetchOpts);
+  }
+
+  if (data && data.error) {
+    log('error', `${data.error}`);
+    return;
+  }
+
+  // Cloud mode: post heartbeat every 30s
+  if (CLOUD_MODE) {
+    const CLOUD_HEARTBEAT_MS = 30_000;
+    const postHeartbeat = async () => {
+      if (!process.env.REDIS_URL) return;
+      const uptime = Math.floor((Date.now() - startTime) / 1000);
+      const memMB = Math.round((process.memoryUsage?.rss?.() ?? process.memoryUsage().rss) / 1048576);
+      try {
+        await fetch(`${API_URL}/api/cloud/status`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${CLOUD_ADMIN_KEY}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ uptime, accounts: workers.filter(w => w.running).length, memMB, pid: process.pid }),
+        });
+      } catch {}
+    };
+    postHeartbeat();
+    setInterval(postHeartbeat, CLOUD_HEARTBEAT_MS);
+    log('info', `${rgb(159, 92, 246)}Cloud heartbeat started${c.reset} ${c.dim}(every ${CLOUD_HEARTBEAT_MS / 1000}s)${c.reset}`);
   }
 
   // Pull Redis/Webhook URLs from API config if not in env
@@ -3524,12 +3647,12 @@ async function start(apiKey, apiUrl) {
         parts.push(`${D}${pulse}♥?${c.reset}`);
       }
       if (parts.length > 0) {
-        console.log(`  ${c.dim}├${c.reset} ${c.bold}${w.username}${c.reset}  ${parts.join('  ')}`);
+        recentLogs.push({ ts: Date.now(), username: w.username, color: w.color, command: 'dm check', response: parts.join('  '), status: 'ok' });
       }
     } catch {}
   }
   if (dmNoLs.length > 0) {
-    console.log(`  ${rgb(239, 68, 68)}⚠${c.reset}  ${c.bold}${c.red}DM confirms 0 lifesavers:${c.reset} ${dmNoLs.join(', ')}`);
+    recentLogs.push({ ts: Date.now(), username: 'system', color: rgb(239, 68, 68), command: 'dm check', response: `⚠ No lifesavers: ${dmNoLs.join(', ')}`, status: 'warn' });
     // Set Redis keys to block crime/search
     for (const w of activeWorkers) {
       if (dmNoLs.includes(w.username) && redis) {
@@ -3541,7 +3664,7 @@ async function start(apiKey, apiUrl) {
     }
   }
   if (dmUnknown.length > 0) {
-    console.log(`  ${rgb(251, 191, 36)}⚠${c.reset}  ${c.dim}Lifesavers unknown — live DM monitor active:${c.reset} ${dmUnknown.join(', ')}`);
+    recentLogs.push({ ts: Date.now(), username: 'system', color: rgb(251, 191, 36), command: 'dm check', response: `⚠ Lifesavers unknown — live monitor: ${dmUnknown.join(', ')}`, status: 'warn' });
     // Crime/search on these accounts will be skipped via safety hold until the live
     // DM gateway listener detects a death (→ sets count) or confirms clean.
   }
@@ -3549,7 +3672,7 @@ async function start(apiKey, apiUrl) {
   if (dmDeaths > 0) dmSummaryParts.push(`${dmDeaths} deaths`);
   if (dmLevelUps > 0) dmSummaryParts.push(`${dmLevelUps} level-ups`);
   if (dmUnknown.length > 0) dmSummaryParts.push(`${dmUnknown.length} pending`);
-  console.log(`  ${rgb(52, 211, 153)}✓${c.reset}  ${c.bold}DM check${c.reset}  ${dmSummaryParts.length > 0 ? c.dim + dmSummaryParts.join(', ') + c.reset : c.dim + 'clean — no deaths or level-ups' + c.reset}`);
+  recentLogs.push({ ts: Date.now(), username: 'system', color: rgb(52, 211, 153), command: 'dm check', response: dmSummaryParts.length > 0 ? dmSummaryParts.join(', ') : 'clean — no deaths or level-ups', status: 'ok' });
   console.log('');
 
   console.log(`  ${rgb(139, 92, 246)}${c.bold}>>>${c.reset}  ${gradientText('Starting grind loops...', [139, 92, 246], [52, 211, 153])}`);

package/package.json

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