Don't wait while forcefully terminate process using kill API on Windows

Disabled use of windows-sys crate as graceful shutdown on Windows is unreliable in this context.

Updated cleanup.rs and server.rs to directly call child.kill().await for terminating processes on Windows.

Improved logging for process termination and error handling during kill and wait.

Removed timeout-based graceful shutdown attempt on Windows since TerminateProcess is inherently forceful and immediate.

This ensures more predictable process cleanup behavior on Windows platforms.

Author: qnixsynapse

src-tauri/Cargo.toml

@@ -63,11 +63,11 @@ nix = "=0.30.1"
 
 [target.'cfg(windows)'.dependencies]
 libc = "0.2.172"
-windows-sys = { version = "0.60.2", features = [
-    "Win32_Foundation",
-    "Win32_System_Console",
-    "Win32_System_Threading" # for using CreateProcess flags like CREATE_NEW_PROCESS_GROUP
-] }
+# windows-sys = { version = "0.60.2", features = [
+#     "Win32_Foundation",
+#     "Win32_System_Console",
+#     "Win32_System_Threading" # for using CreateProcess flags like CREATE_NEW_PROCESS_GROUP
+# ] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-updater = "2"

src-tauri/src/core/utils/extensions/inference_llamacpp_extension/cleanup.rs

@@ -1,6 +1,5 @@
 use crate::core::state::AppState;
 use tauri::State;
-use tokio::time::{timeout, Duration};
 
 pub async fn cleanup_processes(state: State<'_, AppState>) {
     let mut map = state.llama_server_process.lock().await;
@@ -12,6 +11,7 @@ pub async fn cleanup_processes(state: State<'_, AppState>) {
             {
                 use nix::sys::signal::{kill, Signal};
                 use nix::unistd::Pid;
+                use tokio::time::{timeout, Duration};
 
                 if let Some(raw_pid) = child.id() {
                     let raw_pid = raw_pid as i32;
@@ -36,18 +36,28 @@ pub async fn cleanup_processes(state: State<'_, AppState>) {
             #[cfg(all(windows, target_arch = "x86_64"))]
             {
                 if let Some(raw_pid) = child.id() {
-                    log::info!("Terminating llama-server PID {}", raw_pid);
+                    log::warn!(
+                        "Gracefully terminating is unsupported on Windows, force-killing PID {}",
+                        raw_pid
+                    );
 
-                    // Brief wait for natural shutdown
-                    match timeout(Duration::from_secs(2), child.wait()).await {
-                        Ok(Ok(status)) => {
-                            log::info!("llama-server exited gracefully: {}", status);
-                        }
-                        _ => {
-                            log::warn!("Force-killing llama-server PID {}", raw_pid);
-                            let _ = child.kill().await;
-                            let _ = child.wait().await;
-                        }
+                    // Since we know a graceful shutdown doesn't work and there are no child processes
+                    // to worry about, we can use `child.kill()` directly. On Windows, this is
+                    // a forceful termination via the `TerminateProcess` API.
+                    if let Err(e) = child.kill().await {
+                        log::error!("Failed to send kill signal to PID {}: {}. It may have already terminated.", raw_pid, e);
+                    }
+                    match child.wait().await {
+                        Ok(status) => log::info!(
+                            "process {} has been terminated. Final exit status: {}",
+                            raw_pid,
+                            status
+                        ),
+                        Err(e) => log::error!(
+                            "Error waiting on child process {} after kill: {}",
+                            raw_pid,
+                            e
+                        ),
                     }
                 }
             }

src-tauri/src/core/utils/extensions/inference_llamacpp_extension/server.rs

@@ -331,18 +331,30 @@ pub async fn unload_llama_model(
         #[cfg(all(windows, target_arch = "x86_64"))]
         {
             if let Some(raw_pid) = child.id() {
-                log::info!("Terminating llama-server PID {}", raw_pid);
+                log::warn!("gracefully killing is unsupported on Windows, force-killing PID {}", raw_pid);
+
+                // Since we know a graceful shutdown doesn't work and there are no child processes
+                // to worry about, we can use `child.kill()` directly. On Windows, this is
+                // a forceful termination via the `TerminateProcess` API.
+                if let Err(e) = child.kill().await {
+                    log::error!(
+                        "Failed to send kill signal to PID {}: {}. It may have already terminated.",
+                        raw_pid,
+                        e
+                    );
+                }
 
-                // Brief wait for natural shutdown
-                match timeout(Duration::from_secs(2), child.wait()).await {
-                    Ok(Ok(status)) => {
-                        log::info!("llama-server exited gracefully: {}", status);
-                    }
-                    _ => {
-                        log::warn!("Force-killing llama-server PID {}", raw_pid);
-                        let _ = child.kill().await;
-                        let _ = child.wait().await;
-                    }
+                match child.wait().await {
+                    Ok(status) => log::info!(
+                        "process {} has been terminated. Final exit status: {}",
+                        raw_pid,
+                        status
+                    ),
+                    Err(e) => log::error!(
+                        "Error waiting on child process {} after kill: {}",
+                        raw_pid,
+                        e
+                    ),
                 }
             }
         }