otop 0.1.22

A btop-like monitor of CPUs, memory, GPUs (NVIDIA and Apple) and processes, in the terminal
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

//! otop: CPUs, memory, GPUs and processes, in the terminal, like btop.
//!
//! CPUs, memory and processes are read through sysinfo. NVIDIA's GPUs are
//! read through NVML, loaded at run time from NVIDIA's driver, and on macOS
//! Apple's GPUs from the IORegistry. All of it is drawn with ratatui.

mod app;
#[cfg(any(target_os = "macos", test))]
mod apple;
mod gpu;
mod hist;
mod mcp;
#[cfg(not(target_os = "macos"))]
mod nvidia;
mod ps;
mod sys;
mod ui;

use clap::Parser;
use std::time::Duration;

/// Monitor CPUs, memory, GPUs and processes, like btop.
///
/// Keys: q or Ctrl-C quits.
///
/// Up/Down, PgUp/PgDn, Home/End pick a process.
///
/// / searches processes by PID, user, name or command; Enter keeps the
/// search, Esc clears it.
///
/// k (or F9) stops the process picked, after asking: t terminates, 9
/// kills, any other key cancels.
///
/// s changes what processes are sorted by, r reverses it.
///
/// g lists every process, those on a GPU, or those on one GPU (NVIDIA's
/// GPUs alone, whose driver says which processes use them).
///
/// h hides or shows the charts; v charts each GPU's utilisation and memory
/// apart, together, or every GPU's in one.
///
/// Plus and minus refresh faster or slower, in steps: 100 ms, 250 ms,
/// 500 ms, 1 s, 2 s, 5 s, 10 s, 30 s, 60 s.
#[derive(Parser)]
#[command(version, args_conflicts_with_subcommands = true)]
struct Args {
    #[command(subcommand)]
    command: Option<Command>,
    /// Milliseconds between samples.
    #[arg(short = 'd', long, default_value_t = 1000, value_parser = clap::value_parser!(u64).range(100..=60000))]
    interval: u64,
    /// Print one sample of the system and its busiest processes, and exit.
    #[arg(long)]
    once: bool,
}

#[derive(clap::Subcommand)]
enum Command {
    /// Serve the CPUs, memory, GPUs and processes to AI agents (Claude,
    /// Cursor, ...) over MCP, on stdin and stdout.
    Mcp,
}

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    if let Some(Command::Mcp) = args.command {
        return mcp::run();
    }
    let every = Duration::from_millis(args.interval);
    let app = app::App::new(sys::Sys::new(), gpu::Gpus::new(), every);
    if args.once {
        // Piped into `head`, say, stdout may close early; that is not an error.
        return match ui::print_once(&app, &mut std::io::stdout().lock()) {
            Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => Ok(()),
            r => Ok(r?),
        };
    }
    let mut app = app;
    let mut terminal = ratatui::init();
    let result = app.run(&mut terminal);
    ratatui::restore();
    result
}

#[cfg(test)]
mod tests {
    use super::Args;
    use clap::Parser;

    #[test]
    fn mcp_takes_none_of_the_screen_s_flags() {
        assert!(Args::try_parse_from(["otop", "mcp"]).is_ok());
        assert!(Args::try_parse_from(["otop", "--once", "mcp"]).is_err());
        assert!(Args::try_parse_from(["otop", "-d", "500", "mcp"]).is_err());
        assert!(Args::try_parse_from(["otop", "-d", "500"]).is_ok());
    }
}