Add WithExitCondition feature

CliWrap.Tests.Dummy/Commands/RunProcessCommand.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+
+namespace CliWrap.Tests.Dummy.Commands;
+
+[Command("run process")]
+public class RunProcessCommand : ICommand
+{
+    [CommandOption("path")]
+    public string FilePath { get; init; } = string.Empty;
+
+    [CommandOption("arguments")]
+    public string Arguments { get; init; } = string.Empty;
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = FilePath,
+            Arguments = Arguments,
+            RedirectStandardInput = true,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        var process = new Process();
+        process.StartInfo = startInfo;
+        process.Start();
+
+        console.Output.WriteLine(process.Id);
+
+        return default;
+    }
+}

CliWrap.Tests/ExitConditionSpecs.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CliWrap.Tests;
+
+public class ExitConditionSpecs()
+{
+    [Fact(Timeout = 15000)]
+    public async Task I_can_execute_a_command_that_creates_child_process_resuing_standard_output_and_finish_after_child_process_exits()
+    {
+        // Arrange
+        var cmd = this.PrepareCommand(line => { });
+
+        // Act
+        var executionStart = DateTime.UtcNow;
+        var result = await cmd.ExecuteAsync();
+        var executionFinish = DateTime.UtcNow;
+
+        // Assert
+        executionFinish
+            .Subtract(executionStart)
+            .Should()
+            .BeGreaterThanOrEqualTo(TimeSpan.FromSeconds(3));
+    }
+
+    [Fact(Timeout = 15000)]
+    public async Task I_can_execute_a_command_that_creates_child_process_resuing_standard_output_and_finish_instantly_after_main_process_exits()
+    {
+        // Arrange
+        int childProcessId = -1;
+        var cmd = this.PrepareCommand(line => childProcessId = Convert.ToInt32(line.Trim()))
+            .WithExitCondition(CommandExitCondition.ProcessExited);
+
+        // Act
+        var executionStart = DateTime.UtcNow;
+        var result = await cmd.ExecuteAsync();
+        var executionFinish = DateTime.UtcNow;
+
+        var process = Process.GetProcessById(childProcessId);
+
+        // Assert
+        executionFinish.Subtract(executionStart).Should().BeLessThan(TimeSpan.FromSeconds(3));
+
+        process.HasExited.Should().BeFalse();
+    }
+
+    /// <summary>
+    /// Prepares a command that will create a sleeping child process and return its id via standard output.
+    /// </summary>
+    private Command PrepareCommand(Action<string> onStandardOutput)
+    {
+        var cmd = Cli.Wrap(Dummy.Program.FilePath)
+            .WithArguments(
+                [
+                    "run",
+                    "process",
+                    "--path",
+                    Dummy.Program.FilePath,
+                    "--arguments",
+                    "sleep 00:00:03"
+                ]
+            )
+            .WithStandardOutputPipe(PipeTarget.ToDelegate(line => onStandardOutput(line)))
+            .WithStandardErrorPipe(
+                PipeTarget.ToDelegate(line => Console.WriteLine($"Error: {line}"))
+            );
+
+        return cmd;
+    }
+}

CliWrap/CommandExitCondition.cs

@@ -1,21 +1,18 @@
-using System;
-
-namespace CliWrap;
+namespace CliWrap;
 
 /// <summary>
-/// Strategy used for veryfing the end of command exectuion.
+/// Strategy used for identifying the end of command exectuion.
 /// </summary>
-[Flags]
 public enum CommandExitCondition
 {
     /// <summary>
-    /// Command is finished when process is finished and all pipes are closed.
+    /// Command execution is considered finished when the process exits and all standard input and output streams are closed.
     /// </summary>
     PipesClosed = 0,
 
     /// <summary>
-    /// Command is finished when the main process exits,
-    /// even if they are child processes still running, which are reusing the same output/error streams.
+    /// Command execution is considered finished when the process exits, even if the process's standard input and output streams are still open,
+    /// for example after being inherited by a grandchild process.
     /// </summary>
     ProcessExited = 1
 }

CliWrap/ICommandConfiguration.cs

@@ -27,6 +27,11 @@ public interface ICommandConfiguration
     /// </summary>
     Credentials Credentials { get; }
 
+    /// <summary>
+    /// Strategy used for veryfing the end of command exectuion.
+    /// </summary>
+    public CommandExitCondition CommandExitCondition { get; }
+
     /// <summary>
     /// Environment variables set for the underlying process.
     /// </summary>