#![allow(dead_code)]
use std::collections::BTreeMap;
use std::fmt;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::{Arc, Mutex, MutexGuard, OnceLock, RwLock, RwLockReadGuard, RwLockWriteGuard};
use std::time::SystemTime;
use anyhow::{anyhow, Context, Result};
use serde::{Deserialize, Serialize};
use serde_json::json;
fn validate_repo_name(name: &str) -> Result<()> {
let mut parts = name.split('/');
let org = parts.next().unwrap_or("");
let repo = parts.next().unwrap_or("");
if parts.next().is_some() || org.is_empty() || repo.is_empty() {
return Err(anyhow!(
"Invalid repo name {name:?}. Expected 'org/repo' (exactly one slash)."
));
}
let valid = |s: &str| {
!s.is_empty()
&& s.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'))
};
if !valid(org) || !valid(repo) {
return Err(anyhow!(
"Invalid repo name {name:?}. Letters/digits/dots/hyphens/underscores only."
));
}
Ok(())
}
pub type PostActivateHook = Arc<dyn Fn(&Path, &str) -> Result<()> + Send + Sync>;
pub type ActivationSummaryHook = Arc<dyn Fn(&Path, &str) -> Option<String> + Send + Sync>;
pub type PostActivateRevsHook = Arc<dyn Fn(&Path, &str, &[String]) -> Result<()> + Send + Sync>;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ActivationId(u64);
impl ActivationId {
pub fn get(self) -> u64 {
self.0
}
}
impl fmt::Display for ActivationId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ActivationBuild {
Plain,
Revisions(Vec<String>),
Reuse,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ActivationRequest {
id: ActivationId,
path: PathBuf,
name: String,
build: ActivationBuild,
}
impl ActivationRequest {
pub fn id(&self) -> ActivationId {
self.id
}
pub fn path(&self) -> &Path {
&self.path
}
pub fn name(&self) -> &str {
&self.name
}
pub fn build(&self) -> &ActivationBuild {
&self.build
}
}
pub struct PreparedActivation {
commit: Box<dyn FnOnce() -> Result<Option<String>> + Send + 'static>,
}
impl PreparedActivation {
pub fn new<F>(commit: F) -> Self
where
F: FnOnce() -> Result<Option<String>> + Send + 'static,
{
Self {
commit: Box::new(commit),
}
}
pub fn summary(summary: Option<String>) -> Self {
Self::new(move || Ok(summary))
}
fn commit(self) -> Result<Option<String>> {
(self.commit)()
}
}
pub type ActivationTransactionHook =
Arc<dyn Fn(&ActivationRequest) -> Result<PreparedActivation> + Send + Sync>;
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, schemars::JsonSchema)]
#[serde(untagged)]
pub enum RevsRequest {
Count(usize),
List(Vec<String>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct InventoryEntry {
cloned_at: String,
last_accessed: String,
#[serde(default)]
access_count: u64,
#[serde(default)]
stale: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
last_built_sha: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
last_built_revs: Option<RevsRequest>,
}
pub use crate::server::manifest::WorkspaceKind;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RootOwnership {
Unowned,
Adopted,
Operator,
}
#[derive(Clone)]
pub struct Workspace {
inner: Arc<WorkspaceInner>,
}
struct WorkspaceInner {
kind: WorkspaceKind,
workspace_dir: PathBuf,
stale_after_days: u32,
state: RwLock<WorkspaceState>,
inventory: Mutex<()>,
legacy_activation: Mutex<()>,
post_activate: Option<PostActivateHook>,
activation_summary: Option<ActivationSummaryHook>,
post_activate_revs: Option<PostActivateRevsHook>,
activation_transaction: Option<ActivationTransactionHook>,
sandbox_root: Option<PathBuf>,
root_ownership: Mutex<RootOwnership>,
root_swap: RwLock<()>,
deferred_anchor: OnceLock<PathBuf>,
adopt_client_roots: bool,
}
#[derive(Debug, Default)]
struct WorkspaceState {
active_repo_name: Option<String>,
active_repo_path: Option<PathBuf>,
last_activation_id: u64,
latest_requested: Option<ActivationId>,
latest_root_intent: Option<ActivationId>,
active_build: Option<ActiveBuildState>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct ActiveBuildState {
activation_id: ActivationId,
name: String,
path: PathBuf,
head_sha: String,
resolved_revs: Option<Vec<String>>,
}
#[derive(Debug, Clone, Copy)]
enum ActivationIntent<'a> {
Bind(Option<&'a Path>),
Refresh { expected_root: Option<&'a Path> },
}
impl<'a> ActivationIntent<'a> {
fn local_root(self) -> Option<&'a Path> {
match self {
Self::Bind(root) => root,
Self::Refresh { expected_root } => expected_root,
}
}
fn refresh_expectation(self) -> Option<Option<&'a Path>> {
match self {
Self::Bind(_) => None,
Self::Refresh { expected_root } => Some(expected_root),
}
}
}
impl WorkspaceState {
fn current_intent(&self, intent: ActivationIntent<'_>) -> Option<ActivationId> {
match intent {
ActivationIntent::Bind(_) => self.latest_root_intent,
ActivationIntent::Refresh { .. } => self.latest_requested,
}
}
fn binding_is(&self, name: &str, root: Option<&Path>) -> bool {
self.active_repo_name.as_deref() == Some(name) && self.active_repo_path.as_deref() == root
}
fn binding_description(&self) -> String {
match (&self.active_repo_path, &self.active_repo_name) {
(Some(path), _) => path.display().to_string(),
(None, Some(name)) => name.clone(),
(None, None) => "nothing".to_string(),
}
}
}
impl Workspace {
pub fn open(
workspace_dir: PathBuf,
stale_after_days: u32,
post_activate: Option<PostActivateHook>,
) -> Result<Self> {
if !workspace_dir.is_dir() {
fs::create_dir_all(&workspace_dir).with_context(|| {
format!("failed to create workspace dir {}", workspace_dir.display())
})?;
}
let repos_dir = workspace_dir.join("repos");
if !repos_dir.is_dir() {
fs::create_dir_all(&repos_dir)
.with_context(|| format!("failed to create repos dir {}", repos_dir.display()))?;
}
let ws = Self {
inner: Arc::new(WorkspaceInner {
kind: WorkspaceKind::Github,
workspace_dir,
stale_after_days,
state: RwLock::new(WorkspaceState::default()),
inventory: Mutex::new(()),
legacy_activation: Mutex::new(()),
post_activate,
activation_summary: None,
post_activate_revs: None,
activation_transaction: None,
sandbox_root: None,
root_ownership: Mutex::new(RootOwnership::Operator),
root_swap: RwLock::new(()),
deferred_anchor: OnceLock::new(),
adopt_client_roots: false,
}),
};
ws.reconcile_inventory()?;
Ok(ws)
}
pub fn open_local(root: PathBuf, post_activate: Option<PostActivateHook>) -> Result<Self> {
if !root.is_dir() {
anyhow::bail!(
"local workspace root does not exist or is not a directory: {}",
root.display()
);
}
let canon_root = root
.canonicalize()
.with_context(|| format!("failed to canonicalize local root {}", root.display()))?;
let inv_dir = canon_root.join(".mcp-workspace");
if !inv_dir.is_dir() {
fs::create_dir_all(&inv_dir).with_context(|| {
format!("failed to create local-workspace dir {}", inv_dir.display())
})?;
}
let mut state = WorkspaceState::default();
let synthetic_name = synthesize_local_name(&canon_root);
state.active_repo_name = Some(synthetic_name);
state.active_repo_path = Some(canon_root.clone());
Ok(Self {
inner: Arc::new(WorkspaceInner {
kind: WorkspaceKind::Local,
workspace_dir: canon_root,
stale_after_days: u32::MAX, state: RwLock::new(state),
inventory: Mutex::new(()),
legacy_activation: Mutex::new(()),
post_activate,
activation_summary: None,
post_activate_revs: None,
activation_transaction: None,
sandbox_root: None,
root_ownership: Mutex::new(RootOwnership::Operator),
root_swap: RwLock::new(()),
deferred_anchor: OnceLock::new(),
adopt_client_roots: false,
}),
})
}
pub fn open_local_unanchored(post_activate: Option<PostActivateHook>) -> Result<Self> {
Ok(Self {
inner: Arc::new(WorkspaceInner {
kind: WorkspaceKind::Local,
workspace_dir: PathBuf::new(),
stale_after_days: u32::MAX, state: RwLock::new(WorkspaceState::default()),
inventory: Mutex::new(()),
legacy_activation: Mutex::new(()),
post_activate,
activation_summary: None,
post_activate_revs: None,
activation_transaction: None,
sandbox_root: None,
root_ownership: Mutex::new(RootOwnership::Unowned),
root_swap: RwLock::new(()),
deferred_anchor: OnceLock::new(),
adopt_client_roots: false,
}),
})
}
pub fn with_adopt_client_roots(mut self) -> Self {
match Arc::get_mut(&mut self.inner) {
Some(inner) => inner.adopt_client_roots = true,
None => tracing::warn!(
"with_adopt_client_roots called after the workspace was cloned; client roots will not be adopted"
),
}
self
}
pub fn adopts_client_roots(&self) -> bool {
self.inner.adopt_client_roots
}
pub fn root_ownership(&self) -> RootOwnership {
*self.lock_ownership()
}
fn lock_ownership(&self) -> MutexGuard<'_, RootOwnership> {
self.inner
.root_ownership
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn lock_operator_swap(&self) -> RwLockReadGuard<'_, ()> {
self.inner
.root_swap
.read()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn lock_adoption(&self) -> RwLockWriteGuard<'_, ()> {
self.inner
.root_swap
.write()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
pub fn with_sandbox_root(mut self, boundary: &Path) -> Result<Self> {
if !matches!(self.inner.kind, WorkspaceKind::Local) {
anyhow::bail!(
"sandbox_root is only valid for local workspaces (this one is {})",
self.inner.kind.as_str()
);
}
if !boundary.is_dir() {
anyhow::bail!(
"sandbox_root does not exist or is not a directory: {}",
boundary.display()
);
}
let canon = boundary.canonicalize().with_context(|| {
format!("failed to canonicalize sandbox_root {}", boundary.display())
})?;
if let Some(active) = self.active_repo_path() {
if !active.starts_with(&canon) {
anyhow::bail!(
"active root {} is outside sandbox_root {}: the configured root must lie inside the containment boundary",
active.display(),
canon.display()
);
}
}
match Arc::get_mut(&mut self.inner) {
Some(inner) => inner.sandbox_root = Some(canon),
None => anyhow::bail!(
"with_sandbox_root called after the workspace was cloned; \
the containment boundary {} would not be enforced",
canon.display()
),
}
Ok(self)
}
pub fn with_activation_summary(mut self, hook: ActivationSummaryHook) -> Self {
match Arc::get_mut(&mut self.inner) {
Some(inner) => inner.activation_summary = Some(hook),
None => tracing::warn!(
"with_activation_summary called after the workspace was cloned; summary not attached"
),
}
self
}
pub fn with_post_activate_revs(mut self, hook: PostActivateRevsHook) -> Self {
match Arc::get_mut(&mut self.inner) {
Some(inner) => inner.post_activate_revs = Some(hook),
None => tracing::warn!(
"with_post_activate_revs called after the workspace was cloned; revs hook not attached"
),
}
self
}
pub fn with_activation_transaction(mut self, hook: ActivationTransactionHook) -> Self {
match Arc::get_mut(&mut self.inner) {
Some(inner) => inner.activation_transaction = Some(hook),
None => tracing::warn!(
"with_activation_transaction called after the workspace was cloned; transaction not attached"
),
}
self
}
pub fn kind(&self) -> WorkspaceKind {
self.inner.kind
}
pub fn workspace_dir(&self) -> &Path {
match self.inner.deferred_anchor.get() {
Some(anchored) => anchored.as_path(),
None => &self.inner.workspace_dir,
}
}
pub fn repos_dir(&self) -> PathBuf {
self.workspace_dir().join("repos")
}
fn inventory_base(&self) -> Option<&Path> {
let base = self.workspace_dir();
(!base.as_os_str().is_empty()).then_some(base)
}
fn inventory_path(&self) -> Option<PathBuf> {
let base = self.inventory_base()?;
Some(match self.inner.kind {
WorkspaceKind::Github => base.join("inventory.json"),
WorkspaceKind::Local => base.join(".mcp-workspace").join("inventory.json"),
})
}
pub fn active_repo_name(&self) -> Option<String> {
self.inner.state.read().unwrap().active_repo_name.clone()
}
pub fn active_repo_path(&self) -> Option<PathBuf> {
self.inner.state.read().unwrap().active_repo_path.clone()
}
pub fn default_github_repo(&self) -> Option<String> {
match self.inner.kind {
WorkspaceKind::Github => self.active_repo_name(),
WorkspaceKind::Local => self.active_repo_path().and_then(|p| parse_origin_repo(&p)),
}
}
fn load_inventory_unlocked(&self) -> BTreeMap<String, InventoryEntry> {
let Some(path) = self.inventory_path() else {
return BTreeMap::new();
};
let Ok(text) = fs::read_to_string(&path) else {
return BTreeMap::new();
};
serde_json::from_str(&text).unwrap_or_default()
}
fn save_inventory_unlocked(&self, inv: &BTreeMap<String, InventoryEntry>) -> Result<()> {
let Some(path) = self.inventory_path() else {
return Ok(());
};
let body = serde_json::to_string_pretty(inv).context("failed to serialise inventory")?;
fs::write(&path, body).with_context(|| format!("failed to write {}", path.display()))?;
Ok(())
}
fn load_inventory(&self) -> BTreeMap<String, InventoryEntry> {
let _guard = self.inner.inventory.lock().unwrap();
self.load_inventory_unlocked()
}
fn reconcile_inventory(&self) -> Result<()> {
let _guard = self.inner.inventory.lock().unwrap();
let mut inv = self.load_inventory_unlocked();
let mut on_disk: Vec<String> = Vec::new();
if self.repos_dir().is_dir() {
for org_entry in fs::read_dir(self.repos_dir())? {
let Ok(org_entry) = org_entry else { continue };
if !org_entry.path().is_dir() {
continue;
}
let org = org_entry.file_name().to_string_lossy().into_owned();
if org.starts_with('.') {
continue;
}
for repo_entry in fs::read_dir(org_entry.path())? {
let Ok(repo_entry) = repo_entry else { continue };
if !repo_entry.path().is_dir() {
continue;
}
let repo = repo_entry.file_name().to_string_lossy().into_owned();
if repo.starts_with('.') {
continue;
}
let rname = format!("{org}/{repo}");
on_disk.push(rname.clone());
inv.entry(rname).or_insert_with(|| {
let mtime = repo_entry
.metadata()
.ok()
.and_then(|m| m.modified().ok())
.map(format_iso)
.unwrap_or_else(now_iso);
InventoryEntry {
cloned_at: mtime.clone(),
last_accessed: mtime,
access_count: 0,
stale: false,
last_built_sha: None,
last_built_revs: None,
}
});
}
}
}
for (rname, entry) in inv.iter_mut() {
if !on_disk.contains(rname) && !entry.stale {
entry.stale = true;
}
}
self.save_inventory_unlocked(&inv)?;
Ok(())
}
fn bump_access(&self, name: &str, action: &str) {
let _guard = self.inner.inventory.lock().unwrap();
let mut inv = self.load_inventory_unlocked();
let now = now_iso();
let entry = inv
.entry(name.to_string())
.or_insert_with(|| InventoryEntry {
cloned_at: now.clone(),
last_accessed: now.clone(),
access_count: 0,
stale: false,
last_built_sha: None,
last_built_revs: None,
});
entry.last_accessed = now.clone();
entry.access_count += 1;
entry.stale = false;
if action == "cloned" || entry.cloned_at.is_empty() {
entry.cloned_at = now;
}
let _ = self.save_inventory_unlocked(&inv);
}
fn mark_stale(&self, name: &str) {
let _guard = self.inner.inventory.lock().unwrap();
let mut inv = self.load_inventory_unlocked();
if let Some(entry) = inv.get_mut(name) {
entry.stale = true;
let _ = self.save_inventory_unlocked(&inv);
}
}
fn sweep_stale(&self) -> Vec<String> {
if matches!(self.inner.kind, WorkspaceKind::Local) {
return Vec::new();
}
let active = self.active_repo_name();
let _guard = self.inner.inventory.lock().unwrap();
let mut inv = self.load_inventory_unlocked();
let cutoff = SystemTime::now()
- std::time::Duration::from_secs(self.inner.stale_after_days as u64 * 86_400);
let mut swept: Vec<String> = Vec::new();
for (rname, entry) in inv.iter_mut() {
if entry.stale {
continue;
}
if Some(rname.as_str()) == active.as_deref() {
continue;
}
let last = parse_iso(&entry.last_accessed).unwrap_or(SystemTime::UNIX_EPOCH);
if last >= cutoff {
continue;
}
let parts: Vec<&str> = rname.splitn(2, '/').collect();
if parts.len() != 2 {
continue;
}
let repo_path = self.repos_dir().join(parts[0]).join(parts[1]);
if repo_path.exists() {
let _ = fs::remove_dir_all(&repo_path);
}
entry.stale = true;
swept.push(rname.clone());
}
if !swept.is_empty() {
let _ = self.save_inventory_unlocked(&inv);
self.prune_empty_org_dirs();
}
swept
}
fn prune_empty_org_dirs(&self) {
let Ok(entries) = fs::read_dir(self.repos_dir()) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if !path.is_dir() {
continue;
}
if let Ok(children) = fs::read_dir(&path) {
let real: Vec<_> = children
.flatten()
.filter(|c| !c.file_name().to_string_lossy().starts_with('.'))
.collect();
if real.is_empty() {
let _ = fs::remove_dir_all(&path);
}
}
}
}
fn clone_or_update(
&self,
name: &str,
requested_local_root: Option<&Path>,
) -> Result<(String, PathBuf, String)> {
if matches!(self.inner.kind, WorkspaceKind::Local) {
let root = requested_local_root
.map(Path::to_path_buf)
.or_else(|| self.active_repo_path())
.context("internal error: local activation without a root")?;
let prev_sha = self.last_built_sha(name);
let fingerprint = fingerprint_dir(&root);
let action = match prev_sha {
Some(p) if p == fingerprint => "current",
None => "cloned", Some(_) => "updated",
};
return Ok((action.to_string(), root, fingerprint));
}
let parts: Vec<&str> = name.splitn(2, '/').collect();
let repo_path = self.repos_dir().join(parts[0]).join(parts[1]);
if !repo_path.exists() {
fs::create_dir_all(repo_path.parent().unwrap()).ok();
let url = format!("https://github.com/{name}.git");
let out = Command::new("git")
.args([
"clone",
"--filter=tree:0",
"--tags",
&url,
repo_path.to_str().unwrap(),
])
.output()
.context("failed to spawn `git clone`")?;
if !out.status.success() {
anyhow::bail!(
"git clone failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
);
}
let sha = git_rev_parse(&repo_path, "HEAD")?;
return Ok(("cloned".to_string(), repo_path, sha));
}
Command::new("git")
.args(["fetch", "origin", "--tags"])
.current_dir(&repo_path)
.output()
.context("git fetch failed")?;
let local = git_rev_parse(&repo_path, "HEAD")?;
let remote = git_rev_parse(&repo_path, "FETCH_HEAD")?;
if local != remote {
Command::new("git")
.args(["reset", "--hard", "FETCH_HEAD"])
.current_dir(&repo_path)
.output()
.context("git reset failed")?;
let sha = git_rev_parse(&repo_path, "HEAD")?;
return Ok(("updated".to_string(), repo_path, sha));
}
Ok(("current".to_string(), repo_path, local))
}
fn resolve_revs(&self, repo_path: &Path, req: &RevsRequest) -> Result<Vec<String>> {
let resolved = match req {
RevsRequest::Count(n) => {
let out = Command::new("git")
.args(["tag", "--sort=-v:refname"])
.current_dir(repo_path)
.output()
.context("failed to spawn `git tag`")?;
if !out.status.success() {
anyhow::bail!(
"cannot resolve revs: `git tag` failed in {} (is it a git repo?): {}",
repo_path.display(),
String::from_utf8_lossy(&out.stderr).trim()
);
}
let tags: Vec<String> = String::from_utf8_lossy(&out.stdout)
.lines()
.map(|l| l.trim().to_string())
.filter(|l| !l.is_empty())
.collect();
if tags.is_empty() {
anyhow::bail!(
"revs={n} requested but '{}' has no tags to resolve",
repo_path.display()
);
}
let mut chosen = select_family_tags(&tags, *n).unwrap_or_else(|| {
let mut raw: Vec<String> = tags.into_iter().take(*n).collect();
raw.reverse();
raw
});
chosen.push("HEAD".to_string());
chosen
}
RevsRequest::List(revs) => {
if revs.is_empty() {
anyhow::bail!("revs list is empty — pass at least one revision");
}
for r in revs {
let out = Command::new("git")
.args([
"rev-parse",
"--verify",
"--quiet",
&format!("{r}^{{commit}}"),
])
.current_dir(repo_path)
.output()
.context("failed to spawn `git rev-parse`")?;
if !out.status.success() {
anyhow::bail!("revision '{r}' does not exist in '{}'", repo_path.display());
}
}
revs.clone()
}
};
Ok(dedup_labels(resolved))
}
fn activate(
&self,
name: &str,
force_rebuild: bool,
revs: Option<&RevsRequest>,
intent: ActivationIntent<'_>,
) -> Result<String> {
let _legacy_guard = self
.inner
.activation_transaction
.is_none()
.then(|| self.inner.legacy_activation.lock().unwrap());
let activation_id = {
let mut state = self.inner.state.write().unwrap();
if let Some(expected_root) = intent.refresh_expectation() {
if !state.binding_is(name, expected_root) {
let now = state.binding_description();
return Ok(format!(
"Refresh of '{name}' was abandoned before it started: the active root is now {now}. \
Nothing was rebuilt — a refresh never changes which root is active."
));
}
}
state.last_activation_id += 1;
let id = ActivationId(state.last_activation_id);
state.latest_requested = Some(id);
if intent.refresh_expectation().is_none() {
state.latest_root_intent = Some(id);
}
id
};
let prev_built_sha = self.last_built_sha(name);
let prev_built_revs = self.last_built_revs(name);
let (action, repo_path, head_sha) = self
.clone_or_update(name, intent.local_root())
.with_context(|| {
format!("activation request {activation_id} source preparation failed")
})?;
let resolved_revs = match revs {
Some(req) => Some(self.resolve_revs(&repo_path, req).with_context(|| {
format!("activation request {activation_id} revision resolution failed")
})?),
None => None,
};
self.bump_access(name, &action);
let is_active_built = {
let state = self.inner.state.read().unwrap();
state.active_build.as_ref().is_some_and(|built| {
built.name == name && built.path == repo_path && built.resolved_revs.is_none()
})
};
let already_built = !force_rebuild
&& resolved_revs.is_none()
&& prev_built_revs.is_none()
&& action == "current"
&& prev_built_sha.as_deref() == Some(head_sha.as_str())
&& is_active_built;
let uses_transaction = self.inner.activation_transaction.is_some();
let revision_build = !already_built
&& resolved_revs.is_some()
&& (uses_transaction || self.inner.post_activate_revs.is_some());
let build = if already_built {
ActivationBuild::Reuse
} else if revision_build {
ActivationBuild::Revisions(resolved_revs.clone().unwrap_or_default())
} else {
ActivationBuild::Plain
};
let request = ActivationRequest {
id: activation_id,
path: repo_path.clone(),
name: name.to_string(),
build,
};
let prepared = if let Some(hook) = &self.inner.activation_transaction {
hook(&request)
} else {
let hook_result = match request.build() {
ActivationBuild::Reuse => Ok(()),
ActivationBuild::Revisions(resolved) => self
.inner
.post_activate_revs
.as_ref()
.map_or(Ok(()), |hook| hook(&repo_path, name, resolved)),
ActivationBuild::Plain => self
.inner
.post_activate
.as_ref()
.map_or(Ok(()), |hook| hook(&repo_path, name)),
};
hook_result.map(|()| {
let summary = self
.inner
.activation_summary
.as_ref()
.and_then(|hook| hook(&repo_path, name));
PreparedActivation::summary(summary)
})
};
let prepared = match prepared {
Ok(prepared) => prepared,
Err(error) => {
let latest = self.inner.state.read().unwrap().current_intent(intent);
if latest != Some(activation_id) {
return Ok(format!(
"Activation request {activation_id} for '{name}' was superseded by request {} before its failed build could publish.",
latest.map_or_else(|| "unknown".to_string(), |id| id.to_string())
));
}
return Err(anyhow!(
"activation request {activation_id} for '{name}' failed during preparation: {error}"
));
}
};
let summary = {
let mut state = self.inner.state.write().unwrap();
if state.current_intent(intent) != Some(activation_id) {
let superseding = state.current_intent(intent);
drop(state);
drop(prepared);
return Ok(format!(
"Activation request {activation_id} for '{name}' was superseded by request {} before publication; its prepared build was discarded.",
superseding.map_or_else(|| "unknown".to_string(), |id| id.to_string())
));
}
if let Some(expected_root) = intent.refresh_expectation() {
if !state.binding_is(name, expected_root) {
let now = state.binding_description();
drop(state);
drop(prepared);
return Ok(format!(
"Refresh request {activation_id} for '{name}' was abandoned: the active root moved to \
{now} while it rebuilt, and a refresh never changes which root is active. \
Its prepared build was discarded."
));
}
}
let summary = prepared.commit().with_context(|| {
format!("activation request {activation_id} for '{name}' failed during commit")
})?;
self.anchor_inventory(&repo_path, name, &action);
if !matches!(request.build(), ActivationBuild::Reuse) {
let built_revs = revision_build.then_some(revs).flatten();
self.record_built(name, &head_sha, built_revs);
}
state.active_repo_name = Some(name.to_string());
state.active_repo_path = Some(repo_path.clone());
state.active_build = Some(ActiveBuildState {
activation_id,
name: name.to_string(),
path: repo_path.clone(),
head_sha: head_sha.clone(),
resolved_revs: match request.build() {
ActivationBuild::Revisions(resolved) => Some(resolved.clone()),
ActivationBuild::Plain | ActivationBuild::Reuse => None,
},
});
summary
};
let verb = match action.as_str() {
"cloned" => "Cloned",
"updated" => "Updated",
"current" => "Activated (already up to date)",
other => other,
};
let suffix = if already_built {
" [build skipped: HEAD matches last-built SHA]"
} else {
""
};
let mut base = format!("{verb} '{name}' at {}.{suffix}", repo_path.display());
if let ActivationBuild::Revisions(resolved) = request.build() {
base.push_str(&format!("\nrevs: {}", resolved.join(", ")));
}
Ok(match summary {
Some(s) if !s.is_empty() => format!("{base}\n\n{s}"),
_ => base,
})
}
fn anchor_inventory(&self, root: &Path, name: &str, action: &str) {
if !matches!(self.inner.kind, WorkspaceKind::Local) || self.inventory_base().is_some() {
return;
}
let inv_dir = root.join(".mcp-workspace");
if let Err(e) = fs::create_dir_all(&inv_dir) {
tracing::warn!(
"failed to create local-workspace dir {}: {e}",
inv_dir.display()
);
return;
}
let _ = self.inner.deferred_anchor.set(root.to_path_buf());
self.bump_access(name, action);
}
fn record_built(&self, name: &str, sha: &str, revs: Option<&RevsRequest>) {
let _guard = self.inner.inventory.lock().unwrap();
let mut inv = self.load_inventory_unlocked();
if let Some(entry) = inv.get_mut(name) {
entry.last_built_sha = Some(sha.to_string());
entry.last_built_revs = revs.cloned();
let _ = self.save_inventory_unlocked(&inv);
}
}
pub fn last_built_sha(&self, name: &str) -> Option<String> {
self.load_inventory()
.get(name)
.and_then(|e| e.last_built_sha.clone())
}
pub fn last_built_revs(&self, name: &str) -> Option<RevsRequest> {
self.load_inventory()
.get(name)
.and_then(|e| e.last_built_revs.clone())
}
fn delete(&self, name: &str) -> Result<String> {
let parts: Vec<&str> = name.splitn(2, '/').collect();
if parts.len() != 2 {
anyhow::bail!("Invalid repo name");
}
let repo_path = self.repos_dir().join(parts[0]).join(parts[1]);
let mut deleted = Vec::new();
if repo_path.exists() {
fs::remove_dir_all(&repo_path).context("failed to remove repo dir")?;
deleted.push("repo");
}
self.mark_stale(name);
self.prune_empty_org_dirs();
if deleted.is_empty() {
return Ok(format!("Nothing to delete — '{name}' not found."));
}
let mut state = self.inner.state.write().unwrap();
if state.active_repo_name.as_deref() == Some(name) {
state.active_repo_name = None;
state.active_repo_path = None;
state.active_build = None;
return Ok(format!(
"Deleted {}. Active repo cleared.",
deleted.join(", ")
));
}
Ok(format!("Deleted {}.", deleted.join(", ")))
}
fn list(&self) -> String {
let inv = self.load_inventory();
if inv.is_empty() {
return "No repos cloned yet. Call repo_management('org/repo') to clone one."
.to_string();
}
let active = self.active_repo_name();
let mut live: Vec<String> = Vec::new();
let mut stale_lines: Vec<String> = Vec::new();
for (rname, entry) in &inv {
let marker = if Some(rname.as_str()) == active.as_deref() {
" [active]"
} else {
""
};
let access = format!(
"{} access{}, last {}",
entry.access_count,
if entry.access_count == 1 { "" } else { "es" },
relative_time(&entry.last_accessed)
);
if entry.stale {
stale_lines.push(format!(
" {rname} [STALE — re-fetch with repo_management('{rname}')] ({access})"
));
} else {
live.push(format!(" {rname}{marker} ({access})"));
}
}
let mut out = String::new();
if !live.is_empty() {
out.push_str(&format!(
"{} live repo(s):\n{}",
live.len(),
live.join("\n")
));
}
if !stale_lines.is_empty() {
if !out.is_empty() {
out.push_str("\n\n");
}
out.push_str(&format!(
"{} stale repo(s):\n{}",
stale_lines.len(),
stale_lines.join("\n")
));
}
out
}
pub fn repo_management(
&self,
name: Option<&str>,
delete: bool,
update: bool,
force_rebuild: bool,
revs: Option<&RevsRequest>,
) -> String {
if matches!(self.inner.kind, WorkspaceKind::Local) {
if name.is_some() {
return "Local-workspace mode does not accept a repo name. Use `set_root_dir(path)` \
to switch the active root, or pass `update=true` / `force_rebuild=true` \
to rebuild against the current root."
.to_string();
}
if delete {
return "Local-workspace mode does not support `delete`. The root is owned by the \
operator; remove it manually."
.to_string();
}
let (active, active_root) = {
let state = self.inner.state.read().unwrap();
match &state.active_repo_name {
Some(n) => (n.clone(), state.active_repo_path.clone()),
None => return "No active local root.".to_string(),
}
};
let _ = update; let effective = match revs {
Some(r) => Some(r.clone()),
None => self.last_built_revs(&active),
};
return self
.activate(
&active,
force_rebuild,
effective.as_ref(),
ActivationIntent::Refresh {
expected_root: active_root.as_deref(),
},
)
.unwrap_or_else(|e| format!("rebuild failed: {e}"));
}
let swept = self.sweep_stale();
let prefix = if swept.is_empty() {
String::new()
} else {
format!(
"[Swept {} idle repo(s) (>{}d): {}]\n\n",
swept.len(),
self.inner.stale_after_days,
swept.join(", ")
)
};
if name.is_none() && !update {
return prefix + &self.list();
}
if update {
let (active, active_root) = {
let state = self.inner.state.read().unwrap();
match &state.active_repo_name {
Some(n) => (n.clone(), state.active_repo_path.clone()),
None => {
return prefix
+ "No active repository. Call repo_management('org/repo') first."
}
}
};
let effective = match revs {
Some(r) => Some(r.clone()),
None => self.last_built_revs(&active),
};
return prefix
+ &self
.activate(
&active,
force_rebuild,
effective.as_ref(),
ActivationIntent::Refresh {
expected_root: active_root.as_deref(),
},
)
.unwrap_or_else(|e| format!("update failed: {e}"));
}
let Some(name) = name else {
return prefix + "Provide a repo name (e.g. repo_management('org/repo')).";
};
if let Err(e) = validate_repo_name(name) {
return prefix + &e.to_string();
}
if delete {
return prefix
+ &self
.delete(name)
.unwrap_or_else(|e| format!("delete failed: {e}"));
}
prefix
+ &self
.activate(name, force_rebuild, revs, ActivationIntent::Bind(None))
.unwrap_or_else(|e| format!("activate failed: {e}"))
}
pub fn set_root_dir(&self, new_root: &Path, revs: Option<&RevsRequest>) -> String {
let _swap = self.lock_operator_swap();
match self.swap_root(new_root, revs, "set_root_dir") {
Ok(msg) => {
*self.lock_ownership() = RootOwnership::Operator;
msg
}
Err(msg) => msg,
}
}
pub fn adopt_client_root(&self, new_root: &Path) -> Result<String, String> {
let _swap = self.lock_adoption();
if *self.lock_ownership() == RootOwnership::Operator {
return Err(
"the active root was chosen by the operator; client roots are fallback-only"
.to_string(),
);
}
let msg = self.swap_root(new_root, None, "adopt_client_root")?;
*self.lock_ownership() = RootOwnership::Adopted;
Ok(msg)
}
fn swap_root(
&self,
new_root: &Path,
revs: Option<&RevsRequest>,
who: &str,
) -> Result<String, String> {
if !matches!(self.inner.kind, WorkspaceKind::Local) {
return Err(format!("{who} is only valid in local-workspace mode."));
}
if !new_root.is_dir() {
return Err(format!(
"Path does not exist or is not a directory: {}",
new_root.display()
));
}
let canon = match new_root.canonicalize() {
Ok(p) => p,
Err(e) => return Err(format!("canonicalize failed: {e}")),
};
if let Some(sandbox) = self.inner.sandbox_root.as_ref() {
if !canon.starts_with(sandbox) {
return Err(format!(
"{who}: {} escapes workspace.sandbox_root ({}). \
The active root is unchanged.",
canon.display(),
sandbox.display()
));
}
}
let synthetic = synthesize_local_name(&canon);
self.activate(
&synthetic,
false,
revs,
ActivationIntent::Bind(Some(&canon)),
)
.map_err(|e| format!("{who} failed: {e}"))
}
}
fn dedup_labels(revs: Vec<String>) -> Vec<String> {
let mut seen = std::collections::HashSet::new();
revs.into_iter()
.filter(|r| seen.insert(r.clone()))
.collect()
}
const PRERELEASE_MARKERS: &[&str] = &["rc", "alpha", "beta", "dev", "pre", "preview"];
#[derive(Debug, Clone, PartialEq, Eq)]
struct ClassifiedTag {
raw: String,
prefix: String,
version: Vec<u64>,
is_prerelease: bool,
}
fn classify_tag(tag: &str) -> Option<ClassifiedTag> {
let bytes = tag.as_bytes();
for i in 0..bytes.len() {
if !bytes[i].is_ascii_digit() {
continue;
}
if i > 0 && bytes[i - 1].is_ascii_digit() {
continue;
}
if let Some((version, is_prerelease)) = parse_version_at(&tag[i..]) {
return Some(ClassifiedTag {
raw: tag.to_string(),
prefix: tag[..i].to_string(),
version,
is_prerelease,
});
}
}
None
}
fn parse_version_at(s: &str) -> Option<(Vec<u64>, bool)> {
let bytes = s.as_bytes();
let mut nums: Vec<u64> = Vec::new();
let mut idx = 0usize;
loop {
let start = idx;
while idx < bytes.len() && bytes[idx].is_ascii_digit() {
idx += 1;
}
if idx == start {
return None; }
nums.push(s[start..idx].parse().ok()?);
if idx + 1 < bytes.len() && bytes[idx] == b'.' && bytes[idx + 1].is_ascii_digit() {
idx += 1;
continue;
}
break;
}
let rest = &s[idx..];
if rest.is_empty() {
return Some((nums, false));
}
let after_sep = rest
.strip_prefix(|c| c == '-' || c == '.' || c == '_')
.unwrap_or(rest);
let lower = after_sep.to_ascii_lowercase();
if PRERELEASE_MARKERS.iter().any(|m| lower.starts_with(m)) {
Some((nums, true))
} else {
None
}
}
fn select_family_tags(tags: &[String], n: usize) -> Option<Vec<String>> {
let classified: Vec<ClassifiedTag> = tags.iter().filter_map(|t| classify_tag(t)).collect();
if classified.is_empty() {
return None;
}
let mut families: BTreeMap<String, Vec<&ClassifiedTag>> = BTreeMap::new();
for c in &classified {
families.entry(c.prefix.clone()).or_default().push(c);
}
let stable_count = |v: &Vec<&ClassifiedTag>| v.iter().filter(|c| !c.is_prerelease).count();
let any_stable = families.values().any(|v| stable_count(v) > 0);
let chosen = families.values().max_by(|a, b| {
if any_stable {
stable_count(a).cmp(&stable_count(b))
} else {
a.len().cmp(&b.len())
}
})?;
let mut pool: Vec<&ClassifiedTag> = if any_stable {
chosen
.iter()
.copied()
.filter(|c| !c.is_prerelease)
.collect()
} else {
chosen.to_vec()
};
pool.sort_by(|a, b| b.version.cmp(&a.version).then_with(|| b.raw.cmp(&a.raw)));
let mut newest: Vec<String> = pool.into_iter().take(n).map(|c| c.raw.clone()).collect();
newest.reverse(); Some(newest)
}
fn synthesize_local_name(root: &Path) -> String {
let name = root
.file_name()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| "local".to_string());
format!("local/{name}")
}
fn parse_origin_repo(root: &Path) -> Option<String> {
let out = Command::new("git")
.arg("-C")
.arg(root)
.args(["remote", "get-url", "origin"])
.output()
.ok()?;
if !out.status.success() {
return None;
}
let url = String::from_utf8(out.stdout).ok()?;
parse_github_remote(url.trim())
}
fn parse_github_remote(url: &str) -> Option<String> {
let path = url
.strip_prefix("git@github.com:")
.or_else(|| url.strip_prefix("https://github.com/"))
.or_else(|| url.strip_prefix("http://github.com/"))
.or_else(|| url.strip_prefix("ssh://git@github.com/"))?;
let path = path.strip_suffix(".git").unwrap_or(path);
let path = path.trim_end_matches('/');
let mut parts = path.split('/');
let org = parts.next().filter(|s| !s.is_empty())?;
let repo = parts.next().filter(|s| !s.is_empty())?;
if parts.next().is_some() {
return None;
}
Some(format!("{org}/{repo}"))
}
fn fingerprint_dir(root: &Path) -> String {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
let walker = ignore::WalkBuilder::new(root)
.standard_filters(true)
.hidden(true)
.git_ignore(true)
.build();
for entry in walker.flatten() {
if !entry.path().is_file() {
continue;
}
let Ok(meta) = entry.metadata() else { continue };
let mtime = meta
.modified()
.ok()
.and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
.map(|d| d.as_secs())
.unwrap_or(0);
entry.path().to_string_lossy().hash(&mut hasher);
mtime.hash(&mut hasher);
meta.len().hash(&mut hasher);
}
format!("local-{:016x}", hasher.finish())
}
fn git_rev_parse(repo_path: &Path, refspec: &str) -> Result<String> {
let out = Command::new("git")
.args(["rev-parse", refspec])
.current_dir(repo_path)
.output()
.context("git rev-parse failed")?;
Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
}
fn now_iso() -> String {
format_iso(SystemTime::now())
}
fn format_iso(t: SystemTime) -> String {
let secs = t
.duration_since(SystemTime::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
chrono_lite::format_secs(secs)
}
fn parse_iso(s: &str) -> Option<SystemTime> {
let secs = chrono_lite::parse_secs(s)?;
SystemTime::UNIX_EPOCH.checked_add(std::time::Duration::from_secs(secs))
}
fn relative_time(iso: &str) -> String {
let Some(t) = parse_iso(iso) else {
return "unknown".to_string();
};
let now = SystemTime::now();
let delta = now.duration_since(t).unwrap_or_default().as_secs();
if delta < 3600 {
"just now".to_string()
} else if delta < 86_400 {
format!("{}h ago", delta / 3600)
} else {
format!("{}d ago", delta / 86_400)
}
}
mod chrono_lite {
pub fn format_secs(secs: u64) -> String {
let days = (secs / 86_400) as i64;
let time = secs % 86_400;
let (y, mo, d) = days_to_civil(days + 719_468);
let h = time / 3600;
let m = (time / 60) % 60;
let s = time % 60;
format!("{y:04}-{mo:02}-{d:02}T{h:02}:{m:02}:{s:02}")
}
pub fn parse_secs(s: &str) -> Option<u64> {
let bytes = s.as_bytes();
if bytes.len() < 19 {
return None;
}
let y: i64 = s.get(0..4)?.parse().ok()?;
let mo: u32 = s.get(5..7)?.parse().ok()?;
let d: u32 = s.get(8..10)?.parse().ok()?;
let h: u64 = s.get(11..13)?.parse().ok()?;
let m: u64 = s.get(14..16)?.parse().ok()?;
let sc: u64 = s.get(17..19)?.parse().ok()?;
let days = civil_to_days(y, mo, d) - 719_468;
Some((days * 86_400) as u64 + h * 3600 + m * 60 + sc)
}
fn days_to_civil(z: i64) -> (i64, u32, u32) {
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
let doe = (z - era * 146_097) as u64;
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
let y = (yoe as i64) + era * 400;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
let m = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32;
let y = if m <= 2 { y + 1 } else { y };
(y, m, d)
}
fn civil_to_days(y: i64, m: u32, d: u32) -> i64 {
let y = if m <= 2 { y - 1 } else { y };
let era = if y >= 0 { y } else { y - 399 } / 400;
let yoe = (y - era * 400) as u64;
let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) as u64 + 2) / 5 + d as u64 - 1;
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
era * 146_097 + doe as i64
}
}
#[allow(dead_code)]
fn _json_keepalive() {
let _ = json!({});
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn validates_repo_names() {
assert!(validate_repo_name("pydata/xarray").is_ok());
assert!(validate_repo_name("my-org.x/repo_v2").is_ok());
assert!(validate_repo_name("xarray").is_err());
assert!(validate_repo_name("a/b/c").is_err());
assert!(validate_repo_name("foo/bar; rm -rf").is_err());
}
#[test]
fn open_creates_layout() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
assert!(ws.repos_dir().is_dir());
}
#[test]
fn empty_list() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let out = ws.repo_management(None, false, false, false, None);
assert!(out.contains("No repos cloned yet"));
}
#[test]
fn invalid_repo_name_rejected() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let out = ws.repo_management(Some("bad name with spaces"), false, false, false, None);
assert!(out.contains("Invalid repo name"));
}
#[test]
fn delete_unknown() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let out = ws.repo_management(Some("nope/none"), true, false, false, None);
assert!(out.contains("Nothing to delete"));
}
#[test]
fn iso_round_trip() {
let now = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs();
let s = chrono_lite::format_secs(now);
let back = chrono_lite::parse_secs(&s).unwrap();
assert_eq!(now, back);
}
#[test]
fn last_built_sha_round_trip() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
ws.bump_access("acme/widgets", "cloned");
assert_eq!(ws.last_built_sha("acme/widgets"), None);
ws.record_built("acme/widgets", "abc1234deadbeef", None);
assert_eq!(
ws.last_built_sha("acme/widgets").as_deref(),
Some("abc1234deadbeef")
);
let ws2 = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
assert_eq!(
ws2.last_built_sha("acme/widgets").as_deref(),
Some("abc1234deadbeef")
);
}
#[test]
fn inventory_loads_legacy_entries_without_sha_field() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let legacy = r#"{
"old/repo": {
"cloned_at": "2024-01-01T00:00:00",
"last_accessed": "2024-01-01T00:00:00",
"access_count": 5,
"stale": false
}
}"#;
std::fs::write(dir.path().join("inventory.json"), legacy).unwrap();
let ws2 = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
assert_eq!(ws2.last_built_sha("old/repo"), None);
let _ = ws;
}
#[test]
fn auto_rebuild_gate_skips_when_sha_matches() {
use std::sync::atomic::{AtomicUsize, Ordering};
let dir = tempfile::tempdir().unwrap();
let calls = Arc::new(AtomicUsize::new(0));
let calls_h = calls.clone();
let hook: PostActivateHook = Arc::new(move |_path, _name| {
calls_h.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let ws = Workspace::open(dir.path().to_path_buf(), 7, Some(hook)).unwrap();
ws.bump_access("acme/widgets", "cloned");
ws.record_built("acme/widgets", "sha_one", None);
assert_eq!(
ws.last_built_sha("acme/widgets").as_deref(),
Some("sha_one")
);
ws.record_built("acme/widgets", "sha_one", None);
assert_eq!(
ws.last_built_sha("acme/widgets").as_deref(),
Some("sha_one")
);
assert_eq!(calls.load(Ordering::SeqCst), 0);
}
#[test]
fn local_workspace_binds_root_immediately() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open_local(dir.path().to_path_buf(), None).unwrap();
assert_eq!(ws.kind(), WorkspaceKind::Local);
assert!(ws.active_repo_path().is_some());
assert!(ws.active_repo_name().unwrap().starts_with("local/"));
}
#[test]
fn local_workspace_rejects_github_ops() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open_local(dir.path().to_path_buf(), None).unwrap();
let out = ws.repo_management(Some("acme/widgets"), false, false, false, None);
assert!(out.contains("does not accept a repo name"));
let out = ws.repo_management(None, true, false, false, None);
assert!(out.contains("does not support `delete`"));
}
#[test]
fn local_workspace_update_rebuilds() {
use std::sync::atomic::{AtomicUsize, Ordering};
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("x.txt"), b"hi").unwrap();
let calls = Arc::new(AtomicUsize::new(0));
let calls_h = calls.clone();
let hook: PostActivateHook = Arc::new(move |_p, _n| {
calls_h.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let ws = Workspace::open_local(dir.path().to_path_buf(), Some(hook)).unwrap();
let _ = ws.repo_management(None, false, true, false, None);
assert_eq!(calls.load(Ordering::SeqCst), 1);
let out = ws.repo_management(None, false, true, false, None);
assert_eq!(
calls.load(Ordering::SeqCst),
1,
"auto-rebuild gate must skip"
);
assert!(out.contains("build skipped"));
}
#[test]
fn parses_github_remote_forms() {
assert_eq!(
parse_github_remote("git@github.com:kkollsga/kglite.git").as_deref(),
Some("kkollsga/kglite")
);
assert_eq!(
parse_github_remote("https://github.com/kkollsga/kglite.git").as_deref(),
Some("kkollsga/kglite")
);
assert_eq!(
parse_github_remote("https://github.com/acme/widget/").as_deref(),
Some("acme/widget")
);
assert_eq!(
parse_github_remote("ssh://git@github.com/acme/widget.git").as_deref(),
Some("acme/widget")
);
assert_eq!(
parse_github_remote("https://gitlab.com/acme/widget.git"),
None
);
assert_eq!(parse_github_remote("git@github.com:acme.git"), None);
assert_eq!(parse_github_remote("not a url"), None);
}
#[test]
fn local_default_github_repo_uses_origin_remote() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
let git = |args: &[&str]| {
Command::new("git")
.arg("-C")
.arg(root)
.args(args)
.output()
.unwrap()
};
if !git(&["init"]).status.success() {
return;
}
git(&[
"remote",
"add",
"origin",
"https://github.com/acme/widget.git",
]);
let ws = Workspace::open_local(root.to_path_buf(), None).unwrap();
assert_eq!(
ws.default_github_repo().as_deref(),
Some("acme/widget"),
"local default repo must come from the origin remote, not the inventory key"
);
assert!(ws.active_repo_name().unwrap().starts_with("local/"));
}
#[test]
fn local_default_github_repo_none_without_remote() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open_local(dir.path().to_path_buf(), None).unwrap();
let def = ws.default_github_repo();
assert!(
def.is_none(),
"expected None for a non-git local root, got {def:?}"
);
}
#[test]
fn set_root_dir_only_in_local_mode() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let out = ws.set_root_dir(dir.path(), None);
assert!(out.contains("only valid in local-workspace"));
}
#[test]
fn update_with_no_active_repo() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let out = ws.repo_management(None, false, true, false, None);
assert!(out.contains("No active repository"));
}
#[test]
fn set_root_dir_updates_active_path() {
let dir = tempfile::tempdir().unwrap();
let child = dir.path().join("child");
std::fs::create_dir_all(&child).unwrap();
let ws = Workspace::open_local(dir.path().to_path_buf(), None).unwrap();
let _ = ws.set_root_dir(&child, None);
assert_eq!(
ws.active_repo_path().unwrap(),
child.canonicalize().unwrap(),
"set_root_dir didn't update active_repo_path"
);
}
#[test]
fn set_root_dir_post_activate_fires_against_new_root() {
let dir = tempfile::tempdir().unwrap();
let child = dir.path().join("child");
std::fs::create_dir_all(&child).unwrap();
std::fs::write(child.join("a.txt"), b"hi").unwrap();
let seen_path: Arc<std::sync::Mutex<Option<PathBuf>>> = Arc::new(Default::default());
let seen = seen_path.clone();
let hook: PostActivateHook = Arc::new(move |p, _n| {
*seen.lock().unwrap() = Some(p.to_path_buf());
Ok(())
});
let ws = Workspace::open_local(dir.path().to_path_buf(), Some(hook)).unwrap();
let _ = ws.set_root_dir(&child, None);
assert_eq!(
seen_path.lock().unwrap().clone().unwrap(),
child.canonicalize().unwrap(),
"post_activate hook saw the wrong root after set_root_dir"
);
}
fn sandbox_layout() -> (tempfile::TempDir, PathBuf, PathBuf, PathBuf) {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let sandbox = base.join("sandbox");
let inside = sandbox.join("child");
let outside = base.join("outside");
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
(td, sandbox, inside, outside)
}
#[test]
fn set_root_dir_outside_sandbox_root_rejected_and_active_root_unchanged() {
let (_td, sandbox, _inside, outside) = sandbox_layout();
let ws = Workspace::open_local(sandbox.clone(), None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
let before = ws.active_repo_path().unwrap();
assert_eq!(before, sandbox);
let out = ws.set_root_dir(&outside, None);
assert!(
out.contains("sandbox_root") && out.contains(&sandbox.display().to_string()),
"rejection must name the boundary it violated, got: {out}"
);
assert_eq!(
ws.active_repo_path().unwrap(),
before,
"a rejected swap must leave the active root untouched"
);
}
#[test]
fn set_root_dir_inside_sandbox_root_activates() {
let (_td, sandbox, inside, _outside) = sandbox_layout();
let ws = Workspace::open_local(sandbox.clone(), None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
let out = ws.set_root_dir(&inside, None);
assert_eq!(
ws.active_repo_path().unwrap(),
inside,
"a target inside the boundary must activate; set_root_dir said: {out}"
);
}
#[test]
fn set_root_dir_dotdot_traversal_out_of_sandbox_rejected() {
let (_td, sandbox, inside, outside) = sandbox_layout();
let ws = Workspace::open_local(sandbox.clone(), None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
let traversal = inside.join("..").join("..").join("outside");
assert!(
traversal.starts_with(&sandbox),
"test is meaningless unless the raw path looks contained"
);
let out = ws.set_root_dir(&traversal, None);
assert!(
out.contains("sandbox_root"),
"`..` escape must be rejected, got: {out}"
);
assert_eq!(ws.active_repo_path().unwrap(), sandbox);
assert_ne!(ws.active_repo_path().unwrap(), outside);
}
#[cfg(unix)]
#[test]
fn set_root_dir_symlink_out_of_sandbox_rejected() {
let (_td, sandbox, _inside, outside) = sandbox_layout();
let link = sandbox.join("escape-hatch");
std::os::unix::fs::symlink(&outside, &link).unwrap();
let ws = Workspace::open_local(sandbox.clone(), None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
assert!(
link.starts_with(&sandbox),
"test is meaningless unless the raw path looks contained"
);
let out = ws.set_root_dir(&link, None);
assert!(
out.contains("sandbox_root"),
"symlink escape must be rejected, got: {out}"
);
assert_eq!(ws.active_repo_path().unwrap(), sandbox);
}
#[test]
fn no_sandbox_root_configured_keeps_swaps_unbounded() {
let (_td, sandbox, _inside, outside) = sandbox_layout();
let ws = Workspace::open_local(sandbox, None).unwrap();
let out = ws.set_root_dir(&outside, None);
assert_eq!(
ws.active_repo_path().unwrap(),
outside,
"unbounded default broken; set_root_dir said: {out}"
);
}
#[test]
fn with_sandbox_root_rejects_active_root_outside_the_boundary() {
let (_td, sandbox, _inside, outside) = sandbox_layout();
let err = Workspace::open_local(outside.clone(), None)
.unwrap()
.with_sandbox_root(&sandbox)
.map(|_| ())
.expect_err("root outside the boundary must not boot");
let msg = err.to_string();
assert!(
msg.contains(&sandbox.display().to_string())
&& msg.contains(&outside.display().to_string()),
"boot error must name both the root and the boundary, got: {msg}"
);
}
#[test]
fn with_sandbox_root_accepts_root_equal_to_the_boundary() {
let (_td, sandbox, inside, _outside) = sandbox_layout();
assert!(Workspace::open_local(sandbox.clone(), None)
.unwrap()
.with_sandbox_root(&sandbox)
.is_ok());
assert!(Workspace::open_local(inside, None)
.unwrap()
.with_sandbox_root(&sandbox)
.is_ok());
}
#[test]
fn with_sandbox_root_rejects_github_workspaces_and_missing_dirs() {
let (_td, sandbox, _inside, _outside) = sandbox_layout();
let gh = Workspace::open(sandbox.join("gh"), 7, None).unwrap();
assert!(
gh.with_sandbox_root(&sandbox)
.map(|_| ())
.unwrap_err()
.to_string()
.contains("only valid for local"),
"sandbox_root on a github workspace must be a loud error"
);
let missing = sandbox.join("nope");
assert!(Workspace::open_local(sandbox, None)
.unwrap()
.with_sandbox_root(&missing)
.is_err());
}
#[test]
fn unanchored_boot_binds_nothing_and_creates_nothing() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let ws = Workspace::open_local_unanchored(None).unwrap();
assert!(ws.active_repo_path().is_none());
assert!(ws.active_repo_name().is_none());
assert_eq!(ws.root_ownership(), RootOwnership::Unowned);
assert!(!ws.adopts_client_roots(), "the knob is opt-in");
assert!(
!base.join(".mcp-workspace").exists(),
"an unanchored boot must not create an inventory dir anywhere"
);
}
#[test]
fn open_local_is_operator_owned_from_the_start() {
let td = tempfile::tempdir().unwrap();
let ws = Workspace::open_local(td.path().to_path_buf(), None).unwrap();
assert_eq!(
ws.root_ownership(),
RootOwnership::Operator,
"a configured root is the operator's, which is what makes adoption fallback-only"
);
}
#[test]
fn adopt_client_root_activates_and_defers_the_inventory_dir() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let project = base.join("project");
std::fs::create_dir_all(&project).unwrap();
let ws = Workspace::open_local_unanchored(None).unwrap();
ws.adopt_client_root(&project).unwrap();
assert_eq!(ws.active_repo_path().as_deref(), Some(project.as_path()));
assert_eq!(ws.root_ownership(), RootOwnership::Adopted);
assert!(
project.join(".mcp-workspace").is_dir(),
"the first activation must create the deferred inventory dir"
);
assert_eq!(ws.workspace_dir(), project.as_path());
}
#[test]
fn the_inventory_home_is_fixed_at_the_first_adoption() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let first = base.join("first");
let second = base.join("second");
std::fs::create_dir_all(&first).unwrap();
std::fs::create_dir_all(&second).unwrap();
let ws = Workspace::open_local_unanchored(None).unwrap();
ws.adopt_client_root(&first).unwrap();
ws.set_root_dir(&second, None);
assert_eq!(ws.active_repo_path().as_deref(), Some(second.as_path()));
assert_eq!(
ws.workspace_dir(),
first.as_path(),
"the inventory must survive later root swaps, exactly as it does after open_local"
);
assert!(!second.join(".mcp-workspace").exists());
}
#[test]
fn adoption_is_refused_once_the_operator_owns_the_root() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let configured = base.join("configured");
let advertised = base.join("advertised");
std::fs::create_dir_all(&configured).unwrap();
std::fs::create_dir_all(&advertised).unwrap();
let ws = Workspace::open_local(configured.clone(), None).unwrap();
let err = ws.adopt_client_root(&advertised).unwrap_err();
assert!(err.contains("operator"), "unexpected reason: {err}");
assert_eq!(
ws.active_repo_path().as_deref(),
Some(configured.as_path()),
"a refused adoption must not touch the active root"
);
}
#[test]
fn set_root_dir_claims_ownership_permanently() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let adopted = base.join("adopted");
let operator = base.join("operator");
let later = base.join("later");
for d in [&adopted, &operator, &later] {
std::fs::create_dir_all(d).unwrap();
}
let ws = Workspace::open_local_unanchored(None).unwrap();
ws.adopt_client_root(&adopted).unwrap();
assert_eq!(ws.root_ownership(), RootOwnership::Adopted);
ws.set_root_dir(&operator, None);
assert_eq!(ws.root_ownership(), RootOwnership::Operator);
assert!(ws.adopt_client_root(&later).is_err());
assert_eq!(ws.active_repo_path().as_deref(), Some(operator.as_path()));
}
#[test]
fn a_failed_set_root_dir_does_not_claim_ownership() {
let (_td, sandbox, inside, outside) = sandbox_layout();
let ws = Workspace::open_local_unanchored(None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
let msg = ws.set_root_dir(&outside, None);
assert!(msg.contains("sandbox_root"), "unexpected message: {msg}");
assert_eq!(
ws.root_ownership(),
RootOwnership::Unowned,
"a rejected swap must not lock out adoption"
);
ws.adopt_client_root(&inside).unwrap();
assert_eq!(ws.root_ownership(), RootOwnership::Adopted);
}
#[test]
fn adoption_goes_through_the_same_containment_check_as_set_root_dir() {
let (_td, sandbox, inside, outside) = sandbox_layout();
let ws = Workspace::open_local_unanchored(None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
let err = ws.adopt_client_root(&outside).unwrap_err();
assert!(
err.contains("sandbox_root") && err.contains(&sandbox.display().to_string()),
"the rejection must name the boundary it violated: {err}"
);
assert!(
ws.active_repo_path().is_none(),
"a rejected adoption must leave the server unanchored"
);
assert_eq!(ws.root_ownership(), RootOwnership::Unowned);
ws.adopt_client_root(&inside).unwrap();
assert_eq!(ws.active_repo_path().as_deref(), Some(inside.as_path()));
}
#[test]
fn adoption_rejects_a_dotdot_escape_from_the_sandbox() {
let (_td, sandbox, inside, outside) = sandbox_layout();
let ws = Workspace::open_local_unanchored(None)
.unwrap()
.with_sandbox_root(&sandbox)
.unwrap();
let traversal = inside.join("..").join("..").join("outside");
assert!(ws.adopt_client_root(&traversal).is_err());
assert!(ws.active_repo_path().is_none());
let _ = outside;
}
#[test]
fn unanchored_refresh_before_adoption_is_a_clean_error() {
let ws = Workspace::open_local_unanchored(None).unwrap();
let out = ws.repo_management(None, false, true, false, None);
assert_eq!(out, "No active local root.", "unexpected output: {out}");
assert!(ws.active_repo_path().is_none());
}
#[test]
fn a_failed_first_adoption_writes_nothing_into_the_clients_root() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let rejected = base.join("rejected");
let good = base.join("good");
std::fs::create_dir_all(&rejected).unwrap();
std::fs::create_dir_all(&good).unwrap();
let hook: PostActivateHook = {
let rejected = rejected.clone();
Arc::new(move |path, _name| {
if path == rejected {
anyhow::bail!("builder refused this root");
}
Ok(())
})
};
let ws = Workspace::open_local_unanchored(Some(hook)).unwrap();
assert!(
ws.adopt_client_root(&rejected).is_err(),
"the hook refused, so the adoption must fail"
);
assert!(
!rejected.join(".mcp-workspace").exists(),
"a failed adoption must not create a directory inside the client's root"
);
assert!(ws.active_repo_path().is_none(), "nothing activated");
assert_eq!(
ws.workspace_dir(),
Path::new(""),
"a failed attempt must not fix the inventory anchor"
);
ws.adopt_client_root(&good).unwrap();
assert_eq!(ws.workspace_dir(), good.as_path());
assert!(good.join(".mcp-workspace").is_dir());
assert!(
good.join(".mcp-workspace").join("inventory.json").is_file(),
"the anchoring activation must still write its inventory receipt"
);
assert!(!rejected.join(".mcp-workspace").exists());
}
#[test]
fn a_non_local_swap_names_the_caller_that_attempted_it() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
let err = ws
.swap_root(dir.path(), None, "adopt_client_root")
.unwrap_err();
assert_eq!(
err, "adopt_client_root is only valid in local-workspace mode.",
"the message must name the caller: {err}"
);
}
#[derive(Default)]
struct Gate {
open: Mutex<bool>,
cv: std::sync::Condvar,
}
impl Gate {
fn open(&self) {
*self.open.lock().unwrap() = true;
self.cv.notify_all();
}
fn wait(&self) {
let mut open = self.open.lock().unwrap();
while !*open {
open = self.cv.wait(open).unwrap();
}
}
fn wait_until(&self, limit: std::time::Duration) {
let open = self.open.lock().unwrap();
let _ = self
.cv
.wait_timeout_while(open, limit, |open| !*open)
.unwrap();
}
}
#[test]
fn an_adoption_cannot_displace_a_concurrent_operator_swap() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let client_root = base.join("client");
let operator_root = base.join("operator");
std::fs::create_dir_all(&client_root).unwrap();
std::fs::create_dir_all(&operator_root).unwrap();
let operator_in_hook = Arc::new(Gate::default());
let adoption_in_hook = Arc::new(Gate::default());
let hook: ActivationTransactionHook = {
let client_root = client_root.clone();
let operator_in_hook = operator_in_hook.clone();
let adoption_in_hook = adoption_in_hook.clone();
Arc::new(move |request| {
if request.path() == client_root {
adoption_in_hook.open();
} else {
operator_in_hook.open();
adoption_in_hook.wait_until(std::time::Duration::from_millis(250));
}
Ok(PreparedActivation::summary(None))
})
};
let ws = Workspace::open_local_unanchored(None)
.unwrap()
.with_activation_transaction(hook);
let operator = {
let ws = ws.clone();
let target = operator_root.clone();
std::thread::spawn(move || ws.set_root_dir(&target, None))
};
operator_in_hook.wait();
let adoption = {
let ws = ws.clone();
let target = client_root.clone();
std::thread::spawn(move || ws.adopt_client_root(&target))
};
let operator_out = operator.join().unwrap();
let adoption_out = adoption.join().unwrap();
assert_eq!(
ws.active_repo_path().as_deref(),
Some(operator_root.as_path()),
"a client root displaced the operator's swap \
(operator said: {operator_out}; adoption said: {adoption_out:?})"
);
assert_eq!(
ws.root_ownership(),
RootOwnership::Operator,
"the surviving root must also be flagged as the operator's"
);
assert!(
adoption_out.is_err(),
"the adoption ran second and must have been refused: {adoption_out:?}"
);
}
#[allow(clippy::type_complexity)]
fn adopted_workspace_with_gated_builds(
base: &Path,
) -> (
Workspace,
PathBuf,
PathBuf,
(Arc<Gate>, Arc<Gate>),
(Arc<Gate>, Arc<Gate>),
) {
let client_root = base.join("client");
let operator_root = base.join("operator");
std::fs::create_dir_all(&client_root).unwrap();
std::fs::create_dir_all(&operator_root).unwrap();
let operator_gates = (Arc::new(Gate::default()), Arc::new(Gate::default()));
let refresh_gates = (Arc::new(Gate::default()), Arc::new(Gate::default()));
let hook: ActivationTransactionHook = {
let operator_root = operator_root.clone();
let (operator_in_hook, release_operator) = operator_gates.clone();
let (refresh_in_hook, release_refresh) = refresh_gates.clone();
let adopted = Arc::new(Mutex::new(false));
Arc::new(move |request| {
if request.path() == operator_root {
operator_in_hook.open();
release_operator.wait();
} else {
let mut adopted = adopted.lock().unwrap();
if *adopted {
refresh_in_hook.open();
release_refresh.wait();
}
*adopted = true;
}
Ok(PreparedActivation::summary(None))
})
};
let ws = Workspace::open_local_unanchored(None)
.unwrap()
.with_activation_transaction(hook);
ws.adopt_client_root(&client_root).unwrap();
assert_eq!(ws.root_ownership(), RootOwnership::Adopted);
(
ws,
client_root,
operator_root,
operator_gates,
refresh_gates,
)
}
#[test]
fn a_refresh_cannot_cancel_an_in_flight_operator_root_swap() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let (ws, client_root, operator_root, (operator_in_hook, release_operator), refresh_gates) =
adopted_workspace_with_gated_builds(&base);
refresh_gates.1.open();
let operator = {
let ws = ws.clone();
let target = operator_root.clone();
std::thread::spawn(move || ws.set_root_dir(&target, None))
};
operator_in_hook.wait();
let refresh_out = ws.repo_management(None, false, true, false, None);
release_operator.open();
let operator_out = operator.join().unwrap();
assert_eq!(
ws.active_repo_path().as_deref(),
Some(operator_root.as_path()),
"a refresh of the adopted root cancelled the operator's swap \
(operator said: {operator_out}; refresh said: {refresh_out})"
);
assert_eq!(
ws.root_ownership(),
RootOwnership::Operator,
"the active root and the ownership flag must name the same party"
);
assert!(
!operator_out.contains("superseded"),
"a refresh must not supersede a root swap: {operator_out}"
);
assert!(
operator_out.contains(&operator_root.display().to_string()),
"the operator's swap must report the root it committed: {operator_out}"
);
assert!(
refresh_out.contains(&client_root.display().to_string()),
"the refresh rebuilt the binding it found: {refresh_out}"
);
}
#[test]
fn a_refresh_cannot_revert_a_root_swap_that_already_reported_success() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let (
ws,
client_root,
operator_root,
(operator_in_hook, release_operator),
(refresh_in_hook, release_refresh),
) = adopted_workspace_with_gated_builds(&base);
let operator = {
let ws = ws.clone();
let target = operator_root.clone();
std::thread::spawn(move || ws.set_root_dir(&target, None))
};
operator_in_hook.wait();
let refresh = {
let ws = ws.clone();
std::thread::spawn(move || ws.repo_management(None, false, true, true, None))
};
refresh_in_hook.wait();
release_operator.open();
let operator_out = operator.join().unwrap();
let reported_root = ws.active_repo_path();
release_refresh.open();
let refresh_out = refresh.join().unwrap();
assert_eq!(
reported_root.as_deref(),
Some(operator_root.as_path()),
"the operator's swap must commit even though a refresh holds a \
newer generation (operator said: {operator_out})"
);
assert!(
!operator_out.contains("superseded")
&& operator_out.contains(&operator_root.display().to_string()),
"the operator's swap must report the root it committed: {operator_out}"
);
assert_eq!(
ws.active_repo_path().as_deref(),
Some(operator_root.as_path()),
"a refresh reverted a root swap that had already reported success \
(refresh said: {refresh_out})"
);
assert_eq!(
ws.root_ownership(),
RootOwnership::Operator,
"the active root and the ownership flag must name the same party"
);
assert!(
refresh_out.contains("abandoned")
&& refresh_out.contains(&operator_root.display().to_string())
&& !refresh_out.contains(&format!("at {}", client_root.display())),
"the refresh must say it was abandoned, and name what displaced it: {refresh_out}"
);
}
#[test]
fn an_operator_swap_wins_when_an_adoption_is_already_mid_activation() {
let td = tempfile::tempdir().unwrap();
let base = td.path().canonicalize().unwrap();
let client_root = base.join("client");
let operator_root = base.join("operator");
std::fs::create_dir_all(&client_root).unwrap();
std::fs::create_dir_all(&operator_root).unwrap();
let adoption_in_hook = Arc::new(Gate::default());
let release_adoption = Arc::new(Gate::default());
let hook: ActivationTransactionHook = {
let client_root = client_root.clone();
let adoption_in_hook = adoption_in_hook.clone();
let release_adoption = release_adoption.clone();
Arc::new(move |request| {
if request.path() == client_root {
adoption_in_hook.open();
release_adoption.wait();
}
Ok(PreparedActivation::summary(None))
})
};
let ws = Workspace::open_local_unanchored(None)
.unwrap()
.with_activation_transaction(hook);
let adoption = {
let ws = ws.clone();
let target = client_root.clone();
std::thread::spawn(move || ws.adopt_client_root(&target))
};
adoption_in_hook.wait();
let operator = {
let ws = ws.clone();
let target = operator_root.clone();
std::thread::spawn(move || ws.set_root_dir(&target, None))
};
release_adoption.open();
let adoption_out = adoption.join().unwrap();
let operator_out = operator.join().unwrap();
assert_eq!(
ws.active_repo_path().as_deref(),
Some(operator_root.as_path()),
"the operator's swap must survive an in-flight adoption \
(adoption said: {adoption_out:?}; operator said: {operator_out})"
);
assert_eq!(ws.root_ownership(), RootOwnership::Operator);
}
#[test]
fn activation_summary_appended_to_activate_message() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("a.txt"), b"x").unwrap();
let summary: ActivationSummaryHook =
Arc::new(|_p, _n| Some("Graph ready: 3 Functions.".to_string()));
let ws = Workspace::open_local(dir.path().to_path_buf(), None)
.unwrap()
.with_activation_summary(summary);
let out = ws.repo_management(None, false, true, false, None);
assert!(
out.contains("Graph ready: 3 Functions."),
"activation message should include the summary; got: {out}"
);
}
#[test]
fn activation_summary_absent_when_not_configured() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("a.txt"), b"x").unwrap();
let ws = Workspace::open_local(dir.path().to_path_buf(), None).unwrap();
let out = ws.repo_management(None, false, true, false, None);
assert!(!out.contains("Graph ready"));
assert!(
out.contains(" at "),
"expected the terse default message; got: {out}"
);
}
#[test]
fn hook_fires_once_per_process_even_when_sha_matches() {
use std::sync::atomic::{AtomicUsize, Ordering};
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("a.txt"), b"stable").unwrap();
let calls = Arc::new(AtomicUsize::new(0));
let make_hook = || -> PostActivateHook {
let c = calls.clone();
Arc::new(move |_p, _n| {
c.fetch_add(1, Ordering::SeqCst);
Ok(())
})
};
let ws = Workspace::open_local(dir.path().to_path_buf(), Some(make_hook())).unwrap();
let _ = ws.repo_management(None, false, true, false, None);
assert_eq!(
calls.load(Ordering::SeqCst),
1,
"first activate must hydrate"
);
let out = ws.repo_management(None, false, true, false, None);
assert_eq!(
calls.load(Ordering::SeqCst),
1,
"repeat activate in same process must skip the hook"
);
assert!(
out.contains("build skipped"),
"expected skip suffix, got: {out}"
);
drop(ws);
let ws2 = Workspace::open_local(dir.path().to_path_buf(), Some(make_hook())).unwrap();
assert!(
ws2.last_built_sha(&ws2.active_repo_name().unwrap())
.is_some(),
"sanity: last_built_sha should survive the restart"
);
let _ = ws2.repo_management(None, false, true, false, None);
assert_eq!(
calls.load(Ordering::SeqCst),
2,
"fresh process must re-fire the hook even when the SHA matches"
);
}
#[test]
fn a_b_a_swap_rebuilds_intervening_root() {
use std::sync::atomic::{AtomicUsize, Ordering};
let root = tempfile::tempdir().unwrap();
let a = root.path().join("projA");
let b = root.path().join("projB");
std::fs::create_dir_all(&a).unwrap();
std::fs::create_dir_all(&b).unwrap();
std::fs::write(a.join("a.txt"), b"alpha").unwrap();
std::fs::write(b.join("b.txt"), b"beta").unwrap();
let built: Arc<std::sync::Mutex<Option<PathBuf>>> = Arc::new(Default::default());
let built_h = built.clone();
let calls = Arc::new(AtomicUsize::new(0));
let calls_h = calls.clone();
let hook: PostActivateHook = Arc::new(move |p, _n| {
*built_h.lock().unwrap() = Some(p.to_path_buf());
calls_h.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let ws = Workspace::open_local(a.clone(), Some(hook)).unwrap();
let _ = ws.set_root_dir(&a, None);
assert_eq!(calls.load(Ordering::SeqCst), 1, "first bind of A hydrates");
assert_eq!(
built.lock().unwrap().clone(),
Some(a.canonicalize().unwrap())
);
let _ = ws.set_root_dir(&b, None);
assert_eq!(calls.load(Ordering::SeqCst), 2, "bind of B rebuilds");
assert_eq!(
built.lock().unwrap().clone(),
Some(b.canonicalize().unwrap())
);
let out = ws.set_root_dir(&a, None);
assert_eq!(
calls.load(Ordering::SeqCst),
3,
"A→B→A must rebuild A; the intervening B overwrote the live slot"
);
assert!(
!out.contains("build skipped"),
"re-bind of a non-active root must not skip; got: {out}"
);
assert_eq!(
built.lock().unwrap().clone(),
Some(a.canonicalize().unwrap()),
"after A→B→A the live slot must hold A, not B"
);
let out = ws.set_root_dir(&a, None);
assert_eq!(
calls.load(Ordering::SeqCst),
3,
"re-binding the already-active root must skip the hook"
);
assert!(
out.contains("build skipped"),
"expected skip suffix, got: {out}"
);
}
#[test]
fn transaction_slow_a_fast_b_discards_stale_build_and_keeps_responses_coherent() {
use std::sync::Barrier;
#[derive(Debug, Clone, PartialEq, Eq)]
struct Installed {
id: ActivationId,
path: PathBuf,
}
let root = tempfile::tempdir().unwrap();
let a = root.path().join("slow-a");
let b = root.path().join("fast-b");
std::fs::create_dir_all(&a).unwrap();
std::fs::create_dir_all(&b).unwrap();
std::fs::write(a.join("a.txt"), b"a").unwrap();
std::fs::write(b.join("b.txt"), b"b").unwrap();
let a = a.canonicalize().unwrap();
let b = b.canonicalize().unwrap();
let a_entered = Arc::new(Barrier::new(2));
let release_a = Arc::new(Barrier::new(2));
let installed: Arc<Mutex<Option<Installed>>> = Arc::new(Mutex::new(None));
let hook: ActivationTransactionHook = {
let a = a.clone();
let a_entered = a_entered.clone();
let release_a = release_a.clone();
let installed = installed.clone();
Arc::new(move |request| {
if request.path() == a {
a_entered.wait();
release_a.wait();
}
let product = Installed {
id: request.id(),
path: request.path().to_path_buf(),
};
let installed = installed.clone();
Ok(PreparedActivation::new(move || {
*installed.lock().unwrap() = Some(product.clone());
Ok(Some(format!(
"product {} for {}",
product.id,
product.path.display()
)))
}))
})
};
let ws = Workspace::open_local(a.clone(), None)
.unwrap()
.with_activation_transaction(hook);
let slow_ws = ws.clone();
let slow_a = a.clone();
let slow = std::thread::spawn(move || slow_ws.set_root_dir(&slow_a, None));
a_entered.wait();
let fast_ws = ws.clone();
let fast_b = b.clone();
let fast = std::thread::spawn(move || fast_ws.set_root_dir(&fast_b, None));
let fast_out = fast.join().unwrap();
release_a.wait();
let slow_out = slow.join().unwrap();
assert!(
fast_out.contains(&b.display().to_string())
&& fast_out.contains("product 2")
&& !fast_out.contains(&a.display().to_string()),
"fast request response must describe only its own committed product: {fast_out}"
);
assert!(
slow_out.contains("request 1")
&& slow_out.contains("superseded by request 2")
&& !slow_out.contains("product 1"),
"stale request must report supersession, not a false activation: {slow_out}"
);
assert_eq!(ws.active_repo_path(), Some(b.clone()));
assert_eq!(installed.lock().unwrap().as_ref().unwrap().path, b);
assert_eq!(
ws.inner
.state
.read()
.unwrap()
.active_build
.as_ref()
.unwrap()
.activation_id,
ActivationId(2),
"latest request must own the final framework state"
);
}
#[test]
fn legacy_callbacks_are_serialized_through_build_and_summary() {
use std::sync::Barrier;
let root = tempfile::tempdir().unwrap();
let a = root.path().join("slow-a");
let b = root.path().join("queued-b");
std::fs::create_dir_all(&a).unwrap();
std::fs::create_dir_all(&b).unwrap();
let a = a.canonicalize().unwrap();
let b = b.canonicalize().unwrap();
let a_entered = Arc::new(Barrier::new(2));
let release_a = Arc::new(Barrier::new(2));
let installed: Arc<Mutex<Option<PathBuf>>> = Arc::new(Mutex::new(None));
let hook: PostActivateHook = {
let a = a.clone();
let a_entered = a_entered.clone();
let release_a = release_a.clone();
let installed = installed.clone();
Arc::new(move |path, _name| {
if path == a {
a_entered.wait();
release_a.wait();
}
*installed.lock().unwrap() = Some(path.to_path_buf());
Ok(())
})
};
let summary: ActivationSummaryHook = {
let installed = installed.clone();
Arc::new(move |_path, _name| {
installed
.lock()
.unwrap()
.as_ref()
.map(|path| format!("legacy product {}", path.display()))
})
};
let ws = Workspace::open_local(a.clone(), Some(hook))
.unwrap()
.with_activation_summary(summary);
let a_ws = ws.clone();
let a_root = a.clone();
let a_thread = std::thread::spawn(move || a_ws.set_root_dir(&a_root, None));
a_entered.wait();
let b_ws = ws.clone();
let b_root = b.clone();
let b_thread = std::thread::spawn(move || b_ws.set_root_dir(&b_root, None));
release_a.wait();
let a_out = a_thread.join().unwrap();
let b_out = b_thread.join().unwrap();
assert!(
a_out.contains(&format!("legacy product {}", a.display()))
&& !a_out.contains(&format!("legacy product {}", b.display())),
"legacy A response crossed activation products: {a_out}"
);
assert!(
b_out.contains(&format!("legacy product {}", b.display()))
&& !b_out.contains(&format!("legacy product {}", a.display())),
"legacy B response crossed activation products: {b_out}"
);
assert_eq!(ws.active_repo_path(), Some(b.clone()));
assert_eq!(*installed.lock().unwrap(), Some(b));
}
#[test]
fn transaction_same_root_plain_vs_revisions_is_generation_ordered() {
use std::sync::Barrier;
let Some((_dir, root)) = git_repo_with_tags(&["v1.0.0", "v2.0.0"]) else {
return;
};
let root = root.canonicalize().unwrap();
let plain_entered = Arc::new(Barrier::new(2));
let release_plain = Arc::new(Barrier::new(2));
let installed: Arc<Mutex<Option<(ActivationId, ActivationBuild)>>> =
Arc::new(Mutex::new(None));
let hook: ActivationTransactionHook = {
let plain_entered = plain_entered.clone();
let release_plain = release_plain.clone();
let installed = installed.clone();
Arc::new(move |request| {
if matches!(request.build(), ActivationBuild::Plain) {
plain_entered.wait();
release_plain.wait();
}
let id = request.id();
let build = request.build().clone();
let installed = installed.clone();
Ok(PreparedActivation::new(move || {
*installed.lock().unwrap() = Some((id, build.clone()));
Ok(Some(format!("installed request {id}: {build:?}")))
}))
})
};
let ws = Workspace::open_local(root.clone(), None)
.unwrap()
.with_activation_transaction(hook);
let plain_ws = ws.clone();
let plain_root = root.clone();
let plain = std::thread::spawn(move || plain_ws.set_root_dir(&plain_root, None));
plain_entered.wait();
let revs_ws = ws.clone();
let revs_root = root.clone();
let revs = std::thread::spawn(move || {
revs_ws.set_root_dir(&revs_root, Some(&RevsRequest::Count(2)))
});
let revs_out = revs.join().unwrap();
release_plain.wait();
let plain_out = plain.join().unwrap();
assert!(revs_out.contains("revs: v1.0.0, v2.0.0, HEAD"));
assert!(revs_out.contains("installed request 2: Revisions"));
assert!(plain_out.contains("superseded by request 2"));
let state = ws.inner.state.read().unwrap();
assert_eq!(state.active_repo_path.as_deref(), Some(root.as_path()));
assert_eq!(
state
.active_build
.as_ref()
.and_then(|built| built.resolved_revs.clone()),
Some(vec!["v1.0.0".into(), "v2.0.0".into(), "HEAD".into()])
);
assert!(matches!(
installed.lock().unwrap().as_ref(),
Some((ActivationId(2), ActivationBuild::Revisions(_)))
));
}
#[test]
fn transaction_current_failure_preserves_committed_source_and_product() {
#[derive(Debug, Clone, PartialEq, Eq)]
struct Installed(ActivationId, PathBuf);
let root = tempfile::tempdir().unwrap();
let good = root.path().join("good");
let broken = root.path().join("broken");
std::fs::create_dir_all(&good).unwrap();
std::fs::create_dir_all(&broken).unwrap();
std::fs::write(good.join("good.txt"), b"good").unwrap();
std::fs::write(broken.join("broken.txt"), b"broken").unwrap();
let good = good.canonicalize().unwrap();
let broken = broken.canonicalize().unwrap();
let installed: Arc<Mutex<Option<Installed>>> = Arc::new(Mutex::new(None));
let hook: ActivationTransactionHook = {
let broken = broken.clone();
let installed = installed.clone();
Arc::new(move |request| {
if request.path() == broken {
anyhow::bail!("builder rejected broken root");
}
let product = Installed(request.id(), request.path().to_path_buf());
let installed = installed.clone();
Ok(PreparedActivation::new(move || {
*installed.lock().unwrap() = Some(product.clone());
Ok(Some(format!("installed request {}", product.0)))
}))
})
};
let ws = Workspace::open_local(good.clone(), None)
.unwrap()
.with_activation_transaction(hook);
let good_out = ws.set_root_dir(&good, None);
assert!(good_out.contains("installed request 1"));
let broken_out = ws.set_root_dir(&broken, None);
assert!(
broken_out.contains("request 2")
&& broken_out.contains("failed during preparation")
&& broken_out.contains("builder rejected broken root"),
"failure must be explicit and request-scoped: {broken_out}"
);
assert_eq!(ws.active_repo_path(), Some(good.clone()));
assert_eq!(installed.lock().unwrap().as_ref().unwrap().1, good);
}
#[test]
fn transaction_stale_failure_reports_superseded_not_current_failure() {
use std::sync::Barrier;
let root = tempfile::tempdir().unwrap();
let slow = root.path().join("slow-failure");
let fast = root.path().join("fast-success");
std::fs::create_dir_all(&slow).unwrap();
std::fs::create_dir_all(&fast).unwrap();
let slow = slow.canonicalize().unwrap();
let fast = fast.canonicalize().unwrap();
let slow_entered = Arc::new(Barrier::new(2));
let release_slow = Arc::new(Barrier::new(2));
let hook: ActivationTransactionHook = {
let slow = slow.clone();
let slow_entered = slow_entered.clone();
let release_slow = release_slow.clone();
Arc::new(move |request| {
if request.path() == slow {
slow_entered.wait();
release_slow.wait();
anyhow::bail!("late preparation failure");
}
Ok(PreparedActivation::summary(Some(format!(
"committed request {}",
request.id()
))))
})
};
let ws = Workspace::open_local(slow.clone(), None)
.unwrap()
.with_activation_transaction(hook);
let slow_ws = ws.clone();
let slow_root = slow.clone();
let slow_thread = std::thread::spawn(move || slow_ws.set_root_dir(&slow_root, None));
slow_entered.wait();
let fast_out = ws.set_root_dir(&fast, None);
release_slow.wait();
let slow_out = slow_thread.join().unwrap();
assert!(fast_out.contains("committed request 2"));
assert!(
slow_out.contains("superseded by request 2")
&& slow_out.contains("failed build")
&& !slow_out.contains("set_root_dir failed"),
"a stale failure is a superseded outcome: {slow_out}"
);
assert_eq!(ws.active_repo_path(), Some(fast));
}
fn git_repo_with_tags(tags: &[&str]) -> Option<(tempfile::TempDir, PathBuf)> {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().to_path_buf();
let git = |args: &[&str]| {
Command::new("git")
.arg("-C")
.arg(&root)
.args(args)
.output()
.unwrap()
};
if !git(&["init"]).status.success() {
return None; }
git(&["config", "user.email", "t@example.com"]);
git(&["config", "user.name", "Test"]);
git(&["config", "commit.gpgsign", "false"]);
for (i, tag) in tags.iter().enumerate() {
std::fs::write(root.join("f.txt"), format!("rev {i}")).unwrap();
git(&["add", "-A"]);
assert!(
git(&["commit", "-m", &format!("c{i}")]).status.success(),
"git commit failed"
);
assert!(git(&["tag", tag]).status.success(), "git tag {tag} failed");
}
Some((dir, root))
}
#[test]
fn classify_tag_extracts_prefix_version_prerelease() {
let c = classify_tag("apache-arrow-25.0.0").unwrap();
assert_eq!(c.prefix, "apache-arrow-");
assert_eq!(c.version, vec![25, 0, 0]);
assert!(!c.is_prerelease);
for t in [
"apache-arrow-25.0.0.dev",
"apache-arrow-25.0.0-rc1",
"apache-arrow-25.0.0-RC0",
"v1.2.3-beta2",
"v1.2.3_alpha",
"v2.0.0-preview",
] {
assert!(
classify_tag(t).unwrap().is_prerelease,
"{t} should be prerelease"
);
}
assert_eq!(classify_tag("go/v18.0.0").unwrap().prefix, "go/v");
assert_eq!(classify_tag("r-15.0.1").unwrap().prefix, "r-");
assert_eq!(classify_tag("v1.2.3").unwrap().prefix, "v");
let c = classify_tag("arrow2-0.17.0").unwrap();
assert_eq!(c.prefix, "arrow2-");
assert_eq!(c.version, vec![0, 17, 0]);
}
#[test]
fn classify_tag_excludes_non_version_tags() {
assert_eq!(classify_tag("r-universe-release"), None);
assert_eq!(classify_tag("latest"), None);
assert_eq!(classify_tag("nightly"), None);
assert_eq!(classify_tag("v1.2.3-foobar"), None);
}
#[test]
fn select_family_tags_picks_dominant_release_family_skipping_prereleases() {
let tags: Vec<String> = [
"apache-arrow-22.0.0",
"apache-arrow-23.0.0",
"apache-arrow-24.0.0",
"apache-arrow-25.0.0-rc0",
"apache-arrow-25.0.0-rc1",
"apache-arrow-25.0.0.dev",
"go/v18.0.0",
"r-15.0.1",
"r-16.1.0",
"r-universe-release",
]
.iter()
.map(|s| s.to_string())
.collect();
let got = select_family_tags(&tags, 2).unwrap();
assert_eq!(got, vec!["apache-arrow-23.0.0", "apache-arrow-24.0.0"]);
}
#[test]
fn select_family_tags_fewer_stable_than_requested_uses_all_stable() {
let tags: Vec<String> = ["v1.0.0", "v2.0.0", "v3.0.0-rc1"]
.iter()
.map(|s| s.to_string())
.collect();
let got = select_family_tags(&tags, 5).unwrap();
assert_eq!(got, vec!["v1.0.0", "v2.0.0"]);
}
#[test]
fn select_family_tags_prerelease_only_family_falls_back_to_prereleases() {
let tags: Vec<String> = ["v1.0.0-rc1", "v1.0.0-rc2", "v0.9.0-beta"]
.iter()
.map(|s| s.to_string())
.collect();
let got = select_family_tags(&tags, 2).unwrap();
assert_eq!(got, vec!["v1.0.0-rc1", "v1.0.0-rc2"]);
}
#[test]
fn select_family_tags_no_version_like_tags_returns_none() {
let tags: Vec<String> = ["latest", "nightly", "stable"]
.iter()
.map(|s| s.to_string())
.collect();
assert_eq!(select_family_tags(&tags, 3), None);
}
#[test]
fn resolve_revs_count_falls_back_to_raw_when_no_version_tags() {
let Some((_d, root)) = git_repo_with_tags(&["latest", "nightly", "stable"]) else {
return;
};
let ws = Workspace::open_local(root.clone(), None).unwrap();
let resolved = ws.resolve_revs(&root, &RevsRequest::Count(2)).unwrap();
assert_eq!(resolved.len(), 3);
assert_eq!(resolved.last().unwrap(), "HEAD");
assert!(resolved[..2].iter().all(|r| r != "HEAD"));
}
#[test]
fn resolve_revs_count_skips_prereleases_of_dominant_family() {
let Some((_d, root)) =
git_repo_with_tags(&["v1.0.0", "v2.0.0", "v3.0.0-rc1", "v3.0.0.dev"])
else {
return;
};
let ws = Workspace::open_local(root.clone(), None).unwrap();
let resolved = ws.resolve_revs(&root, &RevsRequest::Count(2)).unwrap();
assert_eq!(resolved, vec!["v1.0.0", "v2.0.0", "HEAD"]);
}
#[test]
fn resolve_revs_count_picks_newest_n_oldest_first_head_last() {
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0", "v1.1.0", "v2.0.0"]) else {
return;
};
let ws = Workspace::open_local(root.clone(), None).unwrap();
let resolved = ws
.resolve_revs(&root, &RevsRequest::Count(2))
.expect("resolve should succeed");
assert_eq!(resolved, vec!["v1.1.0", "v2.0.0", "HEAD"]);
}
#[test]
fn resolve_revs_count_fewer_tags_than_requested_uses_all() {
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0", "v2.0.0"]) else {
return;
};
let ws = Workspace::open_local(root.clone(), None).unwrap();
let resolved = ws.resolve_revs(&root, &RevsRequest::Count(10)).unwrap();
assert_eq!(resolved, vec!["v1.0.0", "v2.0.0", "HEAD"]);
}
#[test]
fn resolve_revs_count_errors_when_no_tags() {
let Some((_d, root)) = git_repo_with_tags(&[]) else {
return;
};
let git = |args: &[&str]| {
Command::new("git")
.arg("-C")
.arg(&root)
.args(args)
.output()
.unwrap()
};
std::fs::write(root.join("f.txt"), b"x").unwrap();
git(&["add", "-A"]);
git(&["commit", "-m", "c0"]);
let ws = Workspace::open_local(root.clone(), None).unwrap();
let err = ws
.resolve_revs(&root, &RevsRequest::Count(3))
.expect_err("no tags → error");
assert!(
err.to_string().contains("no tags"),
"expected a 'no tags' error, got: {err}"
);
}
#[test]
fn dedup_labels_is_order_preserving_first_wins() {
assert_eq!(
dedup_labels(vec!["HEAD".into(), "HEAD".into()]),
vec!["HEAD"]
);
assert_eq!(
dedup_labels(vec![
"v1".into(),
"v2".into(),
"v1".into(),
"v3".into(),
"v2".into(),
]),
vec!["v1", "v2", "v3"]
);
assert_eq!(dedup_labels(vec![]), Vec::<String>::new());
assert_eq!(dedup_labels(vec!["a".into(), "b".into()]), vec!["a", "b"]);
}
#[test]
fn resolve_revs_list_dedups_duplicate_revspecs() {
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0"]) else {
return;
};
let ws = Workspace::open_local(root.clone(), None).unwrap();
let got = ws
.resolve_revs(
&root,
&RevsRequest::List(vec!["HEAD".into(), "HEAD".into()]),
)
.unwrap();
assert_eq!(got, vec!["HEAD"]);
let got = ws
.resolve_revs(
&root,
&RevsRequest::List(vec!["v1.0.0".into(), "HEAD".into(), "v1.0.0".into()]),
)
.unwrap();
assert_eq!(got, vec!["v1.0.0", "HEAD"]);
}
#[test]
fn resolve_revs_list_validates_and_rejects_unknown() {
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0", "v1.1.0"]) else {
return;
};
let ws = Workspace::open_local(root.clone(), None).unwrap();
let ok = ws
.resolve_revs(
&root,
&RevsRequest::List(vec!["v1.1.0".into(), "v1.0.0".into()]),
)
.unwrap();
assert_eq!(ok, vec!["v1.1.0", "v1.0.0"]);
let err = ws
.resolve_revs(&root, &RevsRequest::List(vec!["v9.9.9".into()]))
.expect_err("unknown rev → error");
assert!(
err.to_string().contains("v9.9.9") && err.to_string().contains("does not exist"),
"expected an unknown-rev error, got: {err}"
);
}
#[test]
fn revs_hook_receives_resolved_revs_and_plain_hook_untouched() {
use std::sync::atomic::{AtomicUsize, Ordering};
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0", "v1.1.0", "v2.0.0"]) else {
return;
};
let plain_calls = Arc::new(AtomicUsize::new(0));
let seen_revs: Arc<std::sync::Mutex<Option<Vec<String>>>> = Arc::new(Default::default());
let pc = plain_calls.clone();
let plain: PostActivateHook = Arc::new(move |_p, _n| {
pc.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let sr = seen_revs.clone();
let revs_hook: PostActivateRevsHook = Arc::new(move |_p, _n, revs| {
*sr.lock().unwrap() = Some(revs.to_vec());
Ok(())
});
let ws = Workspace::open_local(root.clone(), Some(plain))
.unwrap()
.with_post_activate_revs(revs_hook);
let out = ws.repo_management(None, false, true, false, Some(&RevsRequest::Count(2)));
assert_eq!(
seen_revs.lock().unwrap().clone().unwrap(),
vec!["v1.1.0", "v2.0.0", "HEAD"]
);
assert_eq!(
plain_calls.load(Ordering::SeqCst),
0,
"plain hook must not fire when the revs-hook handled the request"
);
assert!(
out.contains("revs: v1.1.0, v2.0.0, HEAD"),
"activation message should list the resolved revs; got: {out}"
);
}
#[test]
fn plain_hook_used_and_no_revs_line_when_no_revs_requested() {
use std::sync::atomic::{AtomicUsize, Ordering};
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0"]) else {
return;
};
let plain_calls = Arc::new(AtomicUsize::new(0));
let revs_seen = Arc::new(AtomicUsize::new(0));
let pc = plain_calls.clone();
let plain: PostActivateHook = Arc::new(move |_p, _n| {
pc.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let rs = revs_seen.clone();
let revs_hook: PostActivateRevsHook = Arc::new(move |_p, _n, _revs| {
rs.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let ws = Workspace::open_local(root.clone(), Some(plain))
.unwrap()
.with_post_activate_revs(revs_hook);
let out = ws.repo_management(None, false, true, false, None);
assert_eq!(plain_calls.load(Ordering::SeqCst), 1);
assert_eq!(
revs_seen.load(Ordering::SeqCst),
0,
"revs-hook must not fire when no revs were requested"
);
assert!(
!out.contains("revs:"),
"no revs line expected on a plain activation; got: {out}"
);
}
#[test]
fn revs_requested_without_revs_hook_falls_back_to_plain_no_revs_line() {
use std::sync::atomic::{AtomicUsize, Ordering};
let Some((_d, root)) = git_repo_with_tags(&["v1.0.0", "v2.0.0"]) else {
return;
};
let plain_calls = Arc::new(AtomicUsize::new(0));
let pc = plain_calls.clone();
let plain: PostActivateHook = Arc::new(move |_p, _n| {
pc.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let ws = Workspace::open_local(root.clone(), Some(plain)).unwrap();
let out = ws.repo_management(None, false, true, false, Some(&RevsRequest::Count(1)));
assert_eq!(plain_calls.load(Ordering::SeqCst), 1);
assert!(
!out.contains("revs:"),
"must not report a rev-set when only the plain hook ran; got: {out}"
);
}
#[allow(clippy::type_complexity)]
fn ws_with_both_hooks(
tags: &[&str],
) -> Option<(
Workspace,
tempfile::TempDir,
PathBuf,
Arc<std::sync::atomic::AtomicUsize>,
Arc<std::sync::atomic::AtomicUsize>,
)> {
use std::sync::atomic::{AtomicUsize, Ordering};
let (d, root) = git_repo_with_tags(tags)?;
let plain_calls = Arc::new(AtomicUsize::new(0));
let revs_calls = Arc::new(AtomicUsize::new(0));
let pc = plain_calls.clone();
let plain: PostActivateHook = Arc::new(move |_p, _n| {
pc.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let rc = revs_calls.clone();
let revs_hook: PostActivateRevsHook = Arc::new(move |_p, _n, _r| {
rc.fetch_add(1, Ordering::SeqCst);
Ok(())
});
let ws = Workspace::open_local(root.clone(), Some(plain))
.unwrap()
.with_post_activate_revs(revs_hook);
Some((ws, d, root, plain_calls, revs_calls))
}
#[test]
fn plain_activation_after_revs_build_rebuilds_plain() {
use std::sync::atomic::Ordering;
let Some((ws, _d, root, plain_calls, revs_calls)) =
ws_with_both_hooks(&["v1.0.0", "v2.0.0"])
else {
return;
};
let _ = ws.set_root_dir(&root, Some(&RevsRequest::Count(2)));
assert_eq!(revs_calls.load(Ordering::SeqCst), 1);
assert_eq!(plain_calls.load(Ordering::SeqCst), 0);
let out = ws.set_root_dir(&root, None);
assert_eq!(
plain_calls.load(Ordering::SeqCst),
1,
"plain re-activation after a revs build must fire the plain hook"
);
assert!(
!out.contains("build skipped"),
"must not skip a plain re-activation after a revs build; got: {out}"
);
assert!(
!out.contains("revs:"),
"plain rebuild must not claim revs; got: {out}"
);
let out = ws.set_root_dir(&root, None);
assert_eq!(
plain_calls.load(Ordering::SeqCst),
1,
"second plain re-bind skips"
);
assert!(
out.contains("build skipped"),
"expected skip suffix; got: {out}"
);
}
#[test]
fn update_after_revs_build_reapplies_stored_revs() {
use std::sync::atomic::Ordering;
let Some((ws, _d, root, plain_calls, revs_calls)) =
ws_with_both_hooks(&["v1.0.0", "v2.0.0"])
else {
return;
};
let _ = ws.set_root_dir(&root, Some(&RevsRequest::Count(2)));
assert_eq!(revs_calls.load(Ordering::SeqCst), 1);
let out = ws.repo_management(None, false, true, false, None);
assert_eq!(
revs_calls.load(Ordering::SeqCst),
2,
"bare update must re-apply the stored rev-set"
);
assert_eq!(
plain_calls.load(Ordering::SeqCst),
0,
"bare update after a revs build must not fall to the plain hook"
);
assert!(
out.contains("revs:"),
"re-applied update should list the revs; got: {out}"
);
}
#[test]
fn revs_activation_after_plain_build_always_rebuilds() {
use std::sync::atomic::Ordering;
let Some((ws, _d, root, plain_calls, revs_calls)) =
ws_with_both_hooks(&["v1.0.0", "v2.0.0"])
else {
return;
};
let _ = ws.set_root_dir(&root, None);
assert_eq!(plain_calls.load(Ordering::SeqCst), 1);
assert_eq!(revs_calls.load(Ordering::SeqCst), 0);
let _ = ws.set_root_dir(&root, Some(&RevsRequest::Count(2)));
assert_eq!(
revs_calls.load(Ordering::SeqCst),
1,
"a revs request must always rebuild, even at an unchanged HEAD"
);
}
#[test]
fn last_built_revs_round_trips_and_clears_on_plain_build() {
let dir = tempfile::tempdir().unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
ws.bump_access("acme/widgets", "cloned");
assert_eq!(ws.last_built_revs("acme/widgets"), None);
ws.record_built("acme/widgets", "sha1", Some(&RevsRequest::Count(3)));
assert_eq!(
ws.last_built_revs("acme/widgets"),
Some(RevsRequest::Count(3))
);
let ws2 = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
assert_eq!(
ws2.last_built_revs("acme/widgets"),
Some(RevsRequest::Count(3))
);
ws2.record_built("acme/widgets", "sha2", None);
assert_eq!(ws2.last_built_revs("acme/widgets"), None);
ws2.record_built(
"acme/widgets",
"sha3",
Some(&RevsRequest::List(vec!["v1".into(), "v2".into()])),
);
assert_eq!(
ws2.last_built_revs("acme/widgets"),
Some(RevsRequest::List(vec!["v1".into(), "v2".into()]))
);
}
#[test]
fn inventory_loads_legacy_entries_without_revs_field() {
let dir = tempfile::tempdir().unwrap();
let legacy = r#"{
"old/repo": {
"cloned_at": "2024-01-01T00:00:00",
"last_accessed": "2024-01-01T00:00:00",
"access_count": 5,
"stale": false,
"last_built_sha": "deadbeef"
}
}"#;
std::fs::write(dir.path().join("inventory.json"), legacy).unwrap();
let ws = Workspace::open(dir.path().to_path_buf(), 7, None).unwrap();
assert_eq!(ws.last_built_sha("old/repo").as_deref(), Some("deadbeef"));
assert_eq!(ws.last_built_revs("old/repo"), None);
}
}