@ricsam/r5d-worker 0.0.67 → 0.0.69

package/README.md

@@ -38,4 +38,6 @@ worker exec macos docker compose up -d
 worker exec macos bun test
 ```
 
+Agent shell commands receive no stdin by default: prompts read immediate EOF instead of hanging. A command started with `interactive: true` is spawned with a writable stdin pipe, and the agent's `shell_write` tool delivers input through the `exec_stdin` protocol message. The worker acknowledges each write with an `operation_result` carrying the delivered byte count, closes stdin on an explicit `eof`, on cancellation, on timeout, and at process exit, and advertises this support through the `execStdinV1` capability in its hello message. Servers refuse interactive runs and stdin writes for workers without the capability, so this is a protocol-compatible release that uses the ordinary worker update flow. Delivered stdin is audited server-side in the run's `process-runs/<runId>/stdin.log`.
+
 When the connected `r5d-browser` requests a port forward, the worker opens each relayed connection only to `127.0.0.1` on the requested worker port. Browser-side and worker-side ports may differ. The worker never opens a public listener, and a disconnected worker leaves the browser's long-lived mapping unavailable until the same worker label reconnects.

package/dist/cjs/main.cjs

@@ -62,6 +62,7 @@ var import_cli_update = require("./cli-update.cjs");
 var import_git_identity = require("./git-identity.cjs");
 var import_heartbeat = require("./heartbeat.cjs");
 var import_process_tree = require("./process-tree.cjs");
+var import_pty_output_coalescer = require("./pty-output-coalescer.cjs");
 var import_port_forward_client = require("./port-forward-client.cjs");
 var import_workspace_incident_state = require("./workspace-incident-state.cjs");
 var import_workspace_command_sync_policy = require("./workspace-command-sync-policy.cjs");
@@ -1960,8 +1961,12 @@ async function executeStreamingCommand(input) {
       activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
     });
     const cwd = resolveCommandCwd(input.resolvedTarget.rootPath, input.message.cwd);
+    const interactive = input.message.interactive === true;
     const subprocess = Bun.spawn(input.message.argv, {
       cwd,
+      // Without an explicit stdin the process reads /dev/null and interactive
+      // prompts see immediate EOF; "pipe" keeps stdin open for exec_stdin.
+      ...interactive ? { stdin: "pipe" } : {},
       stdout: "pipe",
       stderr: "pipe",
       detached: true,
@@ -1983,7 +1988,8 @@ async function executeStreamingCommand(input) {
       argv: input.message.argv,
       command: input.message.command,
       cwd,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...interactive ? { interactive: true, stdin: subprocess.stdin } : {}
     });
     started = true;
     sendWorkerMessage(input.ws, {
@@ -1997,6 +2003,7 @@ async function executeStreamingCommand(input) {
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
         timedOut = true;
+        closeProcessStdin(activeProcesses.get(input.message.runId));
         void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
           process.stderr.write(
             `[r5d-worker] failed to terminate timed-out process ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
@@ -2056,10 +2063,21 @@ async function executeStreamingCommand(input) {
     if (timeout) {
       clearTimeout(timeout);
     }
+    closeProcessStdin(activeProcesses.get(input.message.runId));
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
 }
+function closeProcessStdin(active) {
+  if (!active?.stdin) {
+    return;
+  }
+  try {
+    void active.stdin.end();
+  } catch {
+  }
+  active.stdin = void 0;
+}
 function sendWorkerMessage(ws, message) {
   const target = currentWorkerSocket ?? ws;
   try {
@@ -2083,7 +2101,8 @@ function buildActiveProcessReports() {
     argv: active.argv,
     command: active.command,
     ...active.cwd ? { cwd: active.cwd } : {},
-    startedAt: active.startedAt
+    startedAt: active.startedAt,
+    ...active.interactive ? { interactive: true } : {}
   }));
 }
 function sendActiveProcessReport(ws) {
@@ -2290,6 +2309,15 @@ async function openPty(input) {
   }) : {};
   const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
   const shell = resolveHostShell(input.message.command);
