ragent-cli 1.11.17 → 1.11.20

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.11.17",
+      version: "1.11.20",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -90,7 +90,7 @@ var require_package = __commonJS({
         commander: "^14.0.3",
         figlet: "^1.9.3",
         "node-pty": "^1.1.0",
-        ws: "^8.19.0"
+        ws: "^8.21.0"
       },
       devDependencies: {
         "@changesets/changelog-github": "^0.5.2",
@@ -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,119 @@ 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.
+   *
+   * Costs one batched `tmux list-panes -a` fork for pids, plus one `capture-pane`
+   * fork ONLY per currently-silent stream (flowing streams are provably alive and
+   * skip the hash) — so ~one fork/tick on a healthy host.
+   */
+  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 fifoSilent = bytesNow === (stream.lastLivenessBytes ?? 0);
+      if (!fifoSilent) {
+        stream.deadPipeStrikes = 0;
+      } else {
+        const contentHash = this.paneContentHash(stream.paneTarget, stream.cleanEnv);
+        if (contentHash !== null) {
+          const paneMoved = stream.lastContentHash !== void 0 && contentHash !== stream.lastContentHash;
+          if (paneMoved) {
+            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.lastContentHash = contentHash;
+        }
+      }
+      stream.lastLivenessBytes = bytesNow;
+    }
+    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
@@ -11285,6 +11407,7 @@ var SessionStreamer = class {
       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)) {
@@ -11329,6 +11452,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);
@@ -11339,7 +11469,7 @@ var SessionStreamer = class {
       try {
         this.sendResetFn?.(sessionId, withScrollback ? "full" : "repaint", targetViewerId);
         const alternateScreen = this.detectAlternateScreen(paneTarget, cleanEnv);
-        if (withScrollback) {
+        if (withScrollback && !alternateScreen) {
           send("\x1B[3J");
           try {
             const scrollback = (0, import_node_child_process2.execFileSync)(
@@ -11384,15 +11514,91 @@ var SessionStreamer = class {
       return false;
     }
   }
+  /** Cheap stable string hash (djb2) for content change-detection. */
+  hashString(s) {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++) h = Math.imul(h, 33) + s.charCodeAt(i) | 0;
+    return (h >>> 0).toString(36) + ":" + s.length;
+  }
+  /**
+   * Hash of a pane's visible content (`capture-pane -p`). This is the watchdog's
+   * activity signal: unlike cursor/history it changes on ANY visible redraw,
+   * including in-place TUI updates (spinners, token counters, status bars) that
+   * a Claude/Gemini pane emits without moving the cursor. Null on tmux failure
+   * (the watchdog then skips the activity check for that tick).
+   */
+  paneContentHash(paneTarget, cleanEnv) {
+    try {
+      const out = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        ["capture-pane", "-t", paneTarget, "-p"],
+        { env: cleanEnv ?? this.tmuxEnv(), timeout: 5e3, encoding: "utf-8" }
+      );
+      return this.hashString(out);
+    } catch {
+      return null;
+    }
+  }
+  /** 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
    * would shift the viewport by 1 row. Returns the number of lines sent
    * (0 when the capture failed or was empty) for relative cursor sync.
    */
-  sendVisiblePane(send, paneTarget, cleanEnv, alternateScreen) {
+  sendVisiblePane(send, paneTarget, cleanEnv, _alternateScreen) {
     try {
-      const captureArgs = alternateScreen ? ["capture-pane", "-a", "-t", paneTarget, "-p", "-e"] : ["capture-pane", "-t", paneTarget, "-p", "-e"];
+      const captureArgs = ["capture-pane", "-t", paneTarget, "-p", "-e"];
       const initial = (0, import_node_child_process2.execFileSync)(
         "tmux",
         captureArgs,
@@ -11435,7 +11641,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 {
@@ -11485,10 +11691,17 @@ 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.lastContentHash = this.paneContentHash(paneTarget, cleanEnv) ?? void 0;
+      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) {
@@ -11517,17 +11730,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 && !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"));
+          }
+        } catch {
         }
-      } catch {
       }
       this.sendFn(sessionId, "\x1B[?1049l\x1B[0m\x1B[2J\x1B[H");
       const sendBroadcast = (data) => this.sendFn(sessionId, data);
@@ -14544,7 +14759,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) => {
@@ -14620,8 +14839,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",
@@ -14629,7 +14851,8 @@ async function runAgent(rawOptions) {
         schemaVersion: 2,
         sessionId,
         seq,
-        snapshot
+        snapshot,
+        ...reset ? { reset: true } : {}
       };
       if (conn.sessionKey) {
         const contentStr = JSON.stringify(payload);
@@ -14724,6 +14947,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,
@@ -14744,6 +14968,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 }));
@@ -14910,6 +15135,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.17",
-      "bom-ref": "ragent-live|ragent-cli@1.11.17",
+      "version": "1.11.20",
+      "bom-ref": "ragent-live|ragent-cli@1.11.20",
       "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.17",
+      "purl": "pkg:npm/ragent-cli@1.11.20",
       "externalReferences": [
         {
           "url": "https://github.com/chadlindell/ragent-live/issues",
@@ -1384,8 +1384,8 @@
     {
       "type": "library",
       "name": "ws",
-      "version": "8.20.0",
-      "bom-ref": "ragent-live|ws@8.20.0",
+      "version": "8.21.0",
+      "bom-ref": "ragent-live|ws@8.21.0",
       "author": "Einar Otto Stangvik",
       "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
       "licenses": [
@@ -1396,10 +1396,10 @@
           }
         }
       ],
-      "purl": "pkg:npm/ws@8.20.0",
+      "purl": "pkg:npm/ws@8.21.0",
       "externalReferences": [
         {
-          "url": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+          "url": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
           "type": "distribution",
           "comment": "as detected from npm-ls property \"resolved\""
         },
@@ -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.17"
+        "ragent-live|ragent-cli@1.11.20"
       ]
     },
     {
@@ -1469,7 +1469,7 @@
         "ragent-live|buffer@6.0.3",
         "ragent-live|events@3.3.0",
         "ragent-live|tslib@2.8.1",
-        "ragent-live|ws@8.20.0"
+        "ragent-live|ws@8.21.0"
       ]
     },
     {
@@ -1584,21 +1584,21 @@
       ]
     },
     {
-      "ref": "ragent-live|ragent-cli@1.11.17",
+      "ref": "ragent-live|ragent-cli@1.11.20",
       "dependsOn": [
         "ragent-live|@azure/web-pubsub-client@1.0.4",
         "ragent-live|@openai/codex-sdk@0.130.0",
         "ragent-live|commander@14.0.3",
         "ragent-live|figlet@1.11.0",
         "ragent-live|node-pty@1.1.0",
-        "ragent-live|ws@8.20.0"
+        "ragent-live|ws@8.21.0"
       ]
     },
     {
       "ref": "ragent-live|tslib@2.8.1"
     },
     {
-      "ref": "ragent-live|ws@8.20.0"
+      "ref": "ragent-live|ws@8.21.0"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ragent-cli",
-  "version": "1.11.17",
+  "version": "1.11.20",
   "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
   "main": "dist/index.js",
   "bin": {
@@ -59,7 +59,7 @@
     "commander": "^14.0.3",
     "figlet": "^1.9.3",
     "node-pty": "^1.1.0",
-    "ws": "^8.19.0"
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.2",