feat: support windows processes in mcp_client

Author: cwoolum

Cargo.lock

@@ -65,6 +65,7 @@ dialoguer = { version = "0.11.0", features = ["fuzzy-select"] }
 dirs = "5.0.0"
 eyre = "0.6.8"
 fd-lock = "4.0.4"
+fig_util.workspace = true
 futures = "0.3.26"
 glob = "0.3.2"
 globset = "0.4.16"

crates/chat-cli/Cargo.toml

@@ -11,10 +11,10 @@ use std::sync::{
 };
 use std::time::Duration;
 
-#[cfg(unix)]
-use nix::sys::signal::Signal;
-#[cfg(unix)]
-use nix::unistd::Pid;
+use fig_util::process_info::{
+    Pid,
+    terminate_process,
+};
 use serde::{
     Deserialize,
     Serialize,
@@ -114,7 +114,6 @@ pub struct Client<T: Transport> {
     server_name: String,
     transport: Arc<T>,
     timeout: u64,
-    #[cfg(unix)]
     server_process_id: Option<Pid>,
     client_info: serde_json::Value,
     current_id: Arc<AtomicU64>,
@@ -130,7 +129,6 @@ impl<T: Transport> Clone for Client<T> {
             timeout: self.timeout,
             // Note that we cannot have an id for the clone because we would kill the original
             // process when we drop the clone
-            #[cfg(unix)]
             server_process_id: None,
             client_info: self.client_info.clone(),
             current_id: self.current_id.clone(),
@@ -158,7 +156,7 @@ impl Client<StdioTransport> {
                 .stderr(Stdio::piped())
                 .envs(std::env::vars());
 
-            #[cfg(unix)]
+            #[cfg(not(windows))]
             command.process_group(0);
 
             if let Some(env) = env {
@@ -169,21 +167,22 @@ impl Client<StdioTransport> {
             command.args(args).spawn()?
         };
 
-        #[cfg(unix)]
+        let server_process_id = child.id().ok_or(ClientError::MissingProcessId)?;
+
+        #[cfg(windows)]
+        let server_process_id = Some(Pid::from_raw(server_process_id)); // On Windows, child.id() returns u32 which matches Pid::from_raw
+        #[cfg(not(windows))]
         let server_process_id = Some(Pid::from_raw(
-            child
-                .id()
-                .ok_or(ClientError::MissingProcessId)?
+            server_process_id
                 .try_into()
                 .map_err(|_err| ClientError::MissingProcessId)?,
-        ));
+        )); // On Unix, safely convert u32 to i32
 
         let transport = Arc::new(transport::stdio::JsonRpcStdioTransport::client(child)?);
         Ok(Self {
             server_name,
             transport,
             timeout,
-            #[cfg(unix)]
             server_process_id,
             client_info,
             current_id: Arc::new(AtomicU64::new(0)),
@@ -193,7 +192,6 @@ impl Client<StdioTransport> {
     }
 }
 
-#[cfg(unix)]
 impl<T> Drop for Client<T>
 where
     T: Transport,
@@ -202,7 +200,7 @@ where
     // This drop trait is here as a fail safe to ensure we don't leave behind any orphans.
     fn drop(&mut self) {
         if let Some(process_id) = self.server_process_id {
-            let _ = nix::sys::signal::kill(process_id, Signal::SIGTERM);
+            let _ = terminate_process(process_id);
         }
     }
 }

crates/chat-cli/src/mcp_client/client.rs

@@ -48,6 +48,7 @@ pub enum Error {
     PList(#[from] plist::Error),
     #[error("Permission denied: {}", .path.display())]
     PermissionDenied { path: PathBuf, inner: io::Error },
+    #[cfg(not(windows))]
     #[error("nix: {}", .0)]
     Nix(#[from] nix::Error),
     #[cfg(target_os = "linux")]

crates/fig_integrations/src/error.rs

@@ -3,6 +3,7 @@ use std::fs::{
     File,
 };
 use std::io::Write;
+#[cfg(not(windows))]
 use std::os::unix::fs::DirBuilderExt;
 use std::path::PathBuf;
 

crates/fig_integrations/src/ssh/mod.rs

@@ -1,6 +1,8 @@
 use std::path::PathBuf;
 use std::str::FromStr;
 
+use nix::sys::signal::Signal;
+
 pub trait LinuxExt {
     fn cmdline(&self) -> Option<String>;
 }
@@ -10,6 +12,11 @@ use super::{
     PidExt,
 };
 
+pub fn terminate_process(pid: Pid) -> Result<(), String> {
+    let nix_pid = nix::unistd::Pid::from_raw(pid.0);
+    nix::sys::signal::kill(nix_pid, Signal::SIGTERM).map_err(|e| format!("Failed to terminate process: {}", e))
+}
+
 impl PidExt for Pid {
     fn current() -> Self {
         nix::unistd::getpid().into()

crates/fig_util/src/process_info/linux.rs

@@ -3,11 +3,19 @@ use std::mem::MaybeUninit;
 use std::os::unix::prelude::OsStrExt;
 use std::path::PathBuf;
 
+use nix::sys::signal::Signal;
+
 use super::{
     Pid,
     PidExt,
 };
 
+/// Terminate a process on macOS
+pub fn terminate_process(pid: Pid) -> Result<(), String> {
+    let nix_pid = nix::unistd::Pid::from_raw(pid.0);
+    nix::sys::signal::kill(nix_pid, Signal::SIGTERM).map_err(|e| format!("Failed to terminate process: {}", e))
+}
+
 impl PidExt for Pid {
     fn current() -> Self {
         nix::unistd::getpid().into()

crates/fig_util/src/process_info/macos.rs

@@ -13,11 +13,13 @@ pub use linux::*;
 
 #[cfg(target_os = "macos")]
 mod macos;
-// #[cfg(target_os = "macos")]
-// pub use macos::*;
+#[cfg(target_os = "macos")]
+pub use macos::*;
 
 #[cfg(target_os = "windows")]
 mod windows;
+#[cfg(target_os = "windows")]
+pub use windows::*;
 
 #[cfg(target_os = "freebsd")]
 mod freebsd;
@@ -52,6 +54,12 @@ macro_rules! pid_decl {
                 write!(f, "{}", self.0)
             }
         }
+
+        impl Pid {
+            pub fn from_raw(raw: $typ) -> Self {
+                Self(raw)
+            }
+        }
     };
 }
 

crates/fig_util/src/process_info/mod.rs

@@ -22,8 +22,10 @@ use windows::Win32::System::Threading::{
     PROCESS_NAME_FORMAT,
     PROCESS_QUERY_INFORMATION,
     PROCESS_QUERY_LIMITED_INFORMATION,
+    PROCESS_TERMINATE,
     PROCESS_VM_READ,
     QueryFullProcessImageNameA,
+    TerminateProcess,
 };
 use windows::core::PSTR;
 
@@ -32,6 +34,23 @@ use super::{
     PidExt,
 };
 
+/// Terminate a process on Windows using the Windows API
+pub fn terminate_process(pid: Pid) -> Result<(), String> {
+    unsafe {
+        // Open the process with termination rights
+        let handle =
+            OpenProcess(PROCESS_TERMINATE, false, pid.0).map_err(|e| format!("Failed to open process: {}", e))?;
+
+        // Create a safe handle that will be closed automatically when dropped
+        let safe_handle = SafeHandle::new(handle).ok_or_else(|| "Invalid process handle".to_string())?;
+
+        // Terminate the process with exit code 1
+        TerminateProcess(*safe_handle, 1).map_err(|e| format!("Failed to terminate process: {}", e))?;
+
+        Ok(())
+    }
+}
+
 struct SafeHandle(HANDLE);
 
 impl SafeHandle {