dbg-cli 0.2.0

A universal debugger CLI that lets AI agents observe runtime state instead of guessing from source code
Documentation 
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

use dbg_cli::deps::{self, Dependency, DependencyCheck, DepStatus};

/// All dependencies gdbg can use.
fn dependencies() -> Vec<Dependency> {
    vec![
        Dependency {
            name: "nsys",
            check: DependencyCheck::Binary {
                name: "nsys",
                alternatives: &["nsys"],
                version_cmd: None,
            },
            install: "Install NVIDIA Nsight Systems: https://developer.nvidia.com/nsight-systems",
        },
        Dependency {
            name: "ncu",
            check: DependencyCheck::Binary {
                name: "ncu",
                alternatives: &["ncu"],
                version_cmd: None,
            },
            install: "Install NVIDIA Nsight Compute: https://developer.nvidia.com/nsight-compute",
        },
        Dependency {
            name: "python3",
            check: DependencyCheck::Binary {
                name: "python3",
                alternatives: &["python3"],
                version_cmd: Some(("python3", &["--version"])),
            },
            install: "https://python.org or: sudo apt install python3",
        },
        Dependency {
            name: "nvcc",
            check: DependencyCheck::Binary {
                name: "nvcc",
                alternatives: &["nvcc"],
                version_cmd: None,
            },
            install: "Install CUDA toolkit: https://developer.nvidia.com/cuda-downloads",
        },
    ]
}

/// Check all dependencies. Returns (name, Vec<DepStatus>) for consistent formatting.
pub fn check_all() -> Vec<(&'static str, Vec<DepStatus>)> {
    let mut statuses: Vec<DepStatus> = dependencies().into_iter().map(deps::check_dep).collect();

    // If ncu is installed, check whether GPU performance counters are accessible.
    if let Some(ncu) = statuses.iter_mut().find(|s| s.name == "ncu" && s.ok) {
        if gpu_profiling_restricted() {
            ncu.warning = Some(
                "GPU performance counters restricted to admin. ncu will fail.\n\
                 \x20   fix: sudo modprobe nvidia NVreg_RestrictProfilingToAdminUsers=0\n\
                 \x20   persist: echo 'options nvidia NVreg_RestrictProfilingToAdminUsers=0' \
                 | sudo tee /etc/modprobe.d/nvidia-perf.conf"
                    .into(),
            );
        }
    }

    vec![("gdbg", statuses)]
}

/// Check whether the NVIDIA driver restricts GPU profiling to admin users.
/// Reads `/proc/driver/nvidia/params` looking for `RmProfilingAdminOnly: 1`.
fn gpu_profiling_restricted() -> bool {
    let Ok(params) = std::fs::read_to_string("/proc/driver/nvidia/params") else {
        return false; // Can't determine — assume ok
    };
    for line in params.lines() {
        if let Some(rest) = line.strip_prefix("RmProfilingAdminOnly:") {
            return rest.trim() == "1";
        }
    }
    false
}

/// Check that at least nsys is available (minimum for gdbg to be useful).
/// Returns a formatted error message if critical deps are missing.
pub fn check_minimum() -> Option<String> {
    let results = check_all();
    let statuses = &results[0].1;
    let nsys = statuses.iter().find(|d| d.name == "nsys").unwrap();

    if nsys.ok {
        return None;
    }

    Some(deps::format_results(&results))
}

/// Format a full dependency report.
pub fn format_report() -> String {
    deps::format_results(&check_all())
}