agent-relay 10.1.0 → 10.2.0

package/dist/cli/lib/attach.d.ts

@@ -37,26 +37,146 @@ export interface AttachSnapshotResult {
     cols?: number;
     /** Cursor position `[row, col]`, 1-indexed, if the call succeeded. */
     cursor?: [number, number];
+    /**
+     * Cumulative per-worker byte offset the grid had consumed when the
+     * snapshot was captured. Used to reconcile the snapshot against buffered
+     * `worker_stream` chunks (drop `offset <= this`, apply the rest).
+     * `undefined` on brokers that predate stream-offset support.
+     */
+    offset?: number;
     /** Human-readable detail for error variants. */
     message?: string;
 }
 /**
  * Fetch a worker's current visible screen as ANSI reproduction bytes and
- * write them to the caller's output. Callers should invoke this BEFORE
- * subscribing to the WebSocket event stream so the user sees the agent's
- * current state before live deltas start arriving.
+ * write them to the caller's output.
  *
- * There is a tiny window between the snapshot capture and the live stream
- * starting in which the agent's output could be missed (≤10ms in practice).
- * Most TUI agents repaint heavily so the next update overwrites anything
- * lost; subscribe-first + buffer + drain would close the gap at the cost
- * of risking double-application of bytes that arrive in both the snapshot
- * and the buffered stream, which is the worse failure mode for TUIs.
+ * The attach clients open and subscribe to the WebSocket event stream
+ * *first*, buffer incoming `worker_stream` chunks, then call this to paint
+ * the snapshot, and finally reconcile the buffer against the snapshot's
+ * `offset` (see {@link StreamSyncBuffer}). That ordering closes the gap
+ * between the snapshot and the live stream: no output emitted around attach
+ * time is lost, and the per-worker byte offset lets the client drop exactly
+ * the chunks the snapshot already reflects so nothing is double-applied.
+ *
+ * On brokers that don't report an `offset`, the clients fall back to
+ * snapshot-authoritative behaviour (paint the snapshot, discard chunks that
+ * arrived before it), which trades a tiny gap for no duplication — the same
+ * bias the pre-offset code had.
  *
  * @returns A status describing the outcome. `ok` means the screen was
- * rendered; other variants carry a message the caller can surface.
+ * rendered; other variants carry a message the caller can surface. `offset`
+ * is populated on `ok` when the broker reports one.
  */
 export declare function captureAndRenderSnapshot(connection: AttachSnapshotConnection, agentName: string, deps: AttachSnapshotDeps): Promise<AttachSnapshotResult>;
