@team-agent/installer 0.2.11 → 0.3.1

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

@@ -0,0 +1,502 @@
+//! status_port extracted from cli::mod inline placeholder.
+use super::*;
+use crate::transport::Transport;
+
+    /// `status.status(workspace, as_json, compact)`(`queries.py:33`,**有副作用**:capture→refresh→save)。
+    pub fn status(workspace: &Path, compact: bool, detail: bool) -> Result<Value, CliError> {
+        let _ = detail;
+        let state = read_runtime_state(workspace);
+        let health = crate::coordinator::coordinator_health(
+            &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
+        );
+        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 agents = enrich_agents(state.get("agents"));
+        let tasks = state
+            .get("tasks")
+            .cloned()
+            .unwrap_or_else(|| json!([]));
+        let leader_receiver = state
+            .get("leader_receiver")
+            .cloned()
+            .unwrap_or_else(|| json!({}));
+        let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
+        let full = json!({
+            "team": state.pointer("/leader/id").cloned().unwrap_or_else(|| json!("leader")),
+            "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
+            "tmux_session_present": tmux_session_present(workspace, session_name.as_str()),
+            "leader_receiver": leader_receiver,
+            "teams": state.get("teams").cloned().unwrap_or_else(|| json!({})),
+            "agents": agents,
+            "agent_health": agent_health(&conn)?,
+            "tasks": tasks,
+            "messages": message_counts(&conn)?,
+            "queued_messages": queued_messages(&conn, 8)?,
+            "results": result_counts(&conn)?,
+            "latest_results": json!([]),
+            "coordinator": coordinator_health_value(health),
+            "last_events": Value::Array(
+                crate::event_log::EventLog::new(workspace)
+                    .tail(10)
+                    .map_err(|e| CliError::Runtime(e.to_string()))?,
+            ),
+        });
+        if compact {
+            Ok(compact_status(full))
+        } else {
+            Ok(full)
+        }
+    }
+    /// `status.format_status(workspace, agent)`(人读)。
+    pub fn format_status(workspace: &Path, agent: Option<&str>) -> Result<String, CliError> {
+        let status = status(workspace, true, false)?;
+        Ok(match agent {
+            Some(agent) => format!("agent {agent}: {}", status.pointer("/agents").is_some()),
+            None => crate::cli::format_status_summary(&status),
+        })
+    }
+    /// `status.approvals(workspace, agent_id)`(JSON)/`format_approvals`(人读)。
+    pub fn approvals(workspace: &Path, agent: Option<&str>, as_json: bool) -> Result<Value, CliError> {
+        let _ = as_json;
+        let state = read_runtime_state(workspace);
+        let session = state.get("session_name").and_then(Value::as_str).filter(|s| !s.is_empty());
+        let mut approvals = Vec::new();
+        if let (Some(session), Some(agents)) = (session, state.get("agents").and_then(Value::as_object)) {
+            let run_ws = crate::model::paths::canonical_run_workspace(workspace)
+                .unwrap_or_else(|_| workspace.to_path_buf());
+            let backend = crate::tmux_backend::TmuxBackend::for_workspace(&run_ws);
+            for (agent_id, agent_state) in agents {
+                if agent.is_some_and(|wanted| wanted != agent_id) {
+                    continue;
+                }
+                let window = agent_window(agent_id, agent_state);
+                let target = crate::transport::Target::SessionWindow {
+                    session: crate::transport::SessionName::new(session.to_string()),
+                    window: crate::transport::WindowName::new(window.clone()),
+                };
+                let Ok(captured) = backend.capture(&target, crate::transport::CaptureRange::Tail(120)) else {
+                    continue;
+                };
+                if let Some(prompt) = crate::provider::extract_approval_prompt(agent_id, &captured.text) {
+                    approvals.push(prompt.to_ordered_value());
+                }
+            }
+        }
+        let waiting_count = approvals.len();
+        Ok(json!({
+            "ok": true,
+            "waiting": waiting_count > 0,
+            "waiting_count": waiting_count,
+            "approvals": approvals,
+            "scan": {
+                "mode": "tail",
+                "lines": 120,
+                "raw_output": false,
+            },
+        }))
+    }
+
+    pub fn format_approvals(value: &Value) -> String {
+        let approvals = value
+            .get("approvals")
+            .and_then(Value::as_array)
+            .map(Vec::as_slice)
+            .unwrap_or(&[]);
+        if approvals.is_empty() {
+            return "No pending approvals.".to_string();
+        }
+        approvals
+            .iter()
+            .map(|approval| {
+                let agent = approval.get("agent_id").and_then(Value::as_str).unwrap_or("-");
+                let kind = approval.get("kind").and_then(Value::as_str).unwrap_or("unknown");
+                let prompt = approval
+                    .get("prompt")
+                    .and_then(Value::as_str)
+                    .or_else(|| approval.get("subject").and_then(Value::as_str))
+                    .unwrap_or("-");
+                format!("{agent}: {kind} {prompt}")
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+    /// `status.inbox(workspace, agent, limit, since)`(JSON)/`format_inbox`(人读)。
+    pub fn inbox(
+        workspace: &Path,
+        agent: &str,
+        limit: usize,
+        since: Option<&str>,
+        as_json: bool,
+    ) -> Result<Value, CliError> {
+        let _ = as_json;
+        let store = crate::message_store::MessageStore::open(workspace)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut messages = store
+            .inbox(agent, limit, None)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        if let Some(cutoff) = since.and_then(parse_rfc3339) {
+            messages.retain(|message| {
+                message
+                    .get("created_at")
+                    .and_then(Value::as_str)
+                    .and_then(parse_rfc3339)
+                    .is_some_and(|created| created >= cutoff)
+            });
+        }
+        Ok(json!({
+            "ok": true,
+            "agent_id": agent,
+            "messages": messages,
+            "since": since,
+        }))
+    }
+
+    fn parse_rfc3339(value: &str) -> Option<chrono::DateTime<chrono::FixedOffset>> {
+        chrono::DateTime::parse_from_rfc3339(value).ok()
+    }
+
+    fn read_runtime_state(workspace: &Path) -> Value {
+        let path = workspace.join(".team").join("runtime").join("state.json");
+        std::fs::read_to_string(path)
+            .ok()
+            .and_then(|s| serde_json::from_str(&s).ok())
+            .unwrap_or_else(|| json!({}))
+    }
+
+    fn agent_window(agent_id: &str, agent_state: &Value) -> String {
+        ["window", "window_name"]
+            .iter()
+            .find_map(|key| agent_state.get(*key).and_then(Value::as_str).filter(|s| !s.is_empty()))
+            .unwrap_or(agent_id)
+            .to_string()
+    }
+
+    fn enrich_agents(agents: Option<&Value>) -> Value {
+        let Some(Value::Object(input)) = agents else {
+            return json!({});
+        };
+        let mut out = Map::new();
+        for (agent_id, value) in input {
+            match value {
+                Value::Object(obj) => {
+                    let mut enriched = obj.clone();
+                    enriched.insert(
+                        "interacted".to_string(),
+                        Value::String(interacted_marker(obj.get("first_send_at"))),
+                    );
+                    out.insert(agent_id.clone(), Value::Object(enriched));
+                }
+                _ => {
+                    out.insert(agent_id.clone(), value.clone());
+                }
+            }
+        }
+        Value::Object(out)
+    }
+
+    fn interacted_marker(value: Option<&Value>) -> String {
+        let Some(raw) = value.and_then(Value::as_str) else {
+            return "never".to_string();
+        };
+        if raw.is_empty() {
+            return "never".to_string();
+        }
+        if chrono::DateTime::parse_from_rfc3339(raw).is_ok() {
+            raw.to_string()
+        } else {
+            "never".to_string()
+        }
+    }
+
+    fn tmux_session_present(workspace: &Path, session_name: Option<&str>) -> bool {
+        let Some(name) = session_name else {
+            return false;
+        };
+        if name.is_empty() {
+            return false;
+        }
+        let run_ws = crate::model::paths::canonical_run_workspace(workspace)
+            .unwrap_or_else(|_| workspace.to_path_buf());
+        crate::tmux_backend::TmuxBackend::for_workspace(&run_ws)
+            .has_session(&crate::transport::SessionName::new(name))
+            .unwrap_or(false)
+    }
+
+    fn message_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
+        status_counts(conn, "messages")
+    }
+
+    fn result_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
+        let by_status = result_status_counts(conn)?;
+        let total = count_rows(conn, "results")?;
+        let invalid = count_where_status(conn, "results", "invalid")?;
+        let collected = count_where_status(conn, "results", "collected")?;
+        let uncollected = total.saturating_sub(collected).saturating_sub(invalid);
+        Ok(json!({
+            "total": total,
+            "uncollected": uncollected,
+            "collected": collected,
+            "invalid": invalid,
+            "by_status": by_status,
+        }))
+    }
+
+    fn status_counts(conn: &rusqlite::Connection, table: &str) -> Result<Value, CliError> {
+        let sql = format!("select status, count(*) from {table} group by status order by status");
+        let mut stmt = conn.prepare(&sql).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut out = 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()))?;
+            out.insert(status, json!(count));
+        }
+        Ok(Value::Object(out))
+    }
+
+    fn result_status_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
+        let mut stmt = conn
+            .prepare(
+                "select status, count(*) from results
+                 where status not in ('collected', 'invalid')
+                 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 out = 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()))?;
+            out.insert(status, json!(count));
+        }
+        Ok(Value::Object(out))
+    }
+
+    fn queued_messages(conn: &rusqlite::Connection, limit: usize) -> Result<Value, CliError> {
+        let limit = i64::try_from(limit).unwrap_or(i64::MAX);
+        let mut stmt = conn
+            .prepare(
+                "select message_id, recipient, status, created_at, delivery_attempts
+                 from messages
+                 where status like 'queued%'
+                 order by created_at desc
+                 limit ?1",
+            )
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let rows = stmt
+            .query_map([limit], |row| {
+                Ok(json!({
+                    "message_id": row.get::<_, String>(0)?,
+                    "recipient": row.get::<_, Option<String>>(1)?,
+                    "status": row.get::<_, String>(2)?,
+                    "created_at": row.get::<_, Option<String>>(3)?,
+                    "delivery_attempts": row.get::<_, i64>(4)?,
+                }))
+            })
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let values = rows
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        Ok(Value::Array(values))
+    }
+
+    fn compact_status(full: Value) -> Value {
+        json!({
+            "team": full.get("team").cloned().unwrap_or(Value::Null),
+            "session_name": full.get("session_name").cloned().unwrap_or(Value::Null),
+            "tmux_session_present": full.get("tmux_session_present").cloned().unwrap_or(Value::Bool(false)),
+            "leader_receiver": compact_object(full.get("leader_receiver"), &[
+                "status", "provider", "mode", "session_name", "window_name", "pane_id", "pane_current_command",
+            ]),
+            "agents": compact_agents(full.get("agents")),
+            "agent_health": full.get("agent_health").cloned().unwrap_or_else(|| json!({})),
+            "tasks": compact_tasks(full.get("tasks")),
+            "messages": full.get("messages").cloned().unwrap_or_else(|| json!({})),
+            "queued_messages": take_array(full.get("queued_messages"), 8),
+            "results": full.get("results").cloned().unwrap_or_else(|| json!({})),
+            "latest_results": take_array(full.get("latest_results"), 5),
+            "coordinator": compact_object(full.get("coordinator"), &["status", "pid", "metadata_ok", "schema_ok"]),
+            "last_events": take_array_tail(full.get("last_events"), 10),
+        })
+    }
+
+    fn compact_agents(value: Option<&Value>) -> Value {
+        let Some(Value::Object(input)) = value else {
+            return json!({});
+        };
+        let mut out = Map::new();
+        for (agent_id, agent) in input {
+            out.insert(agent_id.clone(), compact_agent_state(agent_id, agent));
+        }
+        Value::Object(out)
+    }
+
+    fn compact_agent_state(agent_id: &str, agent: &Value) -> Value {
+        let Some(input) = agent.as_object() else {
+            return json!({});
+        };
+        let mut out = Map::new();
+        out.insert(
+            "agent_id".to_string(),
+            input
+                .get("agent_id")
+                .cloned()
+                .unwrap_or_else(|| Value::String(agent_id.to_string())),
+        );
+        for key in [
+            "status",
+            "provider",
+            "model",
+            "tmux_window_present",
+            "session_id",
+            "captured_via",
+            "attribution_confidence",
+        ] {
+            if let Some(value) = input.get(key) {
+                out.insert(key.to_string(), value.clone());
+            }
+        }
+        if let Some(display) = input.get("display") {
+            let compact_display = compact_object(
+                Some(display),
+                &["backend", "status", "workspace_window", "pane_id", "pid", "pids", "reason"],
+            );
+            if compact_display.as_object().is_some_and(|obj| !obj.is_empty()) {
+                out.insert("display".to_string(), compact_display);
+            }
+        }
+        Value::Object(out)
+    }
+
+    fn compact_tasks(value: Option<&Value>) -> Value {
+        let Some(Value::Array(tasks)) = value else {
+            return json!([]);
+        };
+        Value::Array(
+            tasks.iter()
+                .map(|task| compact_object(Some(task), &["id", "title", "status", "assignee", "type"]))
+                .collect(),
+        )
+    }
+
+    fn compact_object(value: Option<&Value>, keys: &[&str]) -> Value {
+        let Some(Value::Object(input)) = value else {
+            return json!({});
+        };
+        let mut out = Map::new();
+        for key in keys {
+            if let Some(value) = input.get(*key) {
+                out.insert((*key).to_string(), value.clone());
+            }
+        }
+        Value::Object(out)
+    }
+
+    fn take_array(value: Option<&Value>, limit: usize) -> Value {
+        let Some(Value::Array(items)) = value else {
+            return json!([]);
+        };
+        Value::Array(items.iter().take(limit).cloned().collect())
+    }
+
+    fn take_array_tail(value: Option<&Value>, limit: usize) -> Value {
+        let Some(Value::Array(items)) = value else {
+            return json!([]);
+        };
+        let start = items.len().saturating_sub(limit);
+        Value::Array(items.iter().skip(start).cloned().collect())
+    }
+
+    fn count_rows(conn: &rusqlite::Connection, table: &str) -> Result<i64, CliError> {
+        let sql = format!("select count(*) from {table}");
+        conn.query_row(&sql, [], |row| row.get::<_, i64>(0))
+            .map_err(|e| CliError::Runtime(e.to_string()))
+    }
+
+    fn count_where_status(
+        conn: &rusqlite::Connection,
+        table: &str,
+        status: &str,
+    ) -> Result<i64, CliError> {
+        let sql = format!("select count(*) from {table} where status = ?1");
+        conn.query_row(&sql, [status], |row| row.get::<_, i64>(0))
+            .map_err(|e| CliError::Runtime(e.to_string()))
+    }
+
+    fn agent_health(conn: &rusqlite::Connection) -> Result<Value, CliError> {
+        let mut stmt = conn
+            .prepare(
+                "select agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at, owner_team_id
+                 from agent_health order by agent_id",
+            )
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut out = Map::new();
+        while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
+            let agent_id: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
+            let status: String = row.get(1).map_err(|e| CliError::Runtime(e.to_string()))?;
+            let mut item = Map::new();
+            item.insert("status".to_string(), json!(status));
+            item.insert(
+                "health_status".to_string(),
+                json!(crate::provider::agent_health_status(
+                    item.get("status").and_then(Value::as_str).unwrap_or("")
+                )),
+            );
+            insert_optional_string(&mut item, "last_output_at", row.get(2).map_err(|e| CliError::Runtime(e.to_string()))?);
+            insert_optional_i64(&mut item, "context_usage_pct", row.get(3).map_err(|e| CliError::Runtime(e.to_string()))?);
+            insert_optional_string(&mut item, "current_task_id", row.get(4).map_err(|e| CliError::Runtime(e.to_string()))?);
+            item.insert(
+                "updated_at".to_string(),
+                json!(row.get::<_, String>(5).map_err(|e| CliError::Runtime(e.to_string()))?),
+            );
+            insert_optional_string(&mut item, "owner_team_id", row.get(6).map_err(|e| CliError::Runtime(e.to_string()))?);
+            out.insert(agent_id, Value::Object(item));
+        }
+        Ok(Value::Object(out))
+    }
+
+    fn insert_optional_string(map: &mut Map<String, Value>, key: &str, value: Option<String>) {
+        if let Some(value) = value {
+            map.insert(key.to_string(), Value::String(value));
+        }
+    }
+
+    fn insert_optional_i64(map: &mut Map<String, Value>, key: &str, value: Option<i64>) {
+        if let Some(value) = value {
+            map.insert(key.to_string(), json!(value));
+        }
+    }
+
+    fn coordinator_health_value(health: crate::coordinator::HealthReport) -> Value {
+        json!({
+            "ok": health.ok,
+            "status": coordinator_status_wire(health.status),
+            "pid": health.pid.map(|p| p.get()),
+            "metadata": health.metadata.map(|m| json!({
+                "pid": m.pid.get(),
+                "protocol_version": m.protocol_version,
+                "message_store_schema_version": m.message_store_schema_version,
+                "source": m.source,
+                "updated_at": m.updated_at,
+            })),
+            "metadata_ok": health.metadata_ok,
+            "schema_ok": health.schema.ok,
+            "schema_error": health.schema.error.map(|e| format!("{e:?}")),
+            "schema": {
+                "message_store_schema_version": health.schema.schema_version,
+            },
+        })
+    }
+
+    fn coordinator_status_wire(status: crate::coordinator::CoordinatorHealthStatus) -> &'static str {
+        match status {
+            crate::coordinator::CoordinatorHealthStatus::Missing => "missing",
+            crate::coordinator::CoordinatorHealthStatus::InvalidPid => "invalid_pid",
+            crate::coordinator::CoordinatorHealthStatus::Running => "running",
+            crate::coordinator::CoordinatorHealthStatus::Stale => "stale",
+        }
+    }