mod access;
pub use access::AccessControl;
use std::path::{Path, PathBuf};
use rmcp::model::{CallToolResult, ContentBlock, ProtocolVersion};
use tokio::io::AsyncWriteExt;
pub const SPEC_VERSION: &str = "2026-07-28";
pub static SUPPORTED_PROTOCOL_VERSIONS: &[ProtocolVersion] = &[ProtocolVersion::V_2026_07_28];
pub fn reject_legacy_initialize()
-> std::future::Ready<Result<rmcp::model::InitializeResult, rmcp::ErrorData>> {
std::future::ready(Err(rmcp::ErrorData::method_not_found::<
rmcp::model::InitializeResultMethod,
>()))
}
pub fn tool_error(message: impl Into<String>) -> CallToolResult {
CallToolResult::error(vec![ContentBlock::text(message)])
}
pub fn text_result(text: impl Into<String>) -> CallToolResult {
CallToolResult::success(vec![ContentBlock::text(text)])
}
pub async fn atomic_write(path: &Path, content: &[u8]) -> std::io::Result<()> {
let unique = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_nanos();
let mut temp_name = path.as_os_str().to_os_string();
temp_name.push(format!(".{unique}.{}.tmp", std::process::id()));
let temp = PathBuf::from(temp_name);
let existing_permissions = capture_existing_permissions(path);
let result = async {
let mut file = tokio::fs::File::create(&temp).await?;
file.write_all(content).await?;
if let Some(permissions) = existing_permissions {
file.set_permissions(permissions).await?;
}
file.sync_all().await?;
tokio::fs::rename(&temp, path).await
}
.await;
if result.is_err() {
let _ = tokio::fs::remove_file(&temp).await;
}
result
}
#[cfg(unix)]
fn capture_existing_permissions(path: &Path) -> Option<std::fs::Permissions> {
let metadata = std::fs::symlink_metadata(path).ok()?;
if !metadata.is_file() {
return None;
}
Some(metadata.permissions())
}
#[cfg(not(unix))]
fn capture_existing_permissions(_path: &Path) -> Option<std::fs::Permissions> {
None
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use std::os::unix::fs::PermissionsExt;
#[tokio::test]
async fn atomic_rewrite_preserves_existing_mode() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("target.txt");
std::fs::write(&path, "old").unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
atomic_write(&path, b"new contents").await.unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "new contents");
let mode = std::fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600, "mode {mode:#o}");
}
#[tokio::test]
async fn new_file_uses_normal_creation_mode() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("fresh.txt");
atomic_write(&path, b"x").await.unwrap();
let mode = std::fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode & 0o600, 0o600, "mode {mode:#o}");
}
}