@team-agent/installer 0.5.74 → 0.5.77

package/crates/team-agent/src/leader/registry.rs

@@ -20,7 +20,9 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
+use std::fmt;
 use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -100,10 +102,45 @@ pub const AMBIGUOUS_NAMES_FIELD: &str = "ambiguous_names";
 /// a fully-qualified form.
 pub const REASON_AMBIGUOUS: &str = "name_ambiguous";
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RegistryRollback {
+    Restored,
+    Superseded,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RegistryRollbackError {
+    InvalidReceipt,
+    LockUnavailable,
+    ReadFailed,
+    RestoreFailed,
+    DeleteFailed,
+}
+
+impl fmt::Display for RegistryRollbackError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let reason = match self {
+            Self::InvalidReceipt => "invalid receipt",
+            Self::LockUnavailable => "registry lock unavailable",
+            Self::ReadFailed => "registry receipt read failed",
+            Self::RestoreFailed => "registry restore failed",
+            Self::DeleteFailed => "registry delete failed",
+        };
+        f.write_str(reason)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RegistryWriteReceipt {
+    pub path: PathBuf,
+    pub bytes: Vec<u8>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RegistryWriteOutcome {
     pub status: &'static str,
     pub path: Option<PathBuf>,
+    pub receipt: Option<RegistryWriteReceipt>,
     pub team_key: String,
     pub workspace_hash: String,
     pub source: String,
@@ -242,7 +279,8 @@ pub fn register_binding_from_state_best_effort(
         chrono::Utc::now().to_rfc3339(),
     );
     let event_log = crate::event_log::EventLog::new(workspace);
-    let write_result = write_entry_best_effort(&entry);
+    let write_receipt = write_entry_best_effort_with_receipt(&entry);
+    let write_result = write_receipt.as_ref().map(|receipt| receipt.path.clone());
     let status = if let Some(path) = &write_result {
         let _ = event_log.write(
             EVENT_REGISTERED,
@@ -268,6 +306,7 @@ pub fn register_binding_from_state_best_effort(
     Some(RegistryWriteOutcome {
         status,
         path: write_result,
+        receipt: write_receipt,
         team_key,
         workspace_hash: entry.workspace_hash,
         source: source.to_string(),
@@ -281,13 +320,19 @@ fn entry_filename(entry: &LeaderRegistryEntry) -> String {
 
 /// Registry write is best-effort. Writes to `.<file>.tmp-<pid>-<counter>`
 /// first, then atomically renames to `<workspace_hash>__<team_key>.json`.
-/// Returns the final path when the write succeeded, `None` otherwise —
-/// the binding command must never fail on registry errors.
+/// Every writer uses the registry lock so conditional rollback can compare
+/// and restore without racing a concurrent publish.
 pub fn write_entry_best_effort(entry: &LeaderRegistryEntry) -> Option<PathBuf> {
-    let dir = registry_dir()?;
-    if let Err(_error) = std::fs::create_dir_all(&dir) {
-        return None;
-    }
+    write_entry_best_effort_with_receipt(entry).map(|receipt| receipt.path)
+}
+
+fn write_entry_best_effort_with_receipt(
+    entry: &LeaderRegistryEntry,
+) -> Option<RegistryWriteReceipt> {
+    with_registry_lock(|dir| write_entry_locked(dir, entry)).flatten()
+}
+
+fn write_entry_locked(dir: &Path, entry: &LeaderRegistryEntry) -> Option<RegistryWriteReceipt> {
     let final_path = dir.join(entry_filename(entry));
     let tmp_name = format!(
         ".{}.tmp-{}-{}",
@@ -296,8 +341,8 @@ pub fn write_entry_best_effort(entry: &LeaderRegistryEntry) -> Option<PathBuf> {
         rand_suffix()
     );
     let tmp_path = dir.join(tmp_name);
-    let serialized = serde_json::to_string_pretty(entry).ok()?;
-    if std::fs::write(&tmp_path, serialized).is_err() {
+    let serialized = serde_json::to_vec_pretty(entry).ok()?;
+    if std::fs::write(&tmp_path, &serialized).is_err() {
         let _ = std::fs::remove_file(&tmp_path);
         return None;
     }
@@ -305,7 +350,118 @@ pub fn write_entry_best_effort(entry: &LeaderRegistryEntry) -> Option<PathBuf> {
         let _ = std::fs::remove_file(&tmp_path);
         return None;
     }
-    Some(final_path)
+    Some(RegistryWriteReceipt {
+        path: final_path,
+        bytes: serialized,
+    })
+}
+
+/// Restore one registry path only when it still contains this writer's exact
+/// receipt. The comparison and restore/delete are held under the same lock as
+/// ordinary registry writers, so a winner cannot slip in between them.
+pub fn restore_entry_if_current_matches(
+    receipt: &RegistryWriteReceipt,
+    previous: Option<&[u8]>,
+) -> Result<RegistryRollback, RegistryRollbackError> {
+    with_registry_lock_result(|dir| {
+        if receipt.path.parent() != Some(dir) {
+            return Err(RegistryRollbackError::InvalidReceipt);
+        }
+        let current = std::fs::read(&receipt.path)
+            .map_err(|_| RegistryRollbackError::ReadFailed)?;
+        if current != receipt.bytes {
+            return Ok(RegistryRollback::Superseded);
+        }
+        match previous {
+            Some(bytes) if replace_entry_bytes_locked(&receipt.path, bytes) => {
+                Ok(RegistryRollback::Restored)
+            }
+            Some(_) => Err(RegistryRollbackError::RestoreFailed),
+            None if std::fs::remove_file(&receipt.path).is_ok() => {
+                Ok(RegistryRollback::Restored)
+            }
+            None => Err(RegistryRollbackError::DeleteFailed),
+        }
+    })
+}
+
+fn remove_entry_if_matches(path: &Path, expected: &LeaderRegistryEntry) -> bool {
+    with_registry_lock(|_| {
+        let Ok(bytes) = std::fs::read(path) else {
+            return false;
+        };
+        let Ok(current) = serde_json::from_slice::<LeaderRegistryEntry>(&bytes) else {
+            return false;
+        };
+        current == *expected && std::fs::remove_file(path).is_ok()
+    })
+    .unwrap_or(false)
+}
+
+fn replace_entry_bytes_locked(path: &Path, bytes: &[u8]) -> bool {
+    let tmp = path.with_extension(format!(
+        "rollback-{}-{}",
+        std::process::id(),
+        rand_suffix()
+    ));
+    if std::fs::write(&tmp, bytes).is_err() {
+        let _ = std::fs::remove_file(&tmp);
+        return false;
+    }
+    if std::fs::rename(&tmp, path).is_err() {
+        let _ = std::fs::remove_file(&tmp);
+        return false;
+    }
+    true
+}
+
+struct RegistryLock {
+    file: std::fs::File,
+}
+
+impl RegistryLock {
+    fn acquire(dir: &Path) -> Option<Self> {
+        let path = dir.join(".registry.lock");
+        let file = std::fs::OpenOptions::new()
+            .create(true)
+            .read(true)
+            .write(true)
+            .truncate(false)
+            .open(path)
+            .ok()?;
+        let started = Instant::now();
+        loop {
+            match crate::platform::file_lock::try_lock_once_nonblocking(&file) {
+                Ok(true) => return Some(Self { file }),
+                Ok(false) if started.elapsed() < Duration::from_secs(2) => {
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+                Ok(false) | Err(_) => return None,
+            }
+        }
+    }
+}
+
+impl Drop for RegistryLock {
+    fn drop(&mut self) {
+        let _ = crate::platform::file_lock::unlock(&self.file);
+    }
+}
+
+fn with_registry_lock<T>(f: impl FnOnce(&Path) -> T) -> Option<T> {
+    let dir = registry_dir()?;
+    std::fs::create_dir_all(&dir).ok()?;
+    let _lock = RegistryLock::acquire(&dir)?;
+    Some(f(&dir))
+}
+
+fn with_registry_lock_result<T>(
+    f: impl FnOnce(&Path) -> Result<T, RegistryRollbackError>,
+) -> Result<T, RegistryRollbackError> {
+    let dir = registry_dir().ok_or(RegistryRollbackError::LockUnavailable)?;
+    std::fs::create_dir_all(&dir).map_err(|_| RegistryRollbackError::LockUnavailable)?;
+    let _lock = RegistryLock::acquire(&dir).ok_or(RegistryRollbackError::LockUnavailable)?;
+    f(&dir)
 }
 
 fn rand_suffix() -> String {
@@ -324,14 +480,16 @@ fn rand_suffix() -> String {
 /// success — the invariant is "no registry entry after unbind", not
 /// "must have found something to delete".
 pub fn unregister_entry(workspace: &Path, team_key: &str) -> Option<PathBuf> {
-    let dir = registry_dir()?;
-    let hash = workspace_hash(workspace);
-    let path = dir.join(format!("{hash}__{team_key}.json"));
-    if path.exists() {
-        std::fs::remove_file(&path).ok()?;
-        return Some(path);
-    }
-    None
+    with_registry_lock(|dir| {
+        let hash = workspace_hash(workspace);
+        let path = dir.join(format!("{hash}__{team_key}.json"));
+        if path.exists() {
+            std::fs::remove_file(&path).ok()?;
+            return Some(path);
+        }
+        None
+    })
+    .flatten()
 }
 
 /// Read and deserialize every `*.json` file under the registry directory.
@@ -470,7 +628,7 @@ pub fn list_validated_with_gc() -> Vec<(LeaderRegistryEntry, &'static str, Optio
                     || r == "team_not_alive"
             })
         {
-            let _ = std::fs::remove_file(&path);
+            let _ = remove_entry_if_matches(&path, &entry);
             continue;
         }
         out.push((entry, status, reason));

package/crates/team-agent/src/leader/types.rs

@@ -419,6 +419,10 @@ pub struct LeaseResult {
     /// paths so existing lease JSON stays stable unless a convergence decision
     /// was actually evaluated.
     pub topology_convergence: Option<Value>,
+    /// Counts returned by the same attach operation when blocked leader
+    /// messages were requeued. Kept typed and team/pane-bound; omitted when
+    /// no attach-window debt was observed.
+    pub attach_window_failures: Option<Value>,
 }
 
 /// Family A 正源 owner 绑定结果(`bind_owner_from_caller_pane` 返回 dict 的 typed 版)。

package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs

@@ -16,6 +16,8 @@
 use std::collections::BTreeSet;
 use std::fs::OpenOptions;
 use std::io::{Read, Write};
+#[cfg(test)]
+use std::cell::RefCell;
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -588,6 +590,58 @@ fn executable_file_type(path: &Path) -> Result<PiExecutableFileType, ProviderErr
     }
 }
 
+#[cfg(test)]
+#[derive(Debug, Default)]
+pub(crate) struct PiCatalogTestObservation {
+    pub(crate) spawn_count: usize,
+    pub(crate) argv: Vec<String>,
+    pub(crate) parent_pid: Option<u32>,
+    pub(crate) parent_exit_success: Option<bool>,
+    pub(crate) parent_exit_code: Option<i32>,
+    pub(crate) reader_timeout: bool,
+}
+
+#[cfg(test)]
+struct PiCatalogTestContext {
+    receipt: PathBuf,
+    helper_mode: Option<String>,
+    observation: PiCatalogTestObservation,
+}
+
+#[cfg(test)]
+thread_local! {
+    static PI_CATALOG_TEST_CONTEXT: RefCell<Option<PiCatalogTestContext>> = RefCell::new(None);
+}
+
+#[cfg(test)]
+pub(crate) fn with_pi_catalog_test_observation<T>(
+    receipt: &Path,
+    helper_mode: Option<&str>,
+    action: impl FnOnce() -> T,
+) -> (T, PiCatalogTestObservation) {
+    PI_CATALOG_TEST_CONTEXT.with(|slot| {
+        assert!(slot
+            .replace(Some(PiCatalogTestContext {
+                receipt: receipt.to_path_buf(),
+                helper_mode: helper_mode.map(str::to_owned),
+                observation: PiCatalogTestObservation::default(),
+            }))
+            .is_none());
+        let result = action();
+        let context = slot.take().expect("Pi catalog test context");
+        (result, context.observation)
+    })
+}
+
+#[cfg(test)]
+fn observe_pi_catalog_test(f: impl FnOnce(&mut PiCatalogTestContext)) {
+    PI_CATALOG_TEST_CONTEXT.with(|slot| {
+        if let Some(context) = slot.borrow_mut().as_mut() {
+            f(context);
+        }
+    });
+}
+
 /// Discover candidates with one PATH-first catalog observation. This deliberately
 /// does not resolve adapters or scan wrapper chains; callers use it only for
 /// rejecting an unqualified role model before lifecycle mutation.
@@ -596,13 +650,36 @@ pub(crate) fn run_pi_catalog(
     timeout: Duration,
     max_bytes: u64,
 ) -> Result<Vec<u8>, String> {
-    let mut child = Command::new(executable)
-        .arg("--list-models")
+    let mut command = Command::new(executable);
+    command.arg("--list-models");
+    #[cfg(test)]
+    observe_pi_catalog_test(|context| {
+        context.observation.spawn_count += 1;
+        context.observation.argv.push("--list-models".to_string());
+        command.env("TEAM_AGENT_MODELS_TIMEOUT_RECEIPT", &context.receipt);
+        if let Some(mode) = context.helper_mode.as_deref() {
+            command.env("TEAM_AGENT_MODELS_TIMEOUT_MODE", mode);
+        }
+    });
+    let mut child = command
         .stdin(Stdio::null())
         .stdout(Stdio::piped())
         .stderr(Stdio::null())
         .spawn()
-        .map_err(|_| "Pi executable is unavailable on PATH".to_string())?;
+        .map_err(|error| {
+            #[cfg(test)]
+            {
+                eprintln!(
+                    "run_pi_catalog spawn failed kind={:?} raw_os_error={:?}",
+                    error.kind(),
+                    error.raw_os_error()
+                );
+            }
+            let _ = error;
+            "Pi executable is unavailable on PATH".to_string()
+        })?;
+    #[cfg(test)]
+    observe_pi_catalog_test(|context| context.observation.parent_pid = Some(child.id()));
     let stdout = child.stdout.take().ok_or_else(|| {
         let _ = child.kill();
         let _ = child.wait();
@@ -618,8 +695,19 @@ pub(crate) fn run_pi_catalog(
     loop {
         match child.try_wait() {
             Ok(Some(status)) => {
-                let (result, bytes) = receiver.recv_timeout(timeout.saturating_sub(start.elapsed()))
-                    .map_err(|_| "Pi model catalog command timed out".to_string())?;
+                #[cfg(test)]
+                observe_pi_catalog_test(|context| {
+                    context.observation.parent_exit_success = Some(status.success());
+                    context.observation.parent_exit_code = status.code();
+                });
+                let (result, bytes) = match receiver.recv_timeout(timeout.saturating_sub(start.elapsed())) {
+                    Ok(value) => value,
+                    Err(_) => {
+                        #[cfg(test)]
+                        observe_pi_catalog_test(|context| context.observation.reader_timeout = true);
+                        return Err("Pi model catalog command timed out".to_string());
+                    }
+                };
                 if !status.success() { return Err("Pi model catalog command failed".into()); }
                 result.map_err(|_| "Pi model catalog could not be read".to_string())?;
                 if bytes.len() as u64 > max_bytes { return Err("Pi model catalog exceeds the bounded output limit".into()); }