dankgrinder 7.1.0 → 7.7.0

package/lib/commands/farm.js

@@ -4,6 +4,7 @@ const {
   isCV2, ensureCV2, stripAnsi, needsItem, clickCV2SelectMenu,
 } = require('./utils');
 const { buyItem, buyItemsBatch } = require('./shop');
+const rawLogger = require('../../lib/rawLogger');
 const {
   downloadImage,
   extractFarmImageUrl,
@@ -474,8 +475,8 @@ function getVisionRepairPlan(actionName, score) {
   }
   if (actionName === 'hoe') {
     const planted = score.ratios?.planted || 0;
-    const wet = score.ratios?.wet || 0;
-    if ((planted + wet) >= 0.45) {
+    const tilled = score.ratios?.tilled || 0;
+    if (planted >= 0.30 || tilled >= 0.30) {
       // Farm likely already progressed beyond hoe stage.
       return null;
     }
@@ -488,10 +489,9 @@ function getVisionRepairPlan(actionName, score) {
 function inferNextActionFromScore(actionName, score) {
   if (!score) return null;
   const planted = score.ratios?.planted || 0;
-  const wet = score.ratios?.wet || 0;
   const tilled = score.ratios?.tilled || 0;
 
-  if (actionName === 'hoe' && (planted + wet) >= 0.45) {
+  if (actionName === 'hoe' && (planted + tilled) >= 0.45) {
     return 'water';
   }
   if (actionName === 'water' && planted >= 0.45) {
@@ -515,16 +515,14 @@ async function inferPreferredActionFromImage(msg) {
     const slots = Math.max(1, (analysis?.rows || 3) * (analysis?.cols || 3));
     const ratios = {
       tilled: (analysis?.counts?.tilled || 0) / slots,
-      wet: (analysis?.counts?.wet || 0) / slots,
       planted: (analysis?.counts?.planted || 0) / slots,
       unknown: (analysis?.counts?.unknown || 0) / slots,
     };
 
     let suggested = null;
-    // Image-first phase routing.
-    if (ratios.planted >= 0.45) suggested = 'plant';
-    else if (ratios.wet >= 0.35) suggested = 'plant';
-    else if (ratios.tilled >= 0.35) suggested = 'water';
+    // Image-first phase routing (3-state: tilled/planted/unknown, no separate wet state).
+    if (ratios.planted >= 0.30) suggested = 'plant';
+    else if (ratios.tilled >= 0.30) suggested = 'water';
     else suggested = 'hoe';
 
     let dbg = null;
@@ -541,7 +539,6 @@ async function inferPreferredActionFromImage(msg) {
 
     LOG.info(`[farm:phase-image] url=${url} grid=${gridToString(analysis)} counts=${JSON.stringify(analysis.counts)} conf=${analysis.avgConfidence} suggested=${suggested} ratios=${JSON.stringify({
       tilled: +ratios.tilled.toFixed(3),
-      wet: +ratios.wet.toFixed(3),
       planted: +ratios.planted.toFixed(3),
       unknown: +ratios.unknown.toFixed(3),
     })}`);
@@ -942,6 +939,17 @@ function pickFarmActionButton(msg, text) {
   return null;
 }
 
+// Captures the ephemeral interaction response content from a CV2 ack object.
+// Dank Memer sends error/success text in the interaction ACK (type 4/7) content field.
+function captureCvvAckContent(ack) {
+  if (!ack) return '';
+  const flags = ack?.flags ?? ack?.data?.flags ?? 0;
+  const content = String(stripAnsi(ack?.content || ack?.data?.content || '')).trim();
+  if (!content) return '';
+  const isEphemeral = (flags & 64) !== 0;
+  return `[ephemeral=${isEphemeral}] ${content}`;
+}
+
 async function clickAndCapture({ channel, waitForDankMemer, response, button, tag, timeoutMs = 9000 }) {
   const baseline = brief(getFullText(response), 400);
   const clickRes = await safeClickButton(response, button);
@@ -951,7 +959,30 @@ async function clickAndCapture({ channel, waitForDankMemer, response, button, ta
     delete response._lastInteractionAck;
   }
 
-  let post = clickRes || null;
+  // CV2 HTTP fallback returns the interaction ACK (not the updated message).
+  // If clickRes looks like an ack rather than a message, extract it and wait for
+  // the edited message instead.
+  const isAckObject = clickRes && typeof clickRes === 'object' && !clickRes.id && (clickRes.interactionStatus || clickRes.interactionType);
+  const capturedAck = isAckObject ? clickRes : null;
+
+  // Register a one-time callback to capture ephemeral responses (e.g. "You harvested: Nothing")
+  // from the raw gateway packet — the only place where ephemeral embeds/CV2 text are preserved.
+  let capturedEphemeral = null;
+  rawLogger.onNextEphemeral((parsed) => {
+    capturedEphemeral = parsed;
+    const cv2t = parsed.cv2Text || '';
+    const allt = parsed.allText || '';
+    const txt = cv2t || allt;
+    if (txt.includes('harvested')) LOG.info(`${tag}-ephemeral harvest: ${txt.slice(0, 200)}`);
+    else LOG.info(`${tag}-ephemeral ${txt.slice(0, 200)}`);
+  });
+
+  // Extra grace period: the ephemeral often arrives after safeClickButton resolves
+  // (the library may return the stale message immediately, before the gateway delivers the
+  // ephemeral). This ensures we capture it even when it arrives late.
+  await sleep(1500);
+
+  let post = (!isAckObject && clickRes) ? clickRes : null;
   if (!post && response.id) post = await waitForEditedMessage(channel, response.id, baseline, timeoutMs);
   if (!post) post = await waitForDankMemer(timeoutMs);
 
@@ -960,17 +991,23 @@ async function clickAndCapture({ channel, waitForDankMemer, response, button, ta
 
   // Capture any additional immediate callback message (often ephemeral-like
   // "only you can see this" notices) that may be separate from edited CV2 post.
+  let extraMsg = null;
   try {
     const side = await waitForDankMemer(1500);
     if (side && side.id !== post.id) {
       logEphemeralLike(`${tag}-post-extra`, side);
-      post._farmExtraInteraction = side;
+      extraMsg = side;
     }
   } catch {}
 
   if (isCV2(post)) await ensureCV2(post);
   logMsg(post, tag);
   logFarmState(tag, post);
+
+  // Attach captured ack and extra message so callers can access them.
+  post._capturedAck = capturedAck;
+  post._farmExtraMsg = extraMsg;
+  post._capturedEphemeral = capturedEphemeral;
   return post;
 }
 
@@ -1117,31 +1154,30 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
     const slots = Math.max(1, (imageAnalysis.rows || 3) * (imageAnalysis.cols || 3));
     const ratios = {
       tilled: (imageAnalysis.counts?.tilled || 0) / slots,
-      wet: (imageAnalysis.counts?.wet || 0) / slots,
       planted: (imageAnalysis.counts?.planted || 0) / slots,
       unknown: (imageAnalysis.counts?.unknown || 0) / slots,
     };
 
-    // Phase-aware selection: pick the earliest incomplete phase.
-    // Harvest when planted >= 45%.
-    if (ratios.planted >= 0.45) {
+    // Phase-aware selection: pick the earliest incomplete phase (3-state model).
+    // Harvest when planted >= 30%.
+    if (ratios.planted >= 0.30) {
       const btn = managedActions.harvest || btns.find(b => hasAny(b, ['harvest', 'reap', 'collect']));
       if (btn) return { action: 'harvest', button: btn, reason: `harvest-ready-vision(planted=${ratios.planted.toFixed(2)})` };
     }
-    // Plant when wet >= 45% or tilled >= 45%.
-    if (ratios.wet >= 0.45 || ratios.tilled >= 0.45) {
+    // Plant when tilled >= 30%.
+    if (ratios.tilled >= 0.30) {
       const btn = managedActions.plant || btns.find(b => hasAny(b, ['plant', 'seed', 'sow']));
-      if (btn) return { action: 'plant', button: btn, reason: `plant-vision(wet=${ratios.wet.toFixed(2)},tilled=${ratios.tilled.toFixed(2)})` };
+      if (btn) return { action: 'plant', button: btn, reason: `plant-vision(tilled=${ratios.tilled.toFixed(2)})` };
     }
-    // Water when we have tilled tiles but not enough wet.
-    if (ratios.tilled >= 0.35 && ratios.wet < 0.35) {
+    // Water when we have tilled tiles.
+    if (ratios.tilled >= 0.15) {
       const btn = managedActions.water || btns.find(b => hasAny(b, ['water', 'watering']));
-      if (btn) return { action: 'water', button: btn, reason: `water-vision(tilled=${ratios.tilled.toFixed(2)},wet=${ratios.wet.toFixed(2)})` };
+      if (btn) return { action: 'water', button: btn, reason: `water-vision(tilled=${ratios.tilled.toFixed(2)})` };
     }
     // Hoe when farm is mostly unknown/empty.
-    if (ratios.tilled < 0.35 && ratios.wet < 0.35 && ratios.planted < 0.35) {
+    if (ratios.tilled < 0.15 && ratios.planted < 0.30) {
       const btn = managedActions.hoe || btns.find(b => hasAny(b, ['hoe', 'till']));
-      if (btn) return { action: 'hoe', button: btn, reason: `hoe-vision(t=${ratios.tilled.toFixed(2)},w=${ratios.wet.toFixed(2)},p=${ratios.planted.toFixed(2)})` };
+      if (btn) return { action: 'hoe', button: btn, reason: `hoe-vision(t=${ratios.tilled.toFixed(2)},p=${ratios.planted.toFixed(2)})` };
     }
   }
 
@@ -1177,11 +1213,20 @@ async function advancePastConfirmation(response, waitForDankMemer) {
   if (!response) return null;
 
   const CONFIRM_WORDS = ['continue', 'confirm', 'confirm all', 'done', 'back to farm', 'back', 'close'];
+  // Also treat "All" buttons as confirmation actions (e.g. "Hoe All", "Water All").
+  // Skip the plain "back" word to avoid matching the Back arrow button; prefer explicit
+  // confirm words first, then fall back to "All" buttons as confirmation.
+  const ALL_AS_CONFIRM = ['hoe all', 'water all', 'plant all', 'harvest all', 'fertilize all'];
   const MAX_PAGES = 3;
 
   for (let page = 0; page < MAX_PAGES; page++) {
     const btns = getAllButtons(response).filter(b => !b.disabled);
-    const confirmBtn = btns.find(b => CONFIRM_WORDS.some(w => buttonHay(b).includes(w)));
+    let confirmBtn = btns.find(b => CONFIRM_WORDS.some(w => buttonHay(b).includes(w)));
+    // Also treat "All" buttons as confirmation (e.g. clicking "Plant All" again on the
+    // confirmation screen advances past it). But prefer explicit confirm words first.
+    if (!confirmBtn) {
+      confirmBtn = btns.find(b => ALL_AS_CONFIRM.some(w => buttonHay(b).includes(w)));
+    }
 
     if (!confirmBtn) {
       // No more confirmation buttons — return the current screen (should be manage menu)
@@ -1197,6 +1242,18 @@ async function advancePastConfirmation(response, waitForDankMemer) {
     try {
       clicked = await safeClickButton(response, confirmBtn);
       logEphemeralLike(`confirm-page-${page}`, clicked);
+      // Preserve CV2 ack so cycle can check for ephemeral errors.
+      if (clicked?._lastInteractionAck) {
+        response._lastInteractionAck = clicked._lastInteractionAck;
+      }
+      // Also capture ephemeral ack content for logging
+      const ackContent = captureCvvAckContent(clicked);
+      if (ackContent) {
+        const flags = clicked?.flags ?? 0;
+        const isEphemeral = (flags & 64) !== 0;
+        const level = isEphemeral ? LOG.warn : LOG.info;
+        level(`[farm:confirm:${page}] ephemeral=${isEphemeral} ack="${ackContent.slice(0, 300)}"`);
+      }
     } catch (e) {
       LOG.warn(`[farm:confirm] click failed on page ${page}: ${e.message}`);
       return response;
@@ -1240,7 +1297,7 @@ async function advancePastConfirmation(response, waitForDankMemer) {
 // ── Single-cycle farm orchestrator ──────────────────────────────────────────
 // Sends `pls farm view` once, then completes the full hoe→water→plant→harvest
 // cycle by looping on the returned manage menu — no additional command sends.
-async function runFarm({ channel, waitForDankMemer, client, redis, accountId }) {
+async function runFarm({ channel, waitForDankMemer, client, redis, accountId, forceRun }) {
   LOG.cmd(`${c.white}${c.bold}pls farm view${c.reset}`);
 
   await channel.send('pls farm view');
@@ -1296,7 +1353,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   if (textHasHarvestReady) LOG.info(`[farm] DETECTED harvest-ready in text (growReadySec=${growReadySec})`);
   if (growReadySec > 0) LOG.info(`[farm] GROW-QUEUE DEBUG: lower=${lower.slice(0, 400)}`);
   LOG.info(`[farm] grow-ready parse=${growReadySec == null ? 'none' : `${growReadySec}s`} redis_recovery=${redisRecoveryMs != null ? `${redisRecoveryMs}ms` : 'n/a'}`);
-  if (!redisRecovered && growReadySec && growReadySec > 20) {
+  if (!forceRun && !redisRecovered && growReadySec && growReadySec > 20) {
     await inferPreferredActionFromImage(response);
     // Re-check every 30s instead of waiting the full grow duration.
     // This ensures the next harvest cycle starts as soon as crops are ready.
@@ -1433,6 +1490,30 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
           label.includes('plant all') || label.includes('harvest all') || label.includes('confirm')) && b.disabled;
       });
       if (disabledAllBtn) {
+        // For harvest: disabled means nothing to harvest — skip to hoe.
+        // For hoe/water/plant: disabled means we don't have the item — try to buy it.
+        const ITEM_FOR_ACTION = { hoe: 'Hoe', water: 'Watering Can', plant: 'Seeds' };
+        const missingItem = ITEM_FOR_ACTION[action];
+        if (missingItem) {
+          LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled — trying to buy ${missingItem}`);
+          const bought = await tryBuyFarmItem({ missing: missingItem, channel, waitForDankMemer, client });
+          if (bought.ok) {
+            LOG.success(`[farm:cycle:${cycleDepth}] Bought ${bought.itemName} — retrying ${action}`);
+            await sleep(1200);
+            // Restart the cycle from farm view to refresh button state
+            await channel.send('pls farm view');
+            const re = await waitForDankMemer(12000);
+            if (!re) { LOG.warn('[farm:cycle] no response after buy retry'); break; }
+            if (isCV2(re)) await ensureCV2(re);
+            cycleResponse = re;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+            initialAnalysis = null;
+            continue;
+          } else {
+            LOG.warn(`[farm:cycle:${cycleDepth}] Could not buy ${missingItem} — skipping to next phase`);
+          }
+        }
         const currentIdx = FARM_PHASE_ORDER.indexOf(action);
         const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
         LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled (no-op) — next=${nextPhase || 'done'}`);
@@ -1460,12 +1541,98 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     // Step 5: advance past any confirmation screens back to the manage menu
     cycleResponse = await advancePastConfirmation(lastApplyResp, waitForDankMemer);
     if (!cycleResponse) { LOG.warn('[farm:cycle] confirmation advance returned null'); break; }
+    if (isCV2(cycleResponse)) await ensureCV2(cycleResponse);
     actionsTaken++;
     lastAction = action;
     text = getFullText(cycleResponse);
     clean = brief(text, 600);
     logFarmState('after-confirm', cycleResponse);
 
+    // ── Farm text detection: determine next action from farm state ─────────────────
+    // After confirmation advances, we may be on the farm view (no action tabs visible).
+    // Use farm text patterns to determine what to do next — this is more reliable
+    // than the button state check (which fails on the farm view).
+    {
+      const postBtns = getAllButtons(cycleResponse);
+      const postActionBtns = postBtns.filter(b => !b.disabled && !isNavOrUtilityButton(b));
+      const postHasActionTabs = postActionBtns.some(b => hasAny(b, ['hoe', 'water', 'plant', 'harvest', 'fertiliz']));
+      const postLower = clean.toLowerCase();
+      const hasSeedsReady = /seeds ready|seeds.*ready|planted|crop.*ready/i.test(postLower);
+      const hasHarvestReady = /ready to harvest|harvest ready|can be harvest|can harvest|wilt/i.test(postLower);
+      const isEmpty = /pretty empty|seems empty|empty\.{0,3}/i.test(postLower) && !hasSeedsReady && !hasHarvestReady;
+      if (!postHasActionTabs && !isEmpty) {
+        // Farm has crops (planted/growing). Force harvest.
+        // cycleResponse is still the farm view (no action tabs) after advancePastConfirmation.
+        // Re-enter the manage menu so findNextFarmActionFromManage has buttons to work with.
+        const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+        if (mb) {
+          LOG.info(`[farm:cycle:${cycleDepth}] farm-text: re-entering manage menu to force harvest`);
+          const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: 'farm-farmtext-harvest-manage' });
+          if (mr) {
+            if (isCV2(mr)) await ensureCV2(mr);
+            cycleResponse = mr;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+          }
+        }
+        forcedNextAction = 'harvest';
+        lastAction = null;
+        cycleDepth++;
+        initialAnalysis = null;
+        await sleep(300);
+        continue;
+      }
+      if (!postHasActionTabs && isEmpty) {
+        // Farm is empty after the action. Re-enter manage menu before forcing hoe.
+        const mb = findFarmButton(cycleResponse, ['manage', 'farm-farm:manage']);
+        if (mb) {
+          LOG.info(`[farm:cycle:${cycleDepth}] farm-text: re-entering manage menu (empty farm)`);
+          const mr = await clickAndCapture({ channel, waitForDankMemer, response: cycleResponse, button: mb, tag: 'farm-farmtext-hoe-manage' });
+          if (mr) {
+            if (isCV2(mr)) await ensureCV2(mr);
+            cycleResponse = mr;
+            text = getFullText(cycleResponse);
+            clean = brief(text, 600);
+          }
+        }
+        forcedNextAction = 'hoe';
+        lastAction = null;
+        cycleDepth++;
+        initialAnalysis = null;
+        await sleep(300);
+        continue;
+      }
+      // Otherwise: we're on manage menu or have action tabs — proceed to find next action.
+    }
+
+    // ── Harvest ephemeral: parse "You harvested: Nothing" to detect no-op ──────────
+    if (action === 'harvest') {
+      const ephemeral = lastApplyResp?._capturedEphemeral;
+      if (ephemeral) {
+        const cv2t = ephemeral.cv2Text || '';
+        const allt = ephemeral.allText || '';
+        const harvestText = cv2t || allt;
+        LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] "${harvestText.slice(0, 300)}"`);
+        // If nothing was harvested, cells are now empty (post-harvest debris).
+        // Force the cycle to proceed to hoe rather than re-analyzing the same state.
+        if (/nothing|0\s*x\s*\w|no\s+crops|\bnone\b/i.test(harvestText)) {
+          LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] Nothing harvested — forcing next action to hoe`);
+          forcedNextAction = 'hoe';
+          lastAction = 'harvest';
+          cycleDepth++;
+          initialAnalysis = null;
+          await sleep(300);
+          continue;
+        }
+        // Something was actually harvested — parse what and log it.
+        const itemMatches = [...harvestText.matchAll(/-?\s*(\d+)\s*x?\s*([A-Za-z]+)/g)];
+        if (itemMatches.length > 0) {
+          const items = itemMatches.map(m => `${m[1]}x ${m[2]}`).join(', ');
+          LOG.info(`[farm:cycle:${cycleDepth}:harvest-ephemeral] Harvested: ${items}`);
+        }
+      }
+    }
+
     // If confirmation screen is identical to post-confirmation screen,
     // check whether we're on a planted confirmation (Dank Memer planted crops
     // and shows "ready at X"). In that case, click "Back" to return to the
@@ -1537,17 +1704,38 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
     const score = scoreResult?.score || null;
     const nextAction = inferNextActionFromScore(action, score);
 
+    // Collect all error/rejection text sources:
+    // 1. Extra follow-up messages from farm actions
+    // 2. CV2 interaction ACK (ephemeral or success/error response)
+    // 3. The main message text after the action
+    const ackContent = captureCvvAckContent(lastApplyResp?._capturedAck);
+    const extraContent = lastApplyResp?._farmExtraMsg
+      ? String(stripAnsi(getFullText(lastApplyResp._farmExtraMsg) || '')).replace(/\s+/g, ' ').trim()
+      : '';
+    const postContent = String(stripAnsi(getFullText(lastApplyResp) || '')).replace(/\s+/g, ' ').trim();
+
+    if (ackContent || extraContent) {
+      const flags = lastApplyResp?._capturedAck?.flags ?? 0;
+      const isEphemeral = (flags & 64) !== 0;
+      const level = isEphemeral ? LOG.warn : LOG.info;
+      level(`[farm:cycle:${cycleDepth}:ephemeral] ephemeral=${isEphemeral} ack="${ackContent.slice(0, 300)}" extra="${extraContent.slice(0, 200)}"`);
+    }
+
+    // Build combined error text for rejection detection
+    const allErrorText = [extraContent, ackContent].filter(Boolean).join(' ');
+
     // Handle rejection messages that indicate wrong phase.
-    const extraText = String(stripAnsi(getFullText(cycleResponse?._farmExtraInteraction) || '')).toLowerCase();
-    if (action === 'plant' && /only\s+plant\s+seeds\s+on\s+an\s+empty\s+tile|tilled\s+and\s+watered/.test(extraText)) {
-      LOG.warn('[farm:cycle] Plant rejected — need hoe first. Restarting from hoe.');
+    if (action === 'plant' && /only\s+plant\s+seeds\s+on\s+an\s+empty\s+tile|tilled\s+and\s+watered|can only plant seeds on an empty tile/.test(allErrorText)) {
+      LOG.warn(`[farm:cycle] Plant rejected — need hoe+water first. Restarting from hoe. err="${allErrorText.slice(0, 200)}"`);
+      forcedNextAction = 'hoe';
       lastAction = null;
       cycleDepth++;
       await sleep(400);
       continue;
     }
-    if (action === 'hoe' && /can only use.*hoe.*empty tile|after a harvest/.test(extraText)) {
+    if (action === 'hoe' && /can only use.*hoe.*empty tile|after a harvest/.test(allErrorText)) {
       LOG.warn('[farm:cycle] Hoe rejected — moving to water phase.');
+      forcedNextAction = 'water';
       lastAction = 'hoe';
       cycleDepth++;
       await sleep(400);
@@ -1556,6 +1744,22 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
 
     if (!nextAction) {
       LOG.info(`[farm:cycle:${cycleDepth}] ${action} done — no next action (score=${score?.score ?? '?'}/${score?.threshold ?? '?'}, conf=${score?.confidence ?? '?'})`);
+      // Enforce strict phase ordering: after water → harvest. Never route to plant from image analysis.
+      if (action === 'water') {
+        const harvestIdx = FARM_PHASE_ORDER.indexOf('harvest');
+        if (harvestIdx >= 0) {
+          const harvestBtn = managedActions.harvest || getAllButtons(cycleResponse).find(b => hasAny(b, ['harvest', 'reap', 'collect']));
+          if (harvestBtn) {
+            LOG.info(`[farm:cycle:${cycleDepth}] enforcing harvest after water (strict phase order)`);
+            forcedNextAction = 'harvest';
+            cycleDepth++;
+            lastAction = 'water';
+            initialAnalysis = null;
+            await sleep(300);
+            continue;
+          }
+        }
+      }
       break;
     }