@tigorhutasuhut/claude-retry 0.1.9 → 0.1.11

package/dist/cli.js

@@ -3,23 +3,24 @@ import { capturePane, inject, listPaneTargets, captureTarget, injectTarget, } fr
 import { runMonitor, runMultiMonitor } from "./monitor.js";
 import { readAccessToken, fetchUsage } from "./usage.js";
 import { discoverAccountDirs, resolvePaneConfigDir } from "./accounts.js";
+import { formatClock } from "./format.js";
 const USAGE = `claude-retry — Auto-inject 'continue' when Claude hits a rate limit in zellij
 
 Usage:
-  claude-retry start               Watch ALL Claude panes across ALL sessions
+  claude-retry start               Watch ALL panes across ALL sessions (acts on the ones showing a rate-limit banner)
   claude-retry monitor <pane-id>   Watch one pane by ID in the current session
   claude-retry help                Show this help
 
 Run as a foreground daemon in any zellij pane (a dedicated session is ideal).
 'start' polls every 60s, walks every live zellij session and every pane, and
-auto-injects 'continue' after each Claude pane's rate-limit reset time. It works
-on detached sessions and skips its own session. New Claude panes are picked up
+auto-injects 'continue' after a pane's rate-limit reset time. It works
+on detached sessions and skips its own session. New panes are picked up
 automatically; closed ones are dropped. Logs go to stderr.
 
 'monitor <pane-id>' is the legacy single-pane mode (current session only).`;
 /** Timestamped stderr logger — chatty so the daemon shows clear signs of life. */
 function log(msg) {
-    const ts = new Date().toISOString().slice(11, 19); // HH:MM:SS
+    const ts = formatClock(); // local HH:MM:SS
     process.stderr.write(`[${ts}] ${msg}\n`);
 }
 const now = () => Date.now();

package/dist/format.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Local-time formatting helpers.
+ * All output uses the machine's local timezone (not UTC).
+ */
+/**
+ * Local wall-clock "HH:MM:SS" (24h).
+ * @param ms - epoch ms; defaults to Date.now() when omitted.
+ */
+export declare function formatClock(ms?: number): string;
+/**
+ * Local "YYYY-MM-DD HH:MM:SS TZ" (e.g. "2026-06-07 14:05:09 GMT+7").
+ * The TZ suffix is derived from Intl.DateTimeFormat; omitted gracefully if unavailable.
+ */
+export declare function formatLocalDateTime(ms: number): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/format.js

@@ -0,0 +1,36 @@
+/**
+ * Local-time formatting helpers.
+ * All output uses the machine's local timezone (not UTC).
+ */
+function pad2(n) {
+    return String(n).padStart(2, '0');
+}
+/**
+ * Local wall-clock "HH:MM:SS" (24h).
+ * @param ms - epoch ms; defaults to Date.now() when omitted.
+ */
+export function formatClock(ms) {
+    const d = new Date(ms ?? Date.now());
+    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+/**
+ * Local "YYYY-MM-DD HH:MM:SS TZ" (e.g. "2026-06-07 14:05:09 GMT+7").
+ * The TZ suffix is derived from Intl.DateTimeFormat; omitted gracefully if unavailable.
+ */
+export function formatLocalDateTime(ms) {
+    const d = new Date(ms);
+    const date = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+    const time = `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+    let tz = '';
+    try {
+        const parts = Intl.DateTimeFormat(undefined, { timeZoneName: 'short' }).formatToParts(d);
+        const tzPart = parts.find((p) => p.type === 'timeZoneName');
+        if (tzPart?.value)
+            tz = ` ${tzPart.value}`;
+    }
+    catch {
+        // Intl unavailable or failed — omit TZ suffix
+    }
+    return `${date} ${time}${tz}`;
+}
+//# sourceMappingURL=format.js.map

package/dist/monitor.d.ts

@@ -6,7 +6,7 @@ export interface MonitorDeps {
     now: () => number;
     sleep: (ms: number) => Promise<void>;
 }
-/** Deps for watching many Claude panes across sessions. Capture/inject are
+/** Deps for watching many panes across sessions. Capture/inject are
  *  addressed by PaneTarget rather than a bare pane id. */
 export interface MultiMonitorDeps {
     listTargets: () => Promise<PaneTarget[]>;
@@ -32,9 +32,9 @@ export declare function createState(): MonitorState;
 export declare function tick(paneId: string, state: MonitorState, deps: MonitorDeps, marginSeconds?: number, fallbackHours?: number): Promise<MonitorStatus>;
 export declare function runMonitor(paneId: string, deps: MonitorDeps, pollIntervalMs?: number, marginSeconds?: number, fallbackHours?: number): Promise<void>;
 /**
- * One discovery+monitor pass over every Claude pane in every live session.
+ * One discovery+monitor pass over every pane in every live session.
  *
- * Re-discovers targets each call so new Claude sessions/panes are picked up and
+ * Re-discovers targets each call so new sessions/panes are picked up and
  * closed ones are pruned. Per-pane state lives in `states`, keyed by the
  * target's label (session:paneId), and persists across calls. A failed
  * discovery or a single pane's capture/inject error is swallowed so one bad

package/dist/monitor.js

@@ -1,5 +1,6 @@
 import { match, isBlockedAtBanner } from "./patterns.js";
 import { parseResetTime, calculateWaitMs } from "./time-parser.js";
+import { formatLocalDateTime } from "./format.js";
 const MAX_MISSES = 3;
 export function createState() {
     return { status: 'monitoring', waitUntil: 0, missCount: 0 };
@@ -65,7 +66,7 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
             await injectContinue();
             state.status = 'monitoring';
             state.waitUntil = 0;
-            logger(`${label} reset reached — injected continue`);
+            logger(`${label} — reset reached, sent 'continue'`);
             return 'retried';
         }
         // Still limited, before reset → keep waiting.
@@ -83,7 +84,7 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
                     // 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`);
+                        logger(`${label} cleared-limit banner at bottom — sent 'continue'`);
                         return 'retried';
                     }
                     logger(`${label} stale banner ignored (account not limited)`);
