apoc 0.9.1

Agentic process control for LLMs
Documentation
//! File identities used to refresh discovered subprocess connections.

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(())
    }
}