Use rustix/libc instead of nix; use pipe to capture double-fork pid

`rustix` and `libc` are already in the dependency tree, and `rustix`
follows IO safety rules, so use those.

We can use a pipe to get the PID of the double-forked process.

src/process.rs

@@ -1,31 +1,50 @@
+use std::fs::File;
+use std::io;
 use std::process::{exit, Command, Stdio};
 
-use nix::sys::wait::waitpid;
-use nix::unistd::{fork, ForkResult};
-
 /// Performs a double fork with setsid to spawn and detach a command.
-pub fn spawn(mut command: Command) {
+pub fn spawn(mut command: Command) -> Option<u32> {
     command
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::null());
 
-    unsafe {
-        match fork() {
-            Ok(ForkResult::Parent { child }) => {
-                let _res = waitpid(Some(child), None);
+    let Ok((read, write)) = rustix::pipe::pipe_with(rustix::pipe::PipeFlags::CLOEXEC) else {
+        return None;
+    };
+
+    match unsafe { libc::fork() } {
+        // Parent process
+        child @ 1.. => {
+            let child = rustix::process::Pid::from_raw(child).unwrap();
+            let _res = rustix::process::waitpid(Some(child), rustix::process::WaitOptions::empty());
+            // Read PID from pipe
+            let mut bytes = [0; 4];
+            if rustix::io::read(read, &mut bytes) == Ok(4) {
+                Some(u32::from_ne_bytes(bytes))
+            } else {
+                None
+            }
+        }
+
+        // Child process
+        0 => {
+            let _res = rustix::process::setsid();
+            if let Ok(child) = command.spawn() {
+                // Write PID to pipe
+                let _ = rustix::io::write(write, &child.id().to_ne_bytes());
             }
 
-            Ok(ForkResult::Child) => {
-                let _res = nix::unistd::setsid();
-                let _res = command.spawn();
+            exit(0)
+        }
 
-                exit(0);
-            }
+        ..=-1 => {
+            println!(
+                "failed to fork and spawn command: {}",
+                io::Error::last_os_error()
+            );
 
-            Err(why) => {
-                println!("failed to fork and spawn command: {}", why.desc());
-            }
+            None
         }
     }
 }