feat(transport): add which_command for cross-platform executable resolution

crates/rmcp/Cargo.toml

@@ -52,6 +52,9 @@ tower-service = { version = "0.3", optional = true }
 # for child process transport
 process-wrap = { version = "9.0", features = ["tokio1"], optional = true }
 
+# for cross-platform executable path resolution
+which = { version = "7", optional = true }
+
 # for ws transport
 # tokio-tungstenite ={ version = "0.26", optional = true }
 
@@ -133,6 +136,7 @@ transport-child-process = [
   "transport-async-rw",
   "tokio/process",
   "dep:process-wrap",
+  "dep:which",
 ]
 transport-streamable-http-server = [
   "transport-streamable-http-server-session",

crates/rmcp/src/transport.rs

@@ -84,7 +84,7 @@ pub use worker::WorkerTransport;
 #[cfg(feature = "transport-child-process")]
 pub mod child_process;
 #[cfg(feature = "transport-child-process")]
-pub use child_process::{ConfigureCommandExt, TokioChildProcess};
+pub use child_process::{ConfigureCommandExt, TokioChildProcess, which_command};
 
 #[cfg(feature = "transport-io")]
 pub mod io;

crates/rmcp/src/transport/child_process.rs

@@ -233,6 +233,54 @@ impl ConfigureCommandExt for tokio::process::Command {
     }
 }
 
+/// Resolve the absolute path to an executable using the system `PATH`,
+/// then return a [`tokio::process::Command`] pointing at it.
+///
+/// This is especially useful on Windows where `.cmd` / `.exe` shim scripts
+/// (e.g. `npx.cmd`) are not reliably found by [`tokio::process::Command`]
+/// without a fully-qualified path.
+///
+/// # Example
+/// ```rust,no_run
+/// use rmcp::transport::child_process::{which_command, ConfigureCommandExt};
+///
+/// # fn example() -> std::io::Result<()> {
+/// let cmd = which_command("npx")?
+///     .configure(|cmd| {
+///         cmd.arg("-y").arg("@modelcontextprotocol/server-everything");
+///     });
+/// # Ok(())
+/// # }
+/// ```
+pub fn which_command(
+    name: impl AsRef<std::ffi::OsStr>,
+) -> std::io::Result<tokio::process::Command> {
+    let resolved = which::which(name.as_ref())
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::NotFound, e))?;
+    Ok(tokio::process::Command::new(resolved))
+}
+
+#[cfg(test)]
+mod tests_which {
+    #[test]
+    fn which_command_resolves_known_binary() {
+        // `ls` exists on every Unix system, `cmd` on Windows
+        #[cfg(unix)]
+        let result = super::which_command("ls");
+        #[cfg(windows)]
+        let result = super::which_command("cmd");
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn which_command_fails_for_nonexistent() {
+        let result = super::which_command("this_binary_definitely_does_not_exist_12345");
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::NotFound);
+    }
+}
+
 #[cfg(unix)]
 #[cfg(test)]
 mod tests {