@tigorhutasuhut/herdr-claude-retry 0.1.1 → 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/cli.js

@@ -102,17 +102,9 @@ async function main() {
     const ac = new AbortController();
     process.on('SIGINT', () => ac.abort());
     process.on('SIGTERM', () => ac.abort());
-    // Construct clients (separate sockets: one for RPC, one for event subscription)
+    // Construct client
     const client = new HerdrClient({ socketPath });
-    const subscribeClient = new HerdrClient({ socketPath });
-    // Wire reconnect log events
-    client.onReconnect = () => {
-        logFn({ event: 'socket.connected' });
-    };
-    subscribeClient.onReconnect = () => {
-        logFn({ event: 'socket.connected', role: 'subscribe' });
-    };
-    // Connect
+    // Connect (connectivity check — open+close a socket)
     logFn({ event: 'daemon.start', version: VERSION, socket_path: socketPath });
     try {
         await client.connect();
@@ -123,21 +115,10 @@ async function main() {
         process.stderr.write(`fatal: could not connect to ${socketPath}: ${err}\n`);
         process.exit(1);
     }
-    try {
-        await subscribeClient.connect();
-        logFn({ event: 'socket.connected', role: 'subscribe' });
-    }
-    catch (err) {
-        logFn({ level: 'error', event: 'socket.dead', role: 'subscribe' });
-        client.destroy();
-        process.stderr.write(`fatal: could not connect subscribe socket to ${socketPath}: ${err}\n`);
-        process.exit(1);
-    }
     // Run daemon — map daemon's string logger to structured events
     try {
         await runDaemon({
             client,
-            subscribeClient,
             marginSeconds,
             sweepIntervalMs: sweepIntervalSeconds * 1000,
             signal: ac.signal,
@@ -146,7 +127,6 @@ async function main() {
     }
     finally {
         client.destroy();
-        subscribeClient.destroy();
         logFn({ event: 'daemon.stop', reason: ac.signal.aborted ? 'signal' : 'exit' });
     }
 }

package/dist/daemon.d.ts

@@ -10,17 +10,6 @@ import { readAccessToken, fetchUsage } from './usage.ts';
 import type { Logger } from './monitor.ts';
 export interface DaemonOpts {
     client: HerdrClient;
-    /**
-     * Separate client used exclusively for event subscriptions.
-     *
-     * herdr closes any connection that sends non-subscribe requests after
-     * `events.subscribe` — so requests (pane.read, agent.list, inject) and the
-     * subscription stream must use different sockets. When provided, `client` is
-     * used only for regular requests and `subscribeClient` is used only for
-     * `events.subscribe`. Both must already be connected. Defaults to `client`
-     * when omitted (fine for unit tests with a mock that handles both).
-     */
-    subscribeClient?: HerdrClient;
     /** Override account dir discovery. */
     accountDirs?: string[];
     /** Extra seconds after resetsAt before injecting. Default 60. */

package/dist/daemon.js

@@ -52,7 +52,7 @@ async function resolveUsage(paneId, client, accountDirs, opts) {
 // Main daemon
 // ---------------------------------------------------------------------------
 export async function runDaemon(opts) {
-    const { client, subscribeClient = client, marginSeconds = 60, sweepIntervalMs = 5 * 60 * 1000, signal, log = (msg) => process.stderr.write(`[herdr] ${msg}\n`), now = () => Date.now(), sleep = (ms) => new Promise((r) => setTimeout(r, ms)), fetchUsageFn = fetchUsage, readTokenFn = readAccessToken, discoverDirsFn = discoverAccountDirs, resolveAccountDirFn = resolveAccountDir, } = opts;
+    const { client, marginSeconds = 60, sweepIntervalMs = 5 * 60 * 1000, signal, log = (msg) => process.stderr.write(`[herdr] ${msg}\n`), now = () => Date.now(), sleep = (ms) => new Promise((r) => setTimeout(r, ms)), fetchUsageFn = fetchUsage, readTokenFn = readAccessToken, discoverDirsFn = discoverAccountDirs, resolveAccountDirFn = resolveAccountDir, } = opts;
     // Discover account dirs (or use override)
     const accountDirs = opts.accountDirs ?? await discoverDirsFn().catch(() => []);
     log(`daemon starting — ${accountDirs.length} account dir(s)`);
@@ -164,6 +164,10 @@ export async function runDaemon(opts) {
     // Event subscription loop (restart-capable, with per-pane subscriptions)
     // -------------------------------------------------------------------------
     let currentPaneIds = [];
+    // Tracks every pane id ever seen via pane_created — persists across resubscribes.
+    // Used to detect historical replays: first sighting of a pane id may trigger a
+    // resubscribe (new pane joined), subsequent sightings are always replays → ignored.
+    const knownCreatedPaneIds = new Set();
     async function buildSubscriptions() {
         let agents = [];
         try {
@@ -171,6 +175,9 @@ export async function runDaemon(opts) {
         }
         catch { /* sweep will catch it */ }
         currentPaneIds = agents.map((a) => a.pane_id);
+        // Seed knownCreatedPaneIds from live panes so initial replays are ignored.
+        for (const id of currentPaneIds)
+            knownCreatedPaneIds.add(id);
         const subs = [
             ...currentPaneIds.map((paneId) => ({
                 type: 'pane.output_matched',
@@ -199,7 +206,7 @@ export async function runDaemon(opts) {
             // Any other generator exit (socket close, pane.created) → restart.
             let shouldStop = false;
             try {
-                const events = subscribeClient.subscribe(subs, innerSignal);
+                const events = client.subscribe(subs, innerSignal);
                 for await (const ev of events) {
                     if (signal?.aborted) {
                         shouldStop = true;
@@ -219,9 +226,34 @@ export async function runDaemon(opts) {
                     }
                     else if (ev.event === 'pane_created') {
                         const paneId = ev.data.pane?.pane_id;
-                        log(`${paneId ?? 'unknown'} — pane created, resubscribing`);
-                        innerAc.abort();
-                        break;
+                        if (paneId && knownCreatedPaneIds.has(paneId)) {
+                            // Already seen this pane_created — historical replay, ignore.
+                            // No log to avoid spam from long history backlogs.
+                        }
+                        else {
+                            // First time seeing this pane_created. Check if pane is actually live
+                            // before resubscribing — historical replays for long-dead panes would
+                            // otherwise trigger N resubscribes on startup.
+                            if (paneId)
+                                knownCreatedPaneIds.add(paneId);
+                            let isLive = false;
+                            try {
+                                const live = await client.agentList();
+                                isLive = live.some((a) => a.pane_id === paneId);
+                                // Also seed known set from current live panes to prevent future replays.
+                                for (const a of live)
+                                    knownCreatedPaneIds.add(a.pane_id);
+                            }
+                            catch { /* treat as not live */ }
+                            if (isLive) {
+                                log(`${paneId} — pane created, resubscribing`);
+                                innerAc.abort();
+                                break;
+                            }
+                            else {
+                                log(`${paneId ?? 'unknown'} — pane_created for dead/historical pane, ignoring`);
+                            }
+                        }
                     }
                     else if (ev.event === 'pane_closed') {
                         const paneId = ev.data.pane_id;
@@ -245,15 +277,6 @@ export async function runDaemon(opts) {
         }
     }
     // -------------------------------------------------------------------------
-    // Reconnect-aware sweep: run sweep on connect/reconnect
-    // -------------------------------------------------------------------------
-    const prevReconnect = client.onReconnect;
-    client.onReconnect = () => {
-        prevReconnect?.();
-        log('reconnected — triggering immediate reconcile sweep');
-        reconcileSweep().catch((e) => log(`sweep error after reconnect: ${e}`));
-    };
-    // -------------------------------------------------------------------------
     // Periodic sweep timer
     // -------------------------------------------------------------------------
     async function runSweepLoop() {

package/dist/herdr.d.ts

@@ -1,8 +1,17 @@
 /**
  * herdr.ts — NDJSON socket client for the herdr daemon.
  *
- * Connects to the herdr UNIX socket, sends JSON-RPC-style requests,
- * and exposes subscription streams as async iterators.
+ * Protocol reality (herdr 0.7.1): every connection is one-shot — the server
+ * closes after ONE request-response. Subscribe connections stay open for the
+ * event stream but must NOT send a second request (kills the connection).
+ *
+ * Design:
+ *   request()   — opens a fresh socket per call, reads one response, destroys.
+ *   subscribe() — opens a dedicated socket per call, sends events.subscribe,
+ *                 awaits subscription_started, then yields events until the
+ *                 socket closes or the abort signal fires.
+ *   connect()   — connectivity check (open + close a socket).
+ *   destroy()   — aborts all live subscribe streams; prevents further use.
  */
 import { type Socket } from 'node:net';
 export type AgentStatus = 'idle' | 'working' | 'blocked' | 'done' | 'unknown';
@@ -95,23 +104,18 @@ export type ConnectFn = (path: string) => Socket;
 export declare class HerdrClient {
     private readonly socketPath;
     private readonly connectFn;
-    private socket;
-    private buffer;
-    private pendingRequests;
-    private eventListeners;
-    private reconnectDelay;
-    private readonly maxDelay;
     private destroyed;
-    onReconnect?: () => void;
+    /** AbortControllers for active subscribe streams — destroy() aborts all. */
+    private readonly subscribeAborts;
     constructor(opts?: {
         socketPath?: string;
         connectFn?: ConnectFn;
-        onReconnect?: () => void;
     });
+    /**
+     * Open a connection and immediately close it. Rejects if the socket is
+     * unreachable. Used by cli.ts startup validation.
+     */
     connect(): Promise<void>;
-    private processBuffer;
-    private handleMessage;
-    private scheduleReconnect;
     destroy(): void;
     private request;
     paneRead(pane_id: string, source?: 'visible' | 'recent' | 'recent_unwrapped' | 'detection', lines?: number): Promise<PaneRead>;
@@ -126,9 +130,15 @@ export declare class HerdrClient {
     inject(pane_id: string): Promise<void>;
     /**
      * Subscribe to a set of event types and return an async iterator of typed events.
-     * The iterator ends when `signal` is aborted or the client is destroyed.
+     *
+     * Opens a dedicated socket, sends events.subscribe, awaits subscription_started,
+     * then yields events. The generator ends when:
+     *   - the socket closes (server side)
+     *   - `signal` is aborted
+     *   - destroy() is called on this client
      */
     subscribe(subscriptions: SubscriptionSpec[], signal?: AbortSignal): AsyncGenerator<HerdrEvent>;
+    private _subscribeOnSocket;
     /**
      * Subscribe to `pane.output_matched` events for a specific pane.
      */

package/dist/herdr.js

@@ -1,8 +1,17 @@
 /**
  * herdr.ts — NDJSON socket client for the herdr daemon.
  *
- * Connects to the herdr UNIX socket, sends JSON-RPC-style requests,
- * and exposes subscription streams as async iterators.
+ * Protocol reality (herdr 0.7.1): every connection is one-shot — the server
+ * closes after ONE request-response. Subscribe connections stay open for the
+ * event stream but must NOT send a second request (kills the connection).
+ *
+ * Design:
+ *   request()   — opens a fresh socket per call, reads one response, destroys.
+ *   subscribe() — opens a dedicated socket per call, sends events.subscribe,
+ *                 awaits subscription_started, then yields events until the
+ *                 socket closes or the abort signal fires.
+ *   connect()   — connectivity check (open + close a socket).
+ *   destroy()   — aborts all live subscribe streams; prevents further use.
  */
 import { createConnection } from 'node:net';
 import { randomUUID } from 'node:crypto';
@@ -20,139 +29,115 @@ function defaultSocketPath() {
 // ---------------------------------------------------------------------------
 // HerdrClient
 // ---------------------------------------------------------------------------
+/** Default per-request timeout in milliseconds. */
+const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
 export class HerdrClient {
     socketPath;
     connectFn;
-    socket = null;
-    buffer = '';
-    pendingRequests = new Map();
-    eventListeners = [];
-    reconnectDelay = 1000;
-    maxDelay = 60_000;
     destroyed = false;
-    onReconnect;
+    /** AbortControllers for active subscribe streams — destroy() aborts all. */
+    subscribeAborts = new Set();
     constructor(opts) {
         this.socketPath = opts?.socketPath ?? defaultSocketPath();
         this.connectFn = opts?.connectFn ?? ((p) => createConnection(p));
-        if (opts?.onReconnect)
-            this.onReconnect = opts.onReconnect;
     }
     // -------------------------------------------------------------------------
-    // Connection management
+    // Connectivity check
     // -------------------------------------------------------------------------
+    /**
+     * Open a connection and immediately close it. Rejects if the socket is
+     * unreachable. Used by cli.ts startup validation.
+     */
     connect() {
         return new Promise((resolve, reject) => {
+            if (this.destroyed) {
+                reject(new Error('Client destroyed'));
+                return;
+            }
             const sock = this.connectFn(this.socketPath);
-            this.socket = sock;
-            this.buffer = '';
             sock.setEncoding('utf8');
             sock.once('connect', () => {
-                this.reconnectDelay = 1000;
+                sock.destroy();
                 resolve();
             });
             sock.once('error', (err) => {
                 reject(err);
             });
-            sock.on('data', (chunk) => {
-                this.buffer += chunk;
-                this.processBuffer();
-            });
-            sock.on('close', () => {
-                if (!this.destroyed) {
-                    this.scheduleReconnect();
-                }
-            });
         });
     }
-    processBuffer() {
-        const lines = this.buffer.split('\n');
-        // Last element may be incomplete — keep in buffer
-        this.buffer = lines.pop() ?? '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const msg = JSON.parse(trimmed);
-                this.handleMessage(msg);
-            }
-            catch {
-                // Malformed line — skip
-            }
-        }
-    }
-    handleMessage(msg) {
-        if ('event' in msg) {
-            // Push to all event listeners
-            const ev = msg;
-            for (const listener of this.eventListeners) {
-                listener(ev);
-            }
-            return;
-        }
-        if ('id' in msg) {
-            const resp = msg;
-            const pending = this.pendingRequests.get(resp.id);
-            if (!pending)
-                return;
-            this.pendingRequests.delete(resp.id);
-            if (resp.error) {
-                pending.reject(new HerdrError(resp.error.code, resp.error.message));
-            }
-            else {
-                pending.resolve(resp.result);
-            }
-        }
-    }
-    scheduleReconnect() {
-        // Reject all pending requests on disconnect
-        for (const [, { reject }] of this.pendingRequests) {
-            reject(new Error('Socket disconnected'));
-        }
-        this.pendingRequests.clear();
-        const delay = this.reconnectDelay;
-        this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxDelay);
-        setTimeout(() => {
-            if (this.destroyed)
-                return;
-            this.connect()
-                .then(() => {
-                this.onReconnect?.();
-            })
-                .catch(() => {
-                // scheduleReconnect will be triggered again by close event
-            });
-        }, delay);
-    }
     destroy() {
         this.destroyed = true;
-        this.socket?.destroy();
-        this.socket = null;
-        for (const [, { reject }] of this.pendingRequests) {
-            reject(new Error('Client destroyed'));
+        for (const ac of this.subscribeAborts) {
+            ac.abort();
         }
-        this.pendingRequests.clear();
+        this.subscribeAborts.clear();
     }
     // -------------------------------------------------------------------------
-    // Raw request
+    // Raw request — one fresh socket per call
     // -------------------------------------------------------------------------
-    request(method, params) {
+    request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
         return new Promise((resolve, reject) => {
-            if (!this.socket || this.socket.destroyed) {
-                reject(new Error('Not connected'));
+            if (this.destroyed) {
+                reject(new Error('Client destroyed'));
                 return;
             }
+            const sock = this.connectFn(this.socketPath);
+            sock.setEncoding('utf8');
+            let settled = false;
+            let buffer = '';
             const id = randomUUID();
-            const line = JSON.stringify({ id, method, params }) + '\n';
-            this.pendingRequests.set(id, {
-                resolve: (v) => resolve(v),
-                reject,
-            });
-            this.socket.write(line, (err) => {
+            const done = (err, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                sock.destroy();
                 if (err) {
-                    this.pendingRequests.delete(id);
                     reject(err);
                 }
+                else {
+                    resolve(value);
+                }
+            };
+            const timer = setTimeout(() => {
+                done(new Error(`Request timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            sock.once('error', (err) => done(err));
+            sock.on('close', () => {
+                done(new Error('Socket closed before response'));
+            });
+            sock.on('data', (chunk) => {
+                buffer += chunk;
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    let msg;
+                    try {
+                        msg = JSON.parse(trimmed);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if ('id' in msg && msg['id'] === id) {
+                        const resp = msg;
+                        if (resp.error) {
+                            done(new HerdrError(resp.error.code, resp.error.message));
+                        }
+                        else {
+                            done(null, resp.result);
+                        }
+                    }
+                }
+            });
+            sock.once('connect', () => {
+                const line = JSON.stringify({ id, method, params }) + '\n';
+                sock.write(line, (err) => {
+                    if (err)
+                        done(err);
+                });
             });
         });
     }
@@ -192,46 +177,129 @@ export class HerdrClient {
         await this.paneSendText(pane_id, 'continue\n');
     }
     // -------------------------------------------------------------------------
-    // Subscription streaming
+    // Subscription streaming — dedicated fresh socket per call
     // -------------------------------------------------------------------------
     /**
      * Subscribe to a set of event types and return an async iterator of typed events.
-     * The iterator ends when `signal` is aborted or the client is destroyed.
+     *
+     * Opens a dedicated socket, sends events.subscribe, awaits subscription_started,
+     * then yields events. The generator ends when:
+     *   - the socket closes (server side)
+     *   - `signal` is aborted
+     *   - destroy() is called on this client
      */
     async *subscribe(subscriptions, signal) {
-        if (!this.socket || this.socket.destroyed) {
-            throw new Error('Not connected');
+        if (this.destroyed) {
+            throw new Error('Client destroyed');
         }
+        const internalAc = new AbortController();
+        this.subscribeAborts.add(internalAc);
+        const effectiveSignal = signal
+            ? AbortSignal.any([signal, internalAc.signal])
+            : internalAc.signal;
+        try {
+            yield* this._subscribeOnSocket(subscriptions, effectiveSignal);
+        }
+        finally {
+            this.subscribeAborts.delete(internalAc);
+        }
+    }
+    async *_subscribeOnSocket(subscriptions, signal) {
+        if (signal.aborted)
+            return;
+        const sock = this.connectFn(this.socketPath);
+        sock.setEncoding('utf8');
+        // Wait for socket connect
+        await new Promise((resolve, reject) => {
+            if (signal.aborted) {
+                sock.destroy();
+                reject(new Error('Aborted before connect'));
+                return;
+            }
+            sock.once('connect', resolve);
+            sock.once('error', reject);
+        });
+        if (signal.aborted) {
+            sock.destroy();
+            return;
+        }
+        // Send subscribe request and wait for subscription_started
         const id = randomUUID();
-        const line = JSON.stringify({ id, method: 'events.subscribe', params: { subscriptions } }) + '\n';
-        // Wait for subscription_started
-        const started = new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, {
-                resolve: () => resolve(),
-                reject,
-            });
+        const reqLine = JSON.stringify({ id, method: 'events.subscribe', params: { subscriptions } }) + '\n';
+        await new Promise((resolve, reject) => {
+            let startedBuffer = '';
+            const onData = (chunk) => {
+                startedBuffer += chunk;
+                const lines = startedBuffer.split('\n');
+                startedBuffer = lines.pop() ?? '';
+                for (const l of lines) {
+                    const trimmed = l.trim();
+                    if (!trimmed)
+                        continue;
+                    let msg;
+                    try {
+                        msg = JSON.parse(trimmed);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if ('id' in msg && msg['id'] === id) {
+                        sock.removeListener('data', onData);
+                        const resp = msg;
+                        if (resp.error) {
+                            reject(new HerdrError(resp.error.code, resp.error.message));
+                        }
+                        else {
+                            resolve();
+                        }
+                    }
+                }
+            };
+            sock.on('data', onData);
+            sock.once('error', reject);
+            sock.write(reqLine);
         });
-        this.socket.write(line);
-        await started;
-        // Now yield events until aborted
+        if (signal.aborted) {
+            sock.destroy();
+            return;
+        }
+        // Yield events until socket closes or signal aborts
         const queue = [];
         let notify = null;
         let done = false;
-        const listener = (ev) => {
-            queue.push(ev);
-            notify?.();
+        let streamBuf = '';
+        const onStreamData = (chunk) => {
+            streamBuf += chunk;
+            const lines = streamBuf.split('\n');
+            streamBuf = lines.pop() ?? '';
+            for (const l of lines) {
+                const trimmed = l.trim();
+                if (!trimmed)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(trimmed);
+                }
+                catch {
+                    continue;
+                }
+                if ('event' in msg) {
+                    queue.push(msg);
+                    notify?.();
+                }
+            }
         };
-        this.eventListeners.push(listener);
         const cleanup = () => {
+            if (done)
+                return;
             done = true;
-            this.eventListeners = this.eventListeners.filter((l) => l !== listener);
+            sock.removeListener('data', onStreamData);
             notify?.();
         };
-        signal?.addEventListener('abort', cleanup, { once: true });
-        // Capture the socket active at subscribe time. If it closes (reconnect),
-        // terminate this generator so the caller can resubscribe on the new socket.
-        const subscribedSocket = this.socket;
-        subscribedSocket?.once('close', cleanup);
+        sock.on('data', onStreamData);
+        sock.once('close', cleanup);
+        sock.once('error', cleanup);
+        signal.addEventListener('abort', cleanup, { once: true });
         try {
             while (!done) {
                 while (queue.length > 0) {
@@ -241,7 +309,6 @@ export class HerdrClient {
                     break;
                 await new Promise((res) => {
                     notify = res;
-                    // If items arrived while we were setting notify, flush immediately
                     if (queue.length > 0 || done)
                         res();
                 });
@@ -250,8 +317,8 @@ export class HerdrClient {
         }
         finally {
             cleanup();
-            subscribedSocket?.removeListener('close', cleanup);
-            signal?.removeEventListener('abort', cleanup);
+            sock.destroy();
+            signal.removeEventListener('abort', cleanup);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigorhutasuhut/herdr-claude-retry",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Herdr daemon — monitor Claude CLI sessions and auto-retry on rate-limit and errors",
   "type": "module",
   "license": "MIT",