Add simple stdin support

source/Shellfish/IInputSource.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Octopus.Shellfish;
+
+public interface IInputSource
+{
+    IEnumerable<string> GetInput();
+}

source/Shellfish/ShellCommand.cs

@@ -26,6 +26,7 @@ public class ShellCommand
 
     List<IOutputTarget>? stdOutTargets;
     List<IOutputTarget>? stdErrTargets;
+    IInputSource? stdInSource;
 
     public ShellCommand(string executable)
     {
@@ -138,18 +139,24 @@ public ShellCommand WithStdErrTarget(IOutputTarget target)
         return this;
     }
 
+    public ShellCommand WithStdInSource(IInputSource source)
+    {
+        stdInSource = source;
+        return this;
+    }
+
     /// <summary>
     /// Launches the process and synchronously waits for it to exit.
     /// </summary>
     public ShellCommandResult Execute(CancellationToken cancellationToken = default)
     {
         using var process = new Process();
-        ConfigureProcess(process, out var shouldBeginOutputRead, out var shouldBeginErrorRead);
+        ConfigureProcess(process, out var shouldBeginOutputRead, out var shouldBeginErrorRead, out var redirectingStdIn);
 
         var exitedEvent = AttachProcessExitedManualResetEvent(process, cancellationToken);
         process.Start();
 
-        BeginIoStreams(process, shouldBeginOutputRead, shouldBeginErrorRead);
+        BeginIoStreams(process, shouldBeginOutputRead, shouldBeginErrorRead, redirectingStdIn);
 
         try
         {
@@ -185,12 +192,12 @@ public ShellCommandResult Execute(CancellationToken cancellationToken = default)
     public async Task<ShellCommandResult> ExecuteAsync(CancellationToken cancellationToken = default)
     {
         using var process = new Process();
-        ConfigureProcess(process, out var shouldBeginOutputRead, out var shouldBeginErrorRead);
+        ConfigureProcess(process, out var shouldBeginOutputRead, out var shouldBeginErrorRead, out var redirectingStdIn);
 
         var exitedTask = AttachProcessExitedTask(process, cancellationToken);
         process.Start();
 
-        BeginIoStreams(process, shouldBeginOutputRead, shouldBeginErrorRead);
+        BeginIoStreams(process, shouldBeginOutputRead, shouldBeginErrorRead, redirectingStdIn);
 
         try
         {
@@ -216,7 +223,7 @@ public async Task<ShellCommandResult> ExecuteAsync(CancellationToken cancellatio
     }
 
     // sets standard flags on the Process that apply for both Execute and ExecuteAsync
-    void ConfigureProcess(Process process, out bool shouldBeginOutputRead, out bool shouldBeginErrorRead)
+    void ConfigureProcess(Process process, out bool shouldBeginOutputRead, out bool shouldBeginErrorRead, out bool redirectingStdIn)
     {
         process.StartInfo.FileName = executable;
 
@@ -264,7 +271,7 @@ void ConfigureProcess(Process process, out bool shouldBeginOutputRead, out bool
             }
         }
 
-        shouldBeginOutputRead = shouldBeginErrorRead = false;
+        shouldBeginOutputRead = shouldBeginErrorRead = redirectingStdIn = false;
         if (stdOutTargets is { Count: > 0 })
         {
             process.StartInfo.RedirectStandardOutput = true;
@@ -292,15 +299,41 @@ void ConfigureProcess(Process process, out bool shouldBeginOutputRead, out bool
                 foreach (var target in targets) target.WriteLine(e.Data);
             };
         }
+
+        if (stdInSource is not null)
+        {
+            process.StartInfo.RedirectStandardInput = true;
+            redirectingStdIn = true;
+        }
     }
 
     // Common code for Execute and ExecuteAsync to handle stdin and stdout streaming
     void BeginIoStreams(Process process,
         bool shouldBeginOutputRead,
-        bool shouldBeginErrorRead)
+        bool shouldBeginErrorRead,
+        bool redirectingStdIn)
     {
         if (shouldBeginOutputRead) process.BeginOutputReadLine();
         if (shouldBeginErrorRead) process.BeginErrorReadLine();
+
+        if (redirectingStdIn)
+        {
+            try
+            {
+                foreach (var val in stdInSource!.GetInput())
+                {
+                    process.StandardInput.Write(val);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // gracefully handle cancellation of the enumerator
+            }
+            finally
+            {
+                process.StandardInput.Close();
+            }
+        }
     }
 
     static async Task FinalWaitForExitAsync(Process process, CancellationToken cancellationToken)

source/Shellfish/StringInputSource.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace Octopus.Shellfish;
+
+class StringInputSource(string value) : IInputSource
+{
+    public IEnumerable<string> GetInput() => [value];
+}
+
+public static class StringInputSourceExtensions
+{
+    public static ShellCommand WithStdInSource(this ShellCommand shellCommand, string input)
+    {
+        shellCommand.WithStdInSource(new StringInputSource(input));
+        return shellCommand;
+    }
+}

source/Tests/Plumbing/TempScript.cs

@@ -0,0 +1,61 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Tests.Plumbing;
+
+public static class TempScript
+{
+    // Some interactions such as stdout or encoding codepages require things that don't work with an inline cmd /c or bash -c command
+    // This helper writes a script file into the temp directory so we can exercise more complex scenarios
+    public static Handle Create(string cmd, string sh)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            var tempFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N") + ".cmd");
+            File.WriteAllText(tempFile, cmd);
+            return new Handle(tempFile);
+        }
+        else
+        {
+            var tempFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N") + ".sh");
+            File.WriteAllText(tempFile, sh.Replace("\r\n", "\n"));
+            return new Handle(tempFile);
+        }
+    }
+
+    public class Handle(string scriptPath) : IDisposable
+    {
+        public string ScriptPath { get; } = scriptPath;
+
+        public void Dispose()
+        {
+            try
+            {
+                File.Delete(ScriptPath);
+            }
+            catch
+            {
+                // nothing to do if we can't delete the temp file
+            }
+        }
+
+        // Returns the host application which will run the script. Either cmd.exe or bash
+        public string GetHostExecutable()
+        {
+            return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "cmd.exe" : "bash";
+        }
+
+        // Returns the command line args to get the host application to run the script
+        // For cmd.exe, returns ["/c", ScriptPath] as it needs /c
+        // For bash, returns [ScriptPath] as it doesn't need any preamble
+        public string[] GetCommandArgs()
+        {
+            // when running cmd.exe we need /c to tell it to run the script; bash doesn't want any preamble for a script file
+            return RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                ? ["/c", ScriptPath]
+                : [ScriptPath];
+
+        }
+    }
+}

source/Tests/PublicSurfaceArea.TheLibraryOnlyExposesWhatWeWantItToExpose.approved.txt

@@ -2,6 +2,7 @@ Octopus.Shellfish.ShellCommandExtensionMethods.WithStdOutTarget
 Octopus.Shellfish.ShellCommandExtensionMethods.WithStdErrTarget
 Octopus.Shellfish.ShellCommandExtensionMethods.WithStdOutTarget
 Octopus.Shellfish.ShellCommandExtensionMethods.WithStdErrTarget
+Octopus.Shellfish.IInputSource.GetInput
 Octopus.Shellfish.IOutputTarget.WriteLine
 Octopus.Shellfish.ShellCommand.WithWorkingDirectory
 Octopus.Shellfish.ShellCommand.WithArguments
@@ -11,10 +12,12 @@ Octopus.Shellfish.ShellCommand.WithCredentials
 Octopus.Shellfish.ShellCommand.WithOutputEncoding
 Octopus.Shellfish.ShellCommand.WithStdOutTarget
 Octopus.Shellfish.ShellCommand.WithStdErrTarget
+Octopus.Shellfish.ShellCommand.WithStdInSource
 Octopus.Shellfish.ShellCommand.Execute
 Octopus.Shellfish.ShellCommand.ExecuteAsync
 Octopus.Shellfish.ShellCommandResult.ExitCode
 Octopus.Shellfish.ShellExecutionException.Errors
 Octopus.Shellfish.ShellExecutionException.Message
 Octopus.Shellfish.ShellExecutor.ExecuteCommand
-Octopus.Shellfish.ShellExecutor.ExecuteCommandWithoutWaiting
+Octopus.Shellfish.ShellExecutor.ExecuteCommandWithoutWaiting
+Octopus.Shellfish.StringInputSourceExtensions.WithStdInSource