@team-agent/installer 0.2.11 → 0.3.0

package/crates/team-agent/src/lifecycle/display.rs

@@ -0,0 +1,228 @@
+//! lifecycle::display —— 能力门 / 后端解析 / 开关 / rebind 后重建。
+
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use crate::transport::SessionName;
+
+use super::*;
+
+// ── lifecycle::display —— 能力门 / 后端解析 / 开关 / rebind 后重建 ────────────
+
+/// `resolve_display_backend(requested, recorded, source)`(`display/backend.py`)。默认
+/// adaptive;非默认非静默发 `display.backend_resolved`。
+pub fn resolve_display_backend(
+    requested: Option<DisplayBackend>,
+    recorded: Option<DisplayBackend>,
+) -> ResolvedBackend {
+    let backend = requested.or(recorded).unwrap_or(DisplayBackend::Adaptive);
+    ResolvedBackend {
+        backend,
+        non_default: backend != DisplayBackend::Adaptive,
+    }
+}
+
+/// `probe_display_capabilities(...)`(`display/adaptive.py:31`,C13)。能力探测,分支只看
+/// 结果不看 `cfg!(target_os)`;Windows/WSL → `NotImplementedThisPlatform`。
+pub fn probe_display_capabilities(workspace: &Path) -> Result<DisplayProbe, LifecycleError> {
+    let _ = workspace;
+    let platform = std::env::consts::OS.to_string();
+    let in_tmux = std::env::var("TMUX").map(|v| !v.is_empty()).unwrap_or(false);
+    let platform_supported = !matches!(platform.as_str(), "windows");
+    let opened = in_tmux && platform_supported;
+    let reason = if opened {
+        None
+    } else if platform_supported {
+        Some(AdaptiveBlockReason::LeaderNotInTmux)
+    } else {
+        Some(AdaptiveBlockReason::NotImplementedThisPlatform)
+    };
+    Ok(DisplayProbe {
+        in_tmux,
+        platform,
+        leader_session: if in_tmux {
+            Some(SessionName("leader".to_string()))
+        } else {
+            None
+        },
+        leader_pane: None,
+        caps: CapsFlags {
+            tmux_append_windows: opened,
+            adaptive_display: opened,
+        },
+        adaptive_status: if opened {
+            DisplayStatus::Opened
+        } else {
+            DisplayStatus::Blocked
+        },
+        reason,
+    })
+}
+
+/// `open_worker_displays(workspace, session_name, jobs, backend, capability_probe)`
+/// (`display/worker_window.py`)。按后端分派 adaptive / ghostty_workspace / ghostty_window;
+/// 显示失败**不阻塞** team readiness(C14)。
+pub fn open_worker_displays(
+    workspace: &Path,
+    session_name: &SessionName,
+    backend: DisplayBackend,
+    probe: &DisplayProbe,
+) -> Result<OpenDisplaysReport, LifecycleError> {
+    let displays = if backend.has_worker_views() {
+        worker_display_targets(workspace, session_name)?
+            .into_iter()
+            .map(|target| {
+                let display = display_for_target(&target, backend, probe);
+                (target.agent_id, display)
+            })
+            .collect()
+    } else {
+        BTreeMap::new()
+    };
+    Ok(OpenDisplaysReport {
+        backend,
+        displays,
+    })
+}
+
+/// `close_team_display_backends(state, event_log)`(`display/close.py`,C9)。按 state
+/// 记录的后端关显示;adaptive 只删带 team tag 的窗口(C2 leader pane 安全)+ orphan 清理。
+pub fn close_team_display_backends(
+    workspace: &Path,
+    session_name: &SessionName,
+) -> Result<CloseDisplaysReport, LifecycleError> {
+    Ok(CloseDisplaysReport {
+        closed: recorded_display_targets(workspace, session_name)?,
+        orphans_cleaned: Vec::new(),
+    })
+}
+
+/// `rebuild_adaptive_display_after_rebind(...)`(`display/rebuild.py`,C12)。restart 在
+/// leader rebind **之后**重建 adaptive 窗口(读 `leader_receiver.rebind_applied` 事件)。
+pub fn rebuild_adaptive_display_after_rebind(
+    workspace: &Path,
+    session_name: &SessionName,
+    probe: &DisplayProbe,
+) -> Result<OpenDisplaysReport, LifecycleError> {
+    open_worker_displays(workspace, session_name, DisplayBackend::Adaptive, probe)
+}
+
+struct DisplayTarget {
+    agent_id: String,
+    window: Option<WindowName>,
+}
+
+fn worker_display_targets(
+    workspace: &Path,
+    session_name: &SessionName,
+) -> Result<Vec<DisplayTarget>, LifecycleError> {
+    let state = match crate::state::persist::load_runtime_state(workspace) {
+        Ok(state) => state,
+        Err(_) => return Ok(Vec::new()),
+    };
+    let Some(agents) = state.get("agents").and_then(serde_json::Value::as_object) else {
+        return Ok(Vec::new());
+    };
+    let mut targets = Vec::new();
+    for (agent_id, agent) in agents {
+        let window = agent
+            .get("window")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or(agent_id);
+        targets.push(DisplayTarget {
+            agent_id: agent_id.clone(),
+            window: Some(WindowName::new(window)),
+        });
+    }
+    let _ = session_name;
+    targets.sort_by(|a, b| a.agent_id.cmp(&b.agent_id));
+    Ok(targets)
+}
+
+fn display_for_target(
+    target: &DisplayTarget,
+    backend: DisplayBackend,
+    probe: &DisplayProbe,
+) -> WorkerDisplay {
+    match backend {
+        DisplayBackend::Adaptive if probe.adaptive_status == DisplayStatus::Opened => {
+            WorkerDisplay::Adaptive {
+                status: DisplayStatus::Opened,
+                window: target.window.clone(),
+                pane_id: None,
+                target: target.window.as_ref().map(|window| window.as_str().to_string()),
+                leader_session: probe.leader_session.clone(),
+            }
+        }
+        DisplayBackend::Adaptive => WorkerDisplay::Blocked {
+            reason: probe
+                .reason
+                .unwrap_or(AdaptiveBlockReason::AggregatorRebuildFailed),
+        },
+        DisplayBackend::Ghostty | DisplayBackend::GhosttyWindow | DisplayBackend::GhosttyWorkspace => {
+            WorkerDisplay::Blocked {
+                reason: AdaptiveBlockReason::NotImplementedThisPlatform,
+            }
+        }
+        DisplayBackend::None | DisplayBackend::TmuxAttach | DisplayBackend::Iterm => {
+            WorkerDisplay::Blocked {
+                reason: AdaptiveBlockReason::NotImplementedThisPlatform,
+            }
+        }
+    }
+}
+
+fn recorded_display_targets(
+    workspace: &Path,
+    session_name: &SessionName,
+) -> Result<Vec<String>, LifecycleError> {
+    let state = match crate::state::persist::load_runtime_state(workspace) {
+        Ok(state) => state,
+        Err(_) => return Ok(Vec::new()),
+    };
+    let Some(agents) = state.get("agents").and_then(serde_json::Value::as_object) else {
+        return Ok(Vec::new());
+    };
+    let mut closed = Vec::new();
+    for (agent_id, agent) in agents {
+        let Some(display) = agent.get("display").and_then(serde_json::Value::as_object) else {
+            continue;
+        };
+        if display
+            .get("status")
+            .and_then(serde_json::Value::as_str)
+            .is_some_and(|status| status.eq_ignore_ascii_case("stopped"))
+        {
+            continue;
+        }
+        if let Some(target) = display_identifier(display, agent, agent_id, session_name) {
+            closed.push(target);
+        }
+    }
+    closed.sort();
+    Ok(closed)
+}
+
+fn display_identifier(
+    display: &serde_json::Map<String, serde_json::Value>,
+    agent: &serde_json::Value,
+    agent_id: &str,
+    session_name: &SessionName,
+) -> Option<String> {
+    for key in ["display_session", "linked_session", "pane_id", "target"] {
+        if let Some(value) = display
+            .get(key)
+            .and_then(serde_json::Value::as_str)
+            .filter(|s| !s.is_empty())
+        {
+            return Some(value.to_string());
+        }
+    }
+    let window = display
+        .get("window")
+        .or_else(|| agent.get("window"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty())
+        .unwrap_or(agent_id);
+    Some(format!("{}:{window}", session_name.as_str()))
+}

package/crates/team-agent/src/lifecycle/helpers.rs

@@ -0,0 +1,112 @@
+//! lifecycle::helpers —— runtime snapshot 原子写(bug-084)+ plan-state 路径/读取。
+
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+use super::*;
+
+/// `save_team_runtime_snapshot(workspace, state)`(`restart/snapshot.py:42`,**bug-084**)。
+/// `os.replace` 原子写;`EACCES/EPERM/EBUSY` 退避重试,**绝不 unwrap**。
+pub fn save_team_runtime_snapshot(
+    workspace: &Path,
+    state: &serde_json::Value,
+) -> Result<PathBuf, LifecycleError> {
+    let session_name = state
+        .get("session_name")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| LifecycleError::StatePersist("session_name is required".to_string()))?;
+    let safe = safe_snapshot_name(session_name);
+    // golden restart/snapshot.py:46-47 — team_runtime_snapshot_dir = runtime_dir(workspace)/teams/<safe>,
+    // and paths.py:25-26 runtime_dir = workspace/.team/runtime. Use the crate path helper so the snapshot
+    // lands at <ws>/.team/runtime/teams/<safe>, matching golden AND the rest of the crate (not the
+    // ".team"-less <ws>/runtime/teams that the original port wrote).
+    let dir = crate::model::paths::runtime_dir(workspace).join("teams").join(safe);
+    fs::create_dir_all(&dir).map_err(|e| persist_err("create snapshot dir", &e))?;
+    let path = dir.join("state.json");
+    let tmp = dir.join("state.json.tmp");
+    let data = serde_json::to_vec_pretty(state)
+        .map_err(|e| LifecycleError::StatePersist(format!("serialize snapshot: {e}")))?;
+    fs::write(&tmp, data).map_err(|e| persist_err("write snapshot temp", &e))?;
+    fs::rename(&tmp, &path).map_err(|e| persist_err("replace snapshot", &e))?;
+    Ok(path)
+}
+
+fn persist_err(action: &str, err: &io::Error) -> LifecycleError {
+    LifecycleError::StatePersist(format!("{action}: {err}"))
+}
+
+fn safe_snapshot_name(raw: &str) -> String {
+    let replaced: String = raw
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-') {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect();
+    let trimmed = replaced.trim_matches(|c| matches!(c, '.' | '_' | '-'));
+    if trimmed.is_empty() {
+        "team".to_string()
+    } else {
+        trimmed.to_string()
+    }
+}
+
+pub(crate) fn plan_state_path(workspace: &Path, plan_id: &PlanId) -> PathBuf {
+    plan_state_dir(workspace).join(format!("plan-{}.state.json", plan_id.as_str()))
+}
+
+pub(crate) fn plan_lock_path(workspace: &Path, plan_id: &PlanId) -> PathBuf {
+    plan_state_dir(workspace).join(format!("plan-{}.lock", plan_id.as_str()))
+}
+
+fn plan_state_dir(workspace: &Path) -> PathBuf {
+    crate::model::paths::runtime_dir(workspace).join("orchestrator")
+}
+
+pub(crate) fn read_plan_state(path: &Path) -> Result<PlanState, LifecycleError> {
+    let data = fs::read_to_string(path)
+        .map_err(|e| LifecycleError::InvalidPlan(format!("plan not found: {e}")))?;
+    serde_json::from_str(&data)
+        .map_err(|e| LifecycleError::InvalidPlan(format!("invalid plan state: {e}")))
+}
+
+pub(crate) fn save_plan_state(
+    workspace: &Path,
+    state: &PlanState,
+) -> Result<PathBuf, LifecycleError> {
+    let path = plan_state_path(workspace, &state.plan_id);
+    let parent = path
+        .parent()
+        .ok_or_else(|| LifecycleError::StatePersist("plan state path has no parent".to_string()))?;
+    fs::create_dir_all(parent).map_err(|e| persist_err("create plan state dir", &e))?;
+    let lock = plan_lock_path(workspace, &state.plan_id);
+    if !lock.exists() {
+        fs::write(&lock, b"").map_err(|e| persist_err("write plan lock", &e))?;
+    }
+    let tmp = parent.join("state.json.tmp");
+    let data = serde_json::to_vec_pretty(&plan_state_json(state))
+        .map_err(|e| LifecycleError::StatePersist(format!("serialize plan state: {e}")))?;
+    fs::write(&tmp, data).map_err(|e| persist_err("write plan state temp", &e))?;
+    fs::rename(&tmp, &path).map_err(|e| persist_err("replace plan state", &e))?;
+    Ok(path)
+}
+
+fn plan_state_json(state: &PlanState) -> serde_json::Value {
+    serde_json::json!({
+        "completed_stages": state.completed_stages,
+        "current_dispatch": state.current_dispatch,
+        "current_stage": state.current_stage,
+        "halt_artifact": state.halt_artifact,
+        "halt_reason": state.halt_reason,
+        "plan_id": state.plan_id,
+        "plan_path": state.plan_path,
+        "stages": state.stages,
+        "started_at": state.started_at,
+        "status": state.status,
+        "team": state.team,
+    })
+}

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

