Windows Fix

Author: steel-bucket

Cargo.lock

@@ -22,6 +22,7 @@ libc = "0.2" # For setpgid and signal constants
 tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] } # For logging setup
 tempfile = "3" # For creating temporary directories in examples/tests
 anyhow = "1.0" # For simple error handling in examples
+windows-sys = "0.59.0"
 
 # Dependency on the library itself (needed for building examples within the workspace)
 # This line might not be strictly necessary if cargo automatically detects it,

Cargo.toml

@@ -14,7 +14,7 @@ use tracing::{debug, instrument, warn};
 #[cfg(unix)]
 use nix::sys::signal::{killpg, Signal};
 #[cfg(windows)]
-use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
+use windows_sys::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
 #[cfg(unix)]
 use nix::unistd::Pid;
 #[cfg(windows)]
@@ -291,39 +291,39 @@ async fn handle_timeout_event(
             }
             Err(e) => {
                 // ESRCH means the process group doesn't exist (likely all processes exited quickly)
-                if e == nix::errno::Errno::ESRCH {
+                return if e == nix::errno::Errno::ESRCH {
                     warn!(pid = pid_u32, error = %e, "Failed to kill process group (ESRCH - likely already exited). Checking child status.");
                     // Check if the *original* child process exited
                     match child.try_wait() {
                         Ok(Some(status)) => {
                             debug!(pid = pid_u32, status = %status, "Original child had already exited before kill signal processed");
-                            return Ok(Some(status)); // Treat as natural exit
+                            Ok(Some(status)) // Treat as natural exit
                         }
                         Ok(None) => {
                             debug!(pid = pid_u32, "Original child still running or uncollected after killpg failed (ESRCH).");
                             // Proceed as if timeout kill was attempted.
-                            return Ok(None);
+                            Ok(None)
                         }
                         Err(wait_err) => {
                             warn!(pid = pid_u32, error = %wait_err, "Error checking child status after failed killpg (ESRCH)");
-                            return Err(CommandError::Wait(wait_err));
+                            Err(CommandError::Wait(wait_err))
                         }
                     }
                 } else {
                     // Another error occurred during killpg (e.g., permissions EPERM)
                     warn!(pid = pid_u32, pgid = pid.as_raw(), error = %e, "Failed to send kill signal to process group.");
                     // Map nix::Error to std::io::Error for CommandError::Kill
-                    return Err(CommandError::Kill(std::io::Error::new(
+                    Err(CommandError::Kill(std::io::Error::new(
                         std::io::ErrorKind::Other,
                         format!("Failed to kill process group for PID {}: {}", pid_u32, e),
-                    )));
+                    )))
                 }
             }
         }
         #[cfg(windows)]
         {
-            use windows::Win32::Foundation::{CloseHandle, HANDLE};
-            use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
+            use windows_sys::Win32::Foundation::{CloseHandle, HANDLE};
+            use windows_sys::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
 
             unsafe {
                 // Open a handle to the process with termination privileges.
@@ -549,6 +549,7 @@ pub async fn run_command_with_timeout(
     // Take ownership to modify, then pass the modified command to spawn_command_and_setup_state
     let mut std_cmd = std::mem::replace(&mut command, StdCommand::new("")); // Take ownership temporarily
     unsafe {
+        #[cfg(unix)]
         std_cmd.pre_exec(|| {
             // libc::setpgid(0, 0) makes the new process its own group leader.
             // Pass 0 for both pid and pgid to achieve this for the calling process.
@@ -559,6 +560,15 @@ pub async fn run_command_with_timeout(
                 Err(std::io::Error::last_os_error())
             }
         });
+        #[cfg(windows)]
+        {
+            use std::os::windows::process::CommandExt;
+            // CREATE_NEW_PROCESS_GROUP makes the new process the root of a new process group.
+            const CREATE_NEW_PROCESS_GROUP: u32 = 0x00000200;
+            std_cmd.creation_flags(CREATE_NEW_PROCESS_GROUP);
+        }
+
+
     }
     // Put the modified command back for spawning
     command = std_cmd;