Ignore remote stdin writes after child exit

Packages/macOS/CmuxRemoteSession/Sources/CmuxRemoteSession/Process/RemoteSessionProcessRunner.swift

@@ -20,6 +20,26 @@ internal import CMUXDebugLog
 /// synchronized by the capture `DispatchGroup` before any read-back, exactly
 /// like the legacy local-variable captures.
 public struct RemoteSessionProcessRunner: RemoteSessionProcessRunning {
+    enum StdinWriter {
+        static func write(
+            _ data: Data,
+            to handle: FileHandle,
+            executableName: String
+        ) throws {
+            do {
+                try handle.writeProcessPipeInput(data)
+            } catch let error as POSIXError where error.code == .EPIPE {
+                // A child may exit before consuming optional stdin. The POSIX
+                // helper turns that expected race into EPIPE instead of SIGPIPE.
+            } catch {
+                throw NSError(domain: "cmux.remote.process", code: 3, userInfo: [
+                    NSLocalizedDescriptionKey: "Failed to write stdin for \(executableName): \(error.localizedDescription)",
+                    NSUnderlyingErrorKey: error,
+                ])
+            }
+        }
+    }
+
     /// Test observation seam (package tests only): invoked right after the
     /// stdout/stderr capture readers are installed, with the pipe read
     /// handles. Return `true` when the hook closes both handles, so the
@@ -33,7 +53,9 @@ public struct RemoteSessionProcessRunner: RemoteSessionProcessRunning {
         self.readHandlesDidInstall = nil
     }
 
-    init(readHandlesDidInstall: (@Sendable (FileHandle, FileHandle) -> Bool)?) {
+    init(
+        readHandlesDidInstall: (@Sendable (FileHandle, FileHandle) -> Bool)? = nil
+    ) {
         self.readHandlesDidInstall = readHandlesDidInstall
     }
 
@@ -187,11 +209,6 @@ public struct RemoteSessionProcessRunner: RemoteSessionProcessRunning {
         }
         defer { operation?.clearCancellationHandler() }
 
-        if let stdin, let pipe = process.standardInput as? Pipe {
-            pipe.fileHandleForWriting.write(stdin)
-            try? pipe.fileHandleForWriting.close()
-        }
-
         func terminateProcessAndWait() {
             process.terminate()
             let terminatedGracefully = exitSemaphore.wait(timeout: .now() + 2.0) == .success
@@ -201,6 +218,29 @@ public struct RemoteSessionProcessRunner: RemoteSessionProcessRunning {
             }
         }
 
+        if let stdin, let pipe = process.standardInput as? Pipe {
+            let inputHandle = pipe.fileHandleForWriting
+            do {
+                try StdinWriter.write(
+                    stdin,
+                    to: inputHandle,
+                    executableName: URL(fileURLWithPath: executable).lastPathComponent
+                )
+            } catch {
+                try? inputHandle.close()
+                if process.isRunning {
+                    terminateProcessAndWait()
+                }
+                finishCaptureAndCloseReadHandles()
+                debugLog(
+                    "remote.proc.stdinWriteFailed exec=\(URL(fileURLWithPath: executable).lastPathComponent) " +
+                    "error=\(error.localizedDescription)"
+                )
+                throw error
+            }
+            try? inputHandle.close()
+        }
+
         let didExitBeforeTimeout = exitSemaphore.wait(timeout: .now() + max(0, timeout)) == .success
         if !didExitBeforeTimeout, process.isRunning {
             if let operation, operation.isCancelled {

Packages/macOS/CmuxRemoteSession/Sources/CmuxRemoteSession/Process/RemoteSessionProcessRunning.swift

@@ -15,8 +15,8 @@ public protocol RemoteSessionProcessRunning: Sendable {
     ///   - operation: Optional transfer-cancellation token; when it cancels,
     ///     the process is terminated and `operation.cancellationError` is
     ///     thrown.
-    /// - Throws: The legacy launch-failure (`cmux.remote.process` code 1) and
-    ///   timeout (code 2) errors, or `operation.cancellationError`.
+    /// - Throws: Launch-failure (`cmux.remote.process` code 1), timeout
+    ///   (code 2), stdin-write (code 3), or `operation.cancellationError`.
     func run(
         _ request: RemoteProcessRequest,
         operation: (any RemoteTransferCancelling)?

Packages/macOS/CmuxRemoteSession/Tests/CmuxRemoteSessionTests/RemoteSessionProcessRunnerTests.swift

@@ -70,6 +70,42 @@ struct RemoteSessionProcessRunnerTests {
         #expect(result.stdout == "hello-stdin")
     }
 
+    @Test("A child closing stdin before a large write does not abort the runner")
+    func childClosingStdinDoesNotAbortRunner() throws {
+        let runner = RemoteSessionProcessRunner()
+        let result = try runner.run(
+            RemoteProcessRequest(
+                executable: "/usr/bin/true",
+                arguments: [],
+                stdin: Data(repeating: 0x41, count: 1_048_576),
+                timeout: 5
+            ),
+            operation: nil
+        )
+
+        #expect(result.status == 0)
+    }
+
+    @Test("An unexpected stdin write error keeps the pinned runner error")
+    func unexpectedStdinWriteErrorKeepsPinnedRunnerError() {
+        let invalidHandle = FileHandle(fileDescriptor: -1, closeOnDealloc: false)
+
+        #expect {
+            try RemoteSessionProcessRunner.StdinWriter.write(
+                Data("payload".utf8),
+                to: invalidHandle,
+                executableName: "sleep"
+            )
+        } throws: { error in
+            let nsError = error as NSError
+            let underlyingError = nsError.userInfo[NSUnderlyingErrorKey] as? POSIXError
+            return nsError.domain == "cmux.remote.process"
+                && nsError.code == 3
+                && nsError.localizedDescription.hasPrefix("Failed to write stdin for sleep:")
+                && underlyingError?.code == .EBADF
+        }
+    }
+
     @Test("Streams a local file through stdin")
     func streamsFileStdin() throws {
         let fileManager = FileManager.default