+  const outputCoalescer = (0, import_pty_output_coalescer.createPtyOutputCoalescer)({
+    send: (data) => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_output",
+        ptyId: input.message.ptyId,
+        data
+      });
+    }
+  });
   const ptyProcess = createNodePtyBridge({
     file: shell.file,
     args: shell.args,
@@ -2314,13 +2342,10 @@ async function openPty(input) {
       });
     },
     onOutput: (data) => {
-      sendWorkerMessage(input.ws, {
-        type: "pty_output",
-        ptyId: input.message.ptyId,
-        data
-      });
+      outputCoalescer.push(data);
     },
     onExit: (event) => {
+      outputCoalescer.flush();
       input.releaseWorkspaceMutation?.();
       activePtys.delete(input.message.ptyId);
       input.onTerminal?.();
@@ -2332,6 +2357,7 @@ async function openPty(input) {
       });
     },
     onError: (error) => {
+      outputCoalescer.flush();
       input.releaseWorkspaceMutation?.();
       activePtys.delete(input.message.ptyId);
       input.onTerminal?.();
@@ -2889,7 +2915,8 @@ async function startWorker(options) {
           browserPortForwarding: true,
           globalWorkspaceSyncLeaseV1: true,
           eventualWorkspaceSyncV1: true,
-          workspaceIncidentCandidatePinV1: true
+          workspaceIncidentCandidatePinV1: true,
+          execStdinV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -3332,6 +3359,7 @@ async function startWorker(options) {
         let cancelMessage;
         if (active) {
           try {
+            closeProcessStdin(active);
             await (0, import_process_tree.terminateProcessTree)(active.process);
             cancelMessage = `Stopped ${active.command}`;
           } catch (error) {
@@ -3353,6 +3381,51 @@ async function startWorker(options) {
         );
         return;
       }
+      if (message.type === "exec_stdin") {
+        const sendAck = (payload) => ws.send(
+          JSON.stringify({
+            type: "operation_result",
+            requestId: message.requestId,
+            ...payload
+          })
+        );
+        const active = activeProcesses.get(message.runId);
+        if (!active) {
+          sendAck({ error: `Process run ${message.runId} is not active on this worker` });
+          return;
+        }
+        if (!active.interactive || !active.stdin) {
+          sendAck({
+            error: `Process run ${message.runId} has no open stdin. Start a new shell command with "interactive": true to write to its stdin.`
+          });
+          return;
+        }
+        try {
+          let bytesWritten = 0;
+          if (message.data !== void 0 && message.data.length > 0) {
+            bytesWritten = await active.stdin.write(message.data);
+            await active.stdin.flush();
+          }
+          if (message.eof === true) {
+            await active.stdin.end();
+            active.stdin = void 0;
+          }
+          if (targetMayMutateVisibleWorkspace(active.target)) {
+            markWorkspaceDirty({ type: "shell_inline", detail: `exec stdin ${message.runId}` });
+          }
+          sendAck({
+            result: {
+              type: "exec_stdin",
+              runId: message.runId,
+              bytesWritten,
+              eof: message.eof === true
+            }
+          });
+        } catch (error) {
+          sendAck({ error: error instanceof Error ? error.message : String(error) });
+        }
+        return;
+      }
       if (message.type === "pty_open") {
         if (cliUpdateInProgress) {
           sendWorkerMessage(ws, {

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.67",
+  "version": "0.0.69",
   "type": "commonjs"
 }

package/dist/cjs/pty-output-coalescer.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pty_output_coalescer_exports = {};
+__export(pty_output_coalescer_exports, {
+  DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS: () => DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS,
+  DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES: () => DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES,
+  createPtyOutputCoalescer: () => createPtyOutputCoalescer
+});
+module.exports = __toCommonJS(pty_output_coalescer_exports);
+const DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS = 8;
+const DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES = 64 * 1024;
+function defaultSchedule(callback, delayMs) {
+  const timer = setTimeout(callback, delayMs);
+  timer.unref();
+  return () => clearTimeout(timer);
+}
+function createPtyOutputCoalescer(options) {
+  const flushIntervalMs = options.flushIntervalMs ?? DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS;
+  const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES;
+  const now = options.now ?? Date.now;
+  const schedule = options.schedule ?? defaultSchedule;
+  let buffer = "";
+  let bufferedBytes = 0;
+  let cancelScheduledFlush = null;
+  let lastSendAt = Number.NEGATIVE_INFINITY;
+  const sendNow = (data) => {
+    lastSendAt = now();
+    options.send(data);
+  };
+  const flush = () => {
+    if (cancelScheduledFlush) {
+      cancelScheduledFlush();
+      cancelScheduledFlush = null;
+    }
+    if (bufferedBytes === 0) {
+      return;
+    }
+    const data = buffer;
+    buffer = "";
+    bufferedBytes = 0;
+    sendNow(data);
+  };
+  const push = (data) => {
+    if (data.length === 0) {
+      return;
+    }
+    if (bufferedBytes === 0 && now() - lastSendAt >= flushIntervalMs) {
+      sendNow(data);
+      return;
+    }
+    buffer += data;
+    bufferedBytes += Buffer.byteLength(data, "utf8");
+    if (bufferedBytes >= maxBufferBytes) {
+      flush();
+      return;
+    }
+    if (!cancelScheduledFlush) {
+      cancelScheduledFlush = schedule(() => {
+        cancelScheduledFlush = null;
+        flush();
+      }, flushIntervalMs);
+    }
+  };
+  return { push, flush };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS,
+  DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES,
+  createPtyOutputCoalescer
+});

package/dist/mjs/main.mjs

@@ -12,6 +12,7 @@ import {
   WORKER_HEARTBEAT_INTERVAL_MS
 } from "./heartbeat.mjs";
 import { terminateProcessTree } from "./process-tree.mjs";
+import { createPtyOutputCoalescer } from "./pty-output-coalescer.mjs";
 import { openWorkerPortForwardRelay } from "./port-forward-client.mjs";
 import { applyWorkspaceIncidentUpdate, releasePendingWorkspaceHead, WorkspaceIncidentOrderingFence } from "./workspace-incident-state.mjs";
 import { acquireWorkspaceCommandMutation, runWorkspaceCommand } from "./workspace-command-sync-policy.mjs";
@@ -1931,8 +1932,12 @@ async function executeStreamingCommand(input) {
       activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
     });
     const cwd = resolveCommandCwd(input.resolvedTarget.rootPath, input.message.cwd);
+    const interactive = input.message.interactive === true;
     const subprocess = Bun.spawn(input.message.argv, {
       cwd,
+      // Without an explicit stdin the process reads /dev/null and interactive
+      // prompts see immediate EOF; "pipe" keeps stdin open for exec_stdin.
+      ...interactive ? { stdin: "pipe" } : {},
       stdout: "pipe",
       stderr: "pipe",
       detached: true,
@@ -1954,7 +1959,8 @@ async function executeStreamingCommand(input) {
       argv: input.message.argv,
       command: input.message.command,
       cwd,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...interactive ? { interactive: true, stdin: subprocess.stdin } : {}
     });
     started = true;
     sendWorkerMessage(input.ws, {
@@ -1968,6 +1974,7 @@ async function executeStreamingCommand(input) {
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
         timedOut = true;
+        closeProcessStdin(activeProcesses.get(input.message.runId));
         void terminateProcessTree(subprocess).catch((error) => {
           process.stderr.write(
             `[r5d-worker] failed to terminate timed-out process ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
@@ -2027,10 +2034,21 @@ async function executeStreamingCommand(input) {
     if (timeout) {
       clearTimeout(timeout);
     }
+    closeProcessStdin(activeProcesses.get(input.message.runId));
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
 }
+function closeProcessStdin(active) {
+  if (!active?.stdin) {
+    return;
+  }
+  try {
+    void active.stdin.end();
+  } catch {
+  }
+  active.stdin = void 0;
+}
 function sendWorkerMessage(ws, message) {
   const target = currentWorkerSocket ?? ws;
   try {
@@ -2054,7 +2072,8 @@ function buildActiveProcessReports() {
     argv: active.argv,
     command: active.command,
     ...active.cwd ? { cwd: active.cwd } : {},
-    startedAt: active.startedAt
+    startedAt: active.startedAt,
+    ...active.interactive ? { interactive: true } : {}
   }));
 }
 function sendActiveProcessReport(ws) {
@@ -2261,6 +2280,15 @@ async function openPty(input) {
   }) : {};
   const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
   const shell = resolveHostShell(input.message.command);
+  const outputCoalescer = createPtyOutputCoalescer({
+    send: (data) => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_output",
+        ptyId: input.message.ptyId,
+        data
+      });
+    }
+  });
   const ptyProcess = createNodePtyBridge({
     file: shell.file,
     args: shell.args,
@@ -2285,13 +2313,10 @@ async function openPty(input) {
       });
     },
     onOutput: (data) => {
-      sendWorkerMessage(input.ws, {
-        type: "pty_output",
-        ptyId: input.message.ptyId,
-        data
-      });
+      outputCoalescer.push(data);
     },
     onExit: (event) => {
+      outputCoalescer.flush();
       input.releaseWorkspaceMutation?.();
       activePtys.delete(input.message.ptyId);
       input.onTerminal?.();
@@ -2303,6 +2328,7 @@ async function openPty(input) {
       });
     },
     onError: (error) => {
+      outputCoalescer.flush();
       input.releaseWorkspaceMutation?.();
       activePtys.delete(input.message.ptyId);
       input.onTerminal?.();
@@ -2860,7 +2886,8 @@ async function startWorker(options) {
           browserPortForwarding: true,
           globalWorkspaceSyncLeaseV1: true,
           eventualWorkspaceSyncV1: true,
-          workspaceIncidentCandidatePinV1: true
+          workspaceIncidentCandidatePinV1: true,
+          execStdinV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -3303,6 +3330,7 @@ async function startWorker(options) {
         let cancelMessage;
         if (active) {
           try {
+            closeProcessStdin(active);
             await terminateProcessTree(active.process);
             cancelMessage = `Stopped ${active.command}`;
           } catch (error) {
@@ -3324,6 +3352,51 @@ async function startWorker(options) {
         );
         return;
       }
+      if (message.type === "exec_stdin") {
+        const sendAck = (payload) => ws.send(
+          JSON.stringify({
+            type: "operation_result",
+            requestId: message.requestId,
+            ...payload
+          })
+        );
+        const active = activeProcesses.get(message.runId);
+        if (!active) {
+          sendAck({ error: `Process run ${message.runId} is not active on this worker` });
+          return;
+        }
+        if (!active.interactive || !active.stdin) {
+          sendAck({
+            error: `Process run ${message.runId} has no open stdin. Start a new shell command with "interactive": true to write to its stdin.`
+          });
+          return;
+        }
+        try {
+          let bytesWritten = 0;
+          if (message.data !== void 0 && message.data.length > 0) {
+            bytesWritten = await active.stdin.write(message.data);
+            await active.stdin.flush();
+          }
+          if (message.eof === true) {
+            await active.stdin.end();
+            active.stdin = void 0;
+          }
+          if (targetMayMutateVisibleWorkspace(active.target)) {
+            markWorkspaceDirty({ type: "shell_inline", detail: `exec stdin ${message.runId}` });
+          }
+          sendAck({
+            result: {
+              type: "exec_stdin",
+              runId: message.runId,
+              bytesWritten,
+              eof: message.eof === true
+            }
+          });
+        } catch (error) {
+          sendAck({ error: error instanceof Error ? error.message : String(error) });
+        }
+        return;
+      }
       if (message.type === "pty_open") {
         if (cliUpdateInProgress) {
           sendWorkerMessage(ws, {

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.67",
+  "version": "0.0.69",
   "type": "module"
 }

package/dist/mjs/pty-output-coalescer.mjs

@@ -0,0 +1,61 @@
+const DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS = 8;
+const DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES = 64 * 1024;
+function defaultSchedule(callback, delayMs) {
+  const timer = setTimeout(callback, delayMs);
+  timer.unref();
+  return () => clearTimeout(timer);
+}
+function createPtyOutputCoalescer(options) {
+  const flushIntervalMs = options.flushIntervalMs ?? DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS;
+  const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES;
+  const now = options.now ?? Date.now;
+  const schedule = options.schedule ?? defaultSchedule;
+  let buffer = "";
+  let bufferedBytes = 0;
+  let cancelScheduledFlush = null;
+  let lastSendAt = Number.NEGATIVE_INFINITY;
+  const sendNow = (data) => {
+    lastSendAt = now();
+    options.send(data);
+  };
+  const flush = () => {
+    if (cancelScheduledFlush) {
+      cancelScheduledFlush();
+      cancelScheduledFlush = null;
+    }
+    if (bufferedBytes === 0) {
+      return;
+    }
+    const data = buffer;
+    buffer = "";
+    bufferedBytes = 0;
+    sendNow(data);
+  };
+  const push = (data) => {
+    if (data.length === 0) {
+      return;
+    }
+    if (bufferedBytes === 0 && now() - lastSendAt >= flushIntervalMs) {
+      sendNow(data);
+      return;
+    }
+    buffer += data;
+    bufferedBytes += Buffer.byteLength(data, "utf8");
+    if (bufferedBytes >= maxBufferBytes) {
+      flush();
+      return;
+    }
+    if (!cancelScheduledFlush) {
+      cancelScheduledFlush = schedule(() => {
+        cancelScheduledFlush = null;
+        flush();
+      }, flushIntervalMs);
+    }
+  };
+  return { push, flush };
+}
+export {
+  DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS,
+  DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES,
+  createPtyOutputCoalescer
+};

package/dist/types/pty-output-coalescer.d.ts

@@ -0,0 +1,20 @@
+export interface PtyOutputCoalescerOptions {
+    send: (data: string) => void;
+    flushIntervalMs?: number;
+    maxBufferBytes?: number;
+    now?: () => number;
+    schedule?: (callback: () => void, delayMs: number) => () => void;
+}
+export interface PtyOutputCoalescer {
+    push(data: string): void;
+    flush(): void;
+}
+export declare const DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS = 8;
+export declare const DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES: number;
+/**
+ * Batches PTY output into fewer, larger relay messages. An isolated chunk
+ * (an interactive keystroke echo) is sent immediately so coalescing adds no
+ * input latency; only sustained bursts (build logs, `cat` of a large file)
+ * are buffered, bounded by the flush interval and the buffer byte cap.
+ */
+export declare function createPtyOutputCoalescer(options: PtyOutputCoalescerOptions): PtyOutputCoalescer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.67",
+  "version": "0.0.69",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",