@team-agent/installer 0.4.11 → 0.5.1

package/crates/team-agent/src/lifecycle/tests/lifecycle_lock.rs

@@ -0,0 +1,321 @@
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use super::*;
+use crate::lifecycle::lock::{
+    acquire_agent_lifecycle_lock, acquire_agent_lifecycle_lock_for_test, LifecycleLockRequest,
+    AGENT_LIFECYCLE_LOCK_NAME, LIFECYCLE_LOCK_HELD_LONG, LIFECYCLE_LOCK_TIMEOUT,
+};
+
+#[test]
+fn lifecycle_lock_timeout_error_contract_and_constants() {
+    assert_eq!(AGENT_LIFECYCLE_LOCK_NAME, "agent-lifecycle");
+    assert_eq!(LIFECYCLE_LOCK_TIMEOUT, Duration::from_secs(30));
+    assert_eq!(LIFECYCLE_LOCK_HELD_LONG, Duration::from_secs(5));
+
+    let ws = temp_ws();
+    let err = LifecycleError::LifecycleLockTimeout {
+        lock_path: crate::model::paths::runtime_dir(&ws).join("agent-lifecycle.lock"),
+        log_path: crate::model::paths::logs_dir(&ws).join("events.jsonl"),
+        operation: "reset-agent".to_string(),
+        waited_ms: 30_000,
+    };
+    assert_eq!(
+        err.to_string(),
+        format!(
+            "error: lifecycle lock timeout after 30s\naction: retry or check for hung reset/start\nlog: {}",
+            crate::model::paths::logs_dir(&ws).join("events.jsonl").display()
+        )
+    );
+}
+
+#[test]
+fn lifecycle_lock_lifecycle_rollback_releases_after_timeout() {
+    let ws = temp_ws();
+    let agent = aid("alpha");
+    let held = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &ws,
+        operation: "reset-agent",
+        team: Some("alpha"),
+        agent_id: Some(&agent),
+    })
+    .expect("hold lifecycle lock");
+
+    let waiter_ws = ws.clone();
+    let waiter_agent = aid("beta");
+    let result = std::thread::spawn(move || {
+        acquire_agent_lifecycle_lock_for_test(
+            LifecycleLockRequest {
+                workspace: &waiter_ws,
+                operation: "start-agent",
+                team: Some("alpha"),
+                agent_id: Some(&waiter_agent),
+            },
+            Duration::from_millis(200),
+            Duration::from_secs(5),
+        )
+    })
+    .join()
+    .expect("waiter thread");
+
+    assert!(
+        matches!(result, Err(LifecycleError::LifecycleLockTimeout { operation, .. }) if operation == "start-agent"),
+        "second lifecycle mutator must time out while lock is held"
+    );
+
+    drop(held);
+    acquire_agent_lifecycle_lock_for_test(
+        LifecycleLockRequest {
+            workspace: &ws,
+            operation: "stop-agent",
+            team: Some("alpha"),
+            agent_id: Some(&agent),
+        },
+        Duration::from_millis(200),
+        Duration::from_secs(5),
+    )
+    .expect("lock released after guard drop");
+}
+
+#[test]
+fn lifecycle_lock_long_held_event_records_holder_and_waiter() {
+    let ws = temp_ws();
+    let holder_agent = aid("holder");
+    let waiter_agent = aid("waiter");
+    let _held = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &ws,
+        operation: "restart",
+        team: Some("alpha"),
+        agent_id: Some(&holder_agent),
+    })
+    .expect("hold lifecycle lock");
+
+    let waiter_ws = ws.clone();
+    let result = std::thread::spawn(move || {
+        acquire_agent_lifecycle_lock_for_test(
+            LifecycleLockRequest {
+                workspace: &waiter_ws,
+                operation: "reset-agent",
+                team: Some("alpha"),
+                agent_id: Some(&waiter_agent),
+            },
+            Duration::from_millis(220),
+            Duration::from_millis(50),
+        )
+    })
+    .join()
+    .expect("waiter thread");
+    assert!(matches!(
+        result,
+        Err(LifecycleError::LifecycleLockTimeout { .. })
+    ));
+
+    let events = read_events(&ws);
+    let event = events
+        .iter()
+        .find(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("lifecycle.lock_held_long")
+        })
+        .unwrap_or_else(|| panic!("missing lifecycle.lock_held_long event: {events:?}"));
+    assert_eq!(event["lock_name"], json!("agent-lifecycle"));
+    assert_eq!(event["operation"], json!("reset-agent"));
+    assert_eq!(event["holder"]["operation"], json!("restart"));
+    assert_eq!(event["holder"]["agent_id"], json!("holder"));
+    assert_eq!(event["threshold_ms"], json!(50));
+    assert_eq!(event["timeout_ms"], json!(220));
+    assert!(
+        event["blocked_queue_len"].as_u64().unwrap_or(0) >= 1,
+        "waiter sidecar should be visible while long-held event is emitted"
+    );
+}
+
+#[test]
+fn lifecycle_lock_phase_b_golden_source_guard() {
+    r2_lifecycle_lock_exists_precondition();
+}
+
+#[test]
+fn r2_lifecycle_lock_exists_precondition() {
+    let src = manifest_src();
+    let lock = read_src("lifecycle/lock.rs");
+    assert!(
+        lock.contains("AGENT_LIFECYCLE_LOCK_NAME: &str = \"agent-lifecycle\""),
+        "lifecycle lock name constant must remain explicit"
+    );
+    assert!(
+        lock.contains("LIFECYCLE_LOCK_TIMEOUT: Duration = Duration::from_secs(30)"),
+        "lifecycle lock timeout constant must remain 30s"
+    );
+    assert!(
+        lock.contains("write_lock_held_long_event") && lock.contains("lifecycle.lock_held_long"),
+        "long-held lifecycle lock event must remain wired"
+    );
+
+    let state_hits = source_files(&src.join("state"))
+        .into_iter()
+        .filter(|path| {
+            let text = std::fs::read_to_string(path).unwrap();
+            text.contains("RuntimeLock::acquire") && text.contains("\"state-save\"")
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        state_hits,
+        vec![src.join("state").join("persist.rs")],
+        "state-save lock must stay owned by state/persist.rs"
+    );
+
+    for path in source_files(&src.join("state")) {
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(
+            !text.contains("LifecycleLock")
+                && !text.contains("acquire_agent_lifecycle_lock")
+                && !text.contains("agent-lifecycle"),
+            "state module must not acquire or know lifecycle lock: {}",
+            path.display()
+        );
+    }
+
+    for path in source_files(&src.join("coordinator")) {
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(
+            !text.contains("acquire_agent_lifecycle_lock") && !text.contains("agent-lifecycle"),
+            "coordinator tick path must not block on lifecycle lock: {}",
+            path.display()
+        );
+    }
+
+    for path in source_files(&src) {
+        if path == src.join("state").join("persist.rs") || is_test_source(&path) {
+            continue;
+        }
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(
+            !text.contains("RuntimeLock::acquire"),
+            "production source outside state/persist.rs must not acquire runtime locks directly: {}",
+            path.display()
+        );
+    }
+
+    for path in source_files(&src) {
+        if path.starts_with(src.join("state")) || path.starts_with(src.join("lifecycle")) {
+            continue;
+        }
+        let text = std::fs::read_to_string(&path).unwrap();
+        let lifecycle_topology_authority_entries = [
+            "save_runtime_state_with_lifecycle_topology_authority",
+            "save_team_scoped_state_with_lifecycle_topology_authority",
+            "save_runtime_state_with_team_tombstone_lifecycle_topology_authority",
+            "save_team_scoped_state_with_tombstone_lifecycle_topology_authority",
+        ];
+        assert!(
+            !lifecycle_topology_authority_entries
+                .iter()
+                .any(|entry| text.contains(entry)),
+            "lifecycle topology authority save entry must not be referenced outside lifecycle/state modules: {}",
+            path.display()
+        );
+    }
+
+    let agent = read_src("lifecycle/restart/agent.rs");
+    assert_public_operation(&agent, "start-agent");
+    assert_public_operation(&agent, "stop-agent");
+    assert_public_operation(&agent, "reset-agent");
+    assert_body_is_unlocked(&agent, "pub(crate) fn start_agent_at_paths");
+    assert_body_is_unlocked(&agent, "pub(super) fn stop_agent_at_paths");
+    assert_body_is_unlocked(&agent, "fn reset_agent_at_paths");
+
+    let remove = read_src("lifecycle/restart/remove.rs");
+    assert_public_operation(&remove, "remove-agent");
+    assert_body_is_unlocked(&remove, "fn remove_agent_at_paths");
+    assert!(
+        !remove.contains("start_agent_with_transport"),
+        "remove rollback runs while remove-agent holds the lifecycle lock; it must use lock-free start_agent_at_paths"
+    );
+
+    let launch = read_src("lifecycle/launch.rs");
+    assert_public_operation(&launch, "add-agent");
+    assert_public_operation(&launch, "fork-agent");
+    assert_body_is_unlocked(&launch, "fn add_agent_with_transport_at_paths");
+
+    let rebuild = read_src("lifecycle/restart/rebuild.rs");
+    assert_public_operation(&rebuild, "restart");
+    let drop_idx = rebuild.find("drop(lifecycle_lock);").unwrap();
+    let coordinator_idx = rebuild
+        .find("start_coordinator_for_workspace(&selected.run_workspace)")
+        .unwrap();
+    let readiness_idx = rebuild.find("wait_restart_readiness_or_timeout(").unwrap();
+    assert!(
+        rebuild.contains("let lifecycle_lock = acquire_agent_lifecycle_lock")
+            && drop_idx < coordinator_idx
+            && coordinator_idx < readiness_idx,
+        "restart must release lifecycle lock before coordinator readiness wait"
+    );
+}
+
+fn is_test_source(path: &Path) -> bool {
+    path.components()
+        .any(|component| component.as_os_str() == "tests")
+        || path
+            .file_name()
+            .and_then(|name| name.to_str())
+            .is_some_and(|name| name == "tests.rs" || name.ends_with("_tests.rs"))
+}
+
+fn read_events(workspace: &Path) -> Vec<serde_json::Value> {
+    let path = crate::model::paths::logs_dir(workspace).join("events.jsonl");
+    std::fs::read_to_string(path)
+        .unwrap_or_default()
+        .lines()
+        .filter_map(|line| serde_json::from_str(line).ok())
+        .collect()
+}
+
+fn manifest_src() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src")
+}
+
+fn read_src(path: &str) -> String {
+    std::fs::read_to_string(manifest_src().join(path)).unwrap()
+}
+
+fn source_files(root: &Path) -> Vec<PathBuf> {
+    let mut out = Vec::new();
+    collect_rs_files(root, &mut out);
+    out.sort();
+    out
+}
+
+fn collect_rs_files(root: &Path, out: &mut Vec<PathBuf>) {
+    for entry in std::fs::read_dir(root).unwrap() {
+        let path = entry.unwrap().path();
+        if path.is_dir() {
+            collect_rs_files(&path, out);
+        } else if path.extension().and_then(|ext| ext.to_str()) == Some("rs") {
+            out.push(path);
+        }
+    }
+}
+
+fn assert_public_operation(source: &str, operation: &str) {
+    assert!(
+        source.contains("acquire_agent_lifecycle_lock")
+            && source.contains(&format!("operation: \"{operation}\"")),
+        "public lifecycle entry must acquire lifecycle lock for {operation}"
+    );
+}
+
+fn assert_body_is_unlocked(source: &str, signature: &str) {
+    let body = source
+        .split_once(signature)
+        .unwrap_or_else(|| panic!("missing signature: {signature}"))
+        .1;
+    let body = body
+        .split_once("\n}\n")
+        .map(|(body, _)| body)
+        .unwrap_or(body);
+    assert!(
+        !body.contains("acquire_agent_lifecycle_lock"),
+        "{signature} must remain lock-free to avoid nested reset deadlocks"
+    );
+}

