ragent-cli 1.4.2 → 1.4.4

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.4.2",
+      version: "1.4.4",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -581,6 +581,9 @@ async function collectSessionInventory(hostId, command) {
   };
   return [...tmux, ...screen, ...zellij, ...bare, ptySession];
 }
+function isElectronProcess(cmd) {
+  return cmd.includes("--type=") || cmd.includes("--user-data-dir=") || cmd.includes("--crashpad-handler-pid=");
+}
 function detectAgentType(command) {
   if (!command) return void 0;
   const cmd = command.toLowerCase();
@@ -593,8 +596,14 @@ function detectAgentType(command) {
   }
   if (binary === "codex" || scriptArg === "codex" || cmd.includes("codex-cli")) return "Codex CLI";
   if (binary === "aider") return "aider";
-  if (binary === "cursor") return "Cursor";
-  if (binary === "windsurf") return "Windsurf";
+  if (binary === "cursor") {
+    if (isElectronProcess(cmd)) return void 0;
+    return "Cursor";
+  }
+  if (binary === "windsurf") {
+    if (isElectronProcess(cmd)) return void 0;
+    return "Windsurf";
+  }
   if (binary === "gemini") return "Gemini CLI";
   if (binary === "amazon-q" || binary === "amazon_q") return "Amazon Q";
   if (binary === "copilot") return "Copilot CLI";
@@ -830,24 +839,71 @@ var OutputBuffer = class {
 // src/websocket.ts
 var import_ws = __toESM(require("ws"));
 var BACKPRESSURE_HIGH_WATER = 256 * 1024;
+var BACKPRESSURE_LOW_WATER = 64 * 1024;
+var MAX_PENDING_QUEUE = 500;
+var DRAIN_INTERVAL_MS = 50;
 function sanitizeForJson(str) {
   return str.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
 }
+var pendingQueue = [];
+var drainTimer = null;
+var drainWs = null;
+var droppedFrames = 0;
+function drainQueue() {
+  if (!drainWs || drainWs.readyState !== import_ws.default.OPEN) {
+    pendingQueue.length = 0;
+    stopDrainTimer();
+    return;
+  }
+  while (pendingQueue.length > 0 && drainWs.bufferedAmount < BACKPRESSURE_LOW_WATER) {
+    const frame = pendingQueue.shift();
+    drainWs.send(frame);
+  }
+  if (pendingQueue.length === 0) {
+    stopDrainTimer();
+  }
+}
+function startDrainTimer(ws) {
+  drainWs = ws;
+  if (!drainTimer) {
+    drainTimer = setInterval(drainQueue, DRAIN_INTERVAL_MS);
+  }
+}
+function stopDrainTimer() {
+  if (drainTimer) {
+    clearInterval(drainTimer);
+    drainTimer = null;
+  }
+  drainWs = null;
+}
 function sendToGroup(ws, group, data) {
   if (!group || ws.readyState !== import_ws.default.OPEN) return;
+  const sanitized = sanitizePayload(data);
+  const frame = JSON.stringify({
+    type: "sendToGroup",
+    group,
+    dataType: "json",
+    data: sanitized,
+    noEcho: true
+  });
   if (ws.bufferedAmount > BACKPRESSURE_HIGH_WATER) {
+    if (pendingQueue.length >= MAX_PENDING_QUEUE) {
+      pendingQueue.shift();
+      droppedFrames++;
+      if (droppedFrames % 100 === 1) {
+        console.warn(`[rAgent] Backpressure: dropped ${droppedFrames} frames (queue full at ${MAX_PENDING_QUEUE})`);
+      }
+    }
+    pendingQueue.push(frame);
+    startDrainTimer(ws);
     return;
   }
-  const sanitized = sanitizePayload(data);
-  ws.send(
-    JSON.stringify({
-      type: "sendToGroup",
-      group,
-      dataType: "json",
-      data: sanitized,
-      noEcho: true
-    })
-  );
+  if (pendingQueue.length > 0) {
+    pendingQueue.push(frame);
+    drainQueue();
+    return;
+  }
+  ws.send(frame);
 }
 function sanitizePayload(obj) {
   const result = {};
@@ -868,6 +924,7 @@ var import_node_child_process2 = require("child_process");
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 var import_node_os = require("os");
+var import_node_string_decoder = require("string_decoder");
 var pty = __toESM(require("node-pty"));
 var STOP_DEBOUNCE_MS = 2e3;
 function parsePaneTarget(sessionId) {
@@ -889,6 +946,37 @@ function parseZellijSession(sessionId) {
   if (!rest) return null;
   return rest.split(":")[0] || null;
 }
+function parseProcessPid(sessionId) {
+  if (!sessionId.startsWith("process:")) return null;
+  const rest = sessionId.slice("process:".length);
+  if (!rest) return null;
+  const pidStr = rest.split(":")[0];
+  const pid = parseInt(pidStr, 10);
+  return isNaN(pid) ? null : pid;
+}
+function unescapeStrace(s) {
+  return s.replace(/\\x([0-9a-fA-F]{2})|\\n|\\r|\\t|\\\\|\\"|\\0/g, (match) => {
+    if (match.startsWith("\\x")) {
+      return String.fromCharCode(parseInt(match.slice(2), 16));
+    }
+    switch (match) {
+      case "\\n":
+        return "\n";
+      case "\\r":
+        return "\r";
+      case "\\t":
+        return "	";
+      case "\\\\":
+        return "\\";
+      case '\\"':
+        return '"';
+      case "\\0":
+        return "\0";
+      default:
+        return match;
+    }
+  });
+}
 var SessionStreamer = class {
   active = /* @__PURE__ */ new Map();
   pendingStops = /* @__PURE__ */ new Map();
@@ -946,6 +1034,9 @@ var SessionStreamer = class {
     if (sessionId.startsWith("zellij:")) {
       return this.startZellijStream(sessionId);
     }
+    if (sessionId.startsWith("process:")) {
+      return this.startProcessStream(sessionId);
+    }
     return false;
   }
   /**
@@ -1020,6 +1111,64 @@ var SessionStreamer = class {
   get activeCount() {
     return this.active.size;
   }
+  /**
+   * Re-send capture-pane data for an already-active tmux stream.
+   * Used when a viewer missed the initial burst (e.g. joinGroup race)
+   * or reconnected ("Retry stream"). Does NOT restart pipe-pane.
+   */
+  resyncStream(sessionId) {
+    const stream = this.active.get(sessionId);
+    if (!stream || stream.stopped || stream.streamType !== "tmux-pipe") return false;
+    const { paneTarget, cleanEnv } = stream;
+    if (!paneTarget || !cleanEnv) return false;
+    try {
+      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);
+        }
+      } catch {
+      }
+      this.sendFn(sessionId, "\x1B[0m\x1B[2J\x1B[H");
+      try {
+        const initial = (0, import_node_child_process2.execFileSync)(
+          "tmux",
+          ["capture-pane", "-t", paneTarget, "-p", "-e"],
+          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+        );
+        if (initial) {
+          this.sendFn(sessionId, initial);
+        }
+      } catch {
+      }
+      try {
+        const cursorInfo = (0, import_node_child_process2.execFileSync)(
+          "tmux",
+          ["display-message", "-t", paneTarget, "-p", "#{cursor_x} #{cursor_y}"],
+          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+        ).trim();
+        const parts = cursorInfo.split(" ");
+        if (parts.length === 2) {
+          const x = parseInt(parts[0], 10);
+          const y = parseInt(parts[1], 10);
+          if (!isNaN(x) && !isNaN(y)) {
+            this.sendFn(sessionId, `\x1B[${y + 1};${x + 1}H`);
+          }
+        }
+      } catch {
+      }
+      console.log(`[rAgent] Resync capture for: ${sessionId}`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[rAgent] Failed to resync stream for ${sessionId}: ${message}`);
+      return false;
+    }
+  }
   // ---------------------------------------------------------------------------
   // tmux streaming (pipe-pane with cursor sync)
   // ---------------------------------------------------------------------------
@@ -1054,7 +1203,9 @@ var SessionStreamer = class {
         initializing: true,
         initBuffer: [],
         cleanEnv,
-        ptyProc: null
+        ptyProc: null,
+        straceProc: null,
+        utf8Decoder: new import_node_string_decoder.StringDecoder("utf8")
       };
       this.active.set(sessionId, stream);
       try {
@@ -1073,7 +1224,8 @@ var SessionStreamer = class {
       stream.catProc = catProc;
       catProc.stdout.on("data", (chunk) => {
         if (stream.stopped) return;
-        const data = chunk.toString("utf-8");
+        const data = stream.utf8Decoder.write(chunk);
+        if (!data) return;
         if (stream.initializing) {
           stream.initBuffer.push(data);
         } else {
@@ -1082,6 +1234,8 @@ var SessionStreamer = class {
       });
       catProc.on("exit", () => {
         if (!stream.stopped) {
+          const remaining = stream.utf8Decoder.end();
+          if (remaining) this.sendFn(sessionId, remaining);
           this.cleanupStream(stream);
           this.active.delete(sessionId);
           this.pendingStops.delete(sessionId);
@@ -1162,7 +1316,9 @@ var SessionStreamer = class {
         catProc: null,
         initializing: false,
         initBuffer: [],
-        ptyProc: proc
+        ptyProc: proc,
+        straceProc: null,
+        utf8Decoder: new import_node_string_decoder.StringDecoder("utf8")
       };
       this.active.set(sessionId, stream);
       proc.onData((data) => {
@@ -1211,7 +1367,9 @@ var SessionStreamer = class {
         catProc: null,
         initializing: false,
         initBuffer: [],
-        ptyProc: proc
+        ptyProc: proc,
+        straceProc: null,
+        utf8Decoder: new import_node_string_decoder.StringDecoder("utf8")
       };
       this.active.set(sessionId, stream);
       proc.onData((data) => {
@@ -1237,6 +1395,89 @@ var SessionStreamer = class {
     }
   }
   // ---------------------------------------------------------------------------
+  // process streaming (strace -p PID write interception)
+  // ---------------------------------------------------------------------------
+  startProcessStream(sessionId) {
+    const pid = parseProcessPid(sessionId);
+    if (!pid) return false;
+    if (!(0, import_node_fs.existsSync)(`/proc/${pid}`)) {
+      console.warn(`[rAgent] Process ${pid} does not exist (no /proc/${pid}).`);
+      return false;
+    }
+    try {
+      const straceProc = (0, import_node_child_process2.spawn)(
+        "strace",
+        ["-p", String(pid), "-e", "trace=write", "-e", "signal=none", "-s", "1000000", "-x"],
+        { stdio: ["ignore", "ignore", "pipe"] }
+      );
+      const stream = {
+        sessionId,
+        streamType: "process-trace",
+        stopped: false,
+        paneTarget: "",
+        fifoPath: "",
+        tmpDir: "",
+        catProc: null,
+        initializing: false,
+        initBuffer: [],
+        ptyProc: null,
+        straceProc,
+        utf8Decoder: new import_node_string_decoder.StringDecoder("utf8")
+      };
+      this.active.set(sessionId, stream);
+      const writeRegex = /^write\(([12]),\s*"((?:[^"\\]|\\.)*)"/;
+      let lineBuf = "";
+      straceProc.stderr.on("data", (chunk) => {
+        if (stream.stopped) return;
+        lineBuf += chunk.toString("utf-8");
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop() ?? "";
+        for (const line of lines) {
+          const match = writeRegex.exec(line.trim());
+          if (!match) continue;
+          const escaped = match[2];
+          const unescaped = unescapeStrace(escaped);
+          if (unescaped) {
+            const decoded = stream.utf8Decoder.write(Buffer.from(unescaped, "binary"));
+            if (decoded) {
+              this.sendFn(sessionId, decoded);
+            }
+          }
+        }
+      });
+      straceProc.on("error", (err) => {
+        if (stream.stopped) return;
+        const message = err.message;
+        if (message.includes("ENOENT")) {
+          this.sendFn(sessionId, "\r\n[rAgent] strace is not installed. Install it to enable process streaming:\r\n  sudo apt install strace  (Debian/Ubuntu)\r\n  sudo dnf install strace  (Fedora/RHEL)\r\n");
+        }
+        stream.stopped = true;
+        this.active.delete(sessionId);
+        this.pendingStops.delete(sessionId);
+        this.onStreamStopped?.(sessionId);
+      });
+      straceProc.on("exit", (code) => {
+        if (stream.stopped) return;
+        const remaining = stream.utf8Decoder.end();
+        if (remaining) this.sendFn(sessionId, remaining);
+        if (code === 1) {
+          this.sendFn(sessionId, "\r\n[rAgent] Permission denied: cannot attach to process.\r\nTo enable process tracing, run:\r\n  sudo sysctl kernel.yama.ptrace_scope=0\r\n");
+        }
+        stream.stopped = true;
+        this.active.delete(sessionId);
+        this.pendingStops.delete(sessionId);
+        console.log(`[rAgent] Session stream ended: ${sessionId}`);
+        this.onStreamStopped?.(sessionId);
+      });
+      console.log(`[rAgent] Started streaming: ${sessionId} (strace PID: ${pid})`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[rAgent] Failed to start process stream for ${sessionId}: ${message}`);
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
   // Cleanup
   // ---------------------------------------------------------------------------
   cleanupStream(stream) {
@@ -1269,6 +1510,14 @@ var SessionStreamer = class {
         }
         stream.ptyProc = null;
       }
+    } else if (stream.streamType === "process-trace") {
+      if (stream.straceProc && !stream.straceProc.killed) {
+        try {
+          stream.straceProc.kill("SIGTERM");
+        } catch {
+        }
+      }
+      stream.straceProc = null;
     }
   }
 };