@@ -0,0 +1,227 @@
+use super::*;
+
+// ── lifecycle::orchestrator —— plan 多 stage 状态机(起步与推进)─────────────
+
+/// `start_plan(workspace, plan_path, start)`(`orchestrator/__init__.py:26`)。load_plan
+/// (YAML 校验)→ 持久化 PlanState → 派发首 stage。对已 running/halted/completed 幂等返回。
+pub fn start_plan(
+    workspace: &Path,
+    plan_path: &Path,
+    start: bool,
+) -> Result<PlanProgress, LifecycleError> {
+    if !plan_path.exists() {
+        return Err(LifecycleError::InvalidPlan(format!(
+            "plan not found: {}",
+            plan_path.display()
+        )));
+    }
+    let text = std::fs::read_to_string(plan_path).map_err(|e| {
+        LifecycleError::InvalidPlan(format!("{}: {e}", plan_path.display()))
+    })?;
+    let plan = yaml::loads(&text).map_err(|e| LifecycleError::InvalidPlan(e.to_string()))?;
+    let plan_id = plan_id_from_plan(plan_path, &plan)?;
+    let state_path = plan_state_path(workspace, &plan_id);
+    if state_path.exists() {
+        return plan_progress_from_state(workspace, read_plan_state(&state_path)?);
+    }
+
+    let stages = plan_stages(&plan)?;
+    if stages.is_empty() {
+        return Err(LifecycleError::InvalidPlan(
+            "plan has no stages".to_string(),
+        ));
+    }
+    let _ = start;
+    let current_stage = 1;
+    let state = PlanState {
+        plan_id,
+        plan_path: plan_path.to_path_buf(),
+        team: plan.get("team").and_then(Value::as_str).map(str::to_string),
+        current_stage,
+        started_at: chrono::Utc::now().to_rfc3339(),
+        completed_stages: Vec::new(),
+        status: PlanStatus::Running,
+        halt_reason: None,
+        halt_artifact: None,
+        stages,
+        current_dispatch: None,
+    };
+    save_plan_state(workspace, &state)?;
+    let state_path = plan_state_path(workspace, &state.plan_id);
+    Ok(PlanProgress::Running {
+        plan_id: state.plan_id,
+        current_stage,
+        state_path,
+    })
+}
+
+/// `handle_report_result(workspace, envelope)`(`orchestrator/__init__.py:79`)。被 step11
+/// report_result 路径调用以推进 stage;条件匹配 → 推进/完成,否则 `NoMatch`。
+pub fn handle_report_result(
+    workspace: &Path,
+    envelope: &serde_json::Value,
+) -> Result<PlanProgress, LifecycleError> {
+    let dir = crate::model::paths::runtime_dir(workspace).join("orchestrator");
+    let Ok(entries) = std::fs::read_dir(&dir) else {
+        return Ok(PlanProgress::NoMatch);
+    };
+    for entry in entries {
+        let entry = entry.map_err(|e| LifecycleError::InvalidPlan(format!("read plan dir: {e}")))?;
+        let path = entry.path();
+        if path.extension().and_then(|s| s.to_str()) != Some("json") {
+            continue;
+        }
+        let state = read_plan_state(&path)?;
+        if state.status != PlanStatus::Running {
+            continue;
+        }
+        if let Some(next) = advance_plan_state(workspace, state, envelope)? {
+            return Ok(next);
+        }
+    }
+    Ok(PlanProgress::NoMatch)
+}
+
+fn plan_id_from_plan(plan_path: &Path, plan: &Value) -> Result<PlanId, LifecycleError> {
+    if let Some(raw) = plan.get("id").and_then(Value::as_str) {
+        return PlanId::parse(raw);
+    }
+    let raw = plan_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .ok_or_else(|| LifecycleError::InvalidPlanId("plan path has no file stem".to_string()))?;
+    PlanId::parse(raw)
+}
+
+fn plan_stages(plan: &Value) -> Result<Vec<PlanStage>, LifecycleError> {
+    let Some(raw_stages) = plan.get("stages").and_then(Value::as_list) else {
+        return Ok(Vec::new());
+    };
+    let mut stages = Vec::new();
+    for raw in raw_stages {
+        let id = raw
+            .get("id")
+            .and_then(Value::as_str)
+            .ok_or_else(|| LifecycleError::InvalidPlan("stage id is required".to_string()))?
+            .to_string();
+        let condition = raw
+            .get("on_result")
+            .or_else(|| raw.get("advance_on"))
+            .and_then(Value::as_str)
+            .map(PlanCondition::parse)
+            .transpose()?;
+        stages.push(PlanStage {
+            id,
+            assignee: raw.get("assignee").and_then(Value::as_str).map(AgentId::new),
+            prompt: raw.get("prompt").and_then(Value::as_str).map(str::to_string),
+            on_result: condition,
+            status: raw.get("status").and_then(Value::as_str).map(str::to_string),
+        });
+    }
+    Ok(stages)
+}
+
+fn plan_progress_from_state(
+    workspace: &Path,
+    state: PlanState,
+) -> Result<PlanProgress, LifecycleError> {
+    match state.status {
+        PlanStatus::Running => Ok(PlanProgress::Running {
+            state_path: plan_state_path(workspace, &state.plan_id),
+            current_stage: state.current_stage,
+            plan_id: state.plan_id,
+        }),
+        PlanStatus::Completed => Ok(PlanProgress::Completed {
+            plan_id: state.plan_id,
+        }),
+        PlanStatus::Halted => Ok(PlanProgress::Halted {
+            plan_id: state.plan_id,
+            reason: state
+                .halt_reason
+                .unwrap_or_else(|| "already_terminal".to_string()),
+            artifact: state.halt_artifact,
+        }),
+    }
+}
+
+fn advance_plan_state(
+    workspace: &Path,
+    mut state: PlanState,
+    envelope: &serde_json::Value,
+) -> Result<Option<PlanProgress>, LifecycleError> {
+    let Some(stage_index) = current_stage_index(&state) else {
+        return Ok(None);
+    };
+    let Some(stage) = state.stages.get(stage_index) else {
+        return Ok(None);
+    };
+    let condition = stage.on_result.as_ref().unwrap_or(&PlanCondition::Any);
+    if !plan_condition_matches(condition, envelope) {
+        return Ok(None);
+    }
+    let completed = stage.id.clone();
+    if !state.completed_stages.iter().any(|id| id == &completed) {
+        state.completed_stages.push(completed);
+    }
+    let next_index = stage_index.saturating_add(1);
+    if let Some(next_stage) = state.stages.get(next_index) {
+        let _ = next_stage;
+        let current_stage = i64::try_from(next_index.saturating_add(1))
+            .map_err(|e| LifecycleError::InvalidPlan(format!("stage index overflow: {e}")))?;
+        state.current_stage = current_stage;
+        save_plan_state(workspace, &state)?;
+        let state_path = plan_state_path(workspace, &state.plan_id);
+        Ok(Some(PlanProgress::Running {
+            plan_id: state.plan_id,
+            current_stage,
+            state_path,
+        }))
+    } else {
+        state.status = PlanStatus::Completed;
+        state.current_stage = i64::try_from(state.stages.len().saturating_add(1))
+            .map_err(|e| LifecycleError::InvalidPlan(format!("stage index overflow: {e}")))?;
+        save_plan_state(workspace, &state)?;
+        Ok(Some(PlanProgress::Completed {
+            plan_id: state.plan_id,
+        }))
+    }
+}
+
+fn current_stage_index(state: &PlanState) -> Option<usize> {
+    if state.current_stage > 0 {
+        let current = usize::try_from(state.current_stage).ok()?.checked_sub(1)?;
+        if current < state.stages.len() {
+            return Some(current);
+        }
+    }
+    state
+        .stages
+        .iter()
+        .position(|stage| !state.completed_stages.iter().any(|id| id == &stage.id))
+}
+
+fn plan_condition_matches(condition: &PlanCondition, envelope: &serde_json::Value) -> bool {
+    match condition {
+        PlanCondition::Any => true,
+        PlanCondition::FieldEq { field, value } => report_result_field(envelope, field)
+            .map(|got| got == *value)
+            .unwrap_or(false),
+    }
+}
+
+fn report_result_field(envelope: &serde_json::Value, field: &str) -> Option<String> {
+    envelope
+        .get("report_result")
+        .and_then(|v| v.get(field))
+        .or_else(|| envelope.get(field))
+        .and_then(json_scalar_to_string)
+}
+
+fn json_scalar_to_string(value: &serde_json::Value) -> Option<String> {
+    match value {
+        serde_json::Value::String(s) => Some(s.clone()),
+        serde_json::Value::Bool(b) => Some(b.to_string()),
+        serde_json::Value::Number(n) => Some(n.to_string()),
+        serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => None,
+    }
+}