use std::io;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use crate::domain::{AccessErrorKind, ControlStateDir, ControlStatePlacement, ProjectStateDir};
#[must_use]
pub(crate) fn metadata_is_reparse_point(metadata: &std::fs::Metadata) -> bool {
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x400;
metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
}
#[cfg(not(windows))]
{
let _ = metadata;
false
}
}
#[must_use]
pub(crate) fn state_directory_entry_type_is_unsafe(
is_directory: bool,
is_symlink: bool,
is_reparse_point: bool,
) -> bool {
!is_directory || is_symlink || is_reparse_point
}
#[must_use]
pub(crate) fn state_directory_metadata_is_unsafe(metadata: &std::fs::Metadata) -> bool {
state_directory_entry_type_is_unsafe(
metadata.is_dir(),
metadata.file_type().is_symlink(),
metadata_is_reparse_point(metadata),
)
}
#[must_use]
pub(crate) fn metadata_is_symlink_or_reparse(metadata: &std::fs::Metadata) -> bool {
metadata.file_type().is_symlink() || metadata_is_reparse_point(metadata)
}
pub(crate) fn path_must_be_regular_non_link(path: &Path) -> io::Result<std::fs::Metadata> {
let metadata = std::fs::symlink_metadata(path)?;
if metadata_is_symlink_or_reparse(&metadata) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!(
"refusing to follow a symlink or reparse point at {}",
path.display()
),
));
}
if !metadata.file_type().is_file() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("not a regular file: {}", path.display()),
));
}
Ok(metadata)
}
pub(crate) fn canonical_abs_stays_under_relative_root(
abs_path: &Path,
relative_path: &str,
) -> bool {
let component_count = Path::new(relative_path).components().count();
let Some(root) = abs_path.ancestors().nth(component_count) else {
return false;
};
match (root.canonicalize(), abs_path.canonicalize()) {
(Ok(canon_root), Ok(canon_path)) => canon_path.starts_with(&canon_root),
_ => true,
}
}
#[must_use]
pub(crate) fn is_loopback_bind_host(host: &str) -> bool {
let trimmed = host.trim().trim_start_matches('[').trim_end_matches(']');
trimmed.eq_ignore_ascii_case("localhost")
|| trimmed
.parse::<IpAddr>()
.map(|ip| ip.is_loopback())
.unwrap_or(false)
}
pub const SYMFORGE_DIR_NAME: &str = ".symforge";
pub const FRECENCY_DB_NAME: &str = "frecency.db";
pub const COUPLING_DB_NAME: &str = "coupling.db";
pub const ANALYTICS_DB_NAME: &str = "analytics.db";
pub const API_KEYS_DB_NAME: &str = "api-keys.db";
pub const STEL_LEDGER_DB_NAME: &str = "stel-ledger.db";
pub const IDEMPOTENCY_DIR_NAME: &str = "idempotency";
pub const INDEX_SNAPSHOT_QUARANTINE_RELATIVE_PATH: &str = "quarantine/index-snapshots";
pub const SYMFORGE_IDEMPOTENCY_DIR_PATH: &str = ".symforge/idempotency";
pub const SYMFORGE_IDEMPOTENCY_RECORDS_DIR_PATH: &str = ".symforge/idempotency/records";
pub const SYMFORGE_IDEMPOTENCY_QUARANTINE_DIR_PATH: &str = ".symforge/idempotency/quarantine";
pub const SYMFORGE_INDEX_SNAPSHOT_QUARANTINE_DIR_PATH: &str =
".symforge/quarantine/index-snapshots";
pub const SYMFORGE_ARTIFACT_QUARANTINE_DIR_PATH: &str = ".symforge/quarantine/artifacts";
pub(crate) fn normalize_event_path(abs_path: &Path, repo_root: &Path) -> Option<String> {
let raw_path = abs_path.to_string_lossy();
let stripped_raw: &str = if let Some(stripped) = raw_path.strip_prefix(r"\\?\") {
stripped
} else {
raw_path.as_ref()
};
let clean_abs = Path::new(stripped_raw);
let relative = clean_abs.strip_prefix(repo_root).or_else(|_| {
let root_raw = repo_root.to_string_lossy();
let stripped_root: &str = if let Some(stripped) = root_raw.strip_prefix(r"\\?\") {
stripped
} else {
return clean_abs.strip_prefix(repo_root);
};
clean_abs.strip_prefix(Path::new(stripped_root))
});
relative
.ok()
.map(|p| p.to_string_lossy().replace('\\', "/"))
}
pub(crate) fn normalized_path_text(path_text: &str, windows: bool) -> String {
if windows {
path_text.replace('\\', "/")
} else {
path_text.to_string()
}
}
pub(crate) fn normalized_path_string(path: &Path) -> String {
normalized_path_text(&dunce::simplified(path).to_string_lossy(), cfg!(windows))
}
#[must_use]
pub fn os_runtime_tag() -> &'static str {
std::env::consts::OS
}
#[must_use]
pub fn os_tagged_runtime_file_name(stem: &str, ext: &str) -> String {
format!("{stem}.{tag}.{ext}", tag = os_runtime_tag())
}
pub fn resolve_symforge_dir(base: &Path) -> PathBuf {
base.join(SYMFORGE_DIR_NAME)
}
pub fn resolve_control_state_placement() -> ControlStatePlacement {
let candidate = std::env::var_os("SYMFORGE_HOME")
.map(PathBuf::from)
.or_else(|| dirs::home_dir().map(|home| home.join(SYMFORGE_DIR_NAME)));
resolve_control_state_placement_with(candidate, prepare_control_state_dir)
}
#[must_use]
pub fn process_control_state_placement() -> &'static ControlStatePlacement {
static PLACEMENT: std::sync::OnceLock<ControlStatePlacement> = std::sync::OnceLock::new();
PLACEMENT.get_or_init(resolve_control_state_placement)
}
pub(crate) fn resolve_control_state_placement_with<F>(
candidate: Option<PathBuf>,
mut prepare: F,
) -> ControlStatePlacement
where
F: FnMut(&Path) -> Result<(), AccessErrorKind>,
{
let Some(directory) = candidate else {
return ControlStatePlacement::ProcessLocal {
safe_reason: AccessErrorKind::NotFound,
};
};
if !directory.is_absolute() {
return ControlStatePlacement::ProcessLocal {
safe_reason: AccessErrorKind::InvalidData,
};
}
match prepare(&directory) {
Ok(()) => ControlStatePlacement::UserLocal {
directory: ControlStateDir::new(directory),
},
Err(safe_reason) => ControlStatePlacement::ProcessLocal { safe_reason },
}
}
fn prepare_control_state_dir(directory: &Path) -> Result<(), AccessErrorKind> {
std::fs::create_dir_all(directory).map_err(|error| access_error_kind(&error))?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(directory, std::fs::Permissions::from_mode(0o700))
.map_err(|error| access_error_kind(&error))?;
}
Ok(())
}
fn access_error_kind(error: &io::Error) -> AccessErrorKind {
match error.kind() {
io::ErrorKind::NotFound => AccessErrorKind::NotFound,
io::ErrorKind::PermissionDenied => AccessErrorKind::PermissionDenied,
io::ErrorKind::InvalidData | io::ErrorKind::InvalidInput => AccessErrorKind::InvalidData,
io::ErrorKind::OutOfMemory => AccessErrorKind::ResourceExhausted,
_ => AccessErrorKind::Other,
}
}
pub fn global_symforge_home() -> io::Result<PathBuf> {
match process_control_state_placement() {
ControlStatePlacement::UserLocal { directory } => Ok(directory.as_path().to_path_buf()),
ControlStatePlacement::ProcessLocal { safe_reason } => Err(io::Error::new(
io_error_kind(*safe_reason),
format!("durable SymForge control state unavailable: {safe_reason:?}"),
)),
}
}
pub fn resolve_user_local_project_state_base() -> io::Result<PathBuf> {
match resolve_control_state_placement() {
ControlStatePlacement::UserLocal { directory } => Ok(directory.as_path().to_path_buf()),
ControlStatePlacement::ProcessLocal { safe_reason } => Err(io::Error::new(
io_error_kind(safe_reason),
format!("durable user-local project state unavailable: {safe_reason:?}"),
)),
}
}
fn io_error_kind(error: AccessErrorKind) -> io::ErrorKind {
match error {
AccessErrorKind::NotFound => io::ErrorKind::NotFound,
AccessErrorKind::PermissionDenied => io::ErrorKind::PermissionDenied,
AccessErrorKind::InvalidData => io::ErrorKind::InvalidData,
AccessErrorKind::ResourceExhausted => io::ErrorKind::OutOfMemory,
AccessErrorKind::Other => io::ErrorKind::Other,
}
}
fn is_unsafe_data_dir_base(path: &Path) -> bool {
let canonical = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
is_sensitive_path(&canonical)
}
pub fn select_runtime_data_base(project_root: Option<&Path>, cwd: Option<&Path>) -> PathBuf {
if let Some(root) = project_root.filter(|p| !is_unsafe_data_dir_base(p)) {
return resolve_symforge_dir(root);
}
if let Some(cwd) = cwd.filter(|p| !is_unsafe_data_dir_base(p)) {
return resolve_symforge_dir(cwd);
}
global_symforge_home().unwrap_or_else(|error| {
tracing::warn!(
"falling back to cwd-relative .symforge after global home resolution failed: {error}"
);
cwd.as_ref()
.map(|path| resolve_symforge_dir(path))
.unwrap_or_else(|| PathBuf::from(SYMFORGE_DIR_NAME))
})
}
pub fn ensure_runtime_symforge_dir(project_root: Option<&Path>) -> io::Result<PathBuf> {
let cwd = std::env::current_dir().ok();
let preferred_base = project_root
.filter(|p| !is_unsafe_data_dir_base(p))
.map(|p| p.to_path_buf())
.or_else(|| {
cwd.as_ref()
.filter(|p| !is_unsafe_data_dir_base(p))
.cloned()
});
if let Some(base) = preferred_base {
match ensure_symforge_dir(&base) {
Ok(dir) => return Ok(dir),
Err(error) if error.kind() == io::ErrorKind::PermissionDenied => {
tracing::warn!(
path = %base.display(),
"cannot create project-local .symforge (permission denied); using global SymForge home"
);
}
Err(error) => return Err(error),
}
} else if let Some(ref launch_cwd) = cwd {
tracing::info!(
path = %launch_cwd.display(),
"launch cwd is not a safe project root for .symforge; using global SymForge home"
);
}
global_symforge_home()
}
pub fn ensure_symforge_dir(base: &Path) -> io::Result<PathBuf> {
let dir = resolve_symforge_dir(base);
std::fs::create_dir_all(&dir).map_err(|e| {
io::Error::new(
e.kind(),
format!("ensuring symforge data dir at {}: {}", dir.display(), e),
)
})?;
Ok(dir)
}
#[must_use]
pub fn symforge_db_path(root: &Path, name: &str) -> PathBuf {
debug_assert!(
!name.contains('/') && !name.contains('\\'),
"symforge_db_path `name` must be a BARE filename (got {name:?}); \
the `.symforge/` prefix is owned by this helper"
);
root.join(SYMFORGE_DIR_NAME).join(name)
}
pub fn ensure_symforge_db_path(root: &Path, name: &str) -> io::Result<PathBuf> {
ensure_symforge_dir(root)?;
Ok(symforge_db_path(root, name))
}
#[must_use]
pub fn project_state_path(state_dir: &ProjectStateDir, relative: &str) -> PathBuf {
debug_assert!(
!Path::new(relative).is_absolute(),
"project-state paths must be relative"
);
state_dir.as_path().join(relative)
}
pub fn ensure_project_state_dir(state_dir: &ProjectStateDir) -> io::Result<()> {
std::fs::create_dir_all(state_dir.as_path()).map_err(|error| {
io::Error::new(
error.kind(),
format!(
"ensuring project state dir at {}: {error}",
state_dir.as_path().display()
),
)
})
}
pub fn ensure_project_state_db_path(
state_dir: &ProjectStateDir,
name: &str,
) -> io::Result<PathBuf> {
debug_assert!(
!name.contains('/') && !name.contains('\\'),
"project-state database name must be bare"
);
ensure_project_state_dir(state_dir)?;
Ok(project_state_path(state_dir, name))
}
#[must_use]
pub fn control_state_path(state_dir: &ControlStateDir, relative: &str) -> PathBuf {
debug_assert!(
!Path::new(relative).is_absolute(),
"control-state paths must be relative"
);
state_dir.as_path().join(relative)
}
pub fn ensure_control_state_dir(state_dir: &ControlStateDir) -> io::Result<()> {
std::fs::create_dir_all(state_dir.as_path()).map_err(|error| {
io::Error::new(
error.kind(),
format!(
"ensuring control state dir at {}: {error}",
state_dir.as_path().display()
),
)
})
}
pub fn resolve_idempotency_dir(base: &Path) -> PathBuf {
base.join(SYMFORGE_IDEMPOTENCY_DIR_PATH)
}
pub fn ensure_idempotency_dir(base: &Path) -> io::Result<PathBuf> {
let dir = resolve_idempotency_dir(base);
std::fs::create_dir_all(&dir).map_err(|e| {
io::Error::new(
e.kind(),
format!("ensuring idempotency dir at {}: {}", dir.display(), e),
)
})?;
Ok(dir)
}
pub fn resolve_index_snapshot_quarantine_dir(base: &Path) -> PathBuf {
base.join(SYMFORGE_INDEX_SNAPSHOT_QUARANTINE_DIR_PATH)
}
pub fn ensure_index_snapshot_quarantine_dir(base: &Path) -> io::Result<PathBuf> {
let dir = resolve_index_snapshot_quarantine_dir(base);
std::fs::create_dir_all(&dir).map_err(|e| {
io::Error::new(
e.kind(),
format!(
"ensuring index snapshot quarantine dir at {}: {}",
dir.display(),
e
),
)
})?;
Ok(dir)
}
pub fn resolve_artifact_quarantine_dir(base: &Path) -> PathBuf {
base.join(SYMFORGE_ARTIFACT_QUARANTINE_DIR_PATH)
}
pub fn ensure_artifact_quarantine_dir(base: &Path) -> io::Result<PathBuf> {
let dir = resolve_artifact_quarantine_dir(base);
std::fs::create_dir_all(&dir).map_err(|e| {
io::Error::new(
e.kind(),
format!(
"ensuring team artifact quarantine dir at {}: {}",
dir.display(),
e
),
)
})?;
Ok(dir)
}
fn strip_verbatim_prefix(s: &str) -> &str {
if let Some(rest) = s.strip_prefix(r"\\?\UNC\") {
rest
} else if let Some(rest) = s.strip_prefix(r"\\?\") {
rest
} else {
s
}
}
const WINDOWS_SENSITIVE_SEGMENTS: &[&str] = &[
"windows",
"program files",
"program files (x86)",
"programdata",
"system32",
];
fn is_windows_sensitive_under_drive(comps: &[&str]) -> bool {
comps
.get(1)
.is_some_and(|first| WINDOWS_SENSITIVE_SEGMENTS.contains(first))
}
fn is_windows_user_container(comps: &[&str]) -> bool {
matches!(comps.get(1), Some(&"users")) && comps.len() <= 3
}
#[must_use]
pub fn fold_case(text: &str) -> String {
text.to_uppercase().to_lowercase()
}
#[must_use]
pub fn is_credential_directory_path(path: &Path) -> bool {
let names: Vec<String> = path
.components()
.filter_map(|component| match component {
std::path::Component::Normal(name) => Some(fold_case(&name.to_string_lossy())),
_ => None,
})
.collect();
names.iter().enumerate().any(|(index, name)| {
matches!(
name.as_str(),
".aws" | ".kube" | ".ssh" | ".gnupg" | ".docker"
) || (name == "gcloud" && index > 0 && names[index - 1] == ".config")
})
}
#[must_use]
pub fn is_sensitive_path(canonical: &Path) -> bool {
let raw = canonical.to_string_lossy();
let stripped = strip_verbatim_prefix(&raw);
#[cfg(windows)]
{
let lower = stripped.replace('\\', "/").to_ascii_lowercase();
let comps: Vec<&str> = lower.split('/').filter(|c| !c.is_empty()).collect();
if let [drive] = comps.as_slice()
&& drive.len() == 2
&& drive.ends_with(':')
&& drive.as_bytes()[0].is_ascii_alphabetic()
{
return true;
}
is_windows_sensitive_under_drive(&comps) || is_windows_user_container(&comps)
}
#[cfg(unix)]
{
let path = Path::new(stripped);
const BLOCKED_RECURSIVE: &[&str] = &[
"/bin", "/boot", "/dev", "/etc", "/lib", "/lib64", "/proc", "/run", "/sbin", "/sys",
"/usr", "/var", "/root", "/Library", "/System", "/private",
];
const BLOCKED_ROOT_ONLY: &[&str] = &["/opt", "/srv", "/media", "/tmp", "/snap"];
let has_normal_component = path
.components()
.any(|c| matches!(c, std::path::Component::Normal(_)));
if path.is_absolute() && !has_normal_component {
return true;
}
for blocked in BLOCKED_RECURSIVE {
if path == Path::new(blocked) || path.starts_with(blocked) {
return true;
}
}
for blocked in BLOCKED_ROOT_ONLY {
if path == Path::new(blocked) {
return true;
}
}
let lower = stripped.to_ascii_lowercase();
let comps: Vec<&str> = lower.split('/').filter(|c| !c.is_empty()).collect();
if let [container, rest @ ..] = comps.as_slice()
&& (*container == "home" || *container == "users")
&& rest.len() <= 1
{
return true;
}
if comps.first() == Some(&"mnt") {
match comps.as_slice() {
[_mnt] => return true,
[_mnt, drive, rest @ ..]
if drive.len() == 1 && drive.as_bytes()[0].is_ascii_alphabetic() =>
{
if rest.is_empty() {
return true;
}
let mut drive_view = Vec::with_capacity(rest.len() + 1);
drive_view.push(*drive);
drive_view.extend_from_slice(rest);
if is_windows_user_container(&drive_view) {
return true;
}
if is_windows_sensitive_under_drive(&drive_view) {
return true;
}
}
_ => {}
}
}
false
}
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::TempDir;
#[test]
fn regular_file_is_accepted_as_non_link() {
let dir = TempDir::new().expect("tempdir");
let path = dir.path().join("plain.txt");
std::fs::write(&path, b"ok").expect("write");
let meta = path_must_be_regular_non_link(&path).expect("regular file");
assert!(meta.file_type().is_file());
assert!(!metadata_is_symlink_or_reparse(&meta));
}
#[cfg(unix)]
#[test]
fn file_symlink_is_refused_as_non_link() {
let dir = TempDir::new().expect("tempdir");
let target = dir.path().join("target.txt");
let link = dir.path().join("link.txt");
std::fs::write(&target, b"secret").expect("write target");
std::os::unix::fs::symlink(&target, &link).expect("symlink");
let err = path_must_be_regular_non_link(&link).expect_err("symlink must be refused");
assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
assert!(
!err.to_string().contains("secret"),
"refusal must not carry target bytes"
);
let target_ok = path_must_be_regular_non_link(&target).expect("positive control");
assert!(target_ok.file_type().is_file());
}
#[cfg(unix)]
#[test]
fn nested_dir_symlink_abs_does_not_stay_under_repo_root() {
let repo = TempDir::new().expect("repo");
let outside = TempDir::new().expect("outside");
std::fs::write(outside.path().join("secret.txt"), b"secret").expect("secret");
std::os::unix::fs::symlink(outside.path(), repo.path().join("junc")).expect("dir symlink");
let nested = repo.path().join("junc/secret.txt");
assert!(
!canonical_abs_stays_under_relative_root(&nested, "junc/secret.txt"),
"canonicalize must place the nested file outside the repo"
);
let plain = repo.path().join("plain.txt");
std::fs::write(&plain, b"ok").expect("plain");
assert!(canonical_abs_stays_under_relative_root(&plain, "plain.txt"));
}
#[cfg(windows)]
#[test]
fn junction_is_reported_as_symlink_or_reparse() {
let root = TempDir::new().expect("temp root");
let outside = TempDir::new().expect("outside");
std::fs::write(outside.path().join("escaped.txt"), b"outside").expect("outside file");
let junction = root.path().join("link");
let status = crate::process_util::hidden_command("cmd")
.args(["/C", "mklink", "/J"])
.arg(&junction)
.arg(outside.path())
.output()
.expect("mklink runs");
assert!(
status.status.success(),
"mklink /J failed: {}",
String::from_utf8_lossy(&status.stderr)
);
let meta = std::fs::symlink_metadata(&junction).expect("symlink_metadata");
assert!(
metadata_is_symlink_or_reparse(&meta),
"a junction must be unsafe to follow"
);
path_must_be_regular_non_link(&junction)
.expect_err("a junction is not a regular non-link file");
let nested = junction.join("escaped.txt");
assert!(
!canonical_abs_stays_under_relative_root(&nested, "link/escaped.txt"),
"nested file under a junction must canonicalize outside the repo"
);
let regular = root.path().join("plain.txt");
std::fs::write(®ular, b"ok").expect("write");
path_must_be_regular_non_link(®ular).expect("positive control");
}
#[test]
fn loopback_bind_hosts_are_localhost_and_loopback_ips() {
assert!(is_loopback_bind_host("127.0.0.1"));
assert!(is_loopback_bind_host("localhost"));
assert!(is_loopback_bind_host("LOCALHOST"));
assert!(is_loopback_bind_host("[::1]"));
assert!(is_loopback_bind_host("::1"));
assert!(!is_loopback_bind_host("0.0.0.0"));
assert!(!is_loopback_bind_host("192.168.1.1"));
assert!(!is_loopback_bind_host(""));
}
#[test]
fn every_state_consumer_requires_its_typed_owner() {
let project_owned = [
("idempotency replay", include_str!("idempotency.rs")),
(
"coupling store",
include_str!("live_index/coupling/lifecycle.rs"),
),
("frecency store", include_str!("live_index/frecency.rs")),
("STEL ledger", include_str!("stel_core/ledger_store.rs")),
("analytics store", include_str!("analytics/store.rs")),
("API-key store", include_str!("server/api_keys.rs")),
("edit-safety TEE", include_str!("edit_safety/tee.rs")),
];
let control_owned = [
("edit-safety trust", include_str!("edit_safety/trust.rs")),
("sidecar port file", include_str!("sidecar/port_file.rs")),
("sidecar server", include_str!("sidecar/server.rs")),
("daemon control", include_str!("daemon.rs")),
("hook adoption", include_str!("cli/hook.rs")),
("operator profile", include_str!("cli/operator_profile.rs")),
("onboarding state", include_str!("cli/onboarding.rs")),
("runtime startup", include_str!("server/serve.rs")),
("version registry", include_str!("version_registry.rs")),
("updater", include_str!("cli/update.rs")),
];
let mut violations = Vec::new();
for (consumer, source) in project_owned {
if !source.contains("ProjectStateDir") {
violations.push(format!(
"{consumer} does not require ProjectStateDir from its resolved project owner"
));
}
}
for (consumer, source) in control_owned {
if !source.contains("ControlStateDir") {
violations.push(format!(
"{consumer} does not require ControlStateDir from its resolved process owner"
));
}
}
let forbidden = [
(
"sidecar port file",
include_str!("sidecar/port_file.rs"),
"select_runtime_data_base(",
),
(
"sidecar server",
include_str!("sidecar/server.rs"),
"select_runtime_data_base(",
),
(
"updater",
include_str!("cli/update.rs"),
"Path::new(\".symforge\")",
),
(
"edit-safety TEE",
include_str!("edit_safety/tee.rs"),
"ensure_symforge_dir(&self.repo_root)",
),
];
for (consumer, source, legacy_path) in forbidden {
if source.contains(legacy_path) {
violations.push(format!(
"{consumer} still reconstructs state through forbidden `{legacy_path}`"
));
}
}
assert!(
violations.is_empty(),
"typed-owner inventory violations:\n{}",
violations.join("\n")
);
}
#[test]
fn control_state_never_falls_back_to_launch_cwd_or_relative_symforge() {
let mut prepare_calls = 0;
let relative =
resolve_control_state_placement_with(Some(PathBuf::from(SYMFORGE_DIR_NAME)), |_| {
prepare_calls += 1;
Ok(())
});
assert_eq!(
relative,
crate::domain::ControlStatePlacement::ProcessLocal {
safe_reason: crate::domain::AccessErrorKind::InvalidData,
}
);
assert_eq!(
prepare_calls, 0,
"relative control state must not be probed"
);
let unavailable = resolve_control_state_placement_with(None, |_| {
prepare_calls += 1;
Ok(())
});
assert_eq!(
unavailable,
crate::domain::ControlStatePlacement::ProcessLocal {
safe_reason: crate::domain::AccessErrorKind::NotFound,
}
);
assert_eq!(
prepare_calls, 0,
"missing user-local state must remain process-local, never inspect launch CWD"
);
let launch_cwd = TempDir::new().unwrap();
let denied_control_dir = launch_cwd.path().join("private-control-state");
let denied = resolve_control_state_placement_with(Some(denied_control_dir), |_| {
prepare_calls += 1;
Err(crate::domain::AccessErrorKind::PermissionDenied)
});
assert_eq!(
denied,
crate::domain::ControlStatePlacement::ProcessLocal {
safe_reason: crate::domain::AccessErrorKind::PermissionDenied,
}
);
assert_eq!(
prepare_calls, 1,
"the chosen user-local path is probed once"
);
assert!(
!launch_cwd.path().join(SYMFORGE_DIR_NAME).exists(),
"an unavailable user-local directory must not create a launch-CWD fallback"
);
}
#[test]
fn select_runtime_data_base_prefers_project_root_over_launch_cwd() {
let tmp = TempDir::new().unwrap();
let project = tmp.path().join("repo");
std::fs::create_dir_all(&project).unwrap();
let chosen = select_runtime_data_base(Some(&project), Some(Path::new("/tmp")));
assert_eq!(chosen, resolve_symforge_dir(&project));
}
#[cfg(windows)]
#[test]
fn select_runtime_data_base_skips_system32_launch_cwd() {
let chosen = select_runtime_data_base(None, Some(Path::new(r"C:\Windows\System32")));
assert!(
!chosen
.to_string_lossy()
.to_ascii_lowercase()
.contains("system32"),
"System32 launch cwd must not host .symforge; got {}",
chosen.display()
);
}
#[test]
fn test_resolve_symforge_dir_prefers_existing_canonical_dir() {
let tmp = TempDir::new().unwrap();
let symforge_dir = tmp.path().join(SYMFORGE_DIR_NAME);
std::fs::create_dir_all(&symforge_dir).unwrap();
let resolved = resolve_symforge_dir(tmp.path());
assert_eq!(resolved, symforge_dir);
}
#[test]
fn test_ensure_symforge_dir_creates_canonical_dir_when_missing() {
let tmp = TempDir::new().unwrap();
let dir = ensure_symforge_dir(tmp.path()).unwrap();
assert_eq!(dir, tmp.path().join(SYMFORGE_DIR_NAME));
assert!(dir.exists(), "canonical directory should be created");
}
#[test]
fn symforge_db_path_is_single_prefixed_never_doubled() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
for name in [
FRECENCY_DB_NAME,
COUPLING_DB_NAME,
ANALYTICS_DB_NAME,
API_KEYS_DB_NAME,
STEL_LEDGER_DB_NAME,
] {
let got = symforge_db_path(root, name);
assert_eq!(
got,
root.join(SYMFORGE_DIR_NAME).join(name),
"{name}: production path must be single-prefixed root/.symforge/<name>"
);
let doubled = root
.join(SYMFORGE_DIR_NAME)
.join(SYMFORGE_DIR_NAME)
.join(name);
assert_ne!(
got, doubled,
"{name}: helper must never produce the doubled root/.symforge/.symforge/<name> path"
);
}
}
#[test]
fn ensure_symforge_db_path_creates_parent_and_returns_single_prefixed() {
let tmp = TempDir::new().unwrap();
let root = tmp.path();
let db = ensure_symforge_db_path(root, ANALYTICS_DB_NAME).unwrap();
assert_eq!(db, root.join(SYMFORGE_DIR_NAME).join(ANALYTICS_DB_NAME));
assert!(
db.parent().unwrap().is_dir(),
"parent .symforge dir must exist after ensure_symforge_db_path"
);
}
#[test]
fn test_idempotency_paths_stay_under_canonical_symforge_dir() {
let tmp = TempDir::new().unwrap();
assert_eq!(
resolve_idempotency_dir(tmp.path()),
tmp.path().join(SYMFORGE_DIR_NAME).join("idempotency")
);
assert_eq!(
tmp.path().join(SYMFORGE_IDEMPOTENCY_RECORDS_DIR_PATH),
resolve_idempotency_dir(tmp.path()).join("records")
);
assert_eq!(
tmp.path().join(SYMFORGE_IDEMPOTENCY_QUARANTINE_DIR_PATH),
resolve_idempotency_dir(tmp.path()).join("quarantine")
);
}
#[test]
fn test_index_snapshot_quarantine_path_stays_under_canonical_symforge_dir() {
let tmp = TempDir::new().unwrap();
assert_eq!(
resolve_index_snapshot_quarantine_dir(tmp.path()),
tmp.path()
.join(SYMFORGE_DIR_NAME)
.join("quarantine")
.join("index-snapshots")
);
}
#[test]
fn test_artifact_quarantine_path_stays_under_canonical_symforge_dir() {
let tmp = TempDir::new().unwrap();
assert_eq!(
resolve_artifact_quarantine_dir(tmp.path()),
tmp.path()
.join(SYMFORGE_DIR_NAME)
.join("quarantine")
.join("artifacts")
);
let dir = ensure_artifact_quarantine_dir(tmp.path()).unwrap();
assert!(dir.is_dir(), "artifact quarantine dir should be created");
}
#[test]
fn strip_verbatim_prefix_handles_plain_unc_and_verbatim() {
assert_eq!(strip_verbatim_prefix(r"\\?\C:\Windows"), r"C:\Windows");
assert_eq!(
strip_verbatim_prefix(r"\\?\UNC\server\share\proj"),
r"server\share\proj"
);
assert_eq!(
strip_verbatim_prefix(r"C:\Users\me\proj"),
r"C:\Users\me\proj"
);
assert_eq!(
strip_verbatim_prefix("/home/user/project"),
"/home/user/project"
);
}
#[cfg(windows)]
#[test]
fn is_sensitive_path_windows_blocks_system_roots_and_subdirs() {
let blocked = [
r"\\?\C:\Windows\System32",
r"\\?\C:\Windows",
r"C:\Windows",
"C:/Windows",
r"C:\Windows\System32\drivers",
r"C:\Program Files\X",
r"C:\Program Files (x86)\Y\bin",
r"C:\ProgramData",
r"C:\ProgramData\some\creds",
r"C:\",
"C:/",
r"D:\",
];
for path in blocked {
assert!(
is_sensitive_path(Path::new(path)),
"expected `{path}` to be refused as sensitive"
);
}
}
#[cfg(windows)]
#[test]
fn is_sensitive_path_windows_blocks_user_profile_container_and_root() {
let blocked = [
r"C:\Users",
"C:/Users",
r"\\?\C:\Users",
r"C:\Users\victim",
"C:/Users/victim",
r"\\?\C:\Users\victim",
];
for path in blocked {
assert!(
is_sensitive_path(Path::new(path)),
"expected `{path}` to be refused as sensitive (profile container/root)"
);
}
}
#[cfg(windows)]
#[test]
fn is_sensitive_path_windows_allows_normal_project_paths() {
let allowed = [
r"\\?\C:\Users\me\project",
r"C:\Users\me\project",
r"C:\Users\me\projects\repo",
r"C:\Users\me\my-windows-project",
r"C:\Users\me\system32-emulator",
r"C:\dev\windows-tools\src",
r"\\?\UNC\server\share\proj",
];
for path in allowed {
assert!(
!is_sensitive_path(Path::new(path)),
"expected `{path}` to be allowed (not sensitive)"
);
}
}
#[cfg(unix)]
#[test]
fn is_sensitive_path_unix_blocks_roots_and_subdirs() {
let blocked = [
"/",
"/etc",
"/etc/passwd",
"/etc/sub",
"/usr",
"/usr/lib/x",
"/root",
"/Library",
"/System",
"/private",
"/home",
"/home/victim",
"/Users",
"/Users/victim",
"/mnt",
"/opt",
"/srv",
"/media",
"/tmp",
"/snap",
"/mnt/c",
"/mnt/c/Users",
"/mnt/c/Users/victim",
"/mnt/c/Windows",
"/mnt/c/Windows/System32",
"/mnt/c/Program Files/X",
"/mnt/c/ProgramData",
];
for path in blocked {
assert!(
is_sensitive_path(Path::new(path)),
"expected `{path}` to be refused as sensitive"
);
}
}
#[cfg(unix)]
#[test]
fn is_sensitive_path_unix_allows_normal_project_paths() {
let allowed = [
"/home/user/project",
"/home/me/repo",
"/home/user/etc-notes",
"/home/user/usr-local-clone",
"/home/me/etcd-client",
"/opt/app",
"/srv/site",
"/tmp/build/proj",
"/mnt/c/Users/me/project",
"/mnt/c/Users/me/repo",
"/mnt/d/dev/windows-tools",
"/mnt/c/code/proj",
];
for path in allowed {
assert!(
!is_sensitive_path(Path::new(path)),
"expected `{path}` to be allowed (not sensitive)"
);
}
}
}