@@ -2198,7 +2447,8 @@ var ControlDispatcher = class {
       "restart-shell",
       "stop-session",
       "stop-detached",
-      "disconnect"
+      "disconnect",
+      "kill-process"
     ]);
     if (dangerousActions.has(action) && this.connection.sessionKey) {
       if (!this.verifyMessageHmac(payload)) {
@@ -2245,6 +2495,25 @@ var ControlDispatcher = class {
           await this.syncInventory();
         }
         return;
+      case "kill-process":
+        if (!sessionId) return;
+        {
+          const pid = parseProcessPid(sessionId);
+          if (pid === null) {
+            console.warn(`[rAgent] kill-process: could not parse PID from ${sessionId}`);
+            return;
+          }
+          this.streamer.stopStream(sessionId);
+          try {
+            process.kill(pid, "SIGTERM");
+            console.log(`[rAgent] Sent SIGTERM to process ${pid} (${sessionId}).`);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[rAgent] Failed to kill process ${pid}: ${message}`);
+          }
+          await this.syncInventory();
+        }
+        return;
       case "stop-detached": {
         const killed = await stopAllDetachedTmuxSessions();
         console.log(`[rAgent] Killed ${killed} detached tmux session(s).`);
@@ -2375,20 +2644,14 @@ var ControlDispatcher = class {
     if (!sessionId) return;
     const ws = this.connection.activeSocket;
     const group = this.connection.activeGroups.privateGroup;
-    if (sessionId.startsWith("process:")) {
-      if (ws && ws.readyState === import_ws4.default.OPEN && group) {
-        sendToGroup(ws, group, {
-          type: "stream-error",
-          sessionId,
-          error: "This agent is running outside a terminal multiplexer. Stop and relaunch via Start Agent to enable live streaming."
-        });
-      }
-      return;
-    }
-    if (sessionId.startsWith("tmux:") || sessionId.startsWith("screen:") || sessionId.startsWith("zellij:")) {
+    if (sessionId.startsWith("tmux:") || sessionId.startsWith("screen:") || sessionId.startsWith("zellij:") || sessionId.startsWith("process:")) {
+      const alreadyStreaming = this.streamer.isStreaming(sessionId);
       const started = this.streamer.startStream(sessionId);
       if (ws && ws.readyState === import_ws4.default.OPEN && group) {
         if (started) {
+          if (alreadyStreaming) {
+            this.streamer.resyncStream(sessionId);
+          }
           sendToGroup(ws, group, { type: "stream-started", sessionId });
         } else {
           sendToGroup(ws, group, {

package/package.json

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