@tigorhutasuhut/claude-retry 0.1.5 → 0.1.7

package/dist/monitor.js

@@ -47,33 +47,29 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
         const limited = match(screenText).limited;
         const { usage } = await resolveAccountUsage(snapshot, resolvePaneAccount, target);
         const marginMs = (marginSeconds ?? 60) * 1000;
-        // 1. Banner gone → limit cleared / claude exited / user already continued / pane reused
+        // Banner absent → claude exited / user already continued / pane id reused → nothing to continue.
         if (!limited) {
             state.status = 'monitoring';
             state.waitUntil = 0;
             logger(`${label} wait abandoned (banner gone)`);
             return 'monitoring';
         }
-        // 2. Account known and NOT limited → stale banner persisting → drop
-        if (usage !== undefined && !usage.limited) {
-            state.status = 'monitoring';
-            state.waitUntil = 0;
-            logger(`${label} wait abandoned (account not limited)`);
-            return 'monitoring';
-        }
-        // 3. Account known, still limited, with a fresh resetsAtMs → refresh waitUntil
+        // Account still limited with a known reset → keep waitUntil aligned to the live reset time.
         if (usage !== undefined && usage.limited && usage.resetsAtMs !== null) {
             state.waitUntil = usage.resetsAtMs + marginMs;
         }
-        // 4. Timer not elapsed → keep waiting
-        if (now < state.waitUntil) {
-            return 'rate-limited';
+        // The limit is over when the account quota has cleared (early/real reset) OR the timer elapsed.
+        const accountCleared = usage !== undefined && !usage.limited;
+        const timerElapsed = now >= state.waitUntil;
+        if (accountCleared || timerElapsed) {
+            await injectContinue();
+            state.status = 'monitoring';
+            state.waitUntil = 0;
+            logger(`${label} reset reached — injected continue`);
+            return 'retried';
         }
-        // 5. Elapsed + banner still present (+ account limited or unknown) → inject
-        await injectContinue();
-        state.status = 'monitoring';
-        state.waitUntil = 0;
-        return 'retried';
+        // Still limited, before reset → keep waiting.
+        return 'rate-limited';
     }
     // state.status === 'monitoring'
     const result = match(screenText);
@@ -115,8 +111,7 @@ export async function tick(paneId, state, deps, marginSeconds, fallbackHours) {
     const screenText = await deps.capture(paneId);
     return stepState(state, screenText, deps.now(), () => deps.inject(paneId, 'continue'), marginSeconds, fallbackHours);
 }
-async function tickTarget(target, state, deps, marginSeconds, fallbackHours, snapshot) {
-    const screenText = await deps.capture(target);
+async function tickTarget(target, state, screenText, deps, marginSeconds, fallbackHours, snapshot) {
     return stepState(state, screenText, deps.now(), () => deps.inject(target, 'continue'), marginSeconds, fallbackHours, snapshot, deps.resolvePaneAccount, target, deps.log);
 }
 export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fallbackHours) {
@@ -150,16 +145,6 @@ export async function multiTick(states, deps, marginSeconds, fallbackHours) {
         log('scan failed: could not list sessions/panes (will retry)');
         return;
     }
-    // Fetch account snapshot once per pass (swallow errors → undefined).
-    let snapshot;
-    if (deps.getAccountSnapshot !== undefined) {
-        try {
-            snapshot = await deps.getAccountSnapshot();
-        }
-        catch {
-            snapshot = undefined;
-        }
-    }
     // Prune state for panes that no longer exist, using miss counter to tolerate
     // transient list-panes failures.
     const live = new Set(targets.map((t) => t.label));
@@ -179,7 +164,38 @@ export async function multiTick(states, deps, marginSeconds, fallbackHours) {
     log(targets.length === 0
         ? 'scan: no Claude panes found'
         : `scan: watching ${targets.length} Claude pane(s) [${targets.map((t) => t.label).join(', ')}]`);
+    // Capture each target's screen once, collecting successes into a map.
+    // Capture failures are logged and that pane is skipped this round.
+    const screens = new Map();
+    for (const target of targets) {
+        try {
+            screens.set(target.label, await deps.capture(target));
+        }
+        catch {
+            log(`${target.label} — capture error (skipped this round)`);
+        }
+    }
+    // Decide whether usage API is needed this pass:
+    // - any pane already in 'waiting' state (among current targets), OR
+    // - any captured screen has a limit banner.
+    const anyWaiting = targets.some((t) => states.get(t.label)?.status === 'waiting');
+    const anyBanner = [...screens.values()].some((s) => match(s).limited);
+    const needUsage = anyWaiting || anyBanner;
+    // Fetch account snapshot only when needed (swallow errors → undefined).
+    let snapshot;
+    if (needUsage && deps.getAccountSnapshot !== undefined) {
+        try {
+            snapshot = await deps.getAccountSnapshot();
+        }
+        catch {
+            snapshot = undefined;
+        }
+    }
     for (const target of targets) {
+        const screenText = screens.get(target.label);
+        // Skip panes whose capture failed this round.
+        if (screenText === undefined)
+            continue;
         let state = states.get(target.label);
         if (!state) {
             state = createState();
@@ -190,12 +206,12 @@ export async function multiTick(states, deps, marginSeconds, fallbackHours) {
         state.missCount = 0;
         const before = state.status;
         try {
-            const status = await tickTarget(target, state, deps, marginSeconds, fallbackHours, snapshot);
+            const status = await tickTarget(target, state, screenText, deps, marginSeconds, fallbackHours, snapshot);
             logPaneStatus(log, target.label, before, state, status);
         }
         catch {
-            // This pane's capture/inject failed — leave its state, keep going.
-            log(`${target.label} — capture/inject error (skipped this round)`);
+            // This pane's inject failed — leave its state, keep going.
+            log(`${target.label} — inject error (skipped this round)`);
         }
     }
 }

package/package.json

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