package/crates/team-agent/src/lifecycle/tests/main_preserved.rs

@@ -33,6 +33,7 @@ type RecordedSpawns = LaneSpawns;
 /// every spawn (kind + argv) like `RecordingLaunchTransport`.
 struct SessionProbeRecordingTransport {
     spawns: RecordedSpawns,
+    spawn_targets: std::sync::Mutex<Vec<(String, String, String)>>,
     session_exists: bool,
     // 0.4.10+ reset hard-gate: record killed panes so liveness/has_pane
     // reflect the kill (the gate checks "did stop actually remove the
@@ -47,11 +48,22 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
     }
     fn spawn_first(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
         self.spawns.lock().unwrap().push(("spawn_first".to_string(), argv.to_vec()));
+        self.spawn_targets.lock().unwrap().push((
+            session.as_str().to_string(),
+            window.as_str().to_string(),
+            "%0".to_string(),
+        ));
         Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new("%0"), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
     }
     fn spawn_into(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
         self.spawns.lock().unwrap().push(("spawn_into".to_string(), argv.to_vec()));
-        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(format!("%{}", window.as_str())), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
+        let pane = format!("%{}", window.as_str());
+        self.spawn_targets.lock().unwrap().push((
+            session.as_str().to_string(),
+            window.as_str().to_string(),
+            pane.clone(),
+        ));
+        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(pane), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
     }
     fn inject(&self, _t: &crate::transport::Target, _p: &crate::transport::InjectPayload, _s: crate::transport::Key, _b: bool) -> Result<crate::transport::InjectReport, crate::transport::TransportError> {
         unimplemented!("not reached by start_agent respawn")
@@ -84,7 +96,25 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
         Ok(())
     }
     fn list_targets(&self) -> Result<Vec<crate::transport::PaneInfo>, crate::transport::TransportError> {
-        Ok(Vec::new())
+        Ok(self
+            .spawn_targets
+            .lock()
+            .unwrap()
+            .iter()
+            .map(|(session, window, pane)| crate::transport::PaneInfo {
+                pane_id: crate::transport::PaneId::new(pane.as_str()),
+                session: crate::transport::SessionName::new(session.as_str()),
+                window_index: None,
+                window_name: Some(crate::transport::WindowName::new(window.as_str())),
+                pane_index: None,
+                tty: None,
+                current_command: Some("node".to_string()),
+                current_path: None,
+                active: false,
+                pane_pid: Some(6856),
+                leader_env: std::collections::BTreeMap::new(),
+            })
+            .collect())
     }
     fn has_session(&self, _s: &crate::transport::SessionName) -> Result<bool, crate::transport::TransportError> {
         Ok(self.session_exists)
@@ -133,7 +163,7 @@ fn start_agent_respawn_into_dead_session_uses_new_session_not_new_window() {
     let ws = respawn_ws_one_resumable_worker();
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     // session_exists=false models the dead CP-1 `-L` server after --discard-session.
-    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), session_exists: false, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
+    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: false, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
     let _ = start_agent_with_transport(&ws, &AgentId::new("alpha"), false, false, false, None, &transport);
     let recorded = spawns.lock().unwrap().clone();
     assert_eq!(recorded.len(), 1, "exactly one respawn for alpha; got {recorded:?}");
@@ -165,7 +195,7 @@ fn reset_agent_discard_session_rebuilds_window_via_start_respawn() {
     let ws = restart_ws_two_resumable_workers(); // compiled spec + state(alpha,bravo running) + seeded coordinator
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     // live session present (other workers keep it alive) but alpha's window was discarded.
-    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
+    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
     let _ = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport);
     let recorded = spawns.lock().unwrap().clone();
     assert!(
@@ -203,7 +233,7 @@ fn reset_agent_discard_session_syncs_projection_epoch_inputs_for_restart_agent_c
 
     let before = chrono::Utc::now();
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
-    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
+    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
     let outcome = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport)
         .expect("reset-agent alpha --discard-session --no-display");
     assert!(