Added output configurations. Related to #3170

io/js/src/main/scala/fs2/io/process/ProcessesPlatform.scala

@@ -36,19 +36,47 @@ private[process] trait ProcessesCompanionPlatform {
     def spawn(process: ProcessBuilder): Resource[F, Process[F]] =
       Resource {
         F.async_[(Process[F], F[Unit])] { cb =>
-          val childProcess = facade.child_process.spawn(
-            process.command,
-            process.args.toJSArray,
-            new facade.child_process.SpawnOptions {
-              cwd = process.workingDirectory.fold[js.UndefOr[String]](js.undefined)(_.toString)
-              env =
+
+
+          val spawnOptions = js.Dynamic.literal {
+              "cwd" -> process.workingDirectory.fold[js.UndefOr[String]](js.undefined)(_.toString)
+              "env" ->(
                 if (process.inheritEnv)
                   (facade.process.env ++ process.extraEnv).toJSDictionary
                 else
-                  process.extraEnv.toJSDictionary
+                  process.extraEnv.toJSDictionary)
             }
+
+          val childProcess = facade.child_process.spawn(
+            process.command,
+            process.args.toJSArray,
+            spawnOptions.asInstanceOf[facade.child_process.SpawnOptions]
           )
 
+          process.outputConfig.stdin match {
+            case StreamOutputMode.Inherit => spawnOptions.updateDynamic("stdio")("inherit")
+            case StreamOutputMode.Ignore  => spawnOptions.updateDynamic("stdio")("ignore")
+            case StreamOutputMode.FileOutput(path) =>
+              spawnOptions.updateDynamic("stdio")(js.Array(path.toString, "pipe", "pipe"))
+            case StreamOutputMode.Pipe => 
+          }
+
+          process.outputConfig.stdout match {
+            case StreamOutputMode.Inherit => spawnOptions.updateDynamic("stdio")("inherit")
+            case StreamOutputMode.Ignore  => spawnOptions.updateDynamic("stdio")("ignore")
+            case StreamOutputMode.FileOutput(path) =>
+              spawnOptions.updateDynamic("stdio")(js.Array("pipe", path.toString, "pipe"))
+            case StreamOutputMode.Pipe =>
+          }
+
+          process.outputConfig.stderr match {
+            case StreamOutputMode.Inherit => spawnOptions.updateDynamic("stdio")("inherit")
+            case StreamOutputMode.Ignore  => spawnOptions.updateDynamic("stdio")("ignore")
+            case StreamOutputMode.FileOutput(path) =>
+              spawnOptions.updateDynamic("stdio")(js.Array("pipe", "pipe", path.toString))
+            case StreamOutputMode.Pipe => 
+          }
+
           val fs2Process = new UnsealedProcess[F] {
 
             def isAlive: F[Boolean] = F.delay {
@@ -84,7 +112,7 @@ private[process] trait ProcessesCompanionPlatform {
               } else {
                 childProcess.kill()
                 childProcess.once("exit", () => cb(Either.unit))
-                Left(None)
+                Left(None) 
               }
             }
           }

io/jvm-native/src/main/scala/fs2/io/process/ProcessesPlatform.scala

@@ -28,7 +28,8 @@ import cats.effect.kernel.Resource
 import cats.syntax.all.*
 import fs2.io.CollectionCompat.*
 
-import java.lang
+import java.lang.ProcessBuilder.Redirect
+
 
 private[process] trait ProcessesCompanionPlatform {
   def forAsync[F[_]](implicit F: Async[F]): Processes[F] = new UnsealedProcesses[F] {
@@ -37,60 +38,81 @@ private[process] trait ProcessesCompanionPlatform {
       Resource
         .make {
           F.blocking {
-            val builder = new lang.ProcessBuilder((process.command :: process.args).asJava)
+          val builder = new java.lang.ProcessBuilder((process.command :: process.args).asJava)
+
+          process.workingDirectory.foreach { path =>
+            builder.directory(path.toNioPath.toFile)
+          }
+
+          val env = builder.environment()
+          if (!process.inheritEnv) env.clear()
+          process.extraEnv.foreach { case (k, v) =>
+            env.put(k, v)
+          }
 
-            process.workingDirectory.foreach { path =>
-              builder.directory(path.toNioPath.toFile)
+          process.outputConfig.stdin match {
+              case StreamOutputMode.Inherit => builder.redirectInput(Redirect.INHERIT)
+              case StreamOutputMode.Ignore  => builder.redirectInput(Redirect.DISCARD)
+              case StreamOutputMode.FileOutput(path) =>
+                builder.redirectInput(Redirect.from(path.toNioPath.toFile))
+              case StreamOutputMode.Pipe => 
             }
 
-            val env = builder.environment()
-            if (!process.inheritEnv) env.clear()
-            process.extraEnv.foreach { case (k, v) =>
-              env.put(k, v)
+            process.outputConfig.stdout match {
+              case StreamOutputMode.Inherit => builder.redirectOutput(Redirect.INHERIT)
+              case StreamOutputMode.Ignore  => builder.redirectOutput(Redirect.DISCARD)
+              case StreamOutputMode.FileOutput(path) =>
+                builder.redirectOutput(Redirect.to(path.toNioPath.toFile))
+              case StreamOutputMode.Pipe =>
             }
 
-            builder.start()
-          }
-        } { process =>
-          F.delay(process.isAlive())
-            .ifM(
-              evalOnVirtualThreadIfAvailable(
-                F.blocking {
-                  process.destroy()
-                  process.waitFor()
-                  ()
-                }
-              ),
-              F.unit
-            )
+            process.outputConfig.stderr match {
+              case StreamOutputMode.Inherit => builder.redirectError(Redirect.INHERIT)
+              case StreamOutputMode.Ignore  => builder.redirectError(Redirect.DISCARD)
+              case StreamOutputMode.FileOutput(path) =>
+                builder.redirectError(Redirect.to(path.toNioPath.toFile))
+              case StreamOutputMode.Pipe => 
+            }
+
+          builder.start()
         }
-        .map { process =>
-          new UnsealedProcess[F] {
-            def isAlive = F.delay(process.isAlive())
+      } { process =>
+        F.delay(process.isAlive())
+          .ifM(
+            F.blocking {
+              process.destroy()
+              process.waitFor()
+              ()
+            },
+            F.unit
+          )
+      }
+      .map { process =>
+        new UnsealedProcess[F] {
+          def isAlive = F.delay(process.isAlive())
 
             def exitValue = isAlive.ifM(
               evalOnVirtualThreadIfAvailable(F.interruptible(process.waitFor())),
               F.delay(process.exitValue())
             )
 
-            def stdin = writeOutputStreamCancelable(
-              F.delay(process.getOutputStream()),
-              F.blocking(process.destroy())
-            )
+          def stdin = writeOutputStreamCancelable(
+            F.delay(process.getOutputStream()),
+            F.blocking(process.destroy())
+          )
 
-            def stdout = readInputStreamCancelable(
-              F.delay(process.getInputStream()),
-              F.blocking(process.destroy()),
-              8192
-            )
+          def stdout = readInputStreamCancelable(
+            F.delay(process.getInputStream()),
+            F.blocking(process.destroy()),
+            8192
+          )
 
-            def stderr = readInputStreamCancelable(
-              F.delay(process.getErrorStream()),
-              F.blocking(process.destroy()),
-              8192
-            )
-
-          }
+          def stderr = readInputStreamCancelable(
+            F.delay(process.getErrorStream()),
+            F.blocking(process.destroy()),
+            8192
+          )
+        }
         }
   }
 }

io/shared/src/main/scala/fs2/io/process/ProcessBuilder.scala

@@ -49,6 +49,9 @@ sealed abstract class ProcessBuilder private {
     */
   def workingDirectory: Option[Path]
 
+  /** Configures how stdout and stderr should be handled. */
+  def outputConfig: ProcessOutputConfig
+
   /** @see [[command]] */
   def withCommand(command: String): ProcessBuilder
 
@@ -67,17 +70,34 @@ sealed abstract class ProcessBuilder private {
   /** @see [[workingDirectory]] */
   def withCurrentWorkingDirectory: ProcessBuilder
 
+  /** @see [[outputMode]] */
+  def withOutputConfig(outputConfig: ProcessOutputConfig): ProcessBuilder
+
   /** Starts the process and returns a handle for interacting with it.
     * Closing the resource will kill the process if it has not already terminated.
     */
   final def spawn[F[_]: Processes]: Resource[F, Process[F]] =
     Processes[F].spawn(this)
 }
 
+sealed trait StreamOutputMode
+object StreamOutputMode {
+  case object Pipe extends StreamOutputMode       
+  case object Inherit extends StreamOutputMode   
+  case object Ignore extends StreamOutputMode    
+  case class FileOutput(path: Path) extends StreamOutputMode 
+}
+
+final case class ProcessOutputConfig(
+    stdin: StreamOutputMode = StreamOutputMode.Pipe,
+    stdout: StreamOutputMode = StreamOutputMode.Pipe,
+    stderr: StreamOutputMode = StreamOutputMode.Pipe
+)
+
 object ProcessBuilder {
 
   def apply(command: String, args: List[String]): ProcessBuilder =
-    ProcessBuilderImpl(command, args, true, Map.empty, None)
+    ProcessBuilderImpl(command, args, true, Map.empty, None, ProcessOutputConfig())
 
   def apply(command: String, args: String*): ProcessBuilder =
     apply(command, args.toList)
@@ -87,7 +107,8 @@ object ProcessBuilder {
       args: List[String],
       inheritEnv: Boolean,
       extraEnv: Map[String, String],
-      workingDirectory: Option[Path]
+      workingDirectory: Option[Path],
+      outputConfig: ProcessOutputConfig
   ) extends ProcessBuilder {
 
     def withCommand(command: String): ProcessBuilder = copy(command = command)
@@ -100,7 +121,9 @@ object ProcessBuilder {
 
     def withWorkingDirectory(workingDirectory: Path): ProcessBuilder =
       copy(workingDirectory = Some(workingDirectory))
+
     def withCurrentWorkingDirectory: ProcessBuilder = copy(workingDirectory = None)
-  }
 
+    def withOutputConfig(outputConfig: ProcessOutputConfig): ProcessBuilder = copy(outputConfig = outputConfig)
+  }
 }

io/shared/src/main/scala/fs2/io/process/Processes.scala

@@ -25,7 +25,6 @@ import cats.effect.IO
 import cats.effect.LiftIO
 import cats.effect.kernel.Async
 import cats.effect.kernel.Resource
-
 sealed trait Processes[F[_]] {
 
   def spawn(process: ProcessBuilder): Resource[F, Process[F]]

io/shared/src/test/scala/fs2/io/process/ProcessSuite.scala

@@ -48,11 +48,9 @@ class ProcessSuite extends Fs2IoSuite {
   }
 
   test("stdout and stderr") {
-    ProcessBuilder(
-      "node",
-      "-e",
-      "console.log('good day stdout'); console.error('how do you do stderr')"
-    ).spawn[IO]
+    ProcessBuilder("node", "-e", "console.log('good day stdout'); console.error('how do you do stderr')")
+      .withOutputConfig(ProcessOutputConfig())
+      .spawn[IO]
       .use { p =>
         val testOut = p.stdout
           .through(fs2.text.utf8.decode)
@@ -72,6 +70,49 @@ class ProcessSuite extends Fs2IoSuite {
       }
   }
 
+  test("merged stdout and stderr") {
+    ProcessBuilder("node", "-e", "console.log('merged stdout'); console.error('merged stderr')")
+      .withOutputConfig(ProcessOutputConfig(stdout = StreamOutputMode.Pipe, stderr = StreamOutputMode.Pipe))
+      .spawn[IO]
+      .use { p =>
+        p.stdout
+          .through(fs2.text.utf8.decode)
+          .compile
+          .string
+          .assert(s => s.contains("merged stdout") && s.contains("merged stderr"))
+      }
+  }
+
+  test("file output") {
+    Files[IO].tempFile.use { path =>
+      ProcessBuilder("echo", "file output test")
+        .withOutputConfig(ProcessOutputConfig(stdout = StreamOutputMode.FileOutput(path)))
+        .spawn[IO]
+        .use(_.exitValue)
+        .assertEquals(0) *> 
+      Files[IO].readUtf8(path).compile.string.assertEquals("file output test\n")
+    }
+  }
+
+  test("ignored output") {
+    ProcessBuilder("echo", "ignored output")
+      .withOutputConfig(ProcessOutputConfig(stdout = StreamOutputMode.Ignore))
+      .spawn[IO]
+      .use(_.exitValue)
+      .assertEquals(0)
+  }
+
+  test("stdin piping") {
+    ProcessBuilder("cat")
+      .withOutputConfig(ProcessOutputConfig(stdin = StreamOutputMode.Pipe))
+      .spawn[IO]
+      .use { p =>
+        val input = Stream.emit("piped input test").through(fs2.text.utf8.encode).through(p.stdin).compile.drain
+        val output = p.stdout.through(fs2.text.utf8.decode).compile.string.assertEquals("piped input test")
+        input *> output
+      }
+  }
+
   if (!isNative)
     test("cat") {
       ProcessBuilder("cat").spawn[IO].use { p =>