@tigorhutasuhut/claude-retry 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tigor Hutasuhut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# claude-retry
+
+Watches every Claude CLI pane in a [zellij](https://zellij.dev/) terminal session. When a pane hits Anthropic's 5-hour usage limit, it detects the rate-limit message, waits until that pane's reset time, then injects `continue` to resume automatically. One daemon covers all your Claude sessions at once.
+
+## Install
+
+```bash
+npm install -g @tigorhutasuhut/claude-retry
+```
+
+The package is scoped (`@tigorhutasuhut/claude-retry`); the installed command is still `claude-retry`.
+
+## Usage
+
+Must be run inside a zellij session. The recommended way to run claude-retry is as a foreground daemon in a dedicated zellij pane:
+
+1. In your main pane, run `claude` as normal.
+2. Open a second pane (e.g. `Ctrl+p` then `d` to split down).
+3. In the new pane, start the daemon:
+
+```bash
+claude-retry start
+```
+
+`start` rediscovers Claude panes on **every pass** (every 60s) via `zellij action list-clients`. This means:
+
+- You only ever need **one** daemon, no matter how many Claude sessions you run.
+- Open a new Claude session in a new pane → it's picked up automatically on the next pass. **No restart needed.**
+- Close a Claude pane → it's dropped from the watch list silently.
+- Each pane gets its own independent rate-limit state.
+
+Leave it running — the pane *is* the daemon. zellij keeps it alive across detach/attach, so you don't need systemd or any external supervisor. Logs stream to stderr so you always see signs of life.
+
+> **Start Claude the right way for detection.** Launch the session with the plain `claude` command, then run the `/remote-control` slash command *inside* it. Do **not** use the `claude remote-control` CLI subcommand directly — that mode silences the on-screen text, so `dump-screen` captures nothing and the rate-limit message can't be detected. Running `claude` → `/remote-control` keeps the session "live" and visible to the monitor.
+
+To pin the daemon to a single pane instead of auto-discovery:
+
+```bash
+# Watch one specific pane by ID:
+claude-retry monitor 3
+
+# Or restrict 'start' to one pane via env:
+CLAUDE_PANE_ID=3 claude-retry start
+```
+
+### Optional: shell wrapper
+
+A shell wrapper is included that launches Claude and a monitor pane together when you run `claude`. It is **optional** — the foreground daemon above is the simpler, recommended path. Source it only if you want the auto-spawn behavior:
+
+**Fish** (`~/.config/fish/config.fish`):
+```fish
+source (npm root -g)/claude-retry/shell/wrapper.fish
+```
+
+**Bash** (`~/.bashrc`) / **Zsh** (`~/.zshrc`):
+```bash
+source "$(npm root -g)/claude-retry/shell/wrapper.bash"
+```
+
+## Configuration
+
+```bash
+CLAUDE_PANE_ID=3 claude-retry start   # pin to one pane, skip auto-discovery
+```
+
+## How it works
+
+Every pass (60s for `start`, 5s for single-pane `monitor`):
+
+1. **Discover** — `start` lists Claude panes via `zellij action list-clients`, matching panes whose command is the `claude` CLI (the daemon's own `claude-retry` pane is excluded). New panes are added, closed panes are pruned.
+2. **Capture** — for each pane, grabs the screen with `zellij action dump-screen` (ANSI stripped).
+3. **Match** — checks the text against the rate-limit patterns.
+4. **Retry** — on detection, parses the reset time and marks the pane `waiting`; once the reset elapses, injects `continue` via `zellij action write-chars`.
+
+Per-pane state persists across passes, so a pane mid-wait isn't disturbed by rediscovery. It runs as a plain foreground process inside the same zellij session as Claude — no transparent session wrapping, no external daemon. The zellij pane is the daemon.
+
+## Requirements
+
+- Node.js >= 20
+- zellij >= 0.40
+- Must be inside a zellij session when running
+
+## Development
+
+```bash
+npm install
+npm run typecheck   # tsc --noEmit
+npm test            # node --test
+npm run build       # tsc -> dist/
+npm run verify      # typecheck + test + build (the publish gate)
+```
+
+## Publishing
+
+Releases are published to npm by GitHub Actions ([.github/workflows/publish.yml](.github/workflows/publish.yml)) when a GitHub Release is published. Auth uses npm [Trusted Publishing](https://docs.npmjs.com/trusted-publishers) (OIDC) — **no `NPM_TOKEN` secret** — and [provenance](https://docs.npmjs.com/generating-provenance-statements) is attached automatically.
+
+### One-time setup
+
+1. **Bootstrap the package** (trusted publishing can only be configured on a package that already exists). Publish `0.1.0` once from your machine:
+   ```bash
+   npm login
+   npm run verify
+   npm publish --provenance=false
+   ```
+   `--provenance=false` is required for this local bootstrap: provenance is only generated in CI via OIDC (`publishConfig.provenance` stays `true` for the Actions publish). Without the flag, a local publish fails with `Automatic provenance generation not supported for provider: null`.
+2. **Configure the trusted publisher** on npmjs.com: open the package → **Settings → Trusted Publisher → GitHub Actions**, and set:
+   - Organization or user: `tigorlazuardi`
+   - Repository: `claude-retry`
+   - Workflow filename: `publish.yml`
+3. (Recommended) In package **Settings**, set publishing access to **require two-factor or trusted publisher**, which disables token publishes entirely.
+
+### Cutting a release
+
+```bash
+npm version patch        # bump version + create git tag
+git push --follow-tags
+gh release create vX.Y.Z --generate-notes
+```
+
+Publishing the GitHub Release triggers the workflow, which runs `npm ci` then `npm publish`. `prepublishOnly` (`npm run verify`) gates the publish on a clean typecheck, test, and build.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { capturePane, inject, listClaudePanes } from "./zellij.js";
+import { runMonitor, runMultiMonitor } from "./monitor.js";
+const USAGE = `claude-retry — Auto-inject 'continue' when Claude hits a rate limit in zellij
+
+Usage:
+  claude-retry start               Watch ALL Claude panes (re-discovers each pass)
+  claude-retry monitor <pane-id>   Watch one specific zellij pane by ID
+  claude-retry help                Show this help
+
+Options:
+  CLAUDE_PANE_ID=<id>   Pin 'start' to a single pane instead of auto-discovery
+
+Run as a foreground daemon in a dedicated zellij pane. 'start' polls every
+60s, finds every pane running the 'claude' CLI, and injects 'continue' after
+each one's rate-limit reset time. New Claude sessions are picked up
+automatically; closed panes are dropped. Logs go to stderr.`;
+/** 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
+    process.stderr.write(`[${ts}] ${msg}\n`);
+}
+const deps = {
+    capture: (id) => capturePane(id),
+    inject: (id, text) => inject(id, text),
+    now: () => Date.now(),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    listPanes: () => listClaudePanes(),
+    log,
+};
+const [, , subcommand, ...rest] = process.argv;
+async function main() {
+    switch (subcommand) {
+        case 'monitor': {
+            const paneId = rest[0];
+            if (!paneId) {
+                console.error('Error: pane-id required\n');
+                console.error(USAGE);
+                process.exit(1);
+            }
+            log(`monitoring single pane ${paneId} (poll 5s)`);
+            await runMonitor(paneId, deps);
+            break;
+        }
+        case 'start': {
+            log('claude-retry daemon starting — discovering Claude panes (poll 60s)');
+            await runMultiMonitor(deps);
+            break;
+        }
+        case 'help': {
+            console.log(USAGE);
+            process.exit(0);
+            break;
+        }
+        default: {
+            console.error(USAGE);
+            process.exit(1);
+        }
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/launcher.d.ts

@@ -0,0 +1,3 @@
+import type { MonitorDeps } from './monitor.ts';
+export declare function buildDeps(): MonitorDeps;
+//# sourceMappingURL=launcher.d.ts.map

package/dist/launcher.js

@@ -0,0 +1,10 @@
+import { capturePane, inject } from "./zellij.js";
+export function buildDeps() {
+    return {
+        capture: (id) => capturePane(id),
+        inject: (id, text) => inject(id, text),
+        now: () => Date.now(),
+        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    };
+}
+//# sourceMappingURL=launcher.js.map

package/dist/monitor.d.ts

@@ -0,0 +1,31 @@
+export interface MonitorDeps {
+    capture: (paneId: string) => Promise<string>;
+    inject: (paneId: string, text: string) => Promise<void>;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+}
+export interface MultiMonitorDeps extends MonitorDeps {
+    listPanes: () => Promise<string[]>;
+    /** Optional sink for chatty progress logs (wired to stderr by the CLI). */
+    log?: (msg: string) => void;
+}
+export type PaneStates = Map<string, MonitorState>;
+export type MonitorStatus = 'monitoring' | 'rate-limited' | 'retried' | 'exited';
+export interface MonitorState {
+    status: 'monitoring' | 'waiting';
+    waitUntil: number;
+}
+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 live Claude pane.
+ *
+ * Re-discovers panes each call so new Claude sessions are picked up and
+ * closed panes are pruned. Per-pane state lives in `states`, keyed by pane ID,
+ * and persists across calls. A failed discovery or a single pane's
+ * capture/inject error is swallowed so one bad pane never stops the others.
+ */
+export declare function multiTick(states: PaneStates, deps: MultiMonitorDeps, marginSeconds?: number, fallbackHours?: number): Promise<void>;
+export declare function runMultiMonitor(deps: MultiMonitorDeps, pollIntervalMs?: number, marginSeconds?: number, fallbackHours?: number): Promise<void>;
+//# sourceMappingURL=monitor.d.ts.map

package/dist/monitor.js

@@ -0,0 +1,107 @@
+import { match } from "./patterns.js";
+import { parseResetTime, calculateWaitMs } from "./time-parser.js";
+export function createState() {
+    return { status: 'monitoring', waitUntil: 0 };
+}
+export async function tick(paneId, state, deps, marginSeconds, fallbackHours) {
+    const screenText = await deps.capture(paneId);
+    if (state.status === 'waiting') {
+        if (deps.now() < state.waitUntil) {
+            return 'rate-limited';
+        }
+        // Wait period elapsed — inject continue
+        await deps.inject(paneId, 'continue');
+        state.status = 'monitoring';
+        state.waitUntil = 0;
+        return 'retried';
+    }
+    // state.status === 'monitoring'
+    const result = match(screenText);
+    if (result.limited) {
+        const resetLine = result.resetLine ?? '';
+        const parsed = parseResetTime(resetLine);
+        const waitMs = calculateWaitMs(parsed, marginSeconds, fallbackHours, new Date(deps.now()));
+        state.waitUntil = deps.now() + waitMs;
+        state.status = 'waiting';
+        return 'rate-limited';
+    }
+    return 'monitoring';
+}
+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);
+    }
+}
+/**
+ * One discovery+monitor pass over every live Claude pane.
+ *
+ * Re-discovers panes each call so new Claude sessions are picked up and
+ * closed panes are pruned. Per-pane state lives in `states`, keyed by pane ID,
+ * and persists across calls. A failed discovery or a single pane's
+ * capture/inject error is swallowed so one bad pane never stops the others.
+ */
+export async function multiTick(states, deps, marginSeconds, fallbackHours) {
+    const log = deps.log ?? (() => { });
+    let panes;
+    try {
+        panes = await deps.listPanes();
+    }
+    catch {
+        // Discovery failed this round — keep existing states, retry next tick.
+        log('scan failed: could not list panes (will retry)');
+        return;
+    }
+    // Prune state for panes that no longer exist.
+    const live = new Set(panes);
+    for (const id of [...states.keys()]) {
+        if (!live.has(id)) {
+            states.delete(id);
+            log(`pane ${id} gone — dropped from watch`);
+        }
+    }
+    log(panes.length === 0
+        ? 'scan: no Claude panes found'
+        : `scan: watching ${panes.length} Claude pane(s) [${panes.join(', ')}]`);
+    for (const id of panes) {
+        let state = states.get(id);
+        if (!state) {
+            state = createState();
+            states.set(id, state);
+            log(`pane ${id} — new Claude session, now watching`);
+        }
+        const before = state.status;
+        try {
+            const status = await tick(id, state, deps, marginSeconds, fallbackHours);
+            logPaneStatus(log, id, before, state, status);
+        }
+        catch {
+            // This pane's capture/inject failed — leave its state, keep going.
+            log(`pane ${id} — capture/inject error (skipped this round)`);
+        }
+    }
+}
+function logPaneStatus(log, id, before, state, status) {
+    if (status === 'rate-limited' && before === 'monitoring') {
+        const until = new Date(state.waitUntil).toISOString();
+        log(`pane ${id} — RATE LIMITED, waiting until ${until}`);
+    }
+    else if (status === 'rate-limited') {
+        log(`pane ${id} — still waiting for reset`);
+    }
+    else if (status === 'retried') {
+        log(`pane ${id} — reset reached, injected 'continue'`);
+    }
+    else {
+        log(`pane ${id} — ok`);
+    }
+}
+export async function runMultiMonitor(deps, pollIntervalMs, marginSeconds, fallbackHours) {
+    const states = new Map();
+    for (;;) {
+        await deps.sleep(pollIntervalMs ?? 60000);
+        await multiTick(states, deps, marginSeconds, fallbackHours);
+    }
+}
+//# sourceMappingURL=monitor.js.map

