use std::path::{Path, PathBuf};
use std::time::Duration;
const SHADOW_PROBE_TIMEOUT: Duration = Duration::from_millis(500);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ShadowKind {
RootSystem,
WindowsMntBleed,
ForeignPrefix,
}
#[derive(Debug, Clone)]
pub struct ShadowReport {
pub our_path: PathBuf,
pub our_version: Option<String>,
pub shadow_path: PathBuf,
pub shadow_version: Option<String>,
pub kind: ShadowKind,
}
pub fn which_all(name: &str) -> Vec<PathBuf> {
let Some(path_var) = std::env::var_os("PATH") else {
return Vec::new();
};
let mut found: Vec<PathBuf> = Vec::new();
let candidate_names = candidate_file_names(name);
for dir in std::env::split_paths(&path_var) {
if dir.as_os_str().is_empty() {
continue;
}
for file_name in &candidate_names {
let candidate = dir.join(file_name);
if candidate.is_file() && !found.iter().any(|existing| existing == &candidate) {
found.push(candidate);
}
}
}
found
}
#[cfg(windows)]
fn candidate_file_names(name: &str) -> Vec<String> {
let mut names: Vec<String> = Vec::new();
if let Some(pathext) = std::env::var_os("PATHEXT") {
for ext in std::env::split_paths(&pathext) {
let ext = ext.to_string_lossy();
let ext = ext.trim();
if ext.is_empty() {
continue;
}
let ext = ext.to_ascii_lowercase();
let ext = ext.strip_prefix('.').unwrap_or(&ext);
let candidate = format!("{name}.{ext}");
if !names.iter().any(|n| n.eq_ignore_ascii_case(&candidate)) {
names.push(candidate);
}
}
}
for ext in [".com", ".exe", ".bat", ".cmd", ".ps1"] {
let candidate = format!("{name}{ext}");
if !names.iter().any(|n| n.eq_ignore_ascii_case(&candidate)) {
names.push(candidate);
}
}
names
}
#[cfg(not(windows))]
fn candidate_file_names(name: &str) -> Vec<String> {
vec![name.to_string()]
}
pub fn detect_shadow(our_binary: &Path) -> Option<ShadowReport> {
let first = which_all("symforge").into_iter().next()?;
if same_install(&first, our_binary) {
return None;
}
let kind = classify_shadow(&first);
let shadow_version = probe_version(&first);
let our_version = probe_version(our_binary);
if let (Some(ours), Some(theirs)) = (&our_version, &shadow_version)
&& ours == theirs
{
return None;
}
Some(ShadowReport {
our_path: our_binary.to_path_buf(),
our_version,
shadow_path: first,
shadow_version,
kind,
})
}
pub(crate) fn same_file(a: &Path, b: &Path) -> bool {
match (std::fs::canonicalize(a), std::fs::canonicalize(b)) {
(Ok(ca), Ok(cb)) => ca == cb,
_ => normalize_for_compare(a) == normalize_for_compare(b),
}
}
fn same_install(a: &Path, b: &Path) -> bool {
if same_file(a, b) {
return true;
}
match (install_root(a), install_root(b)) {
(Some(ra), Some(rb)) => ra == rb,
_ => false,
}
}
fn install_root(launcher: &Path) -> Option<PathBuf> {
let dir = launcher.parent()?;
if dir.file_name().map(|n| n == "bin").unwrap_or(false)
&& let Some(pkg_dir) = dir.parent()
&& pkg_dir
.file_name()
.map(|n| n.to_string_lossy().starts_with("symforge-"))
.unwrap_or(false)
&& let Some(node_modules) = pkg_dir.parent()
&& node_modules
.file_name()
.map(|n| n == "node_modules")
.unwrap_or(false)
&& let Some(prefix) = node_modules.parent()
{
return Some(canonicalize_or_normalize(prefix));
}
if dir.file_name().map(|n| n == "bin").unwrap_or(false)
&& let Some(prefix) = dir.parent()
{
return Some(canonicalize_or_normalize(prefix));
}
Some(canonicalize_or_normalize(dir))
}
fn canonicalize_or_normalize(dir: &Path) -> PathBuf {
match std::fs::canonicalize(dir) {
Ok(c) => c,
Err(_) => PathBuf::from(normalize_for_compare(dir)),
}
}
fn normalize_for_compare(path: &Path) -> String {
let mut s = path.to_string_lossy().replace('\\', "/");
for prefix in ["//?/", "//./"] {
if let Some(stripped) = s.strip_prefix(prefix) {
s = stripped.to_string();
break;
}
}
if cfg!(windows) {
s.to_ascii_lowercase()
} else {
s
}
}
fn classify_shadow(shadow: &Path) -> ShadowKind {
if running_under_wsl() && path_starts_with_mnt(shadow) {
return ShadowKind::WindowsMntBleed;
}
if is_system_prefix(shadow) {
return ShadowKind::RootSystem;
}
ShadowKind::ForeignPrefix
}
fn is_system_prefix(shadow: &Path) -> bool {
const SYSTEM_PREFIXES: [&str; 5] = ["/usr/local/", "/usr/", "/opt/", "/bin/", "/sbin/"];
let s = shadow.to_string_lossy().replace('\\', "/");
SYSTEM_PREFIXES.iter().any(|prefix| s.starts_with(prefix))
}
fn path_starts_with_mnt(shadow: &Path) -> bool {
let s = shadow.to_string_lossy().replace('\\', "/");
s.starts_with("/mnt/")
}
#[cfg(unix)]
fn running_under_wsl() -> bool {
std::fs::read_to_string("/proc/version")
.map(|v| {
let v = v.to_ascii_lowercase();
v.contains("microsoft") || v.contains("wsl")
})
.unwrap_or(false)
}
#[cfg(not(unix))]
fn running_under_wsl() -> bool {
false
}
fn probe_version(path: &Path) -> Option<String> {
use std::sync::mpsc;
let path = path.to_path_buf();
let (tx, rx) = mpsc::channel();
std::thread::spawn(move || {
let result = crate::process_util::hidden_command(&path)
.arg("--version")
.stdin(std::process::Stdio::null())
.output();
let _ = tx.send(result);
});
match rx.recv_timeout(SHADOW_PROBE_TIMEOUT) {
Ok(Ok(output)) => parse_version(&String::from_utf8_lossy(&output.stdout)),
Ok(Err(_)) | Err(_) => None,
}
}
fn parse_version(text: &str) -> Option<String> {
text.lines().find_map(|line| {
line.split_whitespace()
.map(str::trim)
.find(|tok| tok.contains('.') && tok.chars().next().is_some_and(|c| c.is_ascii_digit()))
.map(str::to_string)
})
}
fn version_label(version: &Option<String>) -> String {
match version {
Some(v) => format!("({v})"),
None => "(version unknown)".to_string(),
}
}
fn prefix_bin_dir(binary: &Path) -> Option<PathBuf> {
binary.parent().map(Path::to_path_buf)
}
pub fn format_shadow_warning(report: &ShadowReport) -> String {
let runs = report.shadow_path.display();
let runs_ver = version_label(&report.shadow_version);
let installed = report.our_path.display();
let installed_ver = version_label(&report.our_version);
let our_bin_dir = prefix_bin_dir(&report.our_path);
let shadow_bin_dir = prefix_bin_dir(&report.shadow_path);
match report.kind {
ShadowKind::RootSystem => {
let modules = system_node_modules_for(&report.shadow_path);
format!(
"WARNING: `symforge` on PATH resolves to a different install than the one you installed.\n \
runs: {runs} {runs_ver} [root-owned shadow]\n \
installed: {installed} {installed_ver}\n\
Fix (removes the root shadow so your install wins):\n \
sudo rm -f {shadow}\n \
sudo rm -rf {modules}",
shadow = report.shadow_path.display(),
)
}
ShadowKind::WindowsMntBleed => {
let bin_hint = our_bin_dir
.as_deref()
.map(|d| d.display().to_string())
.unwrap_or_else(|| "$HOME/.npm-global/bin".to_string());
format!(
"WARNING: a Windows npm-global on /mnt is ahead of your Linux symforge on PATH.\n \
runs: {runs} {runs_ver}\n \
installed: {installed} {installed_ver}\n\
Fix (put your Linux npm prefix bin first, in login shells too):\n \
add to ~/.profile: export PATH=\"{bin_hint}:$PATH\""
)
}
ShadowKind::ForeignPrefix => {
let our_dir = our_bin_dir
.as_deref()
.map(|d| d.display().to_string())
.unwrap_or_else(|| installed.to_string());
let shadow_dir = shadow_bin_dir
.as_deref()
.map(|d| d.display().to_string())
.unwrap_or_else(|| runs.to_string());
if cfg!(windows) {
format!(
"WARNING: `symforge` on PATH resolves to a different install than the one you installed.\n \
runs: {runs} {runs_ver} [foreign prefix shadow]\n \
installed: {installed} {installed_ver}\n\
Fix: your install's bin dir must come BEFORE the shadow's on PATH.\n \
{our_dir} must precede {shadow_dir}\n \
verify with: Get-Command symforge -All (the first hit is what runs)\n \
reorder your user PATH so {our_dir} comes first, e.g. in PowerShell:\n \
[Environment]::SetEnvironmentVariable('Path', '{our_dir};' + [Environment]::GetEnvironmentVariable('Path','User'), 'User')\n \
(or edit it via System Properties > Environment Variables > Path), then open a new shell.\n \
note: with nvm-for-windows the active node prefix bin wins, so `nvm use` can re-shadow you."
)
} else {
format!(
"WARNING: `symforge` on PATH resolves to a different install than the one you installed.\n \
runs: {runs} {runs_ver} [foreign prefix shadow]\n \
installed: {installed} {installed_ver}\n\
Fix (ensure your install's bin precedes the shadow on PATH):\n \
add to ~/.profile: export PATH=\"{our_dir}:$PATH\"\n \
(it currently resolves to {shadow_dir} first)"
)
}
}
}
}
pub fn format_shadow_warning_compact(report: &ShadowReport) -> String {
let kind = match report.kind {
ShadowKind::RootSystem => "root-owned shadow",
ShadowKind::WindowsMntBleed => "/mnt Windows-bleed shadow",
ShadowKind::ForeignPrefix => "foreign-prefix shadow",
};
format!(
"WARNING: PATH shadow [{kind}]: bare `symforge` runs {runs} {runs_ver}, not your install {ours} {ours_ver}; run full `health` for the exact fix.",
runs = report.shadow_path.display(),
runs_ver = version_label(&report.shadow_version),
ours = report.our_path.display(),
ours_ver = version_label(&report.our_version),
)
}
fn system_node_modules_for(shadow: &Path) -> String {
let s = shadow.to_string_lossy().replace('\\', "/");
let trimmed = s.trim_end_matches('/');
let prefix = trimmed
.rsplit_once('/') .map(|(head, _)| head)
.and_then(|head| head.rsplit_once('/')) .map(|(prefix, _)| prefix);
match prefix {
Some(prefix) if !prefix.is_empty() => {
format!("{prefix}/lib/node_modules/symforge")
}
_ => "/usr/local/lib/node_modules/symforge".to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
struct PathGuard {
prev: Option<std::ffi::OsString>,
}
impl PathGuard {
fn set(value: &std::ffi::OsStr) -> Self {
let prev = std::env::var_os("PATH");
#[allow(unsafe_code)]
unsafe {
std::env::set_var("PATH", value)
};
Self { prev }
}
}
impl Drop for PathGuard {
fn drop(&mut self) {
#[allow(unsafe_code)]
match &self.prev {
Some(prev) => unsafe { std::env::set_var("PATH", prev) },
None => unsafe { std::env::remove_var("PATH") },
}
}
}
fn touch_symforge(dir: &Path) -> PathBuf {
let name = if cfg!(windows) {
"symforge.cmd"
} else {
"symforge"
};
let path = dir.join(name);
fs::write(&path, b"#shim").unwrap();
path
}
fn join_path_dirs(dirs: &[&Path]) -> std::ffi::OsString {
std::env::join_paths(dirs.iter().map(|d| d.as_os_str())).unwrap()
}
#[test]
fn which_all_returns_both_installs_in_path_order() {
let _lock = ENV_LOCK.lock().unwrap();
let first_dir = tempfile::tempdir().unwrap();
let second_dir = tempfile::tempdir().unwrap();
let first = touch_symforge(first_dir.path());
let second = touch_symforge(second_dir.path());
let path = join_path_dirs(&[first_dir.path(), second_dir.path()]);
let _guard = PathGuard::set(&path);
let found = which_all("symforge");
assert_eq!(found.len(), 2, "both installs should resolve");
assert_eq!(found[0], first, "PATH-first dir must come first");
assert_eq!(found[1], second, "PATH-second dir must come second");
}
#[test]
fn which_all_skips_directories_without_the_binary() {
let _lock = ENV_LOCK.lock().unwrap();
let empty_dir = tempfile::tempdir().unwrap();
let has_it = tempfile::tempdir().unwrap();
let real = touch_symforge(has_it.path());
let path = join_path_dirs(&[empty_dir.path(), has_it.path()]);
let _guard = PathGuard::set(&path);
let found = which_all("symforge");
assert_eq!(found, vec![real], "only the dir holding the binary counts");
}
#[test]
fn which_all_dedups_a_repeated_path_dir() {
let _lock = ENV_LOCK.lock().unwrap();
let dir = tempfile::tempdir().unwrap();
let real = touch_symforge(dir.path());
let path = join_path_dirs(&[dir.path(), dir.path()]);
let _guard = PathGuard::set(&path);
let found = which_all("symforge");
assert_eq!(found, vec![real], "a repeated PATH dir yields one hit");
}
#[cfg(windows)]
#[test]
fn which_all_resolves_pathext_cmd_shim_on_windows() {
let _lock = ENV_LOCK.lock().unwrap();
let dir = tempfile::tempdir().unwrap();
let shim = dir.path().join("symforge.cmd");
fs::write(&shim, b"@echo off").unwrap();
let path = join_path_dirs(&[dir.path()]);
let _guard = PathGuard::set(&path);
let found = which_all("symforge");
assert_eq!(found, vec![shim], "PATHEXT .cmd shim must resolve");
}
#[test]
fn detect_shadow_returns_none_when_path_first_is_us() {
let _lock = ENV_LOCK.lock().unwrap();
let dir = tempfile::tempdir().unwrap();
let ours = touch_symforge(dir.path());
let path = join_path_dirs(&[dir.path()]);
let _guard = PathGuard::set(&path);
assert!(
detect_shadow(&ours).is_none(),
"the only PATH install is us -> no shadow"
);
}
#[test]
fn detect_shadow_returns_none_when_no_symforge_on_path() {
let _lock = ENV_LOCK.lock().unwrap();
let empty = tempfile::tempdir().unwrap();
let ours = empty.path().join(if cfg!(windows) {
"symforge.cmd"
} else {
"symforge"
});
let path = join_path_dirs(&[empty.path()]);
let _guard = PathGuard::set(&path);
assert!(
detect_shadow(&ours).is_none(),
"no symforge on PATH -> no shadow"
);
}
#[test]
fn detect_shadow_reports_a_different_path_first_install() {
let _lock = ENV_LOCK.lock().unwrap();
let shadow_dir = tempfile::tempdir().unwrap();
let our_dir = tempfile::tempdir().unwrap();
let shadow = touch_symforge(shadow_dir.path());
let ours = touch_symforge(our_dir.path());
let path = join_path_dirs(&[shadow_dir.path(), our_dir.path()]);
let _guard = PathGuard::set(&path);
let report = detect_shadow(&ours).expect("a different PATH-first install is a shadow");
assert_eq!(report.shadow_path, shadow);
assert_eq!(report.our_path, ours);
assert_eq!(report.kind, ShadowKind::ForeignPrefix);
}
#[test]
fn detect_shadow_none_when_shim_delegates_to_same_install() {
let _lock = ENV_LOCK.lock().unwrap();
let prefix = tempfile::tempdir().unwrap();
let shim_cmd = prefix.path().join("symforge.cmd");
fs::write(&shim_cmd, b"@echo off").unwrap();
let shim_ps1 = prefix.path().join("symforge.ps1");
fs::write(&shim_ps1, b"# ps shim").unwrap();
let shim_bare = prefix.path().join("symforge");
fs::write(&shim_bare, b"#!/bin/sh").unwrap();
let bin_dir = prefix
.path()
.join("node_modules")
.join("symforge-windows-x64")
.join("bin");
fs::create_dir_all(&bin_dir).unwrap();
let exe_name = if cfg!(windows) {
"symforge.exe"
} else {
"symforge"
};
let platform_exe = bin_dir.join(exe_name);
fs::write(&platform_exe, b"#exe").unwrap();
let path = join_path_dirs(&[prefix.path()]);
let _guard = PathGuard::set(&path);
assert!(
detect_shadow(&platform_exe).is_none(),
"a launcher shim delegating into the same npm install is NOT a shadow"
);
}
#[test]
fn same_install_collapses_npm_launcher_artifacts() {
let prefix = tempfile::tempdir().unwrap();
let shim = prefix.path().join("symforge.cmd");
fs::write(&shim, b"@echo off").unwrap();
let bin_dir = prefix
.path()
.join("node_modules")
.join("symforge-linux-x64")
.join("bin");
fs::create_dir_all(&bin_dir).unwrap();
let exe = bin_dir.join("symforge");
fs::write(&exe, b"#exe").unwrap();
assert!(
same_install(&shim, &exe),
"prefix-root shim and node_modules platform exe share one install"
);
let other = tempfile::tempdir().unwrap();
let other_shim = other.path().join("symforge.cmd");
fs::write(&other_shim, b"@echo off").unwrap();
assert!(
!same_install(&shim, &other_shim),
"two distinct npm prefixes are distinct installs"
);
}
#[test]
fn detect_shadow_suppresses_when_versions_match() {
let ours = Some("7.21.0".to_string());
let theirs = Some("7.21.0".to_string());
let suppressed = matches!((&ours, &theirs), (Some(a), Some(b)) if a == b);
assert!(suppressed, "identical probed versions suppress the warning");
let theirs_old = Some("7.10.0".to_string());
let suppressed_old = matches!((&ours, &theirs_old), (Some(a), Some(b)) if a == b);
assert!(
!suppressed_old,
"genuinely different versions still warn (in both surfaces)"
);
}
#[test]
fn install_root_recognizes_npm_layouts() {
let prefix = tempfile::tempdir().unwrap();
let canon = std::fs::canonicalize(prefix.path()).unwrap();
let shim = prefix.path().join("symforge.cmd");
fs::write(&shim, b"@echo off").unwrap();
assert_eq!(install_root(&shim).as_deref(), Some(canon.as_path()));
let bin_dir = prefix
.path()
.join("node_modules")
.join("symforge-darwin-arm64")
.join("bin");
fs::create_dir_all(&bin_dir).unwrap();
let exe = bin_dir.join("symforge");
fs::write(&exe, b"#exe").unwrap();
assert_eq!(install_root(&exe).as_deref(), Some(canon.as_path()));
let unix_bin = prefix.path().join("bin");
fs::create_dir_all(&unix_bin).unwrap();
let unix_shim = unix_bin.join("symforge");
fs::write(&unix_shim, b"#!/bin/sh").unwrap();
assert_eq!(install_root(&unix_shim).as_deref(), Some(canon.as_path()));
}
#[test]
fn classify_shadow_flags_usr_local_as_root_system() {
assert_eq!(
classify_shadow(Path::new("/usr/local/bin/symforge")),
ShadowKind::RootSystem
);
assert_eq!(
classify_shadow(Path::new("/usr/bin/symforge")),
ShadowKind::RootSystem
);
assert_eq!(
classify_shadow(Path::new("/opt/symforge/bin/symforge")),
ShadowKind::RootSystem
);
}
#[test]
fn classify_shadow_flags_mnt_under_wsl_else_foreign() {
let mnt = Path::new("/mnt/c/Users/you/.npm-global/symforge");
let kind = classify_shadow(mnt);
if running_under_wsl() {
assert_eq!(kind, ShadowKind::WindowsMntBleed);
} else {
assert_eq!(kind, ShadowKind::ForeignPrefix);
}
assert_ne!(
kind,
ShadowKind::RootSystem,
"/mnt is never a Linux system prefix"
);
}
#[test]
fn classify_shadow_flags_arbitrary_prefix_as_foreign() {
assert_eq!(
classify_shadow(Path::new("/home/you/.nvm/versions/node/v20/bin/symforge")),
ShadowKind::ForeignPrefix
);
}
#[test]
fn format_warning_root_system_has_exact_remediation_and_both_versions() {
let report = ShadowReport {
our_path: PathBuf::from("/home/you/.npm-global/bin/symforge"),
our_version: Some("7.17.3".to_string()),
shadow_path: PathBuf::from("/usr/local/bin/symforge"),
shadow_version: Some("7.15.2".to_string()),
kind: ShadowKind::RootSystem,
};
let warning = format_shadow_warning(&report);
assert!(warning.contains("sudo rm -f /usr/local/bin/symforge"));
assert!(warning.contains("sudo rm -rf /usr/local/lib/node_modules/symforge"));
assert!(warning.contains("/usr/local/bin/symforge"));
assert!(warning.contains("/home/you/.npm-global/bin/symforge"));
assert!(warning.contains("(7.15.2)"), "shadow version shown");
assert!(warning.contains("(7.17.3)"), "our version shown");
assert!(warning.is_ascii(), "warning must be plain ASCII");
}
#[test]
fn format_warning_windows_mnt_bleed_points_login_path_at_our_bin() {
let report = ShadowReport {
our_path: PathBuf::from("/home/you/.npm-global/bin/symforge"),
our_version: Some("7.17.3".to_string()),
shadow_path: PathBuf::from("/mnt/c/Users/you/.npm-global/symforge"),
shadow_version: None,
kind: ShadowKind::WindowsMntBleed,
};
let warning = format_shadow_warning(&report);
assert!(warning.contains("/mnt/c/Users/you/.npm-global/symforge"));
assert!(
warning.contains("export PATH=\"/home/you/.npm-global/bin:$PATH\""),
"login PATH fix points at OUR bin dir, got: {warning}"
);
assert!(warning.contains("~/.profile"));
assert!(
warning.contains("(version unknown)"),
"unknown shadow version is labelled"
);
assert!(warning.is_ascii());
}
#[cfg(not(windows))]
#[test]
fn format_warning_foreign_prefix_orders_our_bin_before_shadow() {
let report = ShadowReport {
our_path: PathBuf::from("/home/you/.npm-global/bin/symforge"),
our_version: Some("7.17.3".to_string()),
shadow_path: PathBuf::from("/home/you/.nvm/versions/node/v20/bin/symforge"),
shadow_version: Some("7.10.0".to_string()),
kind: ShadowKind::ForeignPrefix,
};
let warning = format_shadow_warning(&report);
assert!(
warning.contains("export PATH=\"/home/you/.npm-global/bin:$PATH\""),
"fix prepends our bin dir, got: {warning}"
);
assert!(
warning.contains("/home/you/.nvm/versions/node/v20/bin"),
"names the shadow dir that currently wins"
);
assert!(warning.contains("(7.17.3)"));
assert!(warning.contains("(7.10.0)"));
assert!(warning.is_ascii());
}
#[cfg(windows)]
#[test]
fn format_warning_foreign_prefix_is_powershell_native_on_windows() {
let report = ShadowReport {
our_path: PathBuf::from(r"C:\Users\me\.npm-global\bin\symforge.exe"),
our_version: Some("7.18.1".to_string()),
shadow_path: PathBuf::from(r"C:\Program Files\nodejs\symforge.exe"),
shadow_version: Some("7.10.0".to_string()),
kind: ShadowKind::ForeignPrefix,
};
let warning = format_shadow_warning(&report);
assert!(
!warning.contains("~/.profile"),
"must not emit POSIX ~/.profile on Windows, got: {warning}"
);
assert!(
!warning.contains("export PATH"),
"must not emit POSIX export PATH on Windows, got: {warning}"
);
assert!(
warning.contains("Get-Command symforge -All"),
"must point at the PowerShell verify command, got: {warning}"
);
assert!(
warning.contains(r"C:\Users\me\.npm-global\bin"),
"must name our bin dir, got: {warning}"
);
assert!(
warning.contains(r"C:\Program Files\nodejs"),
"must name the shadow bin dir, got: {warning}"
);
assert!(warning.contains("(7.18.1)"));
assert!(warning.contains("(7.10.0)"));
assert!(warning.is_ascii(), "warning must be plain ASCII");
}
#[test]
fn format_warning_compact_is_single_line_with_kind_and_versions() {
let report = ShadowReport {
our_path: PathBuf::from("/home/you/.npm-global/bin/symforge"),
our_version: Some("7.17.3".to_string()),
shadow_path: PathBuf::from("/usr/local/bin/symforge"),
shadow_version: Some("7.15.2".to_string()),
kind: ShadowKind::RootSystem,
};
let line = format_shadow_warning_compact(&report);
assert_eq!(line.lines().count(), 1, "compact banner is one line");
assert!(line.contains("root-owned shadow"));
assert!(line.contains("(7.15.2)"));
assert!(line.contains("(7.17.3)"));
assert!(line.is_ascii());
}
#[test]
fn parse_version_scans_past_a_leading_banner() {
let out = "symforge update available\nsymforge 7.17.3\n";
assert_eq!(parse_version(out), Some("7.17.3".to_string()));
}
#[test]
fn system_node_modules_derives_from_prefix() {
assert_eq!(
system_node_modules_for(Path::new("/usr/local/bin/symforge")),
"/usr/local/lib/node_modules/symforge"
);
assert_eq!(
system_node_modules_for(Path::new("/opt/symforge/bin/symforge")),
"/opt/symforge/lib/node_modules/symforge"
);
}
}