🤖 fix: make exec stdin.close idempotent for remote runtimes

CI integration tests showed ssh exec streams could return a stdin WritableStream that fails on close for short-lived commands. Wrap child stdin with a small WritableStream facade so close() is safe even if the underlying stream is already ended.

Author: ammar-agent

src/node/runtime/RemoteRuntime.ts

@@ -15,7 +15,7 @@
  */
 
 import type { ChildProcess } from "child_process";
-import { Readable, Writable } from "stream";
+import { Readable } from "stream";
 import type {
   Runtime,
   ExecOptions,
@@ -145,7 +145,50 @@ export abstract class RemoteRuntime implements Runtime {
     // Convert Node.js streams to Web Streams
     const stdout = Readable.toWeb(childProcess.stdout!) as unknown as ReadableStream<Uint8Array>;
     const stderr = Readable.toWeb(childProcess.stderr!) as unknown as ReadableStream<Uint8Array>;
-    const stdin = Writable.toWeb(childProcess.stdin!) as unknown as WritableStream<Uint8Array>;
+
+    // Writable.toWeb(childProcess.stdin) is surprisingly easy to get into an invalid state
+    // for short-lived remote commands (notably via SSH) where stdin may already be closed
+    // by the time callers attempt `await stream.stdin.close()`.
+    //
+    // Wrap stdin ourselves so close() is idempotent.
+    const stdin = new WritableStream<Uint8Array>({
+      write: async (chunk) => {
+        const nodeStdin = childProcess.stdin;
+        if (!nodeStdin || nodeStdin.destroyed) {
+          return;
+        }
+
+        await new Promise<void>((resolve, reject) => {
+          const onError = (err: Error) => {
+            nodeStdin.off("error", onError);
+            reject(err);
+          };
+          nodeStdin.on("error", onError);
+
+          nodeStdin.write(Buffer.from(chunk), (err) => {
+            nodeStdin.off("error", onError);
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve();
+          });
+        });
+      },
+      close: async () => {
+        const nodeStdin = childProcess.stdin;
+        if (!nodeStdin || nodeStdin.destroyed || nodeStdin.writableEnded) {
+          return;
+        }
+
+        await new Promise<void>((resolve) => {
+          nodeStdin.end(() => resolve());
+        });
+      },
+      abort: () => {
+        childProcess.stdin?.destroy();
+      },
+    });
 
     // Track if we killed the process due to timeout or abort
     let timedOut = false;