@tigorhutasuhut/claude-retry 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # 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.
+Watches every pane across **all** your [zellij](https://zellij.dev/) sessions. When a pane hits Anthropic's usage/session limit, it detects the rate-limit banner, waits until that pane's reset time, then clears the input and injects `continue` to resume automatically. One daemon covers every session at once — even detached ones.
 
 ## Install
 
@@ -12,35 +12,31 @@ The package is scoped (`@tigorhutasuhut/claude-retry`); the installed command is
 
 ## 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:
+Run it as a foreground daemon, ideally in its **own dedicated zellij session** (the daemon skips its own session, so this keeps it from scanning itself):
 
 ```bash
+# in a session you keep around, e.g. "Claude Retry Monitor":
 claude-retry start
 ```
 
-`start` rediscovers Claude panes on **every pass** (every 60s) via `zellij action list-clients`. This means:
+`start` re-scans **every pass** (60s): it walks all live zellij sessions and every pane in them, dumps each pane's screen, and acts on the ones showing a rate-limit banner. This means:
+
+- **One** daemon covers every session — projects, branches, all of them.
+- It works on **detached** sessions (uses zellij's global `--session` flag, not attached clients).
+- Open a brand-new Claude session anywhere → picked up on the next pass. **No restart needed.**
+- Close a pane → dropped from the watch list silently.
+- Each pane keeps its own independent rate-limit state.
 
-- 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. Chatty logs stream to stderr so you always see signs of life.
 
-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 banner can't be detected. Running `claude` → `/remote-control` keeps the session "live" and visible to the monitor.
 
-> **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.
+### Single-pane mode (legacy)
 
-To pin the daemon to a single pane instead of auto-discovery:
+To watch just one pane in the **current** session, by ID:
 
 ```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
@@ -57,22 +53,16 @@ source (npm root -g)/claude-retry/shell/wrapper.fish
 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`.
+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 — no pane-identification guesswork needed.
+4. **Retry** — on detection, the reset time is parsed and the pane is marked `waiting`. Once the reset 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`.
 
-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.
+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.
 
 ## Requirements
 

package/dist/cli.js

@@ -1,31 +1,41 @@
 #!/usr/bin/env node
-import { capturePane, inject, listClaudePanes } from "./zellij.js";
+import { capturePane, inject, listPaneTargets, captureTarget, injectTarget, } 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 start               Watch ALL Claude panes across ALL sessions
+  claude-retry monitor <pane-id>   Watch one pane by ID in the current session
   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 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
+automatically; closed ones are dropped. Logs go to stderr.
 
-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.`;
+'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
     process.stderr.write(`[${ts}] ${msg}\n`);
 }
-const deps = {
+const now = () => Date.now();
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Single-pane (legacy 'monitor') deps — addressed by bare pane id.
+const singleDeps = {
     capture: (id) => capturePane(id),
     inject: (id, text) => inject(id, text),
-    now: () => Date.now(),
-    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
-    listPanes: () => listClaudePanes(),
+    now,
+    sleep,
+};
+// Multi-session ('start') deps — addressed by PaneTarget across sessions.
+const multiDeps = {
+    listTargets: () => listPaneTargets(),
+    capture: (t) => captureTarget(t),
+    inject: (t, text) => injectTarget(t, text),
+    now,
+    sleep,
     log,
 };
 const [, , subcommand, ...rest] = process.argv;
@@ -39,12 +49,12 @@ async function main() {
                 process.exit(1);
             }
             log(`monitoring single pane ${paneId} (poll 5s)`);
-            await runMonitor(paneId, deps);
+            await runMonitor(paneId, singleDeps);
             break;
         }
         case 'start': {
-            log('claude-retry daemon starting — discovering Claude panes (poll 60s)');
-            await runMultiMonitor(deps);
+            log('claude-retry daemon starting — walking all sessions/panes (poll 60s)');
+            await runMultiMonitor(multiDeps);
             break;
         }
         case 'help': {

package/dist/monitor.d.ts

@@ -1,11 +1,18 @@
+import type { PaneTarget } from './zellij.ts';
 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[]>;
+/** Deps for watching many Claude panes across sessions. Capture/inject are
+ *  addressed by PaneTarget rather than a bare pane id. */
+export interface MultiMonitorDeps {
+    listTargets: () => Promise<PaneTarget[]>;
+    capture: (target: PaneTarget) => Promise<string>;
+    inject: (target: PaneTarget, text: string) => Promise<void>;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
     /** Optional sink for chatty progress logs (wired to stderr by the CLI). */
     log?: (msg: string) => void;
 }
@@ -19,12 +26,13 @@ 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.
+ * One discovery+monitor pass over every Claude pane in every live session.
  *
- * 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.
+ * Re-discovers targets each call so new Claude 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
+ * 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>;

package/dist/monitor.js

@@ -3,14 +3,18 @@ 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);
+/**
+ * Core state transition for one pane, given its current screen text.
+ * `injectContinue` is called only when a wait period has elapsed. Shared by
+ * single-pane (tick) and multi-session (tickTarget) monitoring.
+ */
+async function stepState(state, screenText, now, injectContinue, marginSeconds, fallbackHours) {
     if (state.status === 'waiting') {
-        if (deps.now() < state.waitUntil) {
+        if (now < state.waitUntil) {
             return 'rate-limited';
         }
         // Wait period elapsed — inject continue
-        await deps.inject(paneId, 'continue');
+        await injectContinue();
         state.status = 'monitoring';
         state.waitUntil = 0;
         return 'retried';
@@ -20,13 +24,21 @@ export async function tick(paneId, state, deps, marginSeconds, fallbackHours) {
     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;
+        const waitMs = calculateWaitMs(parsed, marginSeconds, fallbackHours, new Date(now));
+        state.waitUntil = now + waitMs;
         state.status = 'waiting';
         return 'rate-limited';
     }
     return 'monitoring';
 }
+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) {
+    const screenText = await deps.capture(target);
+    return stepState(state, screenText, deps.now(), () => deps.inject(target, 'continue'), marginSeconds, fallbackHours);
+}
 export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fallbackHours) {
     const state = createState();
     for (;;) {
@@ -35,66 +47,67 @@ export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fa
     }
 }
 /**
- * One discovery+monitor pass over every live Claude pane.
+ * One discovery+monitor pass over every Claude pane in every live session.
  *
- * 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.
+ * Re-discovers targets each call so new Claude 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
+ * pane never stops the others.
  */
 export async function multiTick(states, deps, marginSeconds, fallbackHours) {
     const log = deps.log ?? (() => { });
-    let panes;
+    let targets;
     try {
-        panes = await deps.listPanes();
+        targets = await deps.listTargets();
     }
     catch {
         // Discovery failed this round — keep existing states, retry next tick.
-        log('scan failed: could not list panes (will retry)');
+        log('scan failed: could not list sessions/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`);
+    const live = new Set(targets.map((t) => t.label));
+    for (const key of [...states.keys()]) {
+        if (!live.has(key)) {
+            states.delete(key);
+            log(`${key} gone — dropped from watch`);
         }
     }
-    log(panes.length === 0
+    log(targets.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);
+        : `scan: watching ${targets.length} Claude pane(s) [${targets.map((t) => t.label).join(', ')}]`);
+    for (const target of targets) {
+        let state = states.get(target.label);
         if (!state) {
             state = createState();
-            states.set(id, state);
-            log(`pane ${id} — new Claude session, now watching`);
+            states.set(target.label, state);
+            log(`${target.label} — new Claude pane, now watching`);
         }
         const before = state.status;
         try {
-            const status = await tick(id, state, deps, marginSeconds, fallbackHours);
-            logPaneStatus(log, id, before, state, status);
+            const status = await tickTarget(target, state, deps, marginSeconds, fallbackHours);
+            logPaneStatus(log, target.label, before, state, status);
         }
         catch {
             // This pane's capture/inject failed — leave its state, keep going.
-            log(`pane ${id} — capture/inject error (skipped this round)`);
+            log(`${target.label} — capture/inject error (skipped this round)`);
         }
     }
 }
-function logPaneStatus(log, id, before, state, status) {
+function logPaneStatus(log, label, before, state, status) {
     if (status === 'rate-limited' && before === 'monitoring') {
         const until = new Date(state.waitUntil).toISOString();
-        log(`pane ${id} — RATE LIMITED, waiting until ${until}`);
+        log(`${label} — RATE LIMITED, waiting until ${until}`);
     }
     else if (status === 'rate-limited') {
-        log(`pane ${id} — still waiting for reset`);
+        log(`${label} — still waiting for reset`);
     }
     else if (status === 'retried') {
-        log(`pane ${id} — reset reached, injected 'continue'`);
+        log(`${label} — reset reached, cleared input + injected 'continue'`);
     }
     else {
-        log(`pane ${id} — ok`);
+        log(`${label} — ok`);
     }
 }
 export async function runMultiMonitor(deps, pollIntervalMs, marginSeconds, fallbackHours) {

package/dist/patterns.js

@@ -12,6 +12,7 @@ export function stripAnsi(text) {
 const LIMIT_PATTERNS = [
     /claude\.ai\/settings/i,
     /usage limit/i,
+    /session limit/i,
     /rate.?limit/i,
     /\blimit\b.*\breached\b/i,
     /\breached\b.*\blimit\b/i,

package/dist/zellij.d.ts

@@ -4,6 +4,39 @@ export type ExecFileFn = (cmd: string, args: string[]) => Promise<{
 }>;
 export declare function capturePane(paneId: string | number, execFileFn?: ExecFileFn): Promise<string>;
 export declare function inject(paneId: string | number, text: string, execFileFn?: ExecFileFn): Promise<void>;
+/**
+ * A single Claude pane to watch, addressable across zellij sessions.
+ * `label` is a stable human-readable key (session:paneId) used for state
+ * tracking and logs.
+ */
+export interface PaneTarget {
+    session: string;
+    paneId: string;
+    label: string;
+}
+/**
+ * List all live zellij session names, skipping EXITED/resurrectable ones and
+ * the daemon's own session (ZELLIJ_SESSION_NAME) so it never watches itself.
+ */
+export declare function listSessions(execFileFn?: ExecFileFn): Promise<string[]>;
+/**
+ * Walk every live session and return every non-plugin, non-exited pane as a
+ * target. We do NOT try to identify which pane is Claude — pane titles and
+ * commands are unreliable (interactive `claude` reports the shell, titles are
+ * the cwd). Instead the monitor dumps each pane's screen and only acts on the
+ * ones actually showing a rate-limit banner. Works on detached sessions via
+ * the global `--session` flag; the daemon's own session is already excluded by
+ * listSessions, so its logs are never scanned.
+ */
+export declare function listPaneTargets(execFileFn?: ExecFileFn): Promise<PaneTarget[]>;
+/** Dump a target pane's visible screen across sessions. */
+export declare function captureTarget(t: PaneTarget, execFileFn?: ExecFileFn): Promise<string>;
+/**
+ * Inject into a target pane across sessions: Ctrl+C to clear any half-typed
+ * input first, then type text + Enter. A single Ctrl+C in Claude Code only
+ * clears the input box (shows "Press Ctrl-C again to exit"), it does not quit.
+ */
+export declare function injectTarget(t: PaneTarget, text: string, execFileFn?: ExecFileFn): Promise<void>;
 /**
  * Discover every live Claude pane (deduped pane IDs).
  *

package/dist/zellij.js

@@ -12,9 +12,95 @@ export async function capturePane(paneId, execFileFn = defaultExecFile) {
     return stdout;
 }
 export async function inject(paneId, text, execFileFn = defaultExecFile) {
+    // Ctrl+C first clears any half-typed input (does not quit Claude), then type + Enter.
+    await execFileFn('zellij', ['action', 'write', '--pane-id', String(paneId), '3']);
     await execFileFn('zellij', ['action', 'write-chars', '--pane-id', String(paneId), text]);
     await execFileFn('zellij', ['action', 'write', '--pane-id', String(paneId), '13']);
 }
+/**
+ * List all live zellij session names, skipping EXITED/resurrectable ones and
+ * the daemon's own session (ZELLIJ_SESSION_NAME) so it never watches itself.
+ */
+export async function listSessions(execFileFn = defaultExecFile) {
+    const own = process.env['ZELLIJ_SESSION_NAME'];
+    const names = [];
+    const { stdout } = await execFileFn('zellij', ['list-sessions', '-n']);
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (/\(EXITED/.test(trimmed))
+            continue; // skip dead/resurrectable sessions
+        // Session names may contain spaces ("Rainbow Road"); the name is everything
+        // before the " [Created ...]" suffix that zellij appends.
+        const idx = trimmed.indexOf(' [');
+        const name = (idx >= 0 ? trimmed.slice(0, idx) : trimmed).trim();
+        if (!name)
+            continue;
+        if (own && name === own)
+            continue; // never watch our own session
+        names.push(name);
+    }
+    return names;
+}
+/**
+ * Walk every live session and return every non-plugin, non-exited pane as a
+ * target. We do NOT try to identify which pane is Claude — pane titles and
+ * commands are unreliable (interactive `claude` reports the shell, titles are
+ * the cwd). Instead the monitor dumps each pane's screen and only acts on the
+ * ones actually showing a rate-limit banner. Works on detached sessions via
+ * the global `--session` flag; the daemon's own session is already excluded by
+ * listSessions, so its logs are never scanned.
+ */
+export async function listPaneTargets(execFileFn = defaultExecFile) {
+    const sessions = await listSessions(execFileFn);
+    const targets = [];
+    for (const session of sessions) {
+        let panes;
+        try {
+            const { stdout } = await execFileFn('zellij', [
+                '--session',
+                session,
+                'action',
+                'list-panes',
+                '-j',
+            ]);
+            panes = JSON.parse(stdout);
+        }
+        catch {
+            continue; // session vanished or output unparseable — skip this round
+        }
+        for (const p of panes) {
+            if (p.is_plugin || p.exited)
+                continue;
+            targets.push({ session, paneId: String(p.id), label: `${session}:${p.id}` });
+        }
+    }
+    return targets;
+}
+/** Dump a target pane's visible screen across sessions. */
+export async function captureTarget(t, execFileFn = defaultExecFile) {
+    const { stdout } = await execFileFn('zellij', [
+        '--session',
+        t.session,
+        'action',
+        'dump-screen',
+        '--pane-id',
+        t.paneId,
+    ]);
+    return stdout;
+}
+/**
+ * Inject into a target pane across sessions: Ctrl+C to clear any half-typed
+ * input first, then type text + Enter. A single Ctrl+C in Claude Code only
+ * clears the input box (shows "Press Ctrl-C again to exit"), it does not quit.
+ */
+export async function injectTarget(t, text, execFileFn = defaultExecFile) {
+    const base = ['--session', t.session, 'action'];
+    await execFileFn('zellij', [...base, 'write', '--pane-id', t.paneId, '3']); // Ctrl+C clears input
+    await execFileFn('zellij', [...base, 'write-chars', '--pane-id', t.paneId, text]);
+    await execFileFn('zellij', [...base, 'write', '--pane-id', t.paneId, '13']); // Enter
+}
 /** 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) {

package/package.json

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