package/dist/patterns.d.ts

@@ -0,0 +1,7 @@
+export declare function stripAnsi(text: string): string;
+export interface MatchResult {
+    limited: boolean;
+    resetLine: string | null;
+}
+export declare function match(text: string): MatchResult;
+//# sourceMappingURL=patterns.d.ts.map

package/dist/patterns.js

@@ -0,0 +1,49 @@
+const CSI_REGEX = /\x1b\[[\x20-\x3f]*[\x40-\x7e]/g;
+const OSC_REGEX = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+const DCS_REGEX = /\x1bP[\s\S]*?(?:\x07|\x1b\\)/g;
+const OTHER_ESC_REGEX = /\x1b[_X^][\s\S]*?(?:\x07|\x1b\\)/g;
+export function stripAnsi(text) {
+    return text
+        .replace(CSI_REGEX, '')
+        .replace(OSC_REGEX, '')
+        .replace(DCS_REGEX, '')
+        .replace(OTHER_ESC_REGEX, '');
+}
+const LIMIT_PATTERNS = [
+    /claude\.ai\/settings/i,
+    /usage limit/i,
+    /rate.?limit/i,
+    /\blimit\b.*\breached\b/i,
+    /\breached\b.*\blimit\b/i,
+    /\bhit\b.*\blimit\b/i,
+    /\blimit\b.*\bexceeded\b/i,
+];
+const RESET_PATTERNS = [
+    /reset/i,
+    /try again/i,
+    /available/i,
+];
+const WINDOW = 6;
+export function match(text) {
+    const stripped = stripAnsi(text);
+    const lines = stripped.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const isLimitLine = LIMIT_PATTERNS.some((p) => p.test(line));
+        if (!isLimitLine)
+            continue;
+        // Search nearby lines (within WINDOW) for a reset line
+        const start = Math.max(0, i - WINDOW);
+        const end = Math.min(lines.length - 1, i + WINDOW);
+        for (let j = start; j <= end; j++) {
+            const nearby = lines[j];
+            if (RESET_PATTERNS.some((p) => p.test(nearby))) {
+                return { limited: true, resetLine: nearby.trim() };
+            }
+        }
+        // No reset line found nearby — return the limit line itself
+        return { limited: true, resetLine: line.trim() };
+    }
+    return { limited: false, resetLine: null };
+}
+//# sourceMappingURL=patterns.js.map

