@tigorhutasuhut/herdr-claude-retry 0.1.0 → 0.1.2

package/README.md

@@ -82,9 +82,9 @@ npm run verify         # typecheck + test + build (publish gate)
 npm run e2e            # acceptance test — needs live herdr
 ```
 
-The e2e test (`test/e2e/blocked-pane.e2e.ts`) creates a temporary herdr workspace, sends a
-rate-limit banner to its root pane, runs the daemon against it, and asserts the daemon detects the
-banner. It skips gracefully if no herdr socket is found.
+The e2e test (`test/e2e/blocked-pane.e2e.ts`) verifies live connectivity to the herdr socket:
+connects, lists agents, reads all live panes (the core one-shot protocol fix), and runs a daemon
+reconcile sweep asserting zero paneRead failures. Skips gracefully if no herdr socket is found.
 
 ## Publishing
 

package/dist/accounts.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Account discovery and pane→account resolution.
+ *
+ * Primary resolution path: UUID→jsonl glob scan across discovered config dirs.
+ * Fallback: shell PID → /proc/<pid>/environ → CLAUDE_CONFIG_DIR.
+ */
+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 ResolveDeps {
+    platform?: string;
+    /** List /proc pids */
+    listProcPids: () => Promise<string[]>;
+    /** Read /proc/<pid>/cmdline */
+    readCmdline: (pid: string) => Promise<string>;
+    /** Read /proc/<pid>/environ */
+    readEnviron: (pid: string) => Promise<string>;
+    /** List subdirs of a directory */
+    readdir: (path: string) => Promise<string[]>;
+    /** Check if a path exists (file or dir) */
+    exists: (path: string) => Promise<boolean>;
+    defaultDir: () => string;
+}
+/**
+ * Scan /proc for claude processes and collect their CLAUDE_CONFIG_DIR values.
+ * Returns deduplicated list including the default dir.
+ */
+export declare function discoverAccountDirs(deps?: Partial<DiscoverDeps>): Promise<string[]>;
+/**
+ * Resolve which config dir owns a pane, given:
+ * - sessionUuid: the Claude Code session UUID from agent_session.value
+ * - shellPid: the shell PID from pane.process_info (for fallback)
+ * - accountDirs: list of discovered config dirs
+ *
+ * Tier order:
+ * 1. Sole account - return it immediately
+ * 2. UUID-to-jsonl scan: glob <configDir>/projects/<star>/<uuid>.jsonl
+ * 3. PID-to-environ: read /proc/<shellPid>/environ, extract CLAUDE_CONFIG_DIR
+ * 4. null
+ */
+export declare function resolveAccountDir(sessionUuid: string | null, shellPid: number | null, accountDirs: string[], deps?: Partial<ResolveDeps>): Promise<string | null>;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/accounts.js

@@ -0,0 +1,173 @@
+/**
+ * Account discovery and pane→account resolution.
+ *
+ * Primary resolution path: UUID→jsonl glob scan across discovered config dirs.
+ * Fallback: shell PID → /proc/<pid>/environ → CLAUDE_CONFIG_DIR.
+ */
+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 defaultConfigDir() {
+    return process.env['CLAUDE_CONFIG_DIR'] ?? `${process.env['HOME'] ?? '/root'}/.claude`;
+}
+function defaultDiscoverDeps() {
+    return {
+        platform: process.platform,
+        readdir: async (p) => {
+            const { readdir } = await import('node:fs/promises');
+            return readdir(p);
+        },
+        readFile: async (p) => {
+            const { readFile } = await import('node:fs/promises');
+            return readFile(p, 'utf8');
+        },
+        defaultDir: defaultConfigDir,
+    };
+}
+function defaultResolveDeps() {
+    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');
+        },
+        readdir: async (p) => {
+            const { readdir } = await import('node:fs/promises');
+            return readdir(p);
+        },
+        exists: async (p) => {
+            const { access } = await import('node:fs/promises');
+            try {
+                await access(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        defaultDir: defaultConfigDir,
+    };
+}
+/**
+ * Scan /proc for claude processes and collect their CLAUDE_CONFIG_DIR values.
+ * Returns deduplicated list including the default dir.
+ */
+export async function discoverAccountDirs(deps) {
+    const merged = { ...defaultDiscoverDeps(), ...deps };
+    const platform = merged.platform ?? process.platform;
+    const base = merged.defaultDir();
+    const dirs = new Set([base]);
+    if (platform !== 'linux') {
+        return [base];
+    }
+    try {
+        const entries = await merged.readdir('/proc');
+        const pids = entries.filter(e => /^\d+$/.test(e));
+        await Promise.all(pids.map(async (pid) => {
+            try {
+                const cmdline = await merged.readFile(`/proc/${pid}/cmdline`);
+                if (!cmdline.includes('claude'))
+                    return;
+                const environ = await merged.readFile(`/proc/${pid}/environ`);
+                const dir = parseConfigDirFromEnviron(environ) ?? base;
+                dirs.add(dir);
+            }
+            catch {
+                // skip unreadable pids
+            }
+        }));
+    }
+    catch {
+        return [base];
+    }
+    return Array.from(dirs);
+}
+/**
+ * Resolve which config dir owns a pane, given:
+ * - sessionUuid: the Claude Code session UUID from agent_session.value
+ * - shellPid: the shell PID from pane.process_info (for fallback)
+ * - accountDirs: list of discovered config dirs
+ *
+ * Tier order:
+ * 1. Sole account - return it immediately
+ * 2. UUID-to-jsonl scan: glob <configDir>/projects/<star>/<uuid>.jsonl
+ * 3. PID-to-environ: read /proc/<shellPid>/environ, extract CLAUDE_CONFIG_DIR
+ * 4. null
+ */
+export async function resolveAccountDir(sessionUuid, shellPid, accountDirs, deps) {
+    const merged = { ...defaultResolveDeps(), ...deps };
+    // Tier 1: sole account
+    if (accountDirs.length === 1) {
+        return accountDirs[0];
+    }
+    if (accountDirs.length === 0) {
+        return null;
+    }
+    // Tier 2: UUID→jsonl scan
+    if (sessionUuid !== null) {
+        for (const configDir of accountDirs) {
+            try {
+                const projectsDir = `${configDir}/projects`;
+                let projects;
+                try {
+                    projects = await merged.readdir(projectsDir);
+                }
+                catch {
+                    continue;
+                }
+                let found = false;
+                for (const project of projects) {
+                    const jsonlPath = `${projectsDir}/${project}/${sessionUuid}.jsonl`;
+                    try {
+                        const exists = await merged.exists(jsonlPath);
+                        if (exists) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        // skip
+                    }
+                }
+                if (found) {
+                    return configDir;
+                }
+            }
+            catch {
+                // skip this dir
+            }
+        }
+    }
+    // Tier 3: PID→environ fallback
+    if (shellPid !== null) {
+        try {
+            const environ = await merged.readEnviron(String(shellPid));
+            const dir = parseConfigDirFromEnviron(environ);
+            if (dir !== null && accountDirs.includes(dir)) {
+                return dir;
+            }
+        }
+        catch {
+            // fallthrough
+        }
+    }
+    // Tier 4: unknown
+    return null;
+}
+//# sourceMappingURL=accounts.js.map

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+/**
+ * cli.ts — CLI entry point for herdr-claude-retry daemon.
+ *
+ * Usage:
+ *   herdr-claude-retry start [options]
+ *     --socket-path <path>    override HERDR_SOCKET_PATH env
+ *     --margin-seconds <n>    default 60
+ *     --sweep-interval <n>    default 300 (seconds)
+ *     --log-level <level>     debug|info|warn|error; default info
+ *     --help                  print usage and exit 0
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,137 @@
+/**
+ * cli.ts — CLI entry point for herdr-claude-retry daemon.
+ *
+ * Usage:
+ *   herdr-claude-retry start [options]
+ *     --socket-path <path>    override HERDR_SOCKET_PATH env
+ *     --margin-seconds <n>    default 60
+ *     --sweep-interval <n>    default 300 (seconds)
+ *     --log-level <level>     debug|info|warn|error; default info
+ *     --help                  print usage and exit 0
+ */
+import { parseArgs } from 'node:util';
+import { HerdrClient } from "./herdr.js";
+import { runDaemon } from "./daemon.js";
+import { makeLogger } from "./log.js";
+import { VERSION } from "./index.js";
+// ---------------------------------------------------------------------------
+// Help text
+// ---------------------------------------------------------------------------
+const HELP = `
+herdr-claude-retry v${VERSION}
+
+Usage:
+  herdr-claude-retry start [options]
+
+Options:
+  --socket-path <path>    Unix socket path (default: HERDR_SOCKET_PATH env or
+                          $HOME/.config/herdr/herdr.sock)
+  --margin-seconds <n>    Extra seconds after rate-limit resets before injecting
+                          (default: 60)
+  --sweep-interval <n>    Reconcile sweep interval in seconds (default: 300)
+  --log-level <level>     Minimum log level: debug|info|warn|error (default: info)
+  --help                  Print this help and exit
+
+Environment:
+  HERDR_SOCKET_PATH       Default socket path if --socket-path not given
+`.trim();
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    // Strip argv[0] (node) and argv[1] (script); grab subcommand if present
+    const rawArgs = process.argv.slice(2);
+    // Handle top-level --help before parseArgs (so it works without a subcommand)
+    if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+        process.stdout.write(HELP + '\n');
+        process.exit(0);
+    }
+    // Require 'start' subcommand
+    const [subcommand, ...rest] = rawArgs;
+    if (subcommand !== 'start') {
+        process.stderr.write(`error: unknown command '${subcommand ?? ''}'. Use 'start'.\n\n${HELP}\n`);
+        process.exit(1);
+    }
+    // Parse options
+    const { values } = parseArgs({
+        args: rest,
+        options: {
+            'socket-path': { type: 'string' },
+            'margin-seconds': { type: 'string' },
+            'sweep-interval': { type: 'string' },
+            'log-level': { type: 'string' },
+            'help': { type: 'boolean' },
+        },
+        strict: true,
+        allowPositionals: false,
+    });
+    if (values['help']) {
+        process.stdout.write(HELP + '\n');
+        process.exit(0);
+    }
+    // Resolve log level
+    const rawLevel = values['log-level'] ?? 'info';
+    const validLevels = ['debug', 'info', 'warn', 'error'];
+    if (!validLevels.includes(rawLevel)) {
+        process.stderr.write(`error: invalid --log-level '${rawLevel}'. Must be one of: ${validLevels.join(', ')}\n`);
+        process.exit(1);
+    }
+    const logLevel = rawLevel;
+    // Construct logger
+    const logFn = makeLogger({ level: logLevel });
+    // Resolve socket path
+    const socketPath = values['socket-path'] ??
+        process.env['HERDR_SOCKET_PATH'] ??
+        `${process.env['HOME']}/.config/herdr/herdr.sock`;
+    // Parse numeric options
+    const marginSeconds = values['margin-seconds'] !== undefined
+        ? parseInt(values['margin-seconds'], 10)
+        : 60;
+    const sweepIntervalSeconds = values['sweep-interval'] !== undefined
+        ? parseInt(values['sweep-interval'], 10)
+        : 300;
+    if (isNaN(marginSeconds) || marginSeconds < 0) {
+        process.stderr.write(`error: invalid --margin-seconds '${values['margin-seconds']}'\n`);
+        process.exit(1);
+    }
+    if (isNaN(sweepIntervalSeconds) || sweepIntervalSeconds < 1) {
+        process.stderr.write(`error: invalid --sweep-interval '${values['sweep-interval']}'\n`);
+        process.exit(1);
+    }
+    // Signal handling
+    const ac = new AbortController();
+    process.on('SIGINT', () => ac.abort());
+    process.on('SIGTERM', () => ac.abort());
+    // Construct client
+    const client = new HerdrClient({ socketPath });
+    // Connect (connectivity check — open+close a socket)
+    logFn({ event: 'daemon.start', version: VERSION, socket_path: socketPath });
+    try {
+        await client.connect();
+        logFn({ event: 'socket.connected' });
+    }
+    catch (err) {
+        logFn({ level: 'error', event: 'socket.dead' });
+        process.stderr.write(`fatal: could not connect to ${socketPath}: ${err}\n`);
+        process.exit(1);
+    }
+    // Run daemon — map daemon's string logger to structured events
+    try {
+        await runDaemon({
+            client,
+            marginSeconds,
+            sweepIntervalMs: sweepIntervalSeconds * 1000,
+            signal: ac.signal,
+            log: (msg) => logFn({ event: 'daemon.internal', msg }),
+        });
+    }
+    finally {
+        client.destroy();
+        logFn({ event: 'daemon.stop', reason: ac.signal.aborted ? 'signal' : 'exit' });
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`fatal: ${err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/daemon.d.ts

@@ -0,0 +1,37 @@
+/**
+ * daemon.ts — Event-driven daemon with reconcile sweep.
+ *
+ * Consumes HerdrClient event subscriptions and a periodic reconcile sweep
+ * to detect rate-limited Claude panes and inject 'continue' when limits reset.
+ */
+import type { HerdrClient } from './herdr.ts';
+import { discoverAccountDirs, resolveAccountDir } from './accounts.ts';
+import { readAccessToken, fetchUsage } from './usage.ts';
+import type { Logger } from './monitor.ts';
+export interface DaemonOpts {
+    client: HerdrClient;
+    /** Override account dir discovery. */
+    accountDirs?: string[];
+    /** Extra seconds after resetsAt before injecting. Default 60. */
+    marginSeconds?: number;
+    /** Reconcile sweep interval in ms. Default 5 * 60 * 1000. */
+    sweepIntervalMs?: number;
+    /** Abort the daemon loop. */
+    signal?: AbortSignal;
+    /** Injectable logger. Defaults to stderr. */
+    log?: Logger;
+    /** Injectable clock. Defaults to Date.now. */
+    now?: () => number;
+    /** Injectable sleep. Defaults to setTimeout promise. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Injectable fetchUsage for DI in tests. */
+    fetchUsageFn?: typeof fetchUsage;
+    /** Injectable readAccessToken for DI in tests. */
+    readTokenFn?: typeof readAccessToken;
+    /** Injectable discoverAccountDirs for DI in tests. */
+    discoverDirsFn?: typeof discoverAccountDirs;
+    /** Injectable resolveAccountDir for DI in tests. */
+    resolveAccountDirFn?: typeof resolveAccountDir;
+}
+export declare function runDaemon(opts: DaemonOpts): Promise<void>;
+//# sourceMappingURL=daemon.d.ts.map