@team-agent/installer 0.5.111 → 0.5.112

package/crates/team-agent/src/cli/diagnose.rs

@@ -1,5 +1,5 @@
 //!
-//! diagnose/preflight/wait-ready CLI helpers.
+//! diagnose/doctor CLI helpers.
 use super::*;
 use crate::model::pane_authority_refusal::{
     PaneAuthorityRecoveryAction, PaneAuthorityRecoveryHint, PaneAuthorityRefusal,
@@ -1159,7 +1159,6 @@ mod tests {
         );
     }
 
-
     fn write_codex_identity_rollout(
         workspace: &std::path::Path,
         session_id: &str,
@@ -1305,123 +1304,6 @@ mod tests {
     }
 }
 
-pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, CliError> {
-    let mut checks = Vec::new();
-    let mut next_actions = Vec::new();
-
-    let compiled = match crate::compiler::compile_team(team) {
-        Ok(spec) => {
-            checks.push(json!({
-                "name": "compile",
-                "ok": true,
-                "agents": compiled_agent_ids(&spec),
-            }));
-            Some(spec)
-        }
-        Err(error) => {
-            checks.push(json!({
-                "name": "compile",
-                "ok": false,
-                "error": error.to_string(),
-            }));
-            next_actions.push(json!(
-                "fix TEAM.md and role front matter, then run preflight again"
-            ));
-            None
-        }
-    };
-
-    let tmux_path = command_path("tmux");
-    checks.push(json!({
-        "name": "tmux",
-        "ok": tmux_path.is_some(),
-        "path": tmux_path,
-    }));
-    if tmux_path.is_none() {
-        next_actions.push(json!("install tmux or add it to PATH"));
-    }
-
-    let workspace = crate::model::paths::team_workspace(team)
-        .map_err(|error| CliError::Runtime(error.to_string()))?;
-    let profile_dir_exists = workspace
-        .join(".team")
-        .join("current")
-        .join("profiles")
-        .exists()
-        || team.join("profiles").exists();
-    let profile_dir_check = json!({
-        "name": "profile_dir",
-        "ok": true,
-        "status": if profile_dir_exists { "present" } else { "not_required" },
-    });
-    let profile_smoke_check = build_profile_smoke_check_for_team(team)?;
-    if profile_smoke_check.get("ok").and_then(Value::as_bool) == Some(false) {
-        let reason = profile_smoke_check
-            .get("reason")
-            .or_else(|| profile_smoke_check.get("error"))
-            .and_then(Value::as_str)
-            .unwrap_or("profile smoke failed");
-        next_actions.push(json!(format!("fix compatible_api profile smoke: {reason}")));
-    }
-    checks.push(json!({
-        "name": "profiles",
-        "ok": true,
-        "checks": compact_profile_checks(team),
-    }));
-    checks.push(profile_smoke_check);
-    checks.push(if compiled.is_some() {
-        json!({
-            "name": "models",
-            "ok": true,
-        })
-    } else {
-        json!({
-            "name": "models",
-            "ok": true,
-            "status": "skipped",
-        })
-    });
-    checks.push(json!({
-        "name": "core_runtime",
-        "ok": true,
-        "status": core_runtime_status(),
-    }));
-    checks.push(profile_dir_check);
-
-    let blockers = preflight_blockers(&checks);
-    let ok = blockers.is_empty();
-    let summary = if ok {
-        "preflight passed".to_string()
-    } else {
-        format!(
-            "preflight found blockers: {}",
-            blocker_names(&blockers).join(", ")
-        )
-    };
-    let checks_value = Value::Array(checks);
-    let details_log = write_details_log(
-        team,
-        "preflight",
-        &json!({
-            "ok": ok,
-            "summary": summary,
-            "checks": checks_value,
-            "blockers": blockers,
-            "next_actions": next_actions,
-        }),
-    )?;
-    let report = json!({
-        "blockers": blockers,
-        "checks": checks_value,
-        "details_log": details_log.to_string_lossy().to_string(),
-        "next_actions": next_actions,
-        "ok": ok,
-        "summary": summary,
-    });
-    let _ = crate::event_log::EventLog::new(team).write("preflight.complete", report.clone());
-    Ok(report)
-}
-
 pub(crate) fn build_profile_smoke_check_for_team(
     team: &std::path::Path,
 ) -> Result<Value, CliError> {
@@ -1519,179 +1401,7 @@ fn copy_optional_field(from: &Value, to: &mut Value, key: &str) {
     obj.insert(key.to_string(), value);
 }
 
-pub(crate) fn build_wait_ready_report(
-    workspace: &std::path::Path,
-    timeout: f64,
-    team: Option<&str>,
-) -> Result<Value, CliError> {
-    // swallow batch 3 ③: an unreadable runtime state must never read as "ready" — the
-    // read error is surfaced verbatim (state_read_error) with ready=false instead of
-    // silently degrading to an empty/stale state.
-    let selected = match crate::state::selector::resolve_active_team(
-        workspace,
-        team,
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    ) {
-        Ok(selected) => selected,
-        Err(error) => {
-            return Ok(json!({
-                "ok": false,
-                "status": "error",
-                "reason": "state_read_error",
-                "state_read_error": error.to_string(),
-                "readiness": {"ready": false},
-                "summary": "runtime state could not be read",
-                "next_actions": [json!("inspect .team/runtime/state.json (corrupt or unreadable) and retry")],
-            }));
-        }
-    };
-    let timeout = if timeout.is_finite() && timeout > 0.0 {
-        timeout
-    } else {
-        0.0
-    };
-    let deadline = std::time::Instant::now() + std::time::Duration::from_secs_f64(timeout);
-    let mut readiness;
-    let mut state_read_error: Option<String>;
-    loop {
-        let mut state = match crate::state::projection::select_runtime_state(
-            &selected.run_workspace,
-            Some(&selected.team_key),
-        ) {
-            Ok(state) => {
-                state_read_error = None;
-                state
-            }
-            Err(error) => {
-                state_read_error = Some(error.to_string());
-                readiness = json!({"ready": false, "state_read_error": error.to_string()});
-                break;
-            }
-        };
-        inject_tmux_session_present(&selected.run_workspace, &mut state);
-        inject_message_counts(&selected.run_workspace, &mut state)?;
-        readiness = wait_readiness(&state);
-        let awaiting_trust = readiness
-            .get("awaiting_trust_prompt")
-            .and_then(Value::as_bool)
-            == Some(true);
-        let ready = readiness.get("ready").and_then(Value::as_bool) == Some(true);
-        if awaiting_trust || ready || std::time::Instant::now() >= deadline {
-            break;
-        }
-        std::thread::sleep(std::time::Duration::from_millis(100));
-    }
-    let awaiting_trust = readiness
-        .get("awaiting_trust_prompt")
-        .and_then(Value::as_bool)
-        == Some(true);
-    let ready = readiness.get("ready").and_then(Value::as_bool) == Some(true);
-    let (ok, status, reason, summary, next_actions) = if state_read_error.is_some() {
-        (
-            false,
-            "error",
-            "state_read_error",
-            "runtime state could not be read",
-            vec![json!(
-                "inspect .team/runtime/state.json (corrupt or unreadable) and retry"
-            )],
-        )
-    } else if awaiting_trust {
-        (
-            false,
-            "pending",
-            "awaiting_trust_prompt",
-            "workers are awaiting trust prompt",
-            vec![json!(
-                "answer the provider trust prompt, then run wait-ready again"
-            )],
-        )
-    } else if ready {
-        (true, "ready", "ready", "workers ready", Vec::new())
-    } else if readiness
-        .get("session_capture_complete")
-        .and_then(Value::as_bool)
-        == Some(false)
-    {
-        (
-            false,
-            "pending",
-            "session_capture_incomplete",
-            "provider session capture is incomplete",
-            vec![json!("wait for provider session capture before restart")],
-        )
-    } else {
-        (
-            false,
-            "timeout",
-            "workers_not_ready",
-            "workers not ready before timeout",
-            vec![json!(
-                "inspect team-agent doctor output and worker terminals"
-            )],
-        )
-    };
-    let details_log = write_details_log(
-        &selected.run_workspace,
-        "wait-ready",
-        &json!({
-            "ok": ok,
-            "status": status,
-            "reason": reason,
-            "timeout": timeout,
-            "readiness": readiness,
-        }),
-    )?;
-    let mut report = json!({
-        "details_log": details_log.to_string_lossy().to_string(),
-        "next_actions": next_actions,
-        "ok": ok,
-        "reason": reason,
-        "readiness": readiness,
-        "status": status,
-        "summary": summary,
-    });
-    if let Some(error) = state_read_error {
-        report["state_read_error"] = json!(error);
-    }
-    Ok(report)
-}
-
-fn inject_tmux_session_present(workspace: &std::path::Path, state: &mut Value) {
-    // Bug #7 (prerelease 0.4.0 gate review §6): probe the SAME endpoint the
-    // runtime actually uses (state.tmux_endpoint / tmux_socket), not the
-    // workspace-hash socket. Otherwise readiness reports `process_started=false`
-    // even though the session is alive on the persisted socket.
-    let Some(session_name) = state
-        .get("session_name")
-        .and_then(Value::as_str)
-        .filter(|s| !s.is_empty())
-    else {
-        return;
-    };
-    let session_name_owned = session_name.to_string();
-    // 0.5.x Phase 1d Batch 3: factory-routed read path. conpty state
-    // hits the shim; tmux state hits the persisted endpoint (byte-
-    // equivalent). Diagnose no longer reports `tmux_session_missing`
-    // for a conpty team just because it can't find a tmux session on
-    // the workspace socket (design §Batch 3 Verification anchor).
-    let resolved = crate::transport_factory::resolve_read_only_transport(
-        workspace,
-        Some(state),
-        crate::transport_factory::TransportPurpose::Diagnose,
-    );
-    let present = match resolved {
-        Ok(r) => r
-            .backend
-            .has_session(&crate::transport::SessionName::new(session_name_owned))
-            .unwrap_or(false),
-        Err(_) => false,
-    };
-    if let Value::Object(map) = state {
-        map.insert("tmux_session_present".to_string(), Value::Bool(present));
-    }
-}
-
+/// Shared status facts, independent of any polling command.
 pub(crate) fn wait_readiness(state: &Value) -> Value {
     let agents = state.get("agents").and_then(Value::as_object);
     let mut process_started = false;
@@ -1767,29 +1477,6 @@ pub(crate) fn wait_readiness(state: &Value) -> Value {
     })
 }
 
