ragent-cli 1.1.1 → 1.2.1

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.1.0",
+      version: "1.2.1",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -435,6 +435,14 @@ async function collectZellijSessions() {
     return [];
   }
 }
+async function getProcessWorkingDir(pid) {
+  try {
+    const cwd = await execAsync(`readlink -f /proc/${pid}/cwd`);
+    return cwd.trim() || null;
+  } catch {
+    return null;
+  }
+}
 async function collectBareAgentProcesses(excludePids) {
   try {
     const raw = await execAsync("ps axo pid,ppid,comm,args --no-headers");
@@ -452,14 +460,18 @@ async function collectBareAgentProcesses(excludePids) {
       if (excludePids?.has(pid)) continue;
       if (seen.has(pid)) continue;
       seen.add(pid);
+      const workingDir = await getProcessWorkingDir(pid);
+      const dirName = workingDir ? workingDir.split("/").pop() : null;
+      const displayName = dirName && dirName !== "/" && dirName !== "" ? `${agentType} (${dirName})` : `${agentType} (pid ${pid})`;
       const id = `process:${pid}`;
       sessions.push({
         id,
         type: "process",
-        name: `${agentType} (pid ${pid})`,
+        name: displayName,
         status: "active",
         command: args,
         agentType,
+        workingDir: workingDir || void 0,
         lastActivityAt: (/* @__PURE__ */ new Date()).toISOString(),
         pids: [pid]
       });
@@ -735,6 +747,7 @@ var OutputBuffer = class {
 };
 
 // src/pty.ts
+var import_node_child_process2 = require("child_process");
 var pty = __toESM(require("node-pty"));
 function isInteractiveShell(command) {
   const trimmed = String(command).trim();
@@ -762,6 +775,27 @@ async function stopTmuxPaneBySessionId(sessionId) {
   await execAsync(`tmux kill-pane -t ${shellQuote(paneTarget)}`, { timeout: 5e3 });
   return true;
 }
+async function sendInputToTmux(sessionId, data) {
+  if (!sessionId.startsWith("tmux:")) return;
+  const target = sessionId.slice("tmux:".length).trim();
+  if (!target) return;
+  const sessionName = target.split(":")[0].split(".")[0];
+  if (!/^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/.test(sessionName)) {
+    console.warn(`[rAgent] Invalid tmux session name: ${sessionName}`);
+    return;
+  }
+  try {
+    await new Promise((resolve, reject) => {
+      (0, import_node_child_process2.execFile)("tmux", ["send-keys", "-t", target, "-l", "--", data], { timeout: 5e3 }, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[rAgent] Failed to send input to ${sessionId}: ${message}`);
+  }
+}
 async function stopAllDetachedTmuxSessions() {
   try {
     const raw = await execAsync(
@@ -1082,6 +1116,120 @@ function sendToGroup(ws, group, data) {
   );
 }
 
+// src/session-streamer.ts
+var pty2 = __toESM(require("node-pty"));
+var STOP_DEBOUNCE_MS = 2e3;
+var SessionStreamer = class {
+  active = /* @__PURE__ */ new Map();
+  pendingStops = /* @__PURE__ */ new Map();
+  sendFn;
+  onStreamStopped;
+  constructor(sendFn, onStreamStopped) {
+    this.sendFn = sendFn;
+    this.onStreamStopped = onStreamStopped;
+  }
+  /**
+   * Start streaming a tmux session. Returns true if streaming started.
+   */
+  startStream(sessionId) {
+    const pendingStop = this.pendingStops.get(sessionId);
+    if (pendingStop) {
+      clearTimeout(pendingStop);
+      this.pendingStops.delete(sessionId);
+      if (this.active.has(sessionId)) {
+        console.log(`[rAgent] Cancelled pending stop for: ${sessionId} (re-mounted)`);
+        return true;
+      }
+    }
+    if (this.active.has(sessionId)) {
+      return true;
+    }
+    const parts = sessionId.split(":");
+    if (parts[0] !== "tmux" || parts.length < 2) {
+      return false;
+    }
+    const tmuxSession = parts[1];
+    try {
+      const cleanEnv = { ...process.env };
+      delete cleanEnv.TMUX;
+      delete cleanEnv.TMUX_PANE;
+      const proc = pty2.spawn("tmux", ["attach-session", "-t", tmuxSession, "-r"], {
+        name: "xterm-256color",
+        cols: 120,
+        rows: 40,
+        cwd: process.cwd(),
+        env: cleanEnv
+      });
+      const stream = { pty: proc, sessionId, tmuxSession };
+      this.active.set(sessionId, stream);
+      proc.onData((data) => {
+        this.sendFn(sessionId, data);
+      });
+      proc.onExit(({ exitCode, signal }) => {
+        this.active.delete(sessionId);
+        this.pendingStops.delete(sessionId);
+        console.log(`[rAgent] Session stream ended: ${sessionId} (exit=${exitCode}, signal=${signal})`);
+        this.onStreamStopped?.(sessionId);
+      });
+      console.log(`[rAgent] Started streaming: ${sessionId} (tmux session: ${tmuxSession})`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[rAgent] Failed to start stream for ${sessionId}: ${message}`);
+      return false;
+    }
+  }
+  /**
+   * Stop streaming a session (debounced to absorb React remount cycles).
+   */
+  stopStream(sessionId) {
+    const stream = this.active.get(sessionId);
+    if (!stream) return;
+    if (this.pendingStops.has(sessionId)) return;
+    const timer = setTimeout(() => {
+      this.pendingStops.delete(sessionId);
+      const s = this.active.get(sessionId);
+      if (!s) return;
+      try {
+        s.pty.kill();
+      } catch {
+      }
+      this.active.delete(sessionId);
+      console.log(`[rAgent] Stopped streaming: ${sessionId}`);
+    }, STOP_DEBOUNCE_MS);
+    this.pendingStops.set(sessionId, timer);
+  }
+  /**
+   * Check if a session is currently being streamed.
+   */
+  isStreaming(sessionId) {
+    return this.active.has(sessionId);
+  }
+  /**
+   * Stop all active streams immediately (no debounce).
+   */
+  stopAll() {
+    for (const timer of this.pendingStops.values()) {
+      clearTimeout(timer);
+    }
+    this.pendingStops.clear();
+    for (const [id, stream] of this.active) {
+      try {
+        stream.pty.kill();
+      } catch {
+      }
+      console.log(`[rAgent] Stopped streaming: ${id}`);
+    }
+    this.active.clear();
+  }
+  /**
+   * Get the number of active streams.
+   */
+  get activeCount() {
+    return this.active.size;
+  }
+};
+
 // src/provisioner.ts
 var import_child_process2 = require("child_process");
 var DANGEROUS_PATTERN = /rm\s+-r[fe]*\s+\/|mkfs|dd\s+if=|:()\s*\{|>\s*\/dev\/sd/i;
@@ -1368,14 +1516,27 @@ async function runAgent(rawOptions) {
   let lastHttpHeartbeatAt = 0;
   const outputBuffer = new OutputBuffer();
   let ptyProcess = null;
+  const ptySessionId = `pty:${options.hostId}`;
   const sendOutput = (chunk) => {
     const ws = activeSocket;
     if (!ws || ws.readyState !== import_ws2.default.OPEN || !activeGroups.privateGroup) {
       outputBuffer.push(chunk);
       return;
     }
-    sendToGroup(ws, activeGroups.privateGroup, { type: "output", data: chunk });
+    sendToGroup(ws, activeGroups.privateGroup, { type: "output", data: chunk, sessionId: ptySessionId });
   };
+  const sessionStreamer = new SessionStreamer(
+    (sessionId, data) => {
+      const ws = activeSocket;
+      if (!ws || ws.readyState !== import_ws2.default.OPEN || !activeGroups.privateGroup) return;
+      sendToGroup(ws, activeGroups.privateGroup, { type: "output", data, sessionId });
+    },
+    (sessionId) => {
+      const ws = activeSocket;
+      if (!ws || ws.readyState !== import_ws2.default.OPEN || !activeGroups.privateGroup) return;
+      sendToGroup(ws, activeGroups.privateGroup, { type: "stream-stopped", sessionId });
+    }
+  );
   const killCurrentShell = () => {
     if (!ptyProcess) return;
     suppressNextShellRespawn = true;
@@ -1403,7 +1564,8 @@ async function runAgent(rawOptions) {
     spawnOrRespawnShell();
   };
   spawnOrRespawnShell();
-  const cleanupSocket = () => {
+  const cleanupSocket = (opts = {}) => {
+    if (opts.stopStreams) sessionStreamer.stopAll();
     if (wsHeartbeatTimer) {
       clearInterval(wsHeartbeatTimer);
       wsHeartbeatTimer = null;
@@ -1495,12 +1657,14 @@ async function runAgent(rawOptions) {
       case "restart-agent":
       case "disconnect":
         reconnectRequested = true;
+        sessionStreamer.stopAll();
         if (activeSocket && activeSocket.readyState === import_ws2.default.OPEN) {
           activeSocket.close();
         }
         return;
       case "stop-agent":
         shouldRun = false;
+        sessionStreamer.stopAll();
         requestStopSelfService();
         if (activeSocket && activeSocket.readyState === import_ws2.default.OPEN) {
           activeSocket.close();
@@ -1571,12 +1735,59 @@ async function runAgent(rawOptions) {
         await syncInventory(true);
         return;
       }
+      case "stream-session": {
+        if (!sessionId) return;
+        if (sessionId.startsWith("process:")) {
+          const ws2 = activeSocket;
+          if (ws2 && ws2.readyState === import_ws2.default.OPEN && activeGroups.privateGroup) {
+            sendToGroup(ws2, activeGroups.privateGroup, {
+              type: "stream-error",
+              sessionId,
+              error: "Live output is not available for standalone processes. Start agents inside tmux for live monitoring."
+            });
+          }
+          return;
+        }
+        if (sessionId.startsWith("tmux:")) {
+          const started = sessionStreamer.startStream(sessionId);
+          const ws2 = activeSocket;
+          if (ws2 && ws2.readyState === import_ws2.default.OPEN && activeGroups.privateGroup) {
+            if (started) {
+              sendToGroup(ws2, activeGroups.privateGroup, {
+                type: "stream-started",
+                sessionId
+              });
+            } else {
+              sendToGroup(ws2, activeGroups.privateGroup, {
+                type: "stream-error",
+                sessionId,
+                error: "Failed to attach to tmux session. It may no longer exist."
+              });
+            }
+          }
+          return;
+        }
+        const ws = activeSocket;
+        if (ws && ws.readyState === import_ws2.default.OPEN && activeGroups.privateGroup) {
+          sendToGroup(ws, activeGroups.privateGroup, {
+            type: "stream-error",
+            sessionId,
+            error: `Streaming not yet supported for session type: ${sessionId.split(":")[0]}`
+          });
+        }
+        return;
+      }
+      case "stop-stream": {
+        if (!sessionId) return;
+        sessionStreamer.stopStream(sessionId);
+        return;
+      }
       default:
     }
   };
   const onSignal = () => {
     shouldRun = false;
-    cleanupSocket();
+    cleanupSocket({ stopStreams: true });
     killCurrentShell();
     releasePidLock(lockPath);
   };
@@ -1632,7 +1843,8 @@ async function runAgent(rawOptions) {
               for (const chunk of buffered) {
                 sendToGroup(ws, activeGroups.privateGroup, {
                   type: "output",
-                  data: chunk
+                  data: chunk,
+                  sessionId: ptySessionId
                 });
               }
             }
@@ -1658,18 +1870,26 @@ async function runAgent(rawOptions) {
             if (msg.type === "message" && msg.group === activeGroups.privateGroup) {
               const payload = msg.data || {};
               if (payload.type === "input" && typeof payload.data === "string") {
-                if (ptyProcess) ptyProcess.write(payload.data);
+                const sid = typeof payload.sessionId === "string" ? payload.sessionId.trim() : "";
+                if (!sid || sid.startsWith("pty:")) {
+                  if (ptyProcess) ptyProcess.write(payload.data);
+                } else if (sid.startsWith("tmux:")) {
+                  await sendInputToTmux(sid, payload.data);
+                }
               } else if (payload.type === "resize" && Number.isInteger(payload.cols) && Number.isInteger(payload.rows)) {
-                try {
-                  if (ptyProcess)
-                    ptyProcess.resize(
-                      payload.cols,
-                      payload.rows
-                    );
-                } catch (error) {
-                  const message = error instanceof Error ? error.message : String(error);
-                  if (!message.includes("EBADF")) {
-                    console.warn(`[rAgent] Resize failed: ${message}`);
+                const sid = typeof payload.sessionId === "string" ? payload.sessionId.trim() : "";
+                if (!sid || sid.startsWith("pty:")) {
+                  try {
+                    if (ptyProcess)
+                      ptyProcess.resize(
+                        payload.cols,
+                        payload.rows
+                      );
+                  } catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (!message.includes("EBADF")) {
+                      console.warn(`[rAgent] Resize failed: ${message}`);
+                    }
                   }
                 }
               } else if (payload.type === "control" && typeof payload.action === "string") {
@@ -1747,7 +1967,7 @@ async function runAgent(rawOptions) {
       reconnectDelay = Math.min(reconnectDelay * 1.5, MAX_RECONNECT_DELAY_MS);
     }
   } finally {
-    cleanupSocket();
+    cleanupSocket({ stopStreams: true });
     killCurrentShell();
     releasePidLock(lockPath);
     process.removeListener("SIGTERM", onSignal);

package/package.json

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