package/dist/time-parser.d.ts

@@ -0,0 +1,14 @@
+export interface AbsoluteTime {
+    hour: number;
+    minute: number;
+    timezone: string | null;
+    ambiguous: boolean;
+}
+export interface RelativeTime {
+    relative: true;
+    waitMs: number;
+}
+export type ParsedTime = AbsoluteTime | RelativeTime | null;
+export declare function parseResetTime(text: string): ParsedTime;
+export declare function calculateWaitMs(parsed: ParsedTime, marginSeconds?: number, fallbackHours?: number, now?: Date): number;
+//# sourceMappingURL=time-parser.d.ts.map

package/dist/time-parser.js

@@ -0,0 +1,148 @@
+const RESET_TIME_REGEX = /resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
+const RELATIVE_TIME_REGEX = /(?:try again|wait|resets?\s+in)[:\s]\s*(?:for\s+)?(?:in\s+)?(\d+)\s*(hours?|minutes?|mins?|h|m)\b/i;
+export function parseResetTime(text) {
+    const relMatch = RELATIVE_TIME_REGEX.exec(text);
+    if (relMatch) {
+        const amount = parseInt(relMatch[1], 10);
+        const unit = relMatch[2].toLowerCase();
+        const isHours = unit.startsWith('h');
+        const waitMs = isHours ? amount * 3600000 : amount * 60000;
+        return { relative: true, waitMs };
+    }
+    const absMatch = RESET_TIME_REGEX.exec(text);
+    if (absMatch) {
+        let hour = parseInt(absMatch[1], 10);
+        const minute = absMatch[2] ? parseInt(absMatch[2], 10) : 0;
+        const meridiem = absMatch[3] ? absMatch[3].toLowerCase() : null;
+        const timezone = absMatch[4] ? absMatch[4].trim() : null;
+        const ambiguous = meridiem === null;
+        if (!ambiguous) {
+            if (meridiem === 'pm' && hour !== 12) {
+                hour += 12;
+            }
+            else if (meridiem === 'am' && hour === 12) {
+                hour = 0;
+            }
+        }
+        return { hour, minute, timezone, ambiguous };
+    }
+    return null;
+}
+function getOffsetMs(timezone, date) {
+    try {
+        // Format the date in the target timezone to get local time
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+        });
+        const parts = formatter.formatToParts(date);
+        const get = (type) => parseInt(parts.find((p) => p.type === type)?.value ?? '0', 10);
+        const year = get('year');
+        const month = get('month') - 1;
+        const day = get('day');
+        const hour = get('hour') % 24; // hour12:false can give 24 for midnight
+        const minute = get('minute');
+        const second = get('second');
+        const localMs = Date.UTC(year, month, day, hour, minute, second);
+        return date.getTime() - localMs;
+    }
+    catch {
+        return 0; // invalid timezone — offset unknown
+    }
+}
+function isValidTimezone(tz) {
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: tz });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function calculateWaitMs(parsed, marginSeconds = 60, fallbackHours = 5, now = new Date()) {
+    const fallbackMs = fallbackHours * 3600000 + marginSeconds * 1000;
+    if (parsed === null) {
+        return fallbackMs;
+    }
+    if ('relative' in parsed) {
+        return parsed.waitMs + marginSeconds * 1000;
+    }
+    // Absolute time
+    const { hour, minute, timezone, ambiguous } = parsed;
+    const tryCalculate = (h) => {
+        if (timezone && isValidTimezone(timezone)) {
+            // DST-safe: build a candidate time in the target timezone
+            // Start from "today" in that timezone and find next occurrence of h:minute
+            const nowMs = now.getTime();
+            const tzOffset = getOffsetMs(timezone, now);
+            // Local time in target tz
+            const localMs = nowMs - tzOffset;
+            const localDate = new Date(localMs);
+            const localMidnight = Date.UTC(localDate.getUTCFullYear(), localDate.getUTCMonth(), localDate.getUTCDate());
+            // Candidate: today at h:minute in that tz
+            let candidateLocalMs = localMidnight + h * 3600000 + minute * 60000;
+            let candidateUtcMs = candidateLocalMs + tzOffset;
+            // DST correction: the offset may differ at the candidate time
+            // Iteratively correct until stable
+            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;
+            }
+            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;
+                }
+            }
+            return candidateUtcMs - nowMs + marginSeconds * 1000;
+        }
+        else {
+            // No timezone or invalid — assume UTC
+            const nowMs = now.getTime();
+            const nowDate = now;
+            const midnight = Date.UTC(nowDate.getUTCFullYear(), nowDate.getUTCMonth(), nowDate.getUTCDate());
+            let candidateMs = midnight + h * 3600000 + minute * 60000;
+            if (candidateMs <= nowMs) {
+                candidateMs += 86400000;
+            }
+            return candidateMs - nowMs + marginSeconds * 1000;
+        }
+    };
+    if (ambiguous) {
+        // No am/pm: check both interpretations, pick the sooner future one
+        const pmHour = hour === 12 ? 12 : hour + 12;
+        const amHour = hour === 12 ? 0 : hour;
+        const waitAm = tryCalculate(amHour);
+        const waitPm = tryCalculate(pmHour);
+        // Return the sooner positive wait
+        if (waitAm > 0 && waitPm > 0)
+            return Math.min(waitAm, waitPm);
+        if (waitAm > 0)
+            return waitAm;
+        if (waitPm > 0)
+            return waitPm;
+        return fallbackMs;
+    }
+    const wait = tryCalculate(hour);
+    if (wait <= 0)
+        return fallbackMs;
+    return wait;
+}
+//# sourceMappingURL=time-parser.js.map

