@tigorhutasuhut/claude-retry 0.1.7 → 0.1.8

package/dist/monitor.js

@@ -1,4 +1,4 @@
-import { match } from "./patterns.js";
+import { match, isBlockedAtBanner } from "./patterns.js";
 import { parseResetTime, calculateWaitMs } from "./time-parser.js";
 const MAX_MISSES = 3;
 export function createState() {
@@ -79,7 +79,13 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
             const { dir: accountDir, usage } = await resolveAccountUsage(snapshot, resolvePaneAccount, target);
             if (accountDir !== null && usage !== undefined) {
                 if (!usage.limited) {
-                    // Staleness gate: account is not limited → banner is stale → ignore
+                    // Account cleared. Either truly stale/incidental, OR a pane parked at a
+                    // limit banner whose quota just reset (restart-after-reset / reopened-idle).
+                    if (isBlockedAtBanner(screenText)) {
+                        await injectContinue();
+                        logger(`${label} cleared-limit banner at bottom — injected continue`);
+                        return 'retried';
+                    }
                     logger(`${label} stale banner ignored (account not limited)`);
                     return 'monitoring';
                 }
@@ -101,6 +107,16 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
         const resetLine = result.resetLine ?? '';
         const parsed = parseResetTime(resetLine);
         const waitMs = calculateWaitMs(parsed, marginSeconds, fallbackHours, new Date(now));
+        if (waitMs <= 0) {
+            // Reset time already passed → limit is over (no roll-to-tomorrow).
+            if (isBlockedAtBanner(screenText)) {
+                await injectContinue();
+                logger(`${label} reset already passed — injected continue`);
+                return 'retried';
+            }
+            logger(`${label} stale banner ignored (reset already passed)`);
+            return 'monitoring';
+        }
         state.waitUntil = now + waitMs;
         state.status = 'waiting';
         return 'rate-limited';

package/dist/patterns.d.ts

@@ -4,4 +4,6 @@ export interface MatchResult {
     resetLine: string | null;
 }
 export declare function match(text: string): MatchResult;
+export declare function strictMatch(text: string): boolean;
+export declare function isBlockedAtBanner(text: string, bottomLines?: number): boolean;
 //# sourceMappingURL=patterns.d.ts.map

package/dist/patterns.js

@@ -47,4 +47,37 @@ export function match(text) {
     }
     return { limited: false, resetLine: null };
 }
+// Canonical Claude rate-limit banner phrasings — specific enough not to fire on
+// normal code/output. Used for high-confidence detection.
+const STRICT_PATTERNS = [
+    /you(?:'ve|'ve|'ve|\s+have)\s+hit\s+your\s+(?:usage|session)\s+limit/i,
+    /\d+-hour\s+limit\s+reached/i,
+    /usage\s+limit\s+reached/i,
+    /session\s+limit\b.*\bresets/i,
+    /upgrade\s+to\s+increase\s+your\s+usage\s+limit/i,
+];
+export function strictMatch(text) {
+    const stripped = stripAnsi(text);
+    return STRICT_PATTERNS.some((p) => p.test(stripped));
+}
+// True when a canonical banner sits in the bottom region of the screen — i.e.
+// claude is parked at the limit message right above its input box, not merely
+// displaying banner text somewhere in scrollback/discussion.
+export function isBlockedAtBanner(text, bottomLines = 15) {
+    const stripped = stripAnsi(text);
+    const lines = stripped.split('\n');
+    // Trim trailing blank lines
+    let end = lines.length - 1;
+    while (end >= 0 && lines[end].trim() === '') {
+        end--;
+    }
+    // Collect last `bottomLines` non-empty lines
+    const nonEmpty = [];
+    for (let i = end; i >= 0 && nonEmpty.length < bottomLines; i--) {
+        if (lines[i].trim() !== '') {
+            nonEmpty.unshift(lines[i]);
+        }
+    }
+    return strictMatch(nonEmpty.join('\n'));
+}
 //# sourceMappingURL=patterns.js.map

package/dist/time-parser.js

@@ -99,17 +99,8 @@ export function calculateWaitMs(parsed, marginSeconds = 60, fallbackHours = 5, n
                 candidateUtcMs = corrected;
             }
             if (candidateUtcMs <= nowMs) {
-                // Tomorrow rollover — advance local midnight by one day
-                candidateLocalMs += 86400000;
-                candidateUtcMs = candidateLocalMs + tzOffset;
-                for (let i = 0; i < 3; i++) {
-                    const candidateDate = new Date(candidateUtcMs);
-                    const candidateTzOffset = getOffsetMs(timezone, candidateDate);
-                    const corrected = candidateLocalMs + candidateTzOffset;
-                    if (corrected === candidateUtcMs)
-                        break;
-                    candidateUtcMs = corrected;
-                }
+                // Reset time already passed — signal "already reset" (non-positive delta)
+                return candidateUtcMs - nowMs;
             }
             return candidateUtcMs - nowMs + marginSeconds * 1000;
         }
@@ -118,9 +109,10 @@ export function calculateWaitMs(parsed, marginSeconds = 60, fallbackHours = 5, n
             const nowMs = now.getTime();
             const nowDate = now;
             const midnight = Date.UTC(nowDate.getUTCFullYear(), nowDate.getUTCMonth(), nowDate.getUTCDate());
-            let candidateMs = midnight + h * 3600000 + minute * 60000;
+            const candidateMs = midnight + h * 3600000 + minute * 60000;
             if (candidateMs <= nowMs) {
-                candidateMs += 86400000;
+                // Reset time already passed — signal "already reset" (non-positive delta)
+                return candidateMs - nowMs;
             }
             return candidateMs - nowMs + marginSeconds * 1000;
         }
@@ -131,18 +123,16 @@ export function calculateWaitMs(parsed, marginSeconds = 60, fallbackHours = 5, n
         const amHour = hour === 12 ? 0 : hour;
         const waitAm = tryCalculate(amHour);
         const waitPm = tryCalculate(pmHour);
-        // Return the sooner positive wait
+        // Return the sooner positive wait; if both past, return least-negative (most recent reset)
         if (waitAm > 0 && waitPm > 0)
             return Math.min(waitAm, waitPm);
         if (waitAm > 0)
             return waitAm;
         if (waitPm > 0)
             return waitPm;
-        return fallbackMs;
+        // Both past: return closest-to-zero (most recent reset)
+        return Math.max(waitAm, waitPm);
     }
-    const wait = tryCalculate(hour);
-    if (wait <= 0)
-        return fallbackMs;
-    return wait;
+    return tryCalculate(hour);
 }
 //# sourceMappingURL=time-parser.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigorhutasuhut/claude-retry",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Monitor Claude CLI in a zellij pane, auto-inject continue on rate-limit",
   "type": "module",
   "license": "MIT",