ragent-cli 1.11.16 → 1.11.18

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.11.16",
+      version: "1.11.18",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -4185,7 +4185,7 @@ var TranscriptWatcherManager = class {
   clearTranscriptState(sessionId) {
     this.sendSnapshotFn(sessionId, [], 0);
     if (this.sendV2SnapshotFn) {
-      this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0);
+      this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0, true);
     }
   }
   /**
@@ -4271,7 +4271,7 @@ var TranscriptWatcherManager = class {
       }
       this.sendSnapshotFn(sessionId, [], 0);
       if (this.sendV2SnapshotFn) {
-        this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0);
+        this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0, true);
       }
       newWatcher.replayFromStart();
       this.active.set(sessionId, { watcher: newWatcher, filePath: newPath, agentType: agentType ?? "" });
@@ -10857,6 +10857,9 @@ var import_node_string_decoder = require("string_decoder");
 var pty = __toESM(require("node-pty"));
 var log17 = createLogger("session-streamer");
 var BACKPRESSURE_RESUME_CHECK_MS = 100;
+var LIVENESS_CHECK_TICKS = 30;
+var DEAD_PIPE_STRIKES = 2;
+var REESTABLISH_BACKOFF_MS = 3e4;
 var STOP_DEBOUNCE_MS = 2e3;
 var MAX_CONCURRENT_STREAMS = 20;
 var MAX_SESSION_BUFFER_BYTES = 64 * 1024;
@@ -10979,11 +10982,19 @@ var SessionStreamer = class {
   lastSeenDroppedFrames = 0;
   /** Sessions whose viewers need a capture-pane resync after frame drops. */
   pendingDropResync = /* @__PURE__ */ new Set();
-  constructor(sendFn, onStreamStopped, sendResetFn, onFramesDropped) {
+  /** Whether the relay socket is currently OPEN. Used to (a) gate resync delivery
+   *  so resync bytes aren't buffered-then-discarded under reconnect churn, and
+   *  (b) gate the liveness watchdog's re-establish so its capture burst lands. */
+  isReadyFn;
+  /** Tick counter for the resume timer; the pipe-liveness check runs every
+   *  LIVENESS_CHECK_TICKS ticks rather than on every 100ms tick. */
+  livenessTick = 0;
+  constructor(sendFn, onStreamStopped, sendResetFn, onFramesDropped, isReadyFn) {
     this.sendFn = sendFn;
     this.onStreamStopped = onStreamStopped;
     this.sendResetFn = sendResetFn;
     this.onFramesDropped = onFramesDropped;
+    this.isReadyFn = isReadyFn ?? (() => true);
     this.cleanupStaleStreams();
     this.startBackpressureResumeTimer();
   }
@@ -11037,8 +11048,110 @@ var SessionStreamer = class {
           this.resyncStream(next.value);
         }
       }
+      if (this.isReadyFn()) {
+        for (const stream of this.active.values()) {
+          if (stream.needsResync && !stream.stopped && stream.streamType === "tmux-pipe" && !stream.initializing) {
+            stream.needsResync = false;
+            this.resyncStream(stream.sessionId);
+            break;
+          }
+        }
+      }
+      if (++this.livenessTick >= LIVENESS_CHECK_TICKS) {
+        this.livenessTick = 0;
+        if (this.isReadyFn()) this.checkPipeLiveness();
+      }
     }, BACKPRESSURE_RESUME_CHECK_MS);
   }