package/dist/zellij.d.ts

@@ -0,0 +1,16 @@
+export type ExecFileFn = (cmd: string, args: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function capturePane(paneId: string | number, execFileFn?: ExecFileFn): Promise<string>;
+export declare function inject(paneId: string | number, text: string, execFileFn?: ExecFileFn): Promise<void>;
+/**
+ * Discover every live Claude pane (deduped pane IDs).
+ *
+ * Honors CLAUDE_PANE_ID as an explicit single-pane override. Otherwise parses
+ * `zellij action list-clients` and returns every pane whose RUNNING_COMMAND is
+ * the `claude` CLI. Returns [] on failure so the caller can retry next tick.
+ */
+export declare function listClaudePanes(execFileFn?: ExecFileFn): Promise<string[]>;
+export declare function resolvePaneId(execFileFn?: ExecFileFn): Promise<string>;
+//# sourceMappingURL=zellij.d.ts.map

package/dist/zellij.js

@@ -0,0 +1,101 @@
+import { execFile as _execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const _execFilePromise = promisify(_execFile);
+const defaultExecFile = (cmd, args) => _execFilePromise(cmd, args, { cwd: process.cwd() });
+export async function capturePane(paneId, execFileFn = defaultExecFile) {
+    const { stdout } = await execFileFn('zellij', [
+        'action',
+        'dump-screen',
+        '--pane-id',
+        String(paneId),
+    ]);
+    return stdout;
+}
+export async function inject(paneId, text, execFileFn = defaultExecFile) {
+    await execFileFn('zellij', ['action', 'write-chars', '--pane-id', String(paneId), text]);
+    await execFileFn('zellij', ['action', 'write', '--pane-id', String(paneId), '13']);
+}
+/** True when a list-clients RUNNING_COMMAND is the `claude` CLI itself.
+ *  Excludes `claude-retry` (the monitor's own pane) and other claude-* tools. */
+function paneCommandIsClaude(runningCommand) {
+    const first = runningCommand.trim().split(/\s+/)[0] ?? '';
+    const base = first.split('/').pop() ?? '';
+    return base === 'claude';
+}
+/**
+ * Discover every live Claude pane (deduped pane IDs).
+ *
+ * Honors CLAUDE_PANE_ID as an explicit single-pane override. Otherwise parses
+ * `zellij action list-clients` and returns every pane whose RUNNING_COMMAND is
+ * the `claude` CLI. Returns [] on failure so the caller can retry next tick.
+ */
+export async function listClaudePanes(execFileFn = defaultExecFile) {
+    const envId = process.env['CLAUDE_PANE_ID'];
+    if (envId)
+        return [envId];
+    const ids = new Set();
+    try {
+        const { stdout } = await execFileFn('zellij', ['action', 'list-clients']);
+        for (const line of stdout.split('\n').slice(1)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parts = trimmed.split(/\s+/);
+            const paneId = parts[1];
+            const runningCommand = parts.slice(2).join(' ');
+            if (paneId !== undefined && paneCommandIsClaude(runningCommand)) {
+                ids.add(paneId);
+            }
+        }
+    }
+    catch {
+        // list-clients failed — return what we have; next tick retries.
+    }
+    return [...ids];
+}
+export async function resolvePaneId(execFileFn = defaultExecFile) {
+    // 1. Explicit env var
+    const envId = process.env['CLAUDE_PANE_ID'];
+    if (envId) {
+        return envId;
+    }
+    // 2. list-clients → parse tabular output → find row with "claude" in RUNNING_COMMAND
+    try {
+        const { stdout: clientsOut } = await execFileFn('zellij', ['action', 'list-clients']);
+        const clientsLines = clientsOut.split('\n');
+        // Header: CLIENT_ID ZELLIJ_PANE_ID RUNNING_COMMAND
+        // Skip header line (index 0), iterate remaining non-empty lines
+        for (const line of clientsLines.slice(1)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parts = trimmed.split(/\s+/);
+            // parts[0] = CLIENT_ID, parts[1] = ZELLIJ_PANE_ID, parts[2..] = RUNNING_COMMAND
+            const runningCommand = parts.slice(2).join(' ');
+            if (runningCommand.toLowerCase().includes('claude')) {
+                const paneId = parts[1];
+                if (paneId !== undefined) {
+                    return paneId;
+                }
+            }
+        }
+    }
+    catch {
+        // list-clients failed — fall through to list-panes
+    }
+    // 3. list-panes -j → filter is_plugin=false → find title contains "claude"
+    try {
+        const { stdout: panesOut } = await execFileFn('zellij', ['action', 'list-panes', '-j']);
+        const panes = JSON.parse(panesOut);
+        const match = panes.find((p) => !p.is_plugin && p.title?.toLowerCase().includes('claude'));
+        if (match !== undefined) {
+            return String(match.id);
+        }
+    }
+    catch {
+        // list-panes failed — fall through to abort
+    }
+    // 4. Abort
+    throw new Error('Cannot resolve Claude pane ID. Set CLAUDE_PANE_ID env var or --pane-id.');
+}
+//# sourceMappingURL=zellij.js.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@tigorhutasuhut/claude-retry",
+  "version": "0.1.0",
+  "description": "Monitor Claude CLI in a zellij pane, auto-inject continue on rate-limit",
+  "type": "module",
+  "license": "MIT",
+  "author": "Tigor Hutasuhut <tigor.hutasuhut@gmail.com>",
+  "homepage": "https://github.com/tigorlazuardi/claude-retry#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tigorlazuardi/claude-retry.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tigorlazuardi/claude-retry/issues"
+  },
+  "keywords": [
+    "claude",
+    "zellij",
+    "rate-limit",
+    "cli",
+    "anthropic",
+    "automation"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "shell/"
+  ],
+  "bin": {
+    "claude-retry": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test 'test/**/*.test.ts'",
+    "verify": "npm run typecheck && npm test && npm run build",
+    "prepublishOnly": "npm run verify"
+  },
+  "devDependencies": {
+    "@types/node": "25.9.1",
+    "typescript": "^5.0.0"
+  }
+}

