internal: Improve code quality of the moon_process crate (#2567)

* internal: Improve code quality of the moon_process crate.

- Fix command output being lost entirely when it contains invalid
  UTF-8 (now lossy converted).
- Fix cache key collisions in `Command::get_cache_key` by
  length-prefixing hashed fields, sorting env vars, and including
  the env variant discriminant.
- Fix command line being logged after streamed output in
  `exec_stream_and_capture_output`.
- Remove `unsafe` from `get_bin_name`.
- Return captured lines through join handles instead of
  `Arc<RwLock<Vec>>`, and dedupe the stream reader loops.
- Remove dead code: `output_stream` module and commented-out
  exec method.
- Replace magic signal/errno numbers with libc constants.
- Move the arg quoting test harness from `src/main.rs` to
  `examples/args.rs` so it no longer builds as a default target.
- Clear the process registry after force-kill tasks complete,
  not before.
- Declare all used tokio features; hoist `libc` to workspace deps.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Hoist windows-sys to workspace dependencies.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Add byte-level exec_stream_and_capture_output_bytes variant.

Tees raw chunks instead of lines: partial lines and carriage
return redraws render in real time, non-UTF-8 output is preserved,
and capture is byte-exact with redraw frames collapsed for clean
cache replay. Prefixes are inserted statefully at line starts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Add test coverage for the moon_process crate.

Covers the Command builder API, cache key stability and collision
resistance, command line formatting, Output status/error conversion,
lossy output strings, SharedChild signal handling, the process
registry lifecycle, and all four exec methods (capture, continuous,
stream, stream+capture) against real child processes. Process
spawning tests are unix-gated.

Also derives Debug for Output and ChildExit.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Fix relative working dir test on Windows.

Build the working dir with join so it uses the native path
separator; a forward slash literal is preserved as-is on Windows
and never matches the expected backslash output.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: milesj

Cargo.toml

@@ -30,6 +30,7 @@ futures = "0.3.31"
 hex = "0.4.3"
 indexmap = "2.13.0"
 iocraft = "0.8.3"
+libc = "0.2.186"
 md5 = "0.8.0"
 miette = "7.6.0"
 num_cpus = "1.17.0"
@@ -87,6 +88,7 @@ tower = "0.5.3"
 tracing = "0.1.44"
 url = "2.5.8"
 uuid = { version = "1.23.2", features = ["v4"] }
+windows-sys = { version = "0.61.2", default-features = false }
 
 # proto/plugin related
 extism = "=1.21.0"

crates/cli/Cargo.toml

@@ -52,7 +52,7 @@ wiggle = "~41.0.4"
 liblzma = { version = "0.4.6", features = ["static"] }
 
 [target.'cfg(unix)'.dependencies]
-libc = "0.2.186"
+libc = { workspace = true }
 
 [dev-dependencies]
 moon_affected = { path = "../affected" }

crates/console/src/lib.rs

@@ -7,6 +7,7 @@ use std::ops::DerefMut;
 
 pub use reporter::*;
 pub use starbase_console::ConsoleError;
+pub use starbase_console::ConsoleStream;
 pub use starbase_console::ui;
 pub use theme::*;
 

crates/daemon-utils/Cargo.toml

@@ -10,15 +10,15 @@ tokio = { workspace = true, features = ["net"] }
 tracing = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-libc = "0.2.186"
+libc = { workspace = true }
 tokio-stream = { version = "0.1.18", features = ["net"] }
 
 [target.'cfg(windows)'.dependencies]
 async-stream = { workspace = true }
 futures-core = "0.3.32"
 md5 = { workspace = true }
 tonic = { workspace = true, features = ["transport"] }
-windows-sys = { version = "0.61.2", default-features = false, features = [
+windows-sys = { workspace = true, features = [
 	"Win32_Foundation",
 	"Win32_System_Threading",
 ] }

crates/process/Cargo.toml

@@ -18,13 +18,21 @@ starbase_shell = { workspace = true }
 system_env = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-tokio = { workspace = true, features = ["io-util", "signal", "sync"] }
+tokio = { workspace = true, features = [
+	"io-util",
+	"macros",
+	"process",
+	"rt",
+	"signal",
+	"sync",
+	"time",
+] }
 
 [target.'cfg(unix)'.dependencies]
-libc = "0.2.186"
+libc = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61.2", default-features = false, features = [
+windows-sys = { workspace = true, features = [
 	# "Win32_System_Console",
 	"Win32_System_Threading",
 ] }

crates/process/src/main.rs crates/process/examples/args.rscrates/process/src/main.rs renamed to crates/process/examples/args.rs

@@ -408,26 +408,11 @@ impl Command {
         match &self.exe {
             CommandExecutable::Binary(bin) => bin.value.to_string_lossy().to_string(),
             CommandExecutable::Script(script) => {
-                if let Some(inner) = script.to_str() {
-                    match inner.find(' ') {
-                        Some(index) => &inner[0..index],
-                        None => inner,
-                    }
-                    .into()
-                } else {
-                    let mut bytes = vec![];
-
-                    for ch in script.as_encoded_bytes() {
-                        if *ch == b' ' {
-                            break;
-                        }
-
-                        bytes.push(*ch);
-                    }
-
-                    unsafe { OsString::from_encoded_bytes_unchecked(bytes) }
-                        .to_string_lossy()
-                        .to_string()
+                let script = script.to_string_lossy();
+
+                match script.find(' ') {
+                    Some(index) => script[0..index].to_string(),
+                    None => script.into_owned(),
                 }
             }
         }
@@ -436,49 +421,69 @@ impl Command {
     pub fn get_cache_key(&self) -> String {
         let mut hasher = FxHasher::default();
 
-        let mut write = |value: &OsString| {
-            hasher.write(value.as_os_str().as_encoded_bytes());
-        };
+        // Length-prefix each field, otherwise consecutive values hash
+        // ambiguously, like ("ab", "c") and ("a", "bc")
+        fn write(hasher: &mut FxHasher, value: &OsStr) {
+            let bytes = value.as_encoded_bytes();
+            hasher.write_usize(bytes.len());
+            hasher.write(bytes);
+        }
+
+        // Sort env vars, as map iteration order is not guaranteed,
+        // and the key must be stable for identical commands
+        let mut env = self.env.iter().collect::<Vec<_>>();
+        env.sort_by(|a, b| a.0.cmp(b.0));
 
-        for (key, value) in &self.env {
-            write(key);
+        for (key, value) in env {
+            write(&mut hasher, key);
 
             match value {
-                Env::Set(value) => write(value),
-                Env::SetIfMissing(value) => write(value),
-                Env::Unset => {}
+                Env::Set(value) => {
+                    hasher.write_u8(1);
+                    write(&mut hasher, value);
+                }
+                Env::SetIfMissing(value) => {
+                    hasher.write_u8(2);
+                    write(&mut hasher, value);
+                }
+                Env::Unset => {
+                    hasher.write_u8(0);
+                }
             };
         }
 
         match &self.exe {
             CommandExecutable::Binary(exe) => {
-                write(&exe.value);
+                write(&mut hasher, &exe.value);
             }
             CommandExecutable::Script(exe) => {
-                write(exe);
+                write(&mut hasher, exe);
             }
         };
 
         for arg in &self.args {
-            write(&arg.value);
+            write(&mut hasher, &arg.value);
         }
 
         if let Some(cwd) = &self.cwd {
-            write(cwd);
+            write(&mut hasher, cwd);
         }
 
         for arg in &self.input {
-            write(arg);
+            write(&mut hasher, arg);
         }
 
-        format!("{}", hasher.finish())
+        hasher.finish().to_string()
     }
 
     pub fn get_command_line(&self, with_shell: bool, with_input: bool) -> String {
         let shell = self.shell.unwrap_or_default().build();
         let use_shell = with_shell && (self.shell.is_some() || self.exe.requires_shell());
         let mut line = OsString::new();
 
+        // Curly quotes are intentional, so that the shell wrapper is
+        // distinguishable from real quoting within the command itself.
+        // This output is only used for logs, never executed!
         if use_shell {
             line.push(shell.to_string());
             line.push(" -c “");