@tigorhutasuhut/claude-retry 0.1.2 → 0.1.3

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 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.
+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.
 
 ## Install
 
@@ -59,16 +59,24 @@ Every pass (60s for `start`, 5s for single-pane `monitor`):
 
 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`.
+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`.
 
 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.
 
+> **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.
+
 ## Requirements
 
-- Node.js >= 20
+- Node.js >= 20 (required for global `fetch`, used by the usage API)
 - zellij >= 0.40
 - Must be inside a zellij session when running
+- A logged-in Claude Code installation with a valid `<CLAUDE_CONFIG_DIR>/.credentials.json` (for usage-API tier 1 detection; without it the daemon degrades to text parsing)
+- `/proc` account discovery is Linux-only; on other platforms the daemon uses the default account and text fallback
 
 ## Development
 

package/dist/accounts.d.ts

@@ -0,0 +1,35 @@
+import { type AccountUsage } from './usage.ts';
+import type { PaneTarget } from './zellij.ts';
+export interface AccountSnapshot {
+    byDir: Map<string, AccountUsage>;
+}
+export declare function parseConfigDirFromEnviron(buf: string): string | null;
+export interface DiscoverDeps {
+    platform: string;
+    readdir: (path: string) => Promise<string[]>;
+    readFile: (path: string) => Promise<string>;
+    defaultDir: () => string;
+}
+export interface ProcDeps {
+    platform?: string;
+    listProcPids: () => Promise<string[]>;
+    readCmdline: (pid: string) => Promise<string>;
+    readEnviron: (pid: string) => Promise<string>;
+    listFds: (pid: string) => Promise<string[]>;
+    readlink: (path: string) => Promise<string>;
+}
+interface ClaudeProc {
+    pid: string;
+    configDir: string;
+    pts: string | null;
+}
+interface ZellijServer {
+    session: string;
+    pts: Set<string>;
+}
+export declare function listClaudeProcs(deps: ProcDeps): Promise<ClaudeProc[]>;
+export declare function listZellijServers(deps: ProcDeps): Promise<ZellijServer[]>;
+export declare function discoverAccountDirs(deps?: Partial<DiscoverDeps>): Promise<string[]>;
+export declare function resolvePaneConfigDir(target: PaneTarget, _snapshot: AccountSnapshot, deps?: ProcDeps): Promise<string | null>;
+export {};
+//# sourceMappingURL=accounts.d.ts.map

package/dist/accounts.js