package/shell/wrapper.bash

@@ -0,0 +1,22 @@
+# >>> claude-retry >>>
+claude() {
+    if [ -z "${ZELLIJ:-}" ]; then
+        echo "[claude-retry] Must run inside a zellij session" >&2
+        return 1
+    fi
+
+    # Launch claude in a new pane, capture pane ID
+    local pane_result
+    pane_result=$(zellij run --close-on-exit -- claude "$@" 2>/dev/null)
+    local pane_id
+    pane_id=$(echo "$pane_result" | grep -oE '[0-9]+$')
+
+    if [ -z "$pane_id" ]; then
+        echo "[claude-retry] Failed to get pane ID from zellij run" >&2
+        return 1
+    fi
+
+    # Start claude-retry monitor in a background pane
+    CLAUDE_PANE_ID="$pane_id" zellij run --close-on-exit --name "claude-retry" -- claude-retry monitor "$pane_id"
+}
+# <<< claude-retry <<<

package/shell/wrapper.fish

@@ -0,0 +1,23 @@
+# >>> claude-retry >>>
+function claude
+    if not set -q ZELLIJ
+        echo "[claude-retry] Must run inside a zellij session" >&2
+        return 1
+    end
+
+    # Launch claude in a new pane, capture pane ID
+    # zellij run returns "terminal_N" on stdout
+    set -l pane_result (zellij run --close-on-exit -- claude $argv 2>/dev/null)
+    # pane_result is like "terminal_3" — extract the numeric ID
+    set -l pane_id (echo $pane_result | grep -oE '[0-9]+$')
+
+    if test -z "$pane_id"
+        echo "[claude-retry] Failed to get pane ID from zellij run" >&2
+        return 1
+    end
+
+    # Start claude-retry monitor in a background pane
+    set -x CLAUDE_PANE_ID $pane_id
+    zellij run --close-on-exit --name "claude-retry" -- claude-retry monitor $pane_id
+end
+# <<< claude-retry <<<