use std::collections::BTreeMap;
use std::io;
use std::path::{Path, PathBuf};
use crate::domain::ControlStateDir;
const REGISTRY_FILE: &str = "versions.json";
pub fn self_version() -> &'static str {
env!("CARGO_PKG_VERSION")
}
pub fn resolve_home() -> Option<ControlStateDir> {
crate::paths::process_control_state_placement()
.directory()
.cloned()
}
fn registry_path(control_state_dir: &ControlStateDir) -> PathBuf {
crate::paths::control_state_path(control_state_dir, REGISTRY_FILE)
}
fn current_exe_key() -> Option<String> {
let exe = std::env::current_exe().ok()?;
let exe = std::fs::canonicalize(&exe).unwrap_or(exe);
Some(exe.to_string_lossy().into_owned())
}
fn load(control_state_dir: &ControlStateDir) -> BTreeMap<String, String> {
std::fs::read(registry_path(control_state_dir))
.ok()
.and_then(|bytes| serde_json::from_slice::<BTreeMap<String, String>>(&bytes).ok())
.unwrap_or_default()
}
fn atomic_write(
control_state_dir: &ControlStateDir,
map: &BTreeMap<String, String>,
) -> io::Result<()> {
crate::paths::ensure_control_state_dir(control_state_dir)?;
let data = serde_json::to_vec_pretty(map).map_err(io::Error::other)?;
let target = registry_path(control_state_dir);
let tmp = target.with_extension("json.tmp");
std::fs::write(&tmp, &data)?;
std::fs::rename(&tmp, &target)
}
pub fn record_self(control_state_dir: &ControlStateDir) {
let _ = record_self_inner(control_state_dir);
}
pub fn record_self_default() {
if let Some(home) = resolve_home() {
record_self(&home);
}
}
fn record_self_inner(control_state_dir: &ControlStateDir) -> io::Result<()> {
let Some(key) = current_exe_key() else {
return Ok(());
};
let mut map = load(control_state_dir);
if map.get(&key).map(String::as_str) == Some(self_version()) {
return Ok(()); }
map.insert(key, self_version().to_string());
atomic_write(control_state_dir, &map)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StaleBinary {
pub running_version: String,
pub running_path: String,
pub newer_version: String,
pub newer_path: String,
}
pub fn detect_stale(control_state_dir: &ControlStateDir) -> Option<StaleBinary> {
let running_path = current_exe_key()?;
let running_version = self_version();
let map = load(control_state_dir);
let mut best: Option<(&String, &String)> = None;
for (path, version) in &map {
if path == &running_path {
continue;
}
if !crate::cli::version::is_newer_version(version, running_version) {
continue;
}
if !Path::new(path).exists() {
continue;
}
match best {
Some((_, best_version))
if !crate::cli::version::is_newer_version(version, best_version) => {}
_ => best = Some((path, version)),
}
}
best.map(|(path, version)| StaleBinary {
running_version: running_version.to_string(),
running_path,
newer_version: version.clone(),
newer_path: path.clone(),
})
}
pub fn prune_missing_entries(control_state_dir: &ControlStateDir) -> usize {
let map = load(control_state_dir);
let before = map.len();
let pruned: BTreeMap<String, String> = map
.into_iter()
.filter(|(path, _)| {
let candidate = Path::new(path);
candidate.exists() || !mount_is_reachable(candidate)
})
.collect();
let removed = before - pruned.len();
if removed > 0 {
let _ = atomic_write(control_state_dir, &pruned);
}
removed
}
fn mount_is_reachable(candidate: &Path) -> bool {
candidate.ancestors().any(|ancestor| {
if is_universal_pseudo_root(ancestor) {
return false;
}
ancestor.exists()
})
}
fn is_universal_pseudo_root(ancestor: &Path) -> bool {
matches!(ancestor.as_os_str().to_str(), Some(r"\\") | Some(r"\\?"))
}
pub fn stale_warning(stale: &StaleBinary) -> String {
let refresh = if cfg!(windows) {
format!(
" Get-Process symforge | Stop-Process -Force\n \
Copy-Item \"{}\" \"{}\" -Force",
stale.newer_path, stale.running_path
)
} else {
format!(
" pkill -f symforge 2>/dev/null; sleep 1\n \
cp -f \"{}\" \"{}\"",
stale.newer_path, stale.running_path
)
};
format!(
"── \u{26a0} Version drift ──\n\
This daemon is serving symforge {running_ver} from:\n {running_path}\n\
but a newer install ({newer_ver}) exists at:\n {newer_path}\n\
The MCP daemon is serving stale code. In your own shell, overwrite the\n\
stale binary with the newer install, then reconnect your MCP client (e.g. /mcp):\n{refresh}",
running_ver = stale.running_version,
running_path = stale.running_path,
newer_ver = stale.newer_version,
newer_path = stale.newer_path,
)
}
pub fn drift_banner(control_state_dir: &ControlStateDir) -> Option<String> {
detect_stale(control_state_dir).map(|stale| stale_warning(&stale))
}
pub fn drift_banner_default() -> Option<String> {
drift_banner(&resolve_home()?)
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeMap;
fn write_registry(control_state_dir: &ControlStateDir, entries: &[(&str, &str)]) {
let map: BTreeMap<String, String> = entries
.iter()
.map(|(p, v)| ((*p).to_string(), (*v).to_string()))
.collect();
atomic_write(control_state_dir, &map).unwrap();
}
#[test]
fn record_self_writes_and_is_idempotent() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
record_self(&home);
let after_first = std::fs::read_to_string(registry_path(&home)).unwrap();
let key = current_exe_key().unwrap();
let map = load(&home);
assert_eq!(map.get(&key).map(String::as_str), Some(self_version()));
record_self(&home);
let after_second = std::fs::read_to_string(registry_path(&home)).unwrap();
assert_eq!(after_first, after_second);
}
#[test]
fn prune_missing_entries_drops_dead_paths_and_keeps_live_ones() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
let live = tmp.path().join("live-symforge");
std::fs::write(&live, b"binary").unwrap();
let live_key = live.to_string_lossy().into_owned();
let dead_key = tmp
.path()
.join("gone-symforge")
.to_string_lossy()
.into_owned();
write_registry(
&home,
&[(live_key.as_str(), "7.15.4"), (dead_key.as_str(), "7.14.4")],
);
let removed = prune_missing_entries(&home);
assert_eq!(removed, 1, "exactly the dead entry should be pruned");
let map = load(&home);
assert!(map.contains_key(&live_key), "live entry kept");
assert!(!map.contains_key(&dead_key), "dead entry removed");
assert_eq!(prune_missing_entries(&home), 0);
}
#[test]
fn prune_missing_entries_drops_dead_entry_when_whole_subtree_was_deleted() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
let gone_root = tmp.path().join("gone");
let dead = gone_root.join("deep").join("symforge.exe");
std::fs::create_dir_all(dead.parent().unwrap()).unwrap();
std::fs::write(&dead, b"binary").unwrap();
std::fs::remove_dir_all(&gone_root).unwrap();
assert!(!gone_root.exists(), "subtree must be gone for the test");
assert!(
tmp.path().exists(),
"an ancestor must remain (drive online)"
);
let dead_key = dead.to_string_lossy().into_owned();
let live = tmp.path().join("live-symforge");
std::fs::write(&live, b"binary").unwrap();
let live_key = live.to_string_lossy().into_owned();
write_registry(
&home,
&[(live_key.as_str(), "7.15.4"), (dead_key.as_str(), "7.14.4")],
);
let removed = prune_missing_entries(&home);
assert_eq!(removed, 1, "the deleted-subtree entry must be pruned");
let map = load(&home);
assert!(map.contains_key(&live_key), "live entry kept");
assert!(
!map.contains_key(&dead_key),
"dead deleted-subtree entry removed"
);
}
#[cfg(windows)]
#[test]
fn prune_missing_entries_keeps_entry_on_offline_mount() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
let absent = ('D'..='Z')
.rev()
.find(|d| !Path::new(&format!(r"{d}:\")).exists())
.expect("at least one drive letter D..=Z should be unmapped on the test host");
let offline_key = format!(r"\\?\{absent}:\offline-mount\bin\symforge.exe");
assert!(
!mount_is_reachable(Path::new(&offline_key)),
"an unmapped drive must be classified unreachable despite the pseudo-root"
);
write_registry(&home, &[(offline_key.as_str(), "7.14.4")]);
let removed = prune_missing_entries(&home);
assert_eq!(removed, 0, "an offline-mount entry must be kept");
assert!(load(&home).contains_key(&offline_key), "offline entry kept");
}
#[test]
fn detect_stale_flags_newer_version_at_existing_path() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
let newer = tmp.path().join("newer-symforge");
std::fs::write(&newer, b"binary").unwrap();
let newer_key = std::fs::canonicalize(&newer)
.unwrap_or(newer)
.to_string_lossy()
.into_owned();
let running = current_exe_key().unwrap();
write_registry(
&home,
&[
(running.as_str(), self_version()),
(newer_key.as_str(), "999.0.0"),
],
);
let stale = detect_stale(&home).expect("newer version at another path is stale");
assert_eq!(stale.newer_version, "999.0.0");
assert_eq!(stale.newer_path, newer_key);
assert_eq!(stale.running_version, self_version());
}
#[test]
fn detect_stale_ignores_missing_newer_binary() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
let running = current_exe_key().unwrap();
write_registry(
&home,
&[
(running.as_str(), self_version()),
("/nonexistent/symforge-binary", "999.0.0"),
],
);
assert!(detect_stale(&home).is_none());
}
#[test]
fn detect_stale_returns_none_when_self_is_newest() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
let running = current_exe_key().unwrap();
write_registry(
&home,
&[
(running.as_str(), self_version()),
("/some/old/symforge", "0.0.1"),
],
);
assert!(detect_stale(&home).is_none());
}
#[test]
fn detect_stale_returns_none_on_empty_registry() {
let tmp = tempfile::TempDir::new().unwrap();
let home = ControlStateDir::new(tmp.path().join("control"));
assert!(detect_stale(&home).is_none());
}
#[test]
fn stale_warning_includes_paths_and_versions() {
let stale = StaleBinary {
running_version: "7.14.4".to_string(),
running_path: "/home/u/.symforge/bin/symforge".to_string(),
newer_version: "7.14.5".to_string(),
newer_path: "/home/u/.npm/symforge".to_string(),
};
let text = stale_warning(&stale);
assert!(text.contains("Version drift"));
assert!(text.contains("7.14.4"));
assert!(text.contains("7.14.5"));
assert!(text.contains("/home/u/.symforge/bin/symforge"));
assert!(text.contains("/home/u/.npm/symforge"));
}
}