Keep what a pipe process wrote before exiting early

When cmd2 captures a pipe process's output, as in a pyscript, that process
writes to pipes that a ProcReader reads. Only a pipe that was not the
terminal's job got its ProcReader after the startup check, so one that had
already exited was reported with RedirectionError without being read: what
it wrote, such as the shell's "command not found", was lost, and its pipes
were left for garbage collection to close. Create the ProcReader right
after the spawn for every pipe, and reap through it on the early exit.

Author: tleonhardt

CHANGELOG.md

@@ -20,6 +20,8 @@
     - When a pipe's process cannot be started, for instance because no more processes can be created
       or `$SHELL` names a program that cannot run, both ends of the pipe are now closed rather than
       left open
+    - When a pipe's process exits before the command runs, what it wrote, such as the shell's
+      "command not found", is no longer lost when cmd2 captures the output, as in a pyscript
 
 ## 4.2.4 (September 8, 2026)
 

cmd2/cmd2.py

@@ -3393,16 +3393,16 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
                         shell=True,
                         **kwargs,
                     )
+                cmd_pipe_proc_reader = utils.ProcReader(proc, self.stdout, sys.stderr, terminal_fd=terminal_fd)
                 if terminal_fd is not None:
-                    cmd_pipe_proc_reader = utils.ProcReader(proc, self.stdout, sys.stderr, terminal_fd=terminal_fd)
                     pipe_stack.enter_context(cmd_pipe_proc_reader._manage_terminal())
 
                 # Popen was called with shell=True so the user can chain pipe commands and redirect their output
                 # like: !ls -l | grep user | wc -l > out.txt. But this makes it difficult to know if the pipe process started
                 # OK, since the shell itself always starts. Therefore, we will wait a short time and check if the pipe process
                 # is still running.
                 with contextlib.suppress(subprocess.TimeoutExpired):
-                    if cmd_pipe_proc_reader is None:
+                    if terminal_fd is None:
                         proc.wait(0.2)
                     else:
                         # Open the start gate only once the pipeline owns the terminal.
@@ -3411,14 +3411,11 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
                                 os.write(new_stdout.fileno(), b"\n")
                             cmd_pipe_proc_reader._wait_for_exit(0.2)
 
-                # Check if the pipe process already exited
+                # Check if the pipe process already exited. Pass on what it wrote to a pipe, such as why it failed.
                 if proc.returncode is not None:
-                    if cmd_pipe_proc_reader is not None:
-                        cmd_pipe_proc_reader.wait()
+                    cmd_pipe_proc_reader.wait()
                     raise RedirectionError(f"Pipe process exited with code {proc.returncode} before command could run")
                 redir_saved_state.redirecting = True
-                if cmd_pipe_proc_reader is None:
-                    cmd_pipe_proc_reader = utils.ProcReader(proc, self.stdout, sys.stderr)
 
                 if terminal_fd is not None:
                     import io

tests/test_cmd2.py

@@ -982,6 +982,7 @@ def test_pipe_to_shell_error(redirection_app, mocker, capsys, terminal) -> None:
     process = popen.return_value
     process.returncode = 127
     process.wait.return_value = 127
+    reader = mocker.patch("cmd2.utils.ProcReader").return_value
     if terminal:
         terminal_stream = mocker.Mock()
         terminal_stream.isatty.return_value = True
@@ -990,7 +991,6 @@ def test_pipe_to_shell_error(redirection_app, mocker, capsys, terminal) -> None:
         mocker.patch("os.tcgetpgrp", return_value=os.getpgrp())
         mocker.patch("os.getsid", return_value=os.getpgrp())
         sigmask = mocker.patch("signal.pthread_sigmask", return_value=set())
-        reader = mocker.patch("cmd2.utils.ProcReader").return_value
         previous_tstp = signal.getsignal(signal.SIGTSTP)
 
         def start_pipe(*args, **kwargs):
@@ -1011,10 +1011,11 @@ def start_pipe(*args, **kwargs):
     assert not out
     assert "Pipe process exited with code 127 before command could run" in " ".join(err)
     assert capsys.readouterr().out == ""
+    # The pipe process is reaped, and what it wrote to a pipe passed on.
+    reader.wait.assert_called_once_with()
     if terminal:
         assert signal.getsignal(signal.SIGTSTP) == previous_tstp
         reader._wait_for_exit.assert_called_once_with(0.2)
-        reader.wait.assert_called_once_with()
         process.wait.assert_not_called()
         # SIGTTOU is blocked only inside ProcReader's lends. Blocking it for the whole pipeline would leak the mask into every
         # child the command starts.
@@ -1024,6 +1025,26 @@ def start_pipe(*args, **kwargs):
     assert popen.call_args.kwargs["stdin"].closed
 
 
+def test_pipe_to_shell_error_keeps_what_the_pipe_process_wrote(redirection_app, mocker) -> None:
+    """A pipe process that exits before the command runs may say why, as a shell does for a command it cannot find.
+
+    With its output captured, as in a pyscript, that must reach the captured stderr too.
+    """
+    real_popen = subprocess.Popen
+
+    def popen(*args, **kwargs):
+        process = real_popen(*args, **kwargs)
+        # Exit before the startup check, however loaded the system is
+        process.wait()
+        return process
+
+    mocker.patch("subprocess.Popen", popen)
+    out, err = run_cmd(redirection_app, "print_output | echo pipe output && cmd2_test_no_such_command")
+    assert out == ["pipe output"]
+    assert "cmd2_test_no_such_command" in " ".join(err)
+    assert "before command could run" in err[-1]
+
+
 @pytest.mark.skipif(sys.platform == "win32", reason="POSIX terminal job control")
 @pytest.mark.parametrize("android", [False, True])
 def test_terminal_pipe_start_gate_uses_the_platform_shell(redirection_app, mocker, monkeypatch, android) -> None: