agent-relay-orchestrator 0.59.0 → 0.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.35"
+    "agent-relay-sdk": "0.2.36"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/terminal-stream.ts

@@ -68,6 +68,10 @@ interface PendingCommand {
   resolve: (lines: string[]) => void;
   reject: (err: Error) => void;
   timer: ReturnType<typeof setTimeout> | null;
+  // Fired SYNCHRONOUSLY when this command's reply block closes — before readLoop hands any
+  // later same-chunk %output to enqueue(). The resync screen-capture uses it to snapshot the
+  // pre-capture delta boundary (#275 dedup); see snapshotPreCaptureDeltas.
+  onFinishSync?: () => void;
 }
 // On attach we include this many lines of tmux scrollback ABOVE the current screen so the
 // viewer can scroll back through pre-attach history (the client lands on the live screen;
@@ -352,6 +356,12 @@ class SessionStream {
   // long the ground gate has been deferring (for the CAN fallback).
   private resyncInFlight = false;
   private groundDeferStart = 0;
+  // #275 dedup: deltas that were in `pending` at the resync capture's %end — the PRE-capture
+  // %output. doResync drains exactly these before the repaint; %output that arrives after the
+  // capture (even later in the same readLoop chunk) accumulates in a fresh `pending` and
+  // applies ON TOP of the repaint on the trailing flush, never re-scrolled beneath it.
+  private resyncPreCapture: Uint8Array[] | null = null;
+  private resyncPreCaptureBytes = 0;
 
   constructor(
     private readonly session: string,
@@ -456,6 +466,11 @@ class SessionStream {
     const entry = this.pendingCommands.shift();
     if (!entry) return; // unexpected extra block — drop it rather than mis-correlate
     if (entry.timer) clearTimeout(entry.timer);
+    // Snapshot the delta boundary NOW, synchronously, before resolve() and before readLoop
+    // processes any further %output in this chunk — so the boundary is exactly this block's %end.
+    if (entry.onFinishSync) {
+      try { entry.onFinishSync(); } catch {}
+    }
     if (isError) entry.reject(new Error(block.lines.join(" ").trim() || "tmux command error"));
     else entry.resolve(block.lines.map(latin1LineToUtf8));
   }
@@ -587,16 +602,22 @@ class SessionStream {
     this.resyncInFlight = true;
     try {
       const repaint = await this.resyncRepaint();
-      if (!repaint || this.closed || this.subscribers.size === 0) return;
-      // Ordering (#275): every %output read before the capture's %end is already in
-      // `pending`; drain it to subscribers BEFORE the repaint so scrolled lines can't
-      // re-apply on top of it (the duplicate-text race). Deltas after %end describe
-      // post-capture changes and correctly apply on top of the repaint next flush.
-      this.flush();
+      // Ordering (#275): the %output snapshotted at the capture's %end (resyncPreCapture) is
+      // the PRE-capture stream — drain it to subscribers BEFORE the repaint so scrolled lines
+      // can't re-apply on top of it (the duplicate-text race). %output that arrived AFTER the
+      // capture stayed in `pending` and applies on top of the repaint via the trailing flush.
+      this.drainPreCaptureDeltas();
+      if (!repaint || this.closed || this.subscribers.size === 0) {
+        this.flush(); // release any post-capture deltas normally (no repaint to inject)
+        return;
+      }
       const out = forceAbort ? this.prependCan(repaint) : repaint;
       this.broadcast(out);
+      this.flush(); // post-capture deltas, on top of the fresh repaint
       tdbg(`resync ${this.session} bytes=${out.length} viewers=${this.subscribers.size}${forceAbort ? " (forced)" : ""}`);
     } catch (e) {
+      this.drainPreCaptureDeltas();
+      this.flush();
       tdbg(`resync ${this.session} failed: ${errMessage(e)}`);
     } finally {
       this.resyncInFlight = false;
@@ -628,12 +649,58 @@ class SessionStream {
   // The grid + cursor are read in-band through the control client (#275), so the capture
   // is serialized with %output deltas and costs no process spawn.
   private async resyncRepaint(): Promise<Uint8Array | null> {
-    const body = await this.readScreen();
-    if (!body) return null;
+    // ORDER IS LOAD-BEARING for the #275 dedup. The screen capture is the serialization
+    // point: doResync drains `pending` (pre-capture %output) and emits this repaint right
+    // after. So the capture MUST be the LAST in-band read here — any awaited round-trip
+    // after it (the old readCursorState/paneDims) lets live %output land in `pending` that
+    // doResync then flushes BEFORE this now-stale repaint, re-scrolling lines the repaint
+    // still shows on-screen into the client's scrollback → duplicated text under load.
+    // Read the cursor first; reuse the cached row count (resize drives its own backfill, so
+    // termRows is authoritative without a round-trip); capture the grid last.
     const cursor = await this.readCursorState();
-    const dims = await this.paneDims();
-    const rows = dims.rows ?? this.termRows;
-    return new TextEncoder().encode(buildInPlaceRepaint(body, rows, cursor));
+    // Capture LAST, and tag it so its %end snapshots the pre-capture delta boundary (the
+    // capture-pane reply IS the serialization point against the %output stream).
+    const lines = await this.command(
+      `capture-pane -p -e -t "${this.session}"`,
+      true,
+      () => this.snapshotPreCaptureDeltas(),
+    ).catch(() => null);
+    const body = lines ? lines.join("\n") : "";
+    if (!body) return null;
+    return new TextEncoder().encode(buildInPlaceRepaint(body, this.termRows, cursor));
+  }
+
+  // Swap the live `pending` buffer aside at the resync capture's %end: these chunks are the
+  // PRE-capture %output (drained before the repaint), and a fresh `pending` collects anything
+  // after (applied on top, next flush). Runs synchronously inside finishBlock (#275).
+  private snapshotPreCaptureDeltas(): void {
+    this.resyncPreCapture = this.pending;
+    this.resyncPreCaptureBytes = this.pendingBytes;
+    this.pending = [];
+    this.pendingBytes = 0;
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  // Broadcast the snapshotted pre-capture deltas (mirrors flush()'s ANSI-state bookkeeping)
+  // ahead of the repaint. No-op when nothing was snapshotted (capture timed out / errored).
+  private drainPreCaptureDeltas(): void {
+    const chunks = this.resyncPreCapture;
+    const total = this.resyncPreCaptureBytes;
+    this.resyncPreCapture = null;
+    this.resyncPreCaptureBytes = 0;
+    if (!chunks || total === 0) return;
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this.broadcastState = scanAnsiState(merged, this.broadcastState);
+    this.broadcast(merged);
+    if (this.broadcastState === "ground") this.fireGroundWaiters();
   }
 
   // Read tmux's authoritative grid (styled) plus a consistent cursor, and turn it into a
@@ -793,14 +860,14 @@ class SessionStream {
   // Write a command to the control client's stdin and register a FIFO entry for its reply
   // block. `wantReply` commands resolve with the block's lines (or reject on %error /
   // timeout); fire-and-forget commands resolve with [] once their empty block closes.
-  private command(line: string, wantReply = false): Promise<string[]> {
+  private command(line: string, wantReply = false, onFinishSync?: () => void): Promise<string[]> {
     if (this.closed) return wantReply ? Promise.reject(new Error("terminal stream closed")) : Promise.resolve([]);
     const stdin = this.proc?.stdin;
     if (!stdin || typeof stdin === "number") {
       return wantReply ? Promise.reject(new Error("control client unavailable")) : Promise.resolve([]);
     }
     return new Promise<string[]>((resolve, reject) => {
-      const entry: PendingCommand = { wantReply, lines: [], resolve, reject, timer: null };
+      const entry: PendingCommand = { wantReply, lines: [], resolve, reject, timer: null, onFinishSync };
       if (wantReply) entry.timer = setTimeout(() => this.commandTimeout(entry), COMMAND_TIMEOUT_MS);
       this.pendingCommands.push(entry);
       try {