tuffcli 0.5.0

Capability lifecycle manager for coding agents.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! `tuff mcp doctor` (RFC-102 stage d, extended by RFC-106 milestone 2) —
//! reach each installed `mcp-server` capability's real server, complete the
//! MCP handshake, and report whether it's actually working, not just
//! configured. Stdio servers are spawned, HTTP servers are dialed. See
//! `crate::mcp_client` for the probe itself.

use std::path::Path;
use std::time::Duration;

use serde::Serialize;

use crate::error::Result;
use crate::lockfile;
use crate::manifest::CapabilityType;
use crate::mcp_client::{self, ProbeReport};

use super::{home_dir, paint, render_table};

#[derive(Serialize)]
struct DoctorRow {
    id: String,
    transport: String,
    harnesses: Vec<String>,
    status: String,
    detail: String,
    tools: Vec<String>,
}

pub fn cmd_mcp_doctor(
    repo_root: &Path,
    agent_filter: &[String],
    global: bool,
    json: bool,
    ignore_failures: bool,
    timeout_secs: u64,
) -> Result<()> {
    let (scope_root, scope) = if global {
        (home_dir()?, crate::resolver::Scope::Global)
    } else {
        (repo_root.to_path_buf(), crate::resolver::Scope::Project)
    };
    let lf = lockfile::require_scoped_lockfile(&scope_root, scope)?;

    let mut candidates: Vec<(String, crate::manifest::McpServerConfig, Vec<String>)> = lf
        .capabilities
        .iter()
        .filter(|(_, entry)| entry.capability_type == CapabilityType::McpServer)
        .filter_map(|(id, entry)| {
            let server = entry.server.clone()?;
            let mut harnesses: Vec<String> = entry.targets.keys().cloned().collect();
            harnesses.sort();
            if !agent_filter.is_empty() && !harnesses.iter().any(|h| agent_filter.contains(h)) {
                return None;
            }
            Some((id.clone(), server, harnesses))
        })
        .collect();
    candidates.sort_by(|a, b| a.0.cmp(&b.0));

    if candidates.is_empty() {
        println!(
            "no mcp-server capabilities installed in {} scope",
            if global { "global" } else { "project" }
        );
        return Ok(());
    }

    let timeout = Duration::from_secs(timeout_secs);
    let reports: Vec<ProbeReport> = super::block_on_oci(async {
        let mut reports = Vec::with_capacity(candidates.len());
        for (_, server, _) in &candidates {
            reports.push(mcp_client::probe(server, timeout).await);
        }
        Ok(reports)
    })?;

    let rows: Vec<DoctorRow> = candidates
        .into_iter()
        .zip(reports)
        .map(|((id, server, harnesses), report)| DoctorRow {
            id,
            transport: server.transport.as_str().to_string(),
            harnesses,
            status: report.status.to_string(),
            detail: report.detail,
            tools: report.tools,
        })
        .collect();

    let all_ok = rows.iter().all(|row| row.status == "ok");

    if json {
        println!("{}", serde_json::to_string_pretty(&rows)?);
    } else {
        let table_rows: Vec<Vec<String>> = rows
            .iter()
            .map(|row| {
                vec![
                    row.id.clone(),
                    row.transport.clone(),
                    row.harnesses.join(", "),
                    style_doctor_status(&row.status),
                    row.detail.clone(),
                ]
            })
            .collect();
        println!(
            "{}",
            render_table(
                &["ID", "TRANSPORT", "HARNESSES", "STATUS", "DETAIL"],
                &table_rows
            )
        );
    }

    if !all_ok && !ignore_failures {
        std::process::exit(1);
    }
    Ok(())
}

fn style_doctor_status(status: &str) -> String {
    match status {
        "ok" => format!("{} {}", paint("✓", "32"), paint("ok", "32")),
        // Nothing was wrong with the server; it was never asked.
        "missing env" => format!("{} {}", paint("?", "33"), paint("missing env", "33")),
        other => format!("{} {}", paint("✗", "31"), paint(other, "31")),
    }
}