+/**
+ * Reconciles a visible-screen snapshot with the live `worker_stream` byte
+ * stream so an attaching client neither loses nor double-applies output
+ * around attach time.
+ *
+ * Usage (subscribe-first):
+ *
+ *   1. Open + subscribe the event WS. Feed every `worker_stream` chunk to
+ *      {@link push} as it arrives, applying the chunk only when `push`
+ *      returns `true`.
+ *   2. Fetch and paint the snapshot.
+ *   3. Call {@link reconcile} with the snapshot's `offset`. Apply the
+ *      returned chunks in order. From then on, `push` returns `true` for
+ *      every chunk (live pass-through).
+ *
+ * Correlation rule: the snapshot reflects every byte with offset `<=`
+ * `snapshotOffset`. A buffered chunk carries the cumulative byte offset at
+ * its *end*; if that end offset is `<=` the snapshot offset the chunk is
+ * already on screen and is dropped, otherwise it is applied.
+ *
+ * The snapshot offset is retained as a post-reconcile *watermark*: once
+ * buffering ends, {@link push} keeps suppressing any live frame whose end
+ * offset is `<=` the watermark. This closes a broker-side race — the PTY
+ * reader advances `consumed_offset` and the grid *before* the decoded chunk
+ * reaches the broadcast queue, so a chunk with `offset <= snapshotOffset`
+ * can still arrive *after* the client reconciles. Offsets are cumulative and
+ * monotonic, so the watermark drops exactly those already-painted stragglers
+ * without touching genuinely new output.
+ */
+export declare class StreamSyncBuffer {
+    private buffering;
+    private readonly buffered;
+    /**
+     * Post-reconcile suppression watermark: the snapshot offset the grid had
+     * already painted. `undefined` until {@link reconcile} runs with a defined
+     * offset (or forever, on brokers without offset support / after
+     * {@link flushAll}), in which case no post-reconcile suppression happens.
+     */
+    private watermark;
+    /**
+     * Record a live `worker_stream` chunk. Returns `true` when the caller
+     * should apply the chunk immediately, `false` when the chunk must be held
+     * or dropped. While buffering, the chunk is retained for {@link reconcile}.
+     * After reconcile, a chunk whose end offset is `<=` the snapshot watermark
+     * is a late-arriving straggler the snapshot already painted and is
+     * suppressed (see the class docstring's race note); everything else passes
+     * through live.
+     */
+    push(chunk: string, offset: number | undefined): boolean;
+    /**
+     * Reconcile the buffered chunks against the painted snapshot's offset and
+     * return the chunks to apply, in order. Switches to live pass-through and
+     * arms the post-reconcile watermark (see {@link push}).
+     *
+     * When `snapshotOffset` is `undefined` (broker without offset support) all
+     * buffered chunks are discarded: they arrived before the snapshot was
+     * painted, so dropping them matches the snapshot-authoritative fallback
+     * and avoids double-painting what the snapshot already shows. No watermark
+     * is armed in that case — there is no offset to compare live frames to.
+     */
+    reconcile(snapshotOffset: number | undefined): string[];
+    /**
+     * Return every buffered chunk unchanged and switch to live pass-through.
+     * Used when no snapshot was painted (transient snapshot failure): there is
+     * nothing to reconcile against, so applying everything preserves output
+     * rather than dropping the buffered live stream.
+     */
+    flushAll(): string[];
+    /** True while chunks are still being buffered (before reconcile). */
+    get isBuffering(): boolean;
+}
+/**
+ * Conservative terminal-reset control sequence emitted on detach (see #1247).
+ *
+ * A drive/view/passthrough session paints the agent's snapshot (which now
+ * re-emits terminal modes) and then relays the live stream, either of which can
+ * leave the *local* terminal in application-cursor-keys, mouse-reporting,
+ * bracketed-paste, or alt-screen mode. Without a reset on detach the user is
+ * dropped back to their shell with arrows emitting escape codes, mouse clicks
+ * spewing coordinates, or a blank alt screen.
+ *
+ * The sequence is intentionally direction-explicit and idempotent. Ordering is
+ * load-bearing (see #1251): a few of these controls move the cursor, and
+ * `\x1b[?1049l` (leave alt screen) *restores* the main-buffer cursor that was
+ * saved on alt-screen entry. Anything that homes the cursor must therefore run
+ * *before* the alt-screen leave, or it clobbers that restored position and the
+ * next shell prompt lands at top-left. Two controls home the cursor:
+ *
+ *  - `\x1b[r` (DECSTBM scroll-region reset) homes the cursor on xterm/DEC-style
+ *    terminals. The scroll-region margins are shared terminal state, so
+ *    resetting them while still in the alt buffer heals a stale region and the
+ *    homing is harmless (the pending `?1049l` restore supersedes it).
+ *  - `\x1b[?6l` (DECOM origin-mode reset) also moves the cursor to home per the
+ *    DEC spec, so it belongs in the same pre-leave group.
+ *
+ * Everything after the alt-screen leave is position-independent (mode flags
+ * that never move the cursor): show cursor, application cursor keys off,
+ * autowrap on, every mouse-reporting mode off, bracketed paste off, numeric
+ * keypad, and a final SGR reset. Only written when stdout is a TTY, consistent
+ * with how the sessions gate raw-mode restore and the status line.
+ */
+export declare const LOCAL_TERMINAL_RESET_SEQUENCE: string;
+/**
+ * Emit {@link LOCAL_TERMINAL_RESET_SEQUENCE} to the local terminal on detach,
+ * but only when stdout is a TTY. A no-op for piped/redirected stdout so the
+ * reset never corrupts a captured log.
+ */
+export declare function resetLocalTerminalOnDetach(write: (chunk: string) => void, isTty: boolean): void;
 /** ----- Interactive attach prep helpers ----- */
 /** Validated attach target: trimmed agent name + resolved broker connection. */
 export interface AttachTarget {
@@ -97,6 +217,8 @@ export declare function syncInitialPtySize(connection: BrokerConnection, name: s
 } | null, verb: string, deps: {
     fetch: typeof globalThis.fetch;
     log: (...args: unknown[]) => void;
+}, options?: {
+    sessionId?: string;
 }): Promise<void>;
 /**
  * Read the worker's prior inbound delivery mode and flip it to
@@ -114,7 +236,167 @@ export declare function switchInboundDeliveryModeOrAbort(connection: BrokerConne
     error: (...args: unknown[]) => void;
 }): Promise<{
     previousMode: InboundDeliveryMode | null;
+    sessionRevision: string | null;
 } | null>;
+/**
+ * Upper bound (ms) on the best-effort detach teardown — resize-ownership
+ * release and inbound-delivery-mode restore. Both are HTTP round-trips to the
+ * broker that can stall if the broker is down; the terminal must still exit
+ * promptly, so `finish()` resolves the exit code once these settle *or* this
+ * deadline elapses, whichever comes first. The broker's idle-takeover net
+ * still frees any ownership left behind.
+ */
+export declare const DETACH_CLEANUP_DEADLINE_MS = 2000;
+/**
+ * Best-effort restore of a worker's inbound delivery mode on detach.
+ *
+ * Two hazards this guards against (see #1247):
+ *
+ *  1. Concurrent-change race — a second session attaching while this one is
+ *     active would read *this* session's mode as the "previous" one, so blindly
+ *     writing `previousMode` back on detach can clobber a change another
+ *     session/CLI made in the meantime. We restore via the broker's atomic
+ *     compare-and-set (`expectedMode: sessionMode`): the broker applies
+ *     `previousMode` only if the worker's current mode still equals what *this*
+ *     session set, and no-ops (`matched: false`) otherwise. This removes the
+ *     read-then-set TOCTOU a client-side re-read still had (a change landing
+ *     between the read and the restore PUT).
+ *  2. Failed initial read — when the pre-attach mode was never learned
+ *     (`previousMode === null`), forcing a default (`auto_inject`) would
+ *     silently cancel an explicit `agent message hold`. In that case we leave
+ *     the mode untouched and warn.
+ *
+ * The broker's monotonic mode revision closes ABA races where another session
+ * changes the mode away and back to `sessionMode` before this restore.
+ */
+export declare function restoreInboundDeliveryModeOnDetach(connection: BrokerConnection, name: string, previousMode: InboundDeliveryMode | null, sessionMode: InboundDeliveryMode, sessionRevision: string | null, verb: string, deps: {
+    fetch: typeof globalThis.fetch;
+    log: (...args: unknown[]) => void;
+}): Promise<void>;
+/**
+ * Streaming scanner that tracks whether a byte stream currently *ends* inside
+ * an incomplete ANSI escape sequence (ESC, CSI, OSC, or DCS/SOS/PM/APC string).
+ *
+ * The attach status line wraps its repaint in cursor save/restore controls;
+ * splicing that in while the agent is mid-transmission of its own CSI sequence
+ * corrupts the agent's output. Feeding every server chunk through this scanner
+ * lets the status painter hold its repaint until the stream is back at a
+ * sequence boundary. State persists across chunks (a sequence may span several
+ * `worker_stream` frames).
+ *
+ * Only ASCII control bytes drive the state machine; multi-byte UTF-8 payload
+ * bytes are printable in the ground state and never appear inside a CSI/escape
+ * sequence, so scanning UTF-16 code units is safe here.
+ */
+export declare class AnsiBoundaryScanner {
+    private state;
+    push(chunk: string): void;
+    reset(): void;
+    /** True when the stream ends at a safe boundary (not mid-sequence). */
+    get atBoundary(): boolean;
+    private step;
+}
+/** Options for {@link StatusLineController}. Timers are injectable for tests. */
+export interface StatusLineControllerOptions {
+    /** Produce the current status-line ANSI string. */
+    render: () => string;
+    /** Write to stdout. */
+    write: (chunk: string) => void;
+    /** When false (stdout is not a TTY) the status line is never painted. */
+    enabled: boolean;
+    /**
+     * Minimum ms between repaints. `0` paints on every request (no coalescing);
+     * a positive value coalesces bursts of per-chunk repaints into at most one
+     * paint per window, shrinking the splice/DECSC-clobber window.
+     */
+    coalesceMs: number;
+    /**
+     * Max ms to hold a repaint while output keeps ending mid escape-sequence
+     * before painting anyway (bounded residual splice risk). Default 100.
+     */
+    boundaryHoldMs?: number;
+    setTimer?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (t: ReturnType<typeof setTimeout>) => void;
+    now?: () => number;
+}
+/**
+ * Coordinates status-line repaints for the interactive attach clients.
+ *
+ * Correctness properties (see #1247):
+ *  - **Non-TTY skip** — when `enabled` is false, nothing is ever written.
+ *  - **Boundary-hold** — a repaint is deferred while the observed output ends
+ *    mid ANSI escape sequence, so the status line never splices into a
+ *    half-transmitted CSI. It paints as soon as the next chunk lands at a
+ *    boundary (or after `boundaryHoldMs` as a bounded fallback).
+ *  - **Coalescing** — repaints are rate-limited to at most one per
+ *    `coalesceMs`, shrinking the window in which our save/restore-cursor wrap
+ *    can clobber the agent's own pending DECSC.
+ *  - **Teardown-safe** — after {@link dispose} no further writes happen.
+ *
+ * Residual risk (documented): ESC 7/ESC 8 (and CSI s/u) share a single
+ * saved-cursor slot on many terminals, so a repaint landing between the
+ * agent's DECSC and DECRC can still restore to the wrong spot. Boundary-hold +
+ * coalescing shrink but do not eliminate that window.
+ */
+export declare class StatusLineController {
+    private readonly opts;
+    private readonly scanner;
+    private timer;
+    private timerForce;
+    private wantPaint;
+    private lastPaintAt;
+    private disposed;
+    constructor(opts: StatusLineControllerOptions);
+    /** Record server output for boundary tracking; flush a held repaint if the
+     *  stream is now back at a sequence boundary. */
+    observeOutput(chunk: string): void;
+    /** Request a repaint (coalesced + boundary-held). */
+    request(): void;
+    /** Stop all painting and cancel any pending timer. */
+    dispose(): void;
+    private now;
+    private flush;
+    private paintNow;
+    private arm;
+    private clearTimer;
+}
+/** Minimal writable surface {@link createBackpressureAwareWriter} needs. */
+export interface BackpressureWritable {
+    write(chunk: string): boolean;
+    once(event: 'drain', listener: () => void): unknown;
+    off?(event: 'drain', listener: () => void): unknown;
+    removeListener?(event: 'drain', listener: () => void): unknown;
+}
+/**
+ * A backpressure-aware writer plus a teardown hook. Call the writer with each
+ * chunk; call {@link BackpressureAwareWriter.dispose} on detach to drop any
+ * still-queued chunks and unhook the pending `'drain'` listener so nothing
+ * flushes to stdout after the session tears down.
+ */
+export interface BackpressureAwareWriter {
+    /** Write a chunk, respecting backpressure. No-op after {@link dispose}. */
+    write: (chunk: string) => void;
+    /** Drop the pending queue and unhook the `'drain'` listener. Idempotent. */
+    dispose: () => void;
+}
+/**
+ * Default stdout writer that respects backpressure (see #1247, item 7).
+ *
+ * When the underlying stream reports saturation (`write()` returns false) we
+ * hold subsequent chunks in a bounded in-memory queue and flush them on
+ * `'drain'`, rather than letting Node's stdout buffer grow without limit under
+ * a fast agent + slow terminal.
+ *
+ * FIFO is preserved even when our own queue reaches `maxQueuedBytes`: rather
+ * than writing the overflow chunk straight through (which would jump it ahead
+ * of older queued chunks and reorder/split the PTY byte stream), we first flush
+ * the entire local queue into stdout's internal buffer — `stdout.write` buffers
+ * internally when saturated, so ignoring its return value here is safe — then
+ * write the new chunk last. Bounded extra buffering, never dropped or reordered
+ * output. Documented residual risk: under sustained overload Node's internal
+ * stdout buffer can still grow.
+ */
+export declare function createBackpressureAwareWriter(stdout: BackpressureWritable, maxQueuedBytes?: number): BackpressureAwareWriter;
 /** Dependencies for `captureInitialSnapshot`. `captureAndRenderSnapshot`
  *  is injectable so tests can substitute a stub. */
 export interface CaptureInitialSnapshotDeps extends AttachSnapshotDeps {

package/dist/cli/lib/attach.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC7B,MAAM,wBAAwB,CAAC;AAGhC,uEAAuE;AACvE,MAAM,WAAW,wBAAwB;IACvC,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;mBACmB;AACnB,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC/B,0EAA0E;IAC1E,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED;;sDAEsD;AACtD,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,IAAI,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,GAAG,iBAAiB,CAAC;IAC1E,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,wBAAwB,EACpC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,oBAAoB,CAAC,CAgD/B;AAED,kDAAkD;AAElD,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,gBAAgB,CAAC;CAC9B;AAED,+EAA+E;AAC/E,MAAM,WAAW,uBAAwB,SAAQ,oBAAoB;IACnE,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACrC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,uBAAuB,EAChC,IAAI,EAAE,uBAAuB,GAC5B,YAAY,GAAG,IAAI,CAerB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,EAChD,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,GAAG,SAAS,CAIpB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,EAChD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE;IAAE,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAAC,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;CAAE,GAC1E,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gCAAgC,CACpD,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,mBAAmB,EAC/B,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE;IAAE,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;CAAE,GAC5E,OAAO,CAAC;IAAE,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,CAAC,CAoB9D;AAED;oDACoD;AACpD,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;IACpE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAClC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,wBAAwB,CAAC,EAAE,OAAO,wBAAwB,CAAC;CAC5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,mBAAmB,GAAG,IAAI,EACxC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,0BAA0B,GAC/B,OAAO,CAAC;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAiC3C"}
+{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/attach.ts"],"names":[],"mappings":"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"}