use camino::{Utf8Path, Utf8PathBuf};
use serde::Serialize;
use crate::domain::manifest::DOCS_SCRATCH_VAR;
use crate::domain::paths::{
self, ActivePaths, Paths, UserEnv, docs_scratch_location, recorded_paths, variable,
};
use crate::domain::profile::{DocsRoot, ProfileId};
use crate::domain::version::CanonVersion;
use crate::error::AppError;
use crate::landing::classify::{Classification, Signals, classify};
use crate::services::verifier;
pub const SCHEMA: &str = "sdd.status/6";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum Alignment {
Aligned,
BinaryNewer,
InstanceNewer,
}
#[derive(Debug, Serialize)]
pub struct StatusReport {
pub schema: &'static str,
pub classification: Option<Classification>,
pub invalid: Option<String>,
pub instance: bool,
pub profile: Option<ProfileId>,
pub docs_root: Option<DocsRoot>,
pub docs_scratch: Option<Utf8PathBuf>,
pub docs_scratch_env: Option<String>,
pub canon_version: Option<CanonVersion>,
pub binary_version: CanonVersion,
pub alignment: Option<Alignment>,
pub managed_drift: usize,
pub adopted_drift: usize,
pub failures: usize,
pub ok: Option<bool>,
pub legacy_state: Vec<LegacyState>,
pub migration: Option<String>,
pub paths: Paths,
}
fn proposals(target: &Utf8Path, env: &UserEnv) -> paths::Proposals {
paths::proposals(env, |relative| target.join(relative).is_dir())
}
fn derived_paths(target: &Utf8Path, env: &UserEnv) -> Paths {
Paths {
user: env.user_paths().map(|user| {
let legacy = env
.legacy_state_root()
.map(|root| root.join(crate::domain::paths::SKILL_RECEIPT_FILE));
user.with_skill_entries_while_a_receipt_exists(legacy.as_deref())
}),
active: None,
candidates: paths::candidates(),
proposals: proposals(target, env),
}
}
fn absent(target: &Utf8Path, classified: Classified) -> StatusReport {
let env = UserEnv::from_process();
StatusReport {
schema: SCHEMA,
classification: Some(classified.classification),
invalid: classified.invalid,
migration: classified.migration,
legacy_state: legacy_state(&env),
paths: derived_paths(target, &env),
instance: false,
profile: None,
docs_root: None,
docs_scratch: None,
docs_scratch_env: variable(DOCS_SCRATCH_VAR),
canon_version: None,
binary_version: CanonVersion::current(),
alignment: None,
managed_drift: 0,
adopted_drift: 0,
failures: 0,
ok: None,
}
}
pub fn status(target: &Utf8Path) -> Result<StatusReport, AppError> {
let manifest = match verifier::read_manifest(target) {
Ok(manifest) => manifest,
Err(AppError::ManifestMissing(_)) => return Ok(absent(target, classify_target(target)?)),
Err(error) => return Err(error),
};
let classified = classify_target(target)?;
let report = verifier::verify(target)?;
let binary = CanonVersion::current();
let alignment = match manifest.canon_version.cmp(&binary) {
std::cmp::Ordering::Equal => Alignment::Aligned,
std::cmp::Ordering::Less => Alignment::BinaryNewer,
std::cmp::Ordering::Greater => Alignment::InstanceNewer,
};
let env = UserEnv::from_process();
let mut resolved = derived_paths(target, &env);
resolved.active = Some(ActivePaths {
profile: manifest.profile,
destinations: recorded_paths(manifest.docs_root),
docs_scratch: docs_scratch_location(manifest.docs_scratch.as_deref(), &env),
});
Ok(StatusReport {
schema: SCHEMA,
classification: (alignment != Alignment::InstanceNewer)
.then_some(classified.classification),
invalid: classified.invalid,
migration: classified.migration,
legacy_state: legacy_state(&env),
paths: resolved,
instance: true,
profile: Some(manifest.profile),
docs_root: Some(manifest.docs_root),
docs_scratch: manifest.docs_scratch,
docs_scratch_env: variable(DOCS_SCRATCH_VAR),
canon_version: Some(manifest.canon_version),
binary_version: binary,
alignment: Some(alignment),
managed_drift: report.managed_drift,
adopted_drift: report.adopted_drift,
failures: report.failures,
ok: Some(report.failures == 0),
})
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct LegacyState {
pub path: Utf8PathBuf,
pub kind: &'static str,
pub active: bool,
}
const LEGACY_STATE: [(&str, &str); 3] = [
("plans", "plan-store"),
("backups", "transaction-backups"),
("skills.journal", "skill-journal"),
];
const LEGACY_CACHE: (&str, &str) = ("bundles", "bundle-cache");
fn legacy_state(env: &UserEnv) -> Vec<LegacyState> {
let mut found = Vec::new();
if let Some(state) = env.state_root() {
for (name, kind) in LEGACY_STATE {
let path = state.path.join(name);
if path.symlink_metadata().is_ok() {
let active = match kind {
"plan-store" => std::fs::read_dir(path.join("plans"))
.is_ok_and(|mut plans| plans.any(|plan| plan.is_ok())),
"skill-journal" => true,
_ => false,
};
found.push(LegacyState { path, kind, active });
}
}
}
if let Some(cache) = env.cache_root() {
let path = cache.path.join(LEGACY_CACHE.0);
if path.symlink_metadata().is_ok() {
found.push(LegacyState {
path,
kind: LEGACY_CACHE.1,
active: false,
});
}
}
found
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Classified {
pub classification: Classification,
pub invalid: Option<String>,
pub migration: Option<String>,
pub beneath: Classification,
}
pub fn classify_target(target: &Utf8Path) -> Result<Classified, AppError> {
if !target.is_dir() {
return Ok(Classified {
classification: Classification::Setup,
invalid: None,
migration: None,
beneath: Classification::Setup,
});
}
let observation = crate::landing::observe::observe(target)?;
let invalid = match (&observation.invalid, &observation.installation) {
(Some(reason), _) => Some(reason.clone()),
(None, _) => crate::domain::instance_config::InstanceConfig::read(target)
.err()
.map(|error| error.to_string()),
};
let written =
observation.installation.is_none() && invalid.is_none() && observation.corpus.settled();
let verdict = if written {
Some(
crate::services::assess::corpus(target, crate::gates::paths::docs_scratch_variable())?
.verdict(),
)
} else {
None
};
let homed = verdict == Some(crate::services::assess::Classification::Brownfield);
let scattered = verdict == Some(crate::services::assess::Classification::NeedsDecision);
let classification = classify(Signals {
invalid: invalid.is_some(),
installed: observation.installation.is_some(),
at_destination: observation
.installation
.as_ref()
.is_some_and(|installed| installed.canon_version == CanonVersion::current()),
drifted: observation
.installation
.as_ref()
.is_some_and(crate::landing::observe::Installation::drifted),
settled: homed,
scattered,
});
let migration = if invalid.is_none() {
crate::domain::instance_config::InstanceConfig::read(target)
.ok()
.and_then(|declaration| declaration.migration)
} else {
None
};
Ok(Classified {
classification: if migration.is_some() {
Classification::Migration
} else {
classification
},
invalid,
migration,
beneath: classification,
})
}