Allow piping repl output to shell commands (#8878)

Add shell support to repl-util in a manner similar to mdb. Thanks to
@rmustacc for the idea.

This allows doing things like the following example from tqdb.

Find all commit operations in the event log and report their event
number:

```
tqdb〉events all ! grep Commit | cut -d "  " -f1
30
31
32
33
34
35
43
44
130
131
132
1035
1036
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1059
1060
1061
1062
1063
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
tqdb〉
```

You can also do things like page output through less:

```
tqdb〉events all ! less
```

Author: andrewjstone

Cargo.lock

@@ -0,0 +1,2 @@
+# Ensure that we can pipe command output to a shell command
+show ! grep DNS

dev-tools/reconfigurator-cli/tests/input/cmds-pipe-to-grep.txt

@@ -0,0 +1,7 @@
+using provided RNG seed: reconfigurator-cli-test
+> # Ensure that we can pipe command output to a shell command
+> show ! grep DNS
+configured external DNS zone name: oxide.example
+internal DNS generations: 
+external DNS generations: 
+

dev-tools/reconfigurator-cli/tests/output/cmds-pipe-to-grep-stderr

@@ -13,3 +13,4 @@ camino.workspace = true
 clap.workspace = true
 reedline.workspace = true
 omicron-workspace-hack.workspace = true
+subprocess.workspace = true

dev-tools/reconfigurator-cli/tests/output/cmds-pipe-to-grep-stdout

@@ -14,6 +14,8 @@ use reedline::Signal;
 use std::fs::File;
 use std::io::BufRead;
 use std::io::BufReader;
+use std::io::Write;
+use subprocess::Exec;
 
 /// Runs the same kind of REPL as `run_repl_on_stdin()`, but reads commands from
 /// a file
@@ -148,12 +150,21 @@ fn process_entry<C: Parser>(
         return LoopResult::Continue;
     }
 
-    // Parse the line of input as a REPL command.
+    // Split on the first `!` character if it exists. Use the first
+    // element of the iterator as the REPL command to parse via clap. Use the
+    // second element, if it exists, as the shell command to pipe the output of
+    // the REPL command into.
+    let mut split = entry.splitn(2, '!');
+
+    // Parse the line of input before any `!` as a REPL command.
     //
     // Using `split_whitespace()` like this is going to be a problem if we ever
     // want to support arguments with whitespace in them (using quotes).  But
     // it's good enough for now.
-    let parts = entry.split_whitespace();
+    //
+    // SAFETY: There is always at least one element in the iterator.
+    let parts = split.next().expect("element exists").split_whitespace();
+
     let parsed_command = C::command()
         .multicall(true)
         .try_get_matches_from(parts)
@@ -176,7 +187,35 @@ fn process_entry<C: Parser>(
 
     match run_one(command) {
         Err(error) => println!("error: {:#}", error),
-        Ok(Some(s)) => println!("{}", s),
+        Ok(Some(repl_cmd_output)) => {
+            if let Some(shell_cmd) = split.next() {
+                let mut child_stdin = Exec::shell(shell_cmd)
+                    .stream_stdin()
+                    .expect("stdin opened");
+
+                // Using `write_all` doesn't play nicely with the shell group
+                // leader, likely due to blocking/signal behavior. We therefore
+                // manually loop over calls to `write`.
+                let mut written_bytes = 0;
+                let to_write = repl_cmd_output.len();
+                while written_bytes < to_write {
+                    match child_stdin
+                        .write(&repl_cmd_output.as_bytes()[written_bytes..])
+                    {
+                        Ok(0) => break,
+                        Ok(n) => written_bytes += n,
+                        Err(_) => {
+                            // Broken pipe is a normal condition reflecting
+                            // that the child process exited early (e.g., as
+                            // `head(1)` does).
+                            break;
+                        }
+                    }
+                }
+            } else {
+                println!("{repl_cmd_output}");
+            }
+        }
         Ok(None) => (),
     }