use std::ffi::OsString;
use std::path::PathBuf;
use incurs_mcp_discovery::{DiscoveredMcpServer, McpTransport, StdioTransport};
pub(super) fn paths(servers: &[DiscoveredMcpServer]) -> Vec<PathBuf> {
let mut paths: Vec<_> = servers
.iter()
.filter(|server| server.enabled)
.filter_map(|server| match &server.transport {
McpTransport::Stdio(binding) => Some(candidates(binding)),
_ => None,
})
.flatten()
.collect();
paths.sort();
paths.dedup();
paths
}
fn candidates(binding: &StdioTransport) -> Vec<PathBuf> {
let cwd = binding
.resolved_cwd
.clone()
.unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
let command = PathBuf::from(&binding.command);
if command.is_absolute() || command.components().count() > 1 {
return vec![cwd.join(command)];
}
let search = binding
.env
.get("PATH")
.map(|value| OsString::from(value.expose()))
.or_else(|| std::env::var_os("PATH"))
.unwrap_or_else(|| OsString::from("/usr/bin:/bin"));
std::env::split_paths(&search)
.map(|directory| cwd.join(directory).join(&command))
.collect()
}
pub(super) fn stamp(paths: &[PathBuf]) -> String {
paths
.iter()
.map(|path| {
let metadata = std::fs::metadata(path).ok();
format!(
"{path:?}:{:?}:{:?}:{:?}",
metadata.as_ref().map(std::fs::Metadata::len),
metadata.as_ref().and_then(|value| value.modified().ok()),
metadata.as_ref().map(identity)
)
})
.collect::<Vec<_>>()
.join("\n")
}
#[cfg(unix)]
fn identity(metadata: &std::fs::Metadata) -> (u64, u64, i64, i64) {
use std::os::unix::fs::MetadataExt;
(
metadata.dev(),
metadata.ino(),
metadata.ctime(),
metadata.ctime_nsec(),
)
}
#[cfg(not(unix))]
fn identity(_metadata: &std::fs::Metadata) {}
#[cfg(test)]
mod tests {
use super::{paths, stamp};
use incurs_mcp_discovery::HostPaths;
use serde_json::json;
type TestResult = Result<(), Box<dyn std::error::Error>>;
#[test]
fn reading_an_executable_does_not_change_its_stamp() -> TestResult {
let root = tempfile::tempdir()?;
let executable = root.path().join("server");
std::fs::write(&executable, "server")?;
let watched = vec![executable.clone()];
let before = stamp(&watched);
assert_eq!(std::fs::read(&executable)?, b"server");
assert_eq!(stamp(&watched), before);
Ok(())
}
#[test]
fn a_missing_executable_becoming_available_changes_its_stamp() -> TestResult {
let root = tempfile::tempdir()?;
let executable = root.path().join("server");
let watched = vec![executable.clone()];
let before = stamp(&watched);
std::fs::write(&executable, "server")?;
assert_ne!(stamp(&watched), before);
Ok(())
}
#[test]
fn configured_path_candidates_are_watched_even_before_they_exist() -> TestResult {
let root = tempfile::tempdir()?;
let directory = root.path().join("bin");
let config = json!({"mcpServers": {"example": {
"command": "server", "env": {"PATH": directory}
}}});
std::fs::write(root.path().join(".mcp.json"), config.to_string())?;
let host = HostPaths::rooted(root.path()).with_project(root.path());
assert_eq!(
paths(&incurs_mcp_discovery::discover(&host).servers),
vec![directory.join("server")]
);
Ok(())
}
}