-fn inject_message_counts(workspace: &std::path::Path, state: &mut Value) -> Result<(), CliError> {
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut stmt = conn
-        .prepare("select status, count(*) from messages group by status order by status")
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut rows = stmt
-        .query([])
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut messages = Map::new();
-    while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
-        let status: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
-        let count: i64 = row.get(1).map_err(|e| CliError::Runtime(e.to_string()))?;
-        messages.insert(status, json!(count));
-    }
-    if let Some(obj) = state.as_object_mut() {
-        obj.insert("messages".to_string(), Value::Object(messages));
-    }
-    Ok(())
-}
-
 fn message_counts_positive(value: Option<&Value>) -> bool {
     let Some(Value::Object(counts)) = value else {
         return false;
@@ -1839,98 +1526,6 @@ fn agent_mcp_ready(agent: &Value) -> bool {
         })
 }
 
-fn command_path(command: &str) -> Option<String> {
-    let output = std::process::Command::new("which")
-        .arg(command)
-        .output()
-        .ok()?;
-    if !output.status.success() {
-        return None;
-    }
-    let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
-    if path.is_empty() {
-        None
-    } else {
-        Some(path)
-    }
-}
-
-fn compact_profile_checks(team: &std::path::Path) -> Vec<Value> {
-    let profiles = team.join("profiles");
-    let Ok(entries) = std::fs::read_dir(&profiles) else {
-        return Vec::new();
-    };
-    let mut checks = Vec::new();
-    for entry in entries.filter_map(std::result::Result::ok) {
-        let path = entry.path();
-        if !path.is_file() {
-            continue;
-        }
-        let name = path
-            .file_stem()
-            .and_then(|stem| stem.to_str())
-            .unwrap_or("profile")
-            .to_string();
-        checks.push(json!({
-            "name": name,
-            "ok": true,
-            "path": path.to_string_lossy().to_string(),
-        }));
-    }
-    checks
-}
-
-fn core_runtime_status() -> &'static str {
-    if std::env::current_exe().is_ok() {
-        "available"
-    } else {
-        "python_fallback"
-    }
-}
-
-fn compiled_agent_ids(spec: &crate::model::yaml::Value) -> Vec<String> {
-    spec.get("agents")
-        .and_then(crate::model::yaml::Value::as_list)
-        .map(|agents| {
-            agents
-                .iter()
-                .filter_map(|agent| agent.get("id").and_then(crate::model::yaml::Value::as_str))
-                .map(ToString::to_string)
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
-fn preflight_blockers(checks: &[Value]) -> Vec<Value> {
-    checks
-        .iter()
-        .filter(|check| check.get("ok").and_then(Value::as_bool) == Some(false))
-        .map(|check| {
-            let name = check
-                .get("name")
-                .and_then(Value::as_str)
-                .unwrap_or("unknown");
-            let reason = check
-                .get("error")
-                .or_else(|| check.get("reason"))
-                .and_then(Value::as_str)
-                .unwrap_or("failed");
-            json!({
-                "name": name,
-                "reason": reason,
-            })
-        })
-        .collect()
-}
-
-fn blocker_names(blockers: &[Value]) -> Vec<String> {
-    blockers
-        .iter()
-        .filter_map(|blocker| blocker.get("name").and_then(Value::as_str))
-        .map(ToString::to_string)
-        .collect()
-}
-
 fn yaml_path_str<'a>(value: &'a crate::model::yaml::Value, keys: &[&str]) -> Option<&'a str> {
     let mut current = value;
     for key in keys {
@@ -1939,23 +1534,6 @@ fn yaml_path_str<'a>(value: &'a crate::model::yaml::Value, keys: &[&str]) -> Opt
     current.as_str()
 }
 
-fn write_details_log(
-    workspace: &std::path::Path,
-    prefix: &str,
-    value: &Value,
-) -> Result<std::path::PathBuf, CliError> {
-    let logs = workspace.join(".team").join("logs");
-    std::fs::create_dir_all(&logs)?;
-    let path = logs.join(format!("{prefix}-{}.json", timestamp_slug()));
-    let bytes = serde_json::to_vec_pretty(value)?;
-    std::fs::write(&path, bytes)?;
-    Ok(path)
-}
-
-fn timestamp_slug() -> String {
-    chrono::Utc::now().timestamp().to_string()
-}
-
 pub(crate) fn count_dir_entries(path: &std::path::Path) -> usize {
     std::fs::read_dir(path)
         .map(|entries| entries.filter_map(std::result::Result::ok).count())