ragent-cli 1.4.1 → 1.4.3

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.4.1",
+      version: "1.4.3",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -830,24 +830,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 +915,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 +937,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 +1025,9 @@ var SessionStreamer = class {
     if (sessionId.startsWith("zellij:")) {
       return this.startZellijStream(sessionId);
     }
+    if (sessionId.startsWith("process:")) {
+      return this.startProcessStream(sessionId);
+    }
     return false;
   }
   /**
@@ -1054,7 +1136,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 +1157,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 +1167,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 +1249,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 +1300,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 +1328,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 +1443,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;
     }
   }
 };
@@ -1660,6 +1842,7 @@ var ConnectionManager = class {
 
 // src/control-dispatcher.ts
 var crypto2 = __toESM(require("crypto"));
+var import_child_process4 = require("child_process");
 var import_ws4 = __toESM(require("ws"));
 
 // src/service.ts
@@ -2197,7 +2380,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)) {
@@ -2244,6 +2428,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).`);
@@ -2277,10 +2480,28 @@ var ControlDispatcher = class {
   handleResize(cols, rows, sessionId) {
     if (!sessionId || sessionId.startsWith("pty:")) {
       this.shell.resize(cols, rows);
+    } else if (sessionId.startsWith("tmux:")) {
+      this.resizeTmuxPane(sessionId, cols, rows);
     } else if (sessionId.startsWith("screen:") || sessionId.startsWith("zellij:")) {
       this.streamer.resize(sessionId, cols, rows);
     }
   }
+  /** Resize a tmux pane to match the viewer's terminal dimensions. */
+  resizeTmuxPane(sessionId, cols, rows) {
+    const paneTarget = sessionId.slice("tmux:".length);
+    if (!paneTarget) return;
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.TMUX;
+    delete cleanEnv.TMUX_PANE;
+    try {
+      (0, import_child_process4.execFileSync)("tmux", ["resize-pane", "-t", paneTarget, "-x", String(cols), "-y", String(rows)], {
+        env: cleanEnv,
+        timeout: 5e3,
+        stdio: "ignore"
+      });
+    } catch {
+    }
+  }
   /** Handle provision request from dashboard. */
   async handleProvision(payload) {
     const provReq = payload;
@@ -2344,8 +2565,7 @@ var ControlDispatcher = class {
     }
     tmuxArgs.push(fullCmd);
     try {
-      const { execFileSync: execFileSync3 } = await import("child_process");
-      execFileSync3("tmux", tmuxArgs, { stdio: "ignore" });
+      (0, import_child_process4.execFileSync)("tmux", tmuxArgs, { stdio: "ignore" });
       console.log(`[rAgent] Started agent session "${sessionName}": ${cmd}`);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -2357,17 +2577,7 @@ 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 started = this.streamer.startStream(sessionId);
       if (ws && ws.readyState === import_ws4.default.OPEN && group) {
         if (started) {

package/package.json

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