+  /**
+   * Re-establish a tmux-pipe stream whose `pane_pid` indicates a program swap
+   * (tmux-resurrect restore, pane reuse, exec) or whose pipe-pane is alive in
+   * tmux's view (`pane_pipe=1`) but no longer feeds our FIFO.
+   *
+   * Why this exists: `pipe-pane` is set up exactly once at stream start. tmux
+   * reports `pipe=1` afterwards even when it has stopped delivering bytes (e.g.
+   * the pane was recreated by a restore racing the connector restart). The
+   * `cat` reader blocks forever rather than exiting, so the normal exit cleanup
+   * never fires, and `resyncStream` deliberately does NOT restart pipe-pane —
+   * so without this the pane is frozen until the stream is torn down by hand.
+   *
+   * Batched into one `tmux list-panes -a` call so liveness costs one fork.
+   */
+  checkPipeLiveness() {
+    const tmuxStreams = [...this.active.values()].filter(
+      (s) => s.streamType === "tmux-pipe" && !s.stopped && !s.initializing
+    );
+    if (tmuxStreams.length === 0) return;
+    const panes = this.readAllPaneInfo();
+    if (!panes) return;
+    const now2 = Date.now();
+    const dead = [];
+    for (const stream of tmuxStreams) {
+      const info = panes.get(stream.paneTarget);
+      if (!info) continue;
+      const backedOff = stream.lastReestablishAt !== void 0 && now2 - stream.lastReestablishAt < REESTABLISH_BACKOFF_MS;
+      if (stream.panePid && info.panePid !== stream.panePid) {
+        if (!backedOff) {
+          dead.push({
+            sessionId: stream.sessionId,
+            reason: "pane program swapped",
+            detail: { oldPid: stream.panePid, newPid: info.panePid }
+          });
+        }
+        continue;
+      }
+      const bytesNow = stream.bytesReceived ?? 0;
+      const paneMoved = info.fingerprint !== stream.lastLivenessFingerprint;
+      const fifoSilent = bytesNow === (stream.lastLivenessBytes ?? 0);
+      if (paneMoved && fifoSilent) {
+        stream.deadPipeStrikes = (stream.deadPipeStrikes ?? 0) + 1;
+        if (stream.deadPipeStrikes >= DEAD_PIPE_STRIKES && !backedOff) {
+          dead.push({
+            sessionId: stream.sessionId,
+            reason: "pipe-pane silent while pane active",
+            detail: { strikes: stream.deadPipeStrikes }
+          });
+        }
+      } else {
+        stream.deadPipeStrikes = 0;
+      }
+      stream.lastLivenessBytes = bytesNow;
+      stream.lastLivenessFingerprint = info.fingerprint;
+    }
+    if (dead.length === 0) return;
+    const [first, ...rest] = dead;
+    log17.warn(`${first.reason}; re-establishing stream`, { sessionId: first.sessionId, ...first.detail });
+    if (rest.length > 0) {
+      log17.info("more dead streams queued for re-establish (one per tick)", { remaining: rest.length });
+    }
+    this.reestablishTmuxStream(first.sessionId);
+  }
+  /**
+   * Tear down a tmux-pipe stream's pipe-pane/FIFO/cat and start a fresh one for
+   * the same sessionId, preserving its viewer set. Sends a new stream-reset +
+   * capture so the portal hard-repaints the pane. Uses a LEAN re-establish (no
+   * 5000-line scrollback re-send) to keep the post-reconnect burst small.
+   */
+  reestablishTmuxStream(sessionId) {
+    const old = this.active.get(sessionId);
+    if (!old || old.streamType !== "tmux-pipe") return;
+    const viewerIds = new Set(old.viewerIds);
+    this.cleanupStream(old);
+    this.active.delete(sessionId);
+    this.disconnectBuffers.delete(sessionId);
+    this.disconnectBufferBytes.delete(sessionId);
+    const restarted = this.startTmuxStream(sessionId, "", { skipScrollback: true });
+    if (restarted) {
+      const fresh = this.active.get(sessionId);
+      if (fresh) {
+        for (const v of viewerIds) fresh.viewerIds.add(v);
+        fresh.lastReestablishAt = Date.now();
+      }
+    } else {
+      log17.warn("failed to re-establish tmux stream", { sessionId });
+      this.onStreamStopped?.(sessionId);
+    }
+  }
   /**
    * Pause a PTY-attach stream when WS queue pressure is high. Only applies
    * to `pty-attach` streams — tmux-pipe (FIFO cat) and process-trace
@@ -11266,6 +11379,34 @@ var SessionStreamer = class {
     this.disconnectBufferBytes.delete(sessionId);
     return result;
   }
+  /**
+   * #556: recover active streams after a relay reconnect.
+   *
+   * For tmux-pipe streams the disconnect-buffered deltas are stale AND
+   * redundant: the portal requests a capture-pane resync on reconnect, and the
+   * capture reflects everything tmux applied to the pane during the disconnect.
+   * Replaying the buffered deltas instead (a) paints stale bytes over the fresh
+   * capture → interleaved garble, and (b) re-floods the relay immediately after
+   * a reconnect, helping trigger Azure's next close — the reconnect churn loop
+   * behind the terminal artifacting. So we DISCARD the buffer and resync.
+   *
+   * pty-attach / process-trace streams have no capture-pane resync, so their
+   * buffered output IS replayed via `replay`.
+   */
+  recoverStreamsAfterReconnect(replay) {
+    for (const stream of this.active.values()) {
+      if (stream.stopped) continue;
+      if (stream.streamType === "tmux-pipe") {
+        this.drainBuffer(stream.sessionId);
+        stream.needsResync = true;
+        this.resyncStream(stream.sessionId);
+      } else {
+        for (const chunk of this.drainBuffer(stream.sessionId)) {
+          replay(stream.sessionId, chunk);
+        }
+      }
+    }
+  }
   /**
    * Re-send capture-pane data for an already-active tmux stream.
    * Used when a viewer missed the initial burst (e.g. joinGroup race),
@@ -11302,6 +11443,13 @@ var SessionStreamer = class {
         stream.initBuffer = [];
         return;
       }
+      if (!this.isReadyFn()) {
+        stream.needsResync = true;
+        stream.initializing = false;
+        stream.initBuffer = [];
+        return;
+      }
+      stream.needsResync = false;
       const send = (data) => {
         if (targetViewerId) {
           this.sendFn(sessionId, data, targetViewerId);
@@ -11357,6 +11505,57 @@ var SessionStreamer = class {
       return false;
     }
   }
+  /** Build a tmux-safe env (TMUX/TMUX_PANE stripped) for liveness queries. */
+  tmuxEnv() {
+    const env = { ...process.env };
+    delete env.TMUX;
+    delete env.TMUX_PANE;
+    return env;
+  }
+  /** Pane pid + a cheap activity fingerprint (cursor + history) for one pane. */
+  readPaneInfo(paneTarget, cleanEnv) {
+    try {
+      const out = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        ["display-message", "-t", paneTarget, "-p", "#{pane_pid}|#{history_size}:#{cursor_x}:#{cursor_y}:#{pane_in_mode}"],
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      ).trim();
+      const sep2 = out.indexOf("|");
+      if (sep2 < 0) return null;
+      return { panePid: out.slice(0, sep2), fingerprint: out.slice(sep2 + 1) };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * One batched tmux call → pane pid + activity fingerprint for every pane,
+   * keyed by `session:window.pane` (matching parsePaneTarget). Returns null on
+   * tmux failure so the watchdog skips this tick rather than acting on no data.
+   */
+  readAllPaneInfo() {
+    try {
+      const out = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        [
+          "list-panes",
+          "-a",
+          "-F",
+          "#{session_name}:#{window_index}.#{pane_index}|#{pane_pid}|#{history_size}:#{cursor_x}:#{cursor_y}:#{pane_in_mode}"
+        ],
+        { env: this.tmuxEnv(), timeout: 5e3, encoding: "utf-8" }
+      );
+      const map = /* @__PURE__ */ new Map();
+      for (const line of out.split("\n")) {
+        if (!line) continue;
+        const parts = line.split("|");
+        if (parts.length < 3) continue;
+        map.set(parts[0], { panePid: parts[1], fingerprint: parts[2] });
+      }
+      return map;
+    } catch {
+      return null;
+    }
+  }
   /**
    * Capture and send the visible pane content. Converts bare \n to \r\n for
    * xterm.js and strips the trailing \r\n to prevent an extra scroll that
@@ -11408,7 +11607,7 @@ var SessionStreamer = class {
   // ---------------------------------------------------------------------------
   // tmux streaming (pipe-pane with cursor sync)
   // ---------------------------------------------------------------------------
-  startTmuxStream(sessionId, viewerKey = "") {
+  startTmuxStream(sessionId, viewerKey = "", opts) {
     const paneTarget = parsePaneTarget(sessionId);
     if (!paneTarget) return false;
     try {
@@ -11458,10 +11657,19 @@ var SessionStreamer = class {
         log17.warn("failed pipe-pane", { sessionId, error: message });
         return false;
       }
+      const paneInfo = this.readPaneInfo(paneTarget, cleanEnv);
+      if (paneInfo) {
+        stream.panePid = paneInfo.panePid;
+        stream.lastLivenessFingerprint = paneInfo.fingerprint;
+      }
+      stream.bytesReceived = 0;
+      stream.lastLivenessBytes = 0;
+      stream.deadPipeStrikes = 0;
       const catProc = (0, import_node_child_process2.spawn)("cat", [fifoPath], { env: cleanEnv, stdio: ["ignore", "pipe", "ignore"] });
       stream.catProc = catProc;
       catProc.stdout.on("data", (chunk) => {
         if (stream.stopped) return;
+        stream.bytesReceived = (stream.bytesReceived ?? 0) + chunk.length;
         const data = stream.utf8Decoder.write(chunk);
         if (!data) return;
         if (stream.initializing) {
@@ -11490,17 +11698,19 @@ var SessionStreamer = class {
       this.sendResetFn?.(sessionId, "full");
       const alternateScreen = this.detectAlternateScreen(paneTarget, cleanEnv);
       stream.alternateScreen = alternateScreen;
-      this.sendFn(sessionId, "\x1B[3J");
-      try {
-        const scrollback = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          ["capture-pane", "-t", paneTarget, "-p", "-e", "-S", "-5000", "-E", "-1"],
-          { env: cleanEnv, timeout: 1e4, encoding: "utf-8" }
-        );
-        if (scrollback && scrollback.length > 0) {
-          this.sendFn(sessionId, scrollback.replace(/\n/g, "\r\n"));
+      if (!opts?.skipScrollback) {
+        this.sendFn(sessionId, "\x1B[3J");
+        try {
+          const scrollback = (0, import_node_child_process2.execFileSync)(
+            "tmux",
+            ["capture-pane", "-t", paneTarget, "-p", "-e", "-S", "-5000", "-E", "-1"],
+            { env: cleanEnv, timeout: 1e4, encoding: "utf-8" }
+          );
+          if (scrollback && scrollback.length > 0) {
+            this.sendFn(sessionId, scrollback.replace(/\n/g, "\r\n"));
+          }
+        } catch {
         }
-      } catch {
       }
       this.sendFn(sessionId, "\x1B[?1049l\x1B[0m\x1B[2J\x1B[H");
       const sendBroadcast = (data) => this.sendFn(sessionId, data);
@@ -14517,7 +14727,11 @@ async function runAgent(rawOptions) {
     },
     () => {
       transcriptWatcher.resyncMarkdownAfterDrop();
-    }
+    },
+    // #556 follow-up: lets the streamer gate resync delivery + the pipe-liveness
+    // watchdog on a confirmed-OPEN socket, so resync bytes aren't buffered then
+    // discarded under reconnect churn and re-establish captures actually land.
+    () => conn.isReady()
   );
   const conn = new ConnectionManager(sessionStreamer, outputBuffer);
   const sendOutput = (chunk) => {
@@ -14593,8 +14807,11 @@ async function runAgent(rawOptions) {
         sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
       }
     },
-    // V2: send full snapshot
-    (sessionId, snapshot, seq) => {
+    // V2: send full snapshot. `reset` marks an explicit clear (new conversation
+    // / transcript file rotation on pane reuse) so the portal's snapshot guard
+    // lets an empty snapshot wipe stale content instead of rejecting it. See the
+    // `reset` field on TranscriptSnapshotMessage (#538) and shouldApplyTranscriptSnapshot.
+    (sessionId, snapshot, seq, reset) => {
       if (!conn.isReady()) return;
       const payload = {
         type: "markdown",
@@ -14602,7 +14819,8 @@ async function runAgent(rawOptions) {
         schemaVersion: 2,
         sessionId,
         seq,
-        snapshot
+        snapshot,
+        ...reset ? { reset: true } : {}
       };
       if (conn.sessionKey) {
         const contentStr = JSON.stringify(payload);
@@ -14697,6 +14915,7 @@ async function runAgent(rawOptions) {
         await new Promise((resolve) => {
           const ws = new import_ws5.default(negotiated.url, "json.webpubsub.azure.v1");
           conn.setConnection(ws, groups, negotiated.sessionKey ?? null);
+          let connectedAt = 0;
           if (negotiated.sessionKey) {
             const enforcer = new ApprovalEnforcer({
               secret: negotiated.sessionKey,
@@ -14717,6 +14936,7 @@ async function runAgent(rawOptions) {
           }
           ws.on("open", async () => {
             log25.info("connector connected to relay");
+            connectedAt = Date.now();
             conn.resetReconnectDelay();
             ws.send(JSON.stringify({ type: "joinGroup", group: groups.privateGroup }));
             ws.send(JSON.stringify({ type: "joinGroup", group: groups.registryGroup }));
@@ -14749,19 +14969,16 @@ async function runAgent(rawOptions) {
                 }
               }
             });
-            for (const [sessionId] of sessionStreamer.activeStreams()) {
-              const buffered = sessionStreamer.drainBuffer(sessionId);
-              for (const chunk of buffered) {
-                for (const outputChunk of splitTransportChunks(chunk)) {
-                  if (conn.sessionKey) {
-                    const { enc, iv, seq } = encryptPayload(outputChunk, conn.sessionKey, conn.txSeq.next());
-                    sendToGroup(ws, groups.privateGroup, { type: "output", enc, iv, seq, sessionId });
-                  } else {
-                    sendToGroup(ws, groups.privateGroup, { type: "output", data: outputChunk, sessionId });
-                  }
+            sessionStreamer.recoverStreamsAfterReconnect((sessionId, chunk) => {
+              for (const outputChunk of splitTransportChunks(chunk)) {
+                if (conn.sessionKey) {
+                  const { enc, iv, seq } = encryptPayload(outputChunk, conn.sessionKey, conn.txSeq.next());
+                  sendToGroup(ws, groups.privateGroup, { type: "output", enc, iv, seq, sessionId });
+                } else {
+                  sendToGroup(ws, groups.privateGroup, { type: "output", data: outputChunk, sessionId });
                 }
               }
-            }
+            });
             await inventory.syncInventory(ws, groups, true);
             conn.startTimers(
               () => inventory.announceToRegistry(ws, groups.registryGroup, "heartbeat"),
@@ -14886,6 +15103,7 @@ async function runAgent(rawOptions) {
             const fields = {};
             if (code) fields.code = code;
             if (reason.length > 0) fields.reason = reason.toString();
+            if (connectedAt > 0) fields.uptimeMs = Date.now() - connectedAt;
             log25.info("relay disconnected; output will be buffered until reconnect", fields);
             conn.cleanup();
             resolve();

package/dist/sbom.json

@@ -1299,8 +1299,8 @@
     {
       "type": "library",
       "name": "ragent-cli",
-      "version": "1.11.16",
-      "bom-ref": "ragent-live|ragent-cli@1.11.16",
+      "version": "1.11.18",
+      "bom-ref": "ragent-live|ragent-cli@1.11.18",
       "author": "Intellimetrics",
       "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
       "licenses": [
@@ -1311,7 +1311,7 @@
           }
         }
       ],
-      "purl": "pkg:npm/ragent-cli@1.11.16",
+      "purl": "pkg:npm/ragent-cli@1.11.18",
       "externalReferences": [
         {
           "url": "https://github.com/chadlindell/ragent-live/issues",
@@ -1436,7 +1436,7 @@
         "ragent-live|@emnapi/wasi-threads@1.2.1",
         "ragent-live|@pkgjs/parseargs@0.11.0",
         "ragent-live|@tybys/wasm-util@0.10.1",
-        "ragent-live|ragent-cli@1.11.16"
+        "ragent-live|ragent-cli@1.11.18"
       ]
     },
     {
@@ -1584,7 +1584,7 @@
       ]
     },
     {
-      "ref": "ragent-live|ragent-cli@1.11.16",
+      "ref": "ragent-live|ragent-cli@1.11.18",
       "dependsOn": [
         "ragent-live|@azure/web-pubsub-client@1.0.4",
         "ragent-live|@openai/codex-sdk@0.130.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ragent-cli",
-  "version": "1.11.16",
+  "version": "1.11.18",
   "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
   "main": "dist/index.js",
   "bin": {