@@ -0,0 +1,197 @@
+import { defaultConfigDir } from "./usage.js";
+export function parseConfigDirFromEnviron(buf) {
+    const entries = buf.split('\0');
+    for (const entry of entries) {
+        if (entry.startsWith('CLAUDE_CONFIG_DIR=')) {
+            const val = entry.slice('CLAUDE_CONFIG_DIR='.length);
+            return val.length > 0 ? val : null;
+        }
+    }
+    return null;
+}
+function defaultProcDeps() {
+    return {
+        platform: process.platform,
+        listProcPids: async () => {
+            const { readdir } = await import('node:fs/promises');
+            const entries = await readdir('/proc');
+            return entries.filter(e => /^\d+$/.test(e));
+        },
+        readCmdline: async (pid) => {
+            const { readFile } = await import('node:fs/promises');
+            return readFile(`/proc/${pid}/cmdline`, 'utf8');
+        },
+        readEnviron: async (pid) => {
+            const { readFile } = await import('node:fs/promises');
+            return readFile(`/proc/${pid}/environ`, 'utf8');
+        },
+        listFds: async (pid) => {
+            const { readdir } = await import('node:fs/promises');
+            return readdir(`/proc/${pid}/fd`);
+        },
+        readlink: async (path) => {
+            const { readlink } = await import('node:fs/promises');
+            return readlink(path);
+        },
+    };
+}
+const CONTRACT_VERSION_SEG = '/contract_version_1/';
+export async function listClaudeProcs(deps) {
+    const result = [];
+    let pids;
+    try {
+        pids = await deps.listProcPids();
+    }
+    catch {
+        return result;
+    }
+    await Promise.all(pids.map(async (pid) => {
+        try {
+            const cmdline = await deps.readCmdline(pid);
+            if (!cmdline.includes('claude'))
+                return;
+            let configDir;
+            try {
+                const environ = await deps.readEnviron(pid);
+                configDir = parseConfigDirFromEnviron(environ) ?? defaultConfigDir();
+            }
+            catch {
+                configDir = defaultConfigDir();
+            }
+            let pts = null;
+            try {
+                const target = await deps.readlink(`/proc/${pid}/fd/0`);
+                if (/^\/dev\/pts\/\d+$/.test(target)) {
+                    pts = target;
+                }
+            }
+            catch {
+                // fd/0 unreadable — pts stays null
+            }
+            result.push({ pid, configDir, pts });
+        }
+        catch {
+            // skip unreadable pid
+        }
+    }));
+    return result;
+}
+export async function listZellijServers(deps) {
+    const result = [];
+    let pids;
+    try {
+        pids = await deps.listProcPids();
+    }
+    catch {
+        return result;
+    }
+    await Promise.all(pids.map(async (pid) => {
+        try {
+            const cmdline = await deps.readCmdline(pid);
+            const args = cmdline.split('\0');
+            const serverIdx = args.indexOf('--server');
+            if (serverIdx === -1)
+                return;
+            const serverPath = args[serverIdx + 1];
+            if (serverPath === undefined)
+                return;
+            const idx = serverPath.lastIndexOf(CONTRACT_VERSION_SEG);
+            if (idx === -1)
+                return;
+            const session = serverPath.slice(idx + CONTRACT_VERSION_SEG.length).trimEnd();
+            if (!session)
+                return;
+            const pts = new Set();
+            try {
+                const fds = await deps.listFds(pid);
+                await Promise.all(fds.map(async (fd) => {
+                    try {
+                        const target = await deps.readlink(`/proc/${pid}/fd/${fd}`);
+                        if (/^\/dev\/pts\/\d+$/.test(target)) {
+                            pts.add(target);
+                        }
+                    }
+                    catch {
+                        // skip unreadable fd
+                    }
+                }));
+            }
+            catch {
+                // listFds failed — server with empty pts still recorded
+            }
+            result.push({ session, pts });
+        }
+        catch {
+            // skip unreadable pid
+        }
+    }));
+    return result;
+}
+export async function discoverAccountDirs(deps) {
+    const platform = deps?.platform ?? process.platform;
+    const readdirFn = deps?.readdir ?? (async (p) => {
+        const { readdir } = await import('node:fs/promises');
+        return readdir(p);
+    });
+    const readFileFn = deps?.readFile ?? (async (p) => {
+        const { readFile } = await import('node:fs/promises');
+        return readFile(p, 'utf8');
+    });
+    const defaultDir = deps?.defaultDir ?? (() => defaultConfigDir());
+    const base = defaultDir();
+    const dirs = new Set([base]);
+    if (platform !== 'linux') {
+        return [base];
+    }
+    try {
+        const entries = await readdirFn('/proc');
+        const pids = entries.filter(e => /^\d+$/.test(e));
+        await Promise.all(pids.map(async (pid) => {
+            try {
+                const cmdline = await readFileFn(`/proc/${pid}/cmdline`);
+                if (!cmdline.includes('claude'))
+                    return;
+                const environ = await readFileFn(`/proc/${pid}/environ`);
+                const dir = parseConfigDirFromEnviron(environ) ?? base;
+                dirs.add(dir);
+            }
+            catch {
+                // skip unreadable pids
+            }
+        }));
+    }
+    catch {
+        // /proc unreadable or other failure → return default only
+        return [base];
+    }
+    return Array.from(dirs);
+}
+export async function resolvePaneConfigDir(target, _snapshot, deps) {
+    try {
+        const d = deps ?? defaultProcDeps();
+        const platform = d.platform ?? process.platform;
+        if (platform !== 'linux')
+            return null;
+        const [servers, claudeProcs] = await Promise.all([
+            listZellijServers(d),
+            listClaudeProcs(d),
+        ]);
+        const server = servers.find(s => s.session === target.session);
+        if (server === undefined)
+            return null;
+        const dirs = new Set();
+        for (const proc of claudeProcs) {
+            if (proc.pts !== null && server.pts.has(proc.pts)) {
+                dirs.add(proc.configDir);
+            }
+        }
+        if (dirs.size === 1) {
+            return [...dirs][0];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=accounts.js.map

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { capturePane, inject, listPaneTargets, captureTarget, injectTarget, } from "./zellij.js";
 import { runMonitor, runMultiMonitor } from "./monitor.js";
+import { readAccessToken, fetchUsage } from "./usage.js";
+import { discoverAccountDirs, resolvePaneConfigDir } from "./accounts.js";
 const USAGE = `claude-retry — Auto-inject 'continue' when Claude hits a rate limit in zellij
 
 Usage:
@@ -37,6 +39,25 @@ const multiDeps = {
     now,
     sleep,
     log,
+    getAccountSnapshot: async () => {
+        const dirs = await discoverAccountDirs();
+        const byDir = new Map();
+        await Promise.all(dirs.map(async (dir) => {
+            try {
+                const tok = await readAccessToken(dir);
+                if (!tok)
+                    return;
+                const usage = await fetchUsage(tok.token);
+                if (usage)
+                    byDir.set(dir, usage);
+            }
+            catch {
+                // swallow per-account errors — one bad account must not break the pass
+            }
+        }));
+        return { byDir };
+    },
+    resolvePaneAccount: (t, snapshot) => resolvePaneConfigDir(t, snapshot),
 };
 const [, , subcommand, ...rest] = process.argv;
 async function main() {
@@ -54,6 +75,7 @@ async function main() {
         }
         case 'start': {
             log('claude-retry daemon starting — walking all sessions/panes (poll 60s)');
+            log('usage-API detection enabled — account-aware rate-limit resolution active');
             await runMultiMonitor(multiDeps);
             break;
         }

package/dist/monitor.d.ts

@@ -1,4 +1,5 @@
 import type { PaneTarget } from './zellij.ts';
+import type { AccountSnapshot } from './accounts.ts';
 export interface MonitorDeps {
     capture: (paneId: string) => Promise<string>;
     inject: (paneId: string, text: string) => Promise<void>;
@@ -15,6 +16,10 @@ export interface MultiMonitorDeps {
     sleep: (ms: number) => Promise<void>;
     /** Optional sink for chatty progress logs (wired to stderr by the CLI). */
     log?: (msg: string) => void;
+    /** If provided, called ONCE per multiTick pass to get current account usage snapshot. */
+    getAccountSnapshot?: () => Promise<AccountSnapshot>;
+    /** If provided, used to resolve which account a pane belongs to when ambiguous. */
+    resolvePaneAccount?: (t: PaneTarget, s: AccountSnapshot) => Promise<string | null>;
 }
 export type PaneStates = Map<string, MonitorState>;
 export type MonitorStatus = 'monitoring' | 'rate-limited' | 'retried' | 'exited';

package/dist/monitor.js

@@ -7,8 +7,11 @@ export function createState() {
  * 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.
+ *
+ * When snapshot/resolver/target/log are provided, applies the three-tier
+ * account-aware limit resolution. Single-pane callers omit these — text path only.
  */
-async function stepState(state, screenText, now, injectContinue, marginSeconds, fallbackHours) {
+async function stepState(state, screenText, now, injectContinue, marginSeconds, fallbackHours, snapshot, resolvePaneAccount, target, log) {
     if (state.status === 'waiting') {
         if (now < state.waitUntil) {
             return 'rate-limited';
@@ -22,6 +25,57 @@ async function stepState(state, screenText, now, injectContinue, marginSeconds,
     // state.status === 'monitoring'
     const result = match(screenText);
     if (result.limited) {
+        const label = target?.label ?? 'pane';
+        const logger = log ?? (() => { });
+        // Tier 1: account-aware resolution when snapshot is available
+        if (snapshot !== undefined) {
+            let accountDir = null;
+            if (snapshot.byDir.size === 1) {
+                // Single account — always attributable, regardless of limited state
+                // (covers both fresh-limit and stale-banner cases without resolver)
+                accountDir = [...snapshot.byDir.keys()][0];
+            }
+            else {
+                // Find dirs that are limited in snapshot
+                const limitedDirs = [];
+                for (const [dir, usage] of snapshot.byDir) {
+                    if (usage.limited)
+                        limitedDirs.push(dir);
+                }
+                if (limitedDirs.length === 1) {
+                    // Exactly one limited account — attribute banner to it
+                    accountDir = limitedDirs[0];
+                }
+                else if (target !== undefined && resolvePaneAccount !== undefined) {
+                    // Ambiguous (0 or 2+) — try proc bridge (phase 2 stub, returns null)
+                    accountDir = await resolvePaneAccount(target, snapshot);
+                }
+            }
+            if (accountDir !== null) {
+                const usage = snapshot.byDir.get(accountDir);
+                if (usage !== undefined) {
+                    if (!usage.limited) {
+                        // Staleness gate: account is not limited → banner is stale → ignore
+                        logger(`${label} stale banner ignored (account not limited)`);
+                        return 'monitoring';
+                    }
+                    // Account confirmed limited — use resetsAtMs if available
+                    const marginMs = (marginSeconds ?? 60) * 1000;
+                    if (usage.resetsAtMs !== null) {
+                        state.waitUntil = usage.resetsAtMs + marginMs;
+                        state.status = 'waiting';
+                        logger(`${label} account ${accountDir} limited, reset ${new Date(usage.resetsAtMs).toISOString()}`);
+                        return 'rate-limited';
+                    }
+                    // resetsAtMs null — fall through to text parse for the time, but
+                    // we know account is limited so we don't need to gate on text
+                    // (fall through to tier 3 below)
+                }
+                // usage missing for this dir — fall through to tier 3
+            }
+            // accountDir null or usage missing — fall through to tier 3
+        }
+        // Tier 3: text fallback (current behavior, unchanged)
         const resetLine = result.resetLine ?? '';
         const parsed = parseResetTime(resetLine);
         const waitMs = calculateWaitMs(parsed, marginSeconds, fallbackHours, new Date(now));
@@ -35,9 +89,9 @@ 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) {
+async function tickTarget(target, state, deps, marginSeconds, fallbackHours, snapshot) {
     const screenText = await deps.capture(target);
-    return stepState(state, screenText, deps.now(), () => deps.inject(target, 'continue'), marginSeconds, fallbackHours);
+    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) {
     const state = createState();
@@ -66,6 +120,16 @@ 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.
     const live = new Set(targets.map((t) => t.label));
     for (const key of [...states.keys()]) {
@@ -86,7 +150,7 @@ export async function multiTick(states, deps, marginSeconds, fallbackHours) {
         }
         const before = state.status;
         try {
-            const status = await tickTarget(target, state, deps, marginSeconds, fallbackHours);
+            const status = await tickTarget(target, state, deps, marginSeconds, fallbackHours, snapshot);
             logPaneStatus(log, target.label, before, state, status);
         }
         catch {

package/dist/usage.d.ts

@@ -0,0 +1,23 @@
+export interface WindowUsage {
+    utilization: number;
+    resetsAtMs: number | null;
+}
+export interface AccountUsage {
+    limited: boolean;
+    resetsAtMs: number | null;
+}
+export type FetchFn = (url: string, init: {
+    headers: Record<string, string>;
+}) => Promise<{
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+export type ReadFileFn = (path: string) => Promise<string>;
+export declare const LIMIT_THRESHOLD: number;
+export declare function defaultConfigDir(env?: NodeJS.ProcessEnv): string;
+export declare function readAccessToken(configDir: string, readFile?: ReadFileFn): Promise<{
+    token: string;
+    expiresAtMs: number | null;
+} | null>;
+export declare function fetchUsage(token: string, fetchFn?: FetchFn, threshold?: number): Promise<AccountUsage | null>;
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.js

@@ -0,0 +1,91 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { readFile as fsReadFile } from 'node:fs/promises';
+export const LIMIT_THRESHOLD = (() => {
+    const raw = process.env['CLAUDE_RETRY_LIMIT_THRESHOLD'];
+    if (raw !== undefined) {
+        const n = Number(raw);
+        if (!Number.isNaN(n))
+            return n;
+    }
+    return 90;
+})();
+export function defaultConfigDir(env) {
+    const e = env ?? process.env;
+    return e['CLAUDE_CONFIG_DIR'] || path.join(os.homedir(), '.claude');
+}
+export async function readAccessToken(configDir, readFile = (p) => fsReadFile(p, 'utf8')) {
+    try {
+        const credPath = path.join(configDir, '.credentials.json');
+        const raw = await readFile(credPath);
+        const parsed = JSON.parse(raw);
+        const oauth = parsed['claudeAiOauth'];
+        if (oauth === null || typeof oauth !== 'object')
+            return null;
+        const oauthObj = oauth;
+        const token = oauthObj['accessToken'];
+        if (typeof token !== 'string' || token === '')
+            return null;
+        const expiresAt = oauthObj['expiresAt'];
+        const expiresAtMs = typeof expiresAt === 'number' ? expiresAt : null;
+        return { token, expiresAtMs };
+    }
+    catch {
+        return null;
+    }
+}
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const WINDOW_KEYS = ['five_hour', 'seven_day', 'seven_day_opus', 'seven_day_sonnet'];
+function defaultFetchFn(url, init) {
+    return fetch(url, init).then((r) => ({
+        status: r.status,
+        json: () => r.json(),
+    }));
+}
+export async function fetchUsage(token, fetchFn = defaultFetchFn, threshold = LIMIT_THRESHOLD) {
+    try {
+        const res = await fetchFn(USAGE_URL, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'anthropic-beta': 'oauth-2025-04-20',
+                'anthropic-version': '2023-06-01',
+            },
+        });
+        if (res.status !== 200)
+            return null;
+        const body = await res.json();
+        if (body === null || typeof body !== 'object')
+            return null;
+        const data = body;
+        const windows = [];
+        for (const key of WINDOW_KEYS) {
+            const w = data[key];
+            if (w === null || w === undefined || typeof w !== 'object')
+                continue;
+            const wObj = w;
+            const utilization = wObj['utilization'];
+            const resetsAt = wObj['resets_at'];
+            if (typeof utilization !== 'number')
+                continue;
+            const resetsAtMs = typeof resetsAt === 'string' ? Date.parse(resetsAt) : null;
+            windows.push({ utilization, resetsAtMs: resetsAtMs !== null && !Number.isNaN(resetsAtMs) ? resetsAtMs : null });
+        }
+        const overThreshold = windows.filter((w) => w.utilization >= threshold);
+        const limited = overThreshold.length > 0;
+        let resetsAtMs = null;
+        if (limited) {
+            for (const w of overThreshold) {
+                if (w.resetsAtMs !== null) {
+                    if (resetsAtMs === null || w.resetsAtMs > resetsAtMs) {
+                        resetsAtMs = w.resetsAtMs;
+                    }
+                }
+            }
+        }
+        return { limited, resetsAtMs };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=usage.js.map

package/package.json

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