@tigorhutasuhut/claude-retry 0.1.7 → 0.1.9

package/README.md

@@ -1,6 +1,6 @@
 # claude-retry
 
-Watches every pane across **all** your [zellij](https://zellij.dev/) sessions. When a pane hits Anthropic's usage/session limit, it detects the on-screen rate-limit banner, then confirms against Anthropic's usage API — the same data the `/usage` command shows — to get the **exact** reset time and to discard stale banners. Once the reset elapses it clears the input and injects `continue` to resume automatically. One daemon covers every session at once — even detached ones.
+Watches every pane across **all** your [zellij](https://zellij.dev/) sessions. When a pane hits Anthropic's usage/session limit, it detects the on-screen rate-limit banner and cross-checks against Anthropic's usage API to get the **exact** reset time and discard stale or incidental banners. Once the reset elapses it clears the input and injects `continue` to resume automatically. One daemon covers every session at once — even detached ones.
 
 ## Install
 
@@ -55,20 +55,34 @@ source "$(npm root -g)/claude-retry/shell/wrapper.bash"
 
 ## How it works
 
-Every pass (60s for `start`, 5s for single-pane `monitor`):
+Every pass (60s for `start`):
 
-1. **Discover** — `zellij list-sessions` enumerates live sessions (EXITED ones and the daemon's own `$ZELLIJ_SESSION_NAME` are skipped). For each, `zellij --session <name> action list-panes -j` lists its panes; plugins and exited panes are dropped. New panes are added, gone ones pruned.
-2. **Capture** — each pane's visible screen is dumped with `zellij --session <name> action dump-screen --pane-id <id>` (ANSI stripped). This works on detached sessions, no attached client required.
-3. **Match** — the text is checked against the rate-limit patterns. Panes that aren't showing a limit banner are simply left alone.
-4. **Resolve** — on a banner match, the reset time is determined via a three-tier cascade:
-   - **Tier 1 — usage API (primary).** Once per pass, the daemon discovers every Claude account in use by reading `CLAUDE_CONFIG_DIR` from each Claude process via `/proc` (Linux). For each account it calls `GET https://api.anthropic.com/api/oauth/usage` with the OAuth token from `<CLAUDE_CONFIG_DIR>/.credentials.json`. If the account is **not** limited the banner is stale — it is silently ignored, no wait issued. If the account **is** limited the daemon waits until the API's exact `resets_at` timestamp. Credentials are re-read every pass, so token refreshes are picked up automatically.
-   - **Tier 2 — /proc pane→account bridge (planned).** Needed only when two or more accounts are limited simultaneously, so the daemon must map a specific pane to its account. This is a phase-2 stub; until implemented, that case falls through to tier 3.
-   - **Tier 3 — text fallback.** Used when the API is unreachable, the account is unknown, or tier 2 is unresolved. Falls back to parsing the reset time from the on-screen banner text (the original behavior). A banner is never silently ignored when the account is unknown — this ensures a real limit is never missed.
-5. **Retry** — once the resolved reset time elapses, the daemon sends **Ctrl+C** (clears any half-typed input — a single Ctrl+C in Claude Code doesn't quit), then types `continue` and Enter via `write-chars` / `write`.
+1. **Discover** — `zellij list-sessions` enumerates live sessions (EXITED ones and the daemon's own `$ZELLIJ_SESSION_NAME` are skipped). For each, `zellij --session <name> action list-panes -j` lists its panes; plugins and exited panes are dropped. New panes are added; gone panes are tracked via a miss-counter and dropped only after **3 consecutive absent passes**, so a transient `list-panes` hiccup never loses a pane mid-wait.
+2. **Capture** — each pane's visible screen is dumped with `zellij --session <name> action dump-screen --pane-id <id>` (ANSI stripped). Works on detached sessions — no attached client required.
+3. **Signal check** — the screen is checked for two signals:
+   - **Loose banner match** — any rate-limit text present anywhere on screen (candidate trigger).
+   - **Canonical banner** (`isBlockedAtBanner`) — a high-confidence match anchored to the **bottom** of the screen, meaning Claude is parked at the limit right above its input box. This distinguishes an active block from incidental banner text in scrollback.
+4. **API call (conditional)** — the usage API (`GET https://api.anthropic.com/api/oauth/usage`) is called **only** when at least one pane shows a banner or is already waiting. Zero API calls when nothing is limited. Account is resolved as: the sole account on the machine, else the sole limited account, else via the Linux `/proc` bridge (pane → pts → `CLAUDE_CONFIG_DIR`), else unknown.
+5. **State machine per pane:**
 
-Per-pane state (keyed by `session:paneId`) persists across passes, so a pane mid-wait isn't disturbed by rediscovery. It runs as a plain foreground process — no transparent session wrapping, no external daemon. The zellij pane is the daemon.
+   **MONITORING:**
+   - No banner → idle, nothing to do.
+   - Banner + account **LIMITED** → enter WAITING until `resets_at`.
+   - Banner + account **CLEARED** → if a canonical banner sits at the bottom (Claude restarted after reset, or a reopened `claude --continue` left idle) → inject `continue`; otherwise ignore (stale or scrollback text — no false triggers).
+   - Banner + account **UNKNOWN** (API down) → parse reset time from on-screen text; future → enter WAITING; already-passed → inject `continue` if canonical banner at bottom, else ignore. A bare past time means the limit already reset — it is never rolled to tomorrow.
 
-> **Multi-account note.** On Linux, account discovery reads `CLAUDE_CONFIG_DIR` from every live Claude process via `/proc`. This means the daemon polls usage for every account in use — not just the default one. On non-Linux systems it falls back to the default account (`~/.claude`) plus tier-3 text parsing.
+   **WAITING:**
+   - Banner gone → abandon (Claude exited, user continued, or pane ID reused).
+   - Account cleared **or** timer elapsed → inject `continue`.
+   - Account still limited → keep waiting; `resets_at` refreshed live each pass.
+
+6. **Inject** — Ctrl+C (clears any half-typed input; one Ctrl+C does not quit Claude Code), then `continue` + Enter via `write-chars` / `write`.
+
+Per-pane state (keyed by `session:paneId`) persists across passes. Runs as a plain foreground process — the zellij pane is the daemon.
+
+> **Single-pane `monitor <id>` mode** is text-only: no account API, just screen scraping against the current session.
+
+> **Multi-account (Linux).** Account discovery reads `CLAUDE_CONFIG_DIR` from every live Claude process via `/proc` and polls usage for each account. On non-Linux the daemon uses the default account (`~/.claude`) and falls back to on-screen time parsing when the API is unavailable.
 
 ## Requirements
 

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';
@@ -117,8 +133,8 @@ async function tickTarget(target, state, screenText, deps, marginSeconds, fallba
 export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fallbackHours) {
     const state = createState();
     for (;;) {
-        await deps.sleep(pollIntervalMs ?? 5000);
         await tick(paneId, state, deps, marginSeconds, fallbackHours);
+        await deps.sleep(pollIntervalMs ?? 5000);
     }
 }
 /**
@@ -233,8 +249,8 @@ function logPaneStatus(log, label, before, state, status) {
 export async function runMultiMonitor(deps, pollIntervalMs, marginSeconds, fallbackHours) {
     const states = new Map();
     for (;;) {
-        await deps.sleep(pollIntervalMs ?? 60000);
         await multiTick(states, deps, marginSeconds, fallbackHours);
+        await deps.sleep(pollIntervalMs ?? 60000);
     }
 }
 //# sourceMappingURL=monitor.js.map

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.9",
   "description": "Monitor Claude CLI in a zellij pane, auto-inject continue on rate-limit",
   "type": "module",
   "license": "MIT",