@@ -94,7 +95,7 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
                 if (usage.resetsAtMs !== null) {
                     state.waitUntil = usage.resetsAtMs + marginMs;
                     state.status = 'waiting';
-                    logger(`${label} account ${accountDir} limited, reset ${new Date(usage.resetsAtMs).toISOString()}`);
+                    logger(`${label} account ${accountDir} limited, 'continue' at ${formatLocalDateTime(state.waitUntil)}`);
                     return 'rate-limited';
                 }
                 // resetsAtMs null — fall through to text parse for the time, but
@@ -111,7 +112,7 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
             // Reset time already passed → limit is over (no roll-to-tomorrow).
             if (isBlockedAtBanner(screenText)) {
                 await injectContinue();
-                logger(`${label} reset already passed — injected continue`);
+                logger(`${label} reset already passed — sent 'continue'`);
                 return 'retried';
             }
             logger(`${label} stale banner ignored (reset already passed)`);
@@ -138,9 +139,9 @@ export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fa
     }
 }
 /**
- * One discovery+monitor pass over every Claude pane in every live session.
+ * One discovery+monitor pass over every pane in every live session.
  *
- * Re-discovers targets each call so new Claude sessions/panes are picked up and
+ * Re-discovers targets each call so new sessions/panes are picked up and
  * closed ones are pruned. Per-pane state lives in `states`, keyed by the
  * target's label (session:paneId), and persists across calls. A failed
  * discovery or a single pane's capture/inject error is swallowed so one bad
@@ -178,8 +179,8 @@ 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(', ')}]`);
+        ? 'scan: no panes found'
+        : `scan: watching ${targets.length} 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();
@@ -216,7 +217,7 @@ export async function multiTick(states, deps, marginSeconds, fallbackHours) {
         if (!state) {
             state = createState();
             states.set(target.label, state);
-            log(`${target.label} — new Claude pane, now watching`);
+            log(`${target.label} — new pane, now watching`);
         }
         // Reset miss counter for panes present this pass
         state.missCount = 0;
@@ -233,14 +234,13 @@ export async function multiTick(states, deps, marginSeconds, fallbackHours) {
 }
 function logPaneStatus(log, label, before, state, status) {
     if (status === 'rate-limited' && before === 'monitoring') {
-        const until = new Date(state.waitUntil).toISOString();
-        log(`${label} — RATE LIMITED, waiting until ${until}`);
+        log(`${label} — rate limited, will send 'continue' at ${formatLocalDateTime(state.waitUntil)}`);
     }
     else if (status === 'rate-limited') {
-        log(`${label} — still waiting for reset`);
+        log(`${label} — waiting, 'continue' at ${formatLocalDateTime(state.waitUntil)}`);
     }
     else if (status === 'retried') {
-        log(`${label} — reset reached, cleared input + injected 'continue'`);
+        log(`${label} — reset reached, sent 'continue'`);
     }
     else {
         log(`${label} — ok`);

package/package.json

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