#[cfg(feature = "cli")]
use clap::{CommandFactory, Parser, Subcommand};
#[cfg(feature = "cli")]
use colored::Colorize;
use std::path::PathBuf;
use std::time::Duration;
#[cfg(feature = "cli")]
#[derive(Parser)]
#[command(name = "ironmon")]
#[command(about = "IronMonitor: Comprehensive hardware monitoring for CPUs, GPUs, NPUs, memory, I/O, and network silicon", long_about = None)]
#[command(version)]
struct Cli {
#[command(subcommand)]
command: Option<Commands>,
#[arg(long, global = true)]
no_telemetry: bool,
#[arg(long, global = true)]
offline: bool,
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum Commands {
#[cfg(feature = "gui")]
Gui {
#[arg(long)]
frame: bool,
#[arg(long, default_value = "inference")]
tab: String,
#[arg(long)]
script: Option<String>,
},
Tui {
#[arg(long)]
frame: bool,
#[arg(long)]
tab: Option<String>,
#[arg(long, default_value = "200")]
width: u16,
#[arg(long, default_value = "50")]
height: u16,
#[arg(long)]
script: Option<String>,
},
Cli {
#[command(subcommand)]
action: CliSubcommand,
#[arg(short, long, default_value = "1.0", global = true)]
interval: f64,
#[arg(short, long, default_value = "text", global = true)]
format: String,
#[arg(short, long, global = true)]
watch: bool,
},
Ai {
#[command(subcommand)]
action: AiSubcommand,
},
Record {
#[command(subcommand)]
action: RecordSubcommand,
},
Privacy {
#[command(subcommand)]
action: PrivacySubcommand,
},
Profile {
#[command(subcommand)]
action: ProfileSubcommand,
},
Tune {
#[arg(long, value_name = "SECONDS")]
watch: Option<u64>,
#[arg(long)]
apply: bool,
#[arg(long)]
confirm: bool,
#[arg(long, value_name = "TIER", default_value = "safe")]
max_risk: String,
#[arg(long, value_name = "CASE")]
r#as: Option<String>,
#[arg(short, long, default_value = "text")]
format: String,
},
Describe {
#[arg(long)]
commands: bool,
#[arg(long)]
writable: bool,
#[arg(long)]
domain: Option<String>,
#[arg(long)]
search: Option<String>,
#[arg(long)]
id: Option<String>,
#[arg(short, long, default_value = "text")]
format: String,
},
Get {
id: String,
#[arg(short, long, default_value = "text")]
format: String,
},
Status {
#[arg(long)]
ascii: bool,
#[arg(long)]
no_color: bool,
#[arg(short, long, default_value = "text")]
format: String,
},
Ids {
#[arg(long)]
baseline: std::path::PathBuf,
#[arg(long)]
watch: Vec<std::path::PathBuf>,
#[arg(short, long, default_value = "text")]
format: String,
},
Snapshot {
#[arg(long)]
domain: Option<String>,
#[arg(long)]
resolved_only: bool,
#[arg(long)]
validate: bool,
#[arg(short, long, default_value = "text")]
format: String,
},
Daemon {
#[arg(short, long)]
config: Option<String>,
#[arg(long)]
sample_config: bool,
},
Serve {
#[arg(short, long, default_value_t = 9100)]
port: u16,
#[arg(long, default_value = "127.0.0.1")]
bind: String,
#[arg(long)]
log_requests: bool,
#[arg(long, value_name = "PATH")]
api_key_file: Option<String>,
#[arg(long = "cors-origin", value_name = "ORIGIN")]
cors_origin: Vec<String>,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum ProfileSubcommand {
List {
#[arg(long)]
json: bool,
},
Show {
subsystem: String,
#[arg(long)]
json: bool,
},
Search {
query: String,
#[arg(long)]
json: bool,
},
Dump {
#[arg(long)]
json: bool,
#[arg(short, long)]
output: Option<PathBuf>,
},
Set {
setting_id: String,
value: String,
#[arg(long)]
confirm: bool,
#[arg(long)]
json: bool,
},
Schemes {
#[arg(long)]
json: bool,
},
Writable {
#[arg(long)]
json: bool,
},
Bench {
#[arg(long)]
json: bool,
},
Watch {
#[arg(short, long, default_value = "5")]
interval: f64,
#[arg(short, long, default_value = "0")]
ticks: u32,
#[arg(short, long)]
subsystem: Option<String>,
},
Audit {
#[arg(short, long, default_value = "20")]
lines: usize,
#[arg(long)]
json: bool,
},
Deviations {
#[arg(long)]
json: bool,
},
Explain {
setting_id: String,
#[arg(long)]
json: bool,
},
Active {
#[arg(short, long)]
matched: bool,
#[arg(long)]
json: bool,
},
Diff {
baseline: PathBuf,
#[arg(short, long)]
against: Option<PathBuf>,
#[arg(long)]
json: bool,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum AiSubcommand {
Query {
question: Option<String>,
},
Manifest {
#[arg(short, long, default_value = "json")]
format: String,
#[arg(short, long)]
output: Option<PathBuf>,
},
Server,
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum CliSubcommand {
Board,
Gpu,
Cpu,
Memory,
Power,
Temperature,
Processes,
Engines,
Audio,
Bluetooth,
Display,
Usb,
All,
Monitor,
Ai {
query: Option<String>,
},
Jetson {
#[command(subcommand)]
action: JetsonSubcommand,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum JetsonSubcommand {
Clocks {
#[command(subcommand)]
action: JetsonClocksAction,
},
Powermode {
#[command(subcommand)]
action: NvpmodelAction,
},
Swap {
#[command(subcommand)]
action: SwapAction,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum JetsonClocksAction {
Enable {
#[arg(long)]
confirm: bool,
},
Disable {
#[arg(long)]
confirm: bool,
},
Status,
Store {
#[arg(long)]
confirm: bool,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum NvpmodelAction {
Show,
List,
Set {
mode_id: u32,
#[arg(short, long)]
force: bool,
#[arg(long)]
confirm: bool,
},
SetName {
name: String,
#[arg(short, long)]
force: bool,
#[arg(long)]
confirm: bool,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum SwapAction {
Status,
Create {
#[arg(short, long, default_value = "/swapfile")]
path: PathBuf,
#[arg(short, long, default_value = "8")]
size: u32,
#[arg(short, long)]
auto: bool,
#[arg(long)]
confirm: bool,
},
Enable {
path: PathBuf,
#[arg(long)]
confirm: bool,
},
Disable {
path: PathBuf,
#[arg(long)]
confirm: bool,
},
Remove {
path: PathBuf,
#[arg(long)]
confirm: bool,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum RecordSubcommand {
Start {
#[arg(short, long, default_value = "ironmon_metrics.db")]
database: PathBuf,
#[arg(long, default_value = "100MB")]
max_size: String,
#[arg(short, long, default_value = "1.0")]
interval: f64,
#[arg(long, default_value = "50")]
max_processes: usize,
#[arg(short, long, default_value = "text")]
format: String,
},
Info {
#[arg(short, long, default_value = "ironmon_metrics.db")]
database: PathBuf,
},
Query {
#[arg(short, long, default_value = "ironmon_metrics.db")]
database: PathBuf,
#[arg(long)]
start: Option<String>,
#[arg(long)]
end: Option<String>,
#[arg(short, long, default_value = "text")]
format: String,
#[arg(short, long)]
limit: Option<usize>,
},
Export {
#[arg(short, long, default_value = "ironmon_metrics.db")]
database: PathBuf,
#[arg(short, long)]
output: PathBuf,
#[arg(long, default_value = "json")]
format: String,
},
Clear {
#[arg(short, long, default_value = "ironmon_metrics.db")]
database: PathBuf,
#[arg(short, long)]
force: bool,
},
}
#[cfg(feature = "cli")]
#[derive(Subcommand)]
enum PrivacySubcommand {
Status,
OptOut,
Review,
OptIn,
Info,
}
#[cfg(feature = "cli")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let cli = Cli::parse();
env_logger::init();
if cli.no_telemetry || cli.offline {
std::env::set_var("IRONMON_NO_TELEMETRY", "1");
if cli.offline {
std::env::set_var("IRONMON_OFFLINE", "1");
}
if std::env::var("IRONMON_VERBOSE").is_ok() {
eprintln!(
"{} {}",
"[INFO]".cyan(),
if cli.offline {
"Running in offline mode - all network features and data collection disabled"
} else {
"Telemetry disabled for this session"
}
);
}
}
match &cli.command {
#[cfg(feature = "gui")]
Some(Commands::Gui { frame, tab, script }) => {
if let Some(source) = script {
handle_gui_script_command(source)?;
} else if *frame {
handle_gui_frame_command(tab)?;
} else {
ironmonitor::gui::run().map_err(|e| format!("GUI error: {}", e))?;
}
}
#[cfg(feature = "gui")]
None => {
ironmonitor::gui::run().map_err(|e| format!("GUI error: {}", e))?;
}
Some(Commands::Tui {
frame,
tab,
width,
height,
script,
}) => {
if let Some(source) = script {
handle_tui_script_command(source, *width, *height)?;
} else if *frame {
handle_tui_frame_command(tab.as_deref(), *width, *height)?;
} else {
ironmonitor::tui::run()?;
}
}
Some(Commands::Tune {
watch,
apply,
confirm,
max_risk,
r#as,
format,
}) => {
handle_tune_command(*watch, *apply, *confirm, max_risk, r#as.as_deref(), format)?;
}
Some(Commands::Cli {
action,
interval,
format,
watch,
}) => {
handle_cli_command(action, *interval, format, *watch)?;
}
Some(Commands::Ai { action }) => match action {
AiSubcommand::Query { question } => {
handle_ai_command(question.as_deref())?;
}
AiSubcommand::Manifest { format, output } => {
handle_ai_manifest(format, output.as_ref())?;
}
AiSubcommand::Server => {
handle_mcp_server()?;
}
},
Some(Commands::Record { action }) => {
handle_record_command(action)?;
}
Some(Commands::Privacy { action }) => {
handle_privacy_command(action)?;
}
Some(Commands::Profile { action }) => {
handle_profile_command(action)?;
}
Some(Commands::Describe {
commands,
writable,
domain,
search,
id,
format,
}) => {
handle_describe_command(
*commands,
*writable,
domain.as_deref(),
search.as_deref(),
id.as_deref(),
format,
)?;
}
Some(Commands::Get { id, format }) => {
handle_get_command(id, format)?;
}
Some(Commands::Status {
ascii,
no_color,
format,
}) => {
handle_status_command(*ascii, *no_color, format)?;
}
Some(Commands::Ids {
baseline,
watch,
format,
}) => {
handle_ids_command(baseline, watch, format)?;
}
Some(Commands::Snapshot {
domain,
resolved_only,
validate,
format,
}) => {
handle_snapshot_command(domain.as_deref(), *resolved_only, *validate, format)?;
}
Some(Commands::Daemon {
config,
sample_config,
}) => {
handle_daemon_command(config.as_deref(), *sample_config)?;
}
Some(Commands::Serve {
port,
bind,
log_requests,
api_key_file,
cors_origin,
}) => {
handle_serve_command(
*port,
bind,
*log_requests,
api_key_file.as_deref(),
cors_origin,
)?;
}
#[cfg(not(feature = "gui"))]
None => {
ironmonitor::tui::run()?;
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn handle_ai_command(query: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
handle_ai_query(query)
}
#[cfg(feature = "cli")]
fn handle_mcp_server() -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ai_api::McpServer;
eprintln!("[*] Starting MCP server on stdio...");
eprintln!(
"[*] Protocol version: {}",
ironmonitor::ai_api::MCP_PROTOCOL_VERSION
);
let mut server = McpServer::new()?;
server.run_stdio()?;
Ok(())
}
#[cfg(feature = "cli")]
fn handle_ai_manifest(
format: &str,
output: Option<&PathBuf>,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ai_api::{AgentManifest, ExportFormat};
let manifest = AgentManifest::new();
let export_format = match format.to_lowercase().as_str() {
"openai" | "chatgpt" | "gpt" | "gpt4" | "o1" | "o3" => ExportFormat::OpenAI,
"anthropic" | "claude" => ExportFormat::Anthropic,
"gemini" | "google" => ExportFormat::Gemini,
"grok" | "xai" => ExportFormat::Grok,
"llama" | "meta" => ExportFormat::Llama,
"mistral" | "mixtral" => ExportFormat::Mistral,
"deepseek" | "r1" => ExportFormat::DeepSeek,
"jsonld" | "json-ld" | "schema" => ExportFormat::JsonLd,
"mcp" => ExportFormat::Mcp,
"json" | "simple" => ExportFormat::SimpleJson,
_ => {
eprintln!("Unknown format '{}'. Supported: openai, anthropic, gemini, grok, llama, mistral, deepseek, jsonld, mcp, json", format);
return Err("Invalid format".into());
}
};
let exported = manifest.export(export_format);
let json_output = serde_json::to_string_pretty(&exported)?;
if let Some(path) = output {
std::fs::write(path, &json_output)?;
eprintln!("[+] Manifest written to: {}", path.display());
} else {
println!("{}", json_output);
}
Ok(())
}
#[cfg(feature = "cli")]
fn handle_cli_command(
action: &CliSubcommand,
interval: f64,
format: &str,
watch: bool,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::backend::{BackendConfig, MonitoringBackend};
use ironmonitor::IronMonitor;
let config = BackendConfig {
update_interval: Duration::from_secs_f64(interval),
..Default::default()
};
let run_watch_mode = |display_fn: &dyn Fn() -> Result<(), Box<dyn std::error::Error>>| -> Result<(), Box<dyn std::error::Error>> {
use crossterm::{
event::{self, Event, KeyCode},
terminal::{disable_raw_mode, enable_raw_mode},
};
println!("Watch mode - Press 'q' to quit, refreshing every {:.1}s", interval);
enable_raw_mode()?;
loop {
print!("\x1B[2J\x1B[1;1H");
if let Err(e) = display_fn() {
disable_raw_mode()?;
return Err(e);
}
println!("\n[Press 'q' to quit]");
if event::poll(Duration::from_secs_f64(interval))? {
if let Event::Key(key) = event::read()? {
if key.code == KeyCode::Char('q') || key.code == KeyCode::Char('Q') {
break;
}
}
}
}
disable_raw_mode()?;
Ok(())
};
match action {
CliSubcommand::Board => {
let stats = IronMonitor::with_interval(interval)?;
let board = stats.board_info();
if format == "json" {
println!("{}", serde_json::to_string_pretty(board)?);
} else {
print_board_info(board);
}
}
CliSubcommand::Gpu => {
let backend = MonitoringBackend::with_config(config)?;
if format == "json" {
let gpu_info: Vec<_> = backend
.gpu_static_info()
.iter()
.zip(backend.gpu_dynamic_info().iter())
.map(|(s, d)| {
serde_json::json!({
"name": s.as_ref().map(|s| s.name.clone()),
"vendor": s.as_ref().map(|s| s.vendor.to_string()),
"utilization": d.as_ref().and_then(|d| d.utilization),
"memory_used": d.as_ref().and_then(|d| d.memory.used),
"memory_total": d.as_ref().and_then(|d| d.memory.total),
"temperature": d.as_ref().and_then(|d| d.thermal.temperature),
"power_draw": d.as_ref().and_then(|d| d.power.draw),
})
})
.collect();
println!("{}", serde_json::to_string_pretty(&gpu_info)?);
} else {
print_gpu_info_backend(&backend);
}
}
CliSubcommand::Cpu => {
let backend = MonitoringBackend::with_config(config)?;
if format == "json" {
if let Some(cpu) = backend.cpu_stats() {
println!("{}", serde_json::to_string_pretty(cpu)?);
}
} else {
print_cpu_info_backend(&backend);
}
}
CliSubcommand::Memory => {
let backend = MonitoringBackend::with_config(config)?;
if format == "json" {
if let Some(mem) = backend.memory_stats() {
println!("{}", serde_json::to_string_pretty(mem)?);
}
} else {
print_memory_info_backend(&backend);
}
}
CliSubcommand::Power => {
let mut stats = IronMonitor::with_interval(interval)?;
let snapshot = stats.snapshot()?;
let readings = ironmonitor::ontology::resolve::snapshot();
let power = ironmonitor::fetch::power(&readings);
if format == "json" {
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!({
"rails": &snapshot.power,
"readings": power,
}))?
);
} else {
print_power_info(&snapshot.power, &power);
}
}
CliSubcommand::Temperature => {
let readings = ironmonitor::ontology::resolve::snapshot();
let temps = ironmonitor::fetch::temperatures(&readings);
if format == "json" {
println!("{}", serde_json::to_string_pretty(&temps)?);
} else {
print_temperature_readings(&temps);
}
}
CliSubcommand::Processes => {
let backend = MonitoringBackend::with_config(config)?;
if format == "json" {
let procs = backend.processes();
println!("{}", serde_json::to_string_pretty(&procs)?);
} else {
print_process_info_backend(&backend)?;
}
}
CliSubcommand::Engines => {
let mut stats = IronMonitor::with_interval(interval)?;
let snapshot = stats.snapshot()?;
if format == "json" {
println!("{}", serde_json::to_string_pretty(&snapshot.engines)?);
} else {
match &snapshot.engines {
Some(engines) => print_engine_info(engines),
None => println!("Engine statistics are not read on this platform."),
}
}
}
CliSubcommand::All => {
let backend = MonitoringBackend::with_config(config)?;
if format == "json" {
let state = backend.get_full_system_state();
println!("{}", serde_json::to_string_pretty(&state)?);
} else {
print_all_info(&backend)?;
}
}
CliSubcommand::Monitor => {
let stats = IronMonitor::with_interval(interval)?;
run_interactive_mode(stats)?;
}
CliSubcommand::Ai { query } => {
handle_ai_query(query.as_deref())?;
}
CliSubcommand::Audio => {
use ironmonitor::audio::AudioMonitor;
let display_audio = || -> Result<(), Box<dyn std::error::Error>> {
let monitor = AudioMonitor::new()?;
if format == "json" {
println!("{}", serde_json::to_string_pretty(monitor.devices())?);
} else {
println!("{}", "═══ Audio Devices ═══".cyan().bold());
match monitor.master_volume() {
Some(v) => println!(" Master Volume: {v}%"),
None => println!(
" Master Volume: not read — IronMonitor has no mixer binding on this platform"
),
}
match monitor.is_muted() {
Some(m) => println!(" Muted: {}", if m { "Yes" } else { "No" }),
None => println!(" Muted: not read"),
}
for device in monitor.devices() {
let state = match &device.state {
Some(s) => format!("{s:?}"),
None => "state not read".to_string(),
};
let name = device.name.as_deref().unwrap_or("name not read");
let direction = match device.device_type {
Some(t) => format!("{t:?}"),
None => "unknown".to_string(),
};
println!(" {} ({}) - {}", name, direction, state);
}
}
Ok(())
};
if watch {
run_watch_mode(&display_audio)?;
} else {
display_audio()?;
}
}
CliSubcommand::Bluetooth => {
use ironmonitor::bluetooth::BluetoothMonitor;
let display_bluetooth = || -> Result<(), Box<dyn std::error::Error>> {
let monitor = BluetoothMonitor::new()?;
if format == "json" {
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!({
"available": monitor.is_available(),
"adapters": monitor.adapters(),
"devices": monitor.devices(),
}))?
);
} else {
println!("{}", "═══ Bluetooth ═══".cyan().bold());
println!(
" Available: {}",
match monitor.is_available() {
Some(true) => "Yes",
Some(false) => "No",
None => "unknown (adapters not read on this platform)",
}
);
println!(" Adapters: {}", monitor.adapters().len());
for adapter in monitor.adapters() {
println!(
" {} ({})",
adapter.name.as_deref().unwrap_or("name not read"),
adapter.address.as_deref().unwrap_or("address not read")
);
}
println!(" Devices: {}", monitor.devices().len());
for device in monitor.devices() {
println!(
" {} - {:?}",
device.name.as_deref().unwrap_or("Unknown"),
device.state
);
}
}
Ok(())
};
if watch {
run_watch_mode(&display_bluetooth)?;
} else {
display_bluetooth()?;
}
}
CliSubcommand::Display => {
use ironmonitor::display::DisplayMonitor;
let display_displays = || -> Result<(), Box<dyn std::error::Error>> {
let monitor = DisplayMonitor::new()?;
if format == "json" {
println!("{}", serde_json::to_string_pretty(monitor.displays())?);
} else {
println!("{}", "═══ Displays ═══".cyan().bold());
println!(" Count: {}", monitor.count());
for display in monitor.displays() {
let mode = match (display.width, display.height) {
(Some(w), Some(h)) => format!("{w}x{h}"),
_ => "mode not readable".to_string(),
};
let rate = match display.refresh_rate {
Some(hz) => format!(" @ {hz:.0}Hz"),
None => String::new(),
};
let conn = match display.connection {
ironmonitor::display::DisplayConnection::Unknown => {
"connection unknown".to_string()
}
other => format!("{other:?}"),
};
println!(
" {} {}{} {}",
display.name.as_deref().unwrap_or("unnamed"),
mode,
rate,
conn
);
}
}
Ok(())
};
if watch {
run_watch_mode(&display_displays)?;
} else {
display_displays()?;
}
}
CliSubcommand::Usb => {
use ironmonitor::usb::UsbMonitor;
let display_usb = || -> Result<(), Box<dyn std::error::Error>> {
let monitor = UsbMonitor::new()?;
if format == "json" {
println!("{}", serde_json::to_string_pretty(monitor.devices())?);
} else {
println!("{}", "═══ USB Devices ═══".cyan().bold());
println!(" Count: {}", monitor.devices().len());
for device in monitor.devices() {
let name = device.product.as_deref().unwrap_or("unnamed");
let ids = match (device.vendor_id, device.product_id) {
(None, None) => "[no usb ids]".to_string(),
(v, p) => format!(
"[{}:{}]",
v.map_or("----".to_string(), |v| format!("{v:04x}")),
p.map_or("----".to_string(), |p| format!("{p:04x}"))
),
};
let class = match device.class {
ironmonitor::usb::UsbDeviceClass::Unknown => {
"class undeclared".to_string()
}
ref c => format!("{c:?}"),
};
let speed = match device.speed {
ironmonitor::usb::UsbSpeed::Unknown => "speed not read".to_string(),
ref s => format!("{s:?}"),
};
println!(" {ids} {name} ({class}, {speed})");
}
}
Ok(())
};
if watch {
run_watch_mode(&display_usb)?;
} else {
display_usb()?;
}
}
CliSubcommand::Jetson { action } => {
handle_jetson_command(action)?;
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn print_board_info(board: &ironmonitor::core::platform_info::BoardInfo) {
println!("{}", "═══ Board Information ═══".cyan().bold());
println!(
" {} {}",
"Model:".white().bold(),
board.hardware.model.yellow()
);
println!(
" {} {} {}",
"System:".white().bold(),
board.platform.system.green(),
board.platform.machine.green()
);
if let Some(dist) = &board.platform.distribution {
println!(" {} {}", "Distribution:".white().bold(), dist.green());
}
if !board.platform.release.is_empty() {
println!(
" {} {}",
"Kernel:".white().bold(),
board.platform.release.green()
);
}
if let Some(l4t) = &board.hardware.l4t {
println!(" {} {}", "L4T:".white().bold(), l4t.magenta());
}
if let Some(cuda) = &board.libraries.cuda {
println!(" {} {}", "CUDA:".white().bold(), cuda.magenta());
}
}
#[cfg(feature = "cli")]
fn print_gpu_info(gpus: &std::collections::HashMap<String, ironmonitor::core::gpu::GpuInfo>) {
println!("{}", "═══ GPU Information ═══".cyan().bold());
if gpus.is_empty() {
println!(" {}", "No GPUs detected".yellow());
return;
}
let mut names: Vec<&String> = gpus.keys().collect();
names.sort();
for name in names {
let gpu = &gpus[name];
println!(
"\n {} {} ({})",
"▶".green(),
name.white().bold(),
format!("{:?}", gpu.gpu_type).magenta()
);
let load_colored = match gpu.status.load {
Some(load) => {
let load_str = format!("{load:.1}%");
if load > 90.0 {
load_str.red().bold()
} else if load > 70.0 {
load_str.yellow()
} else {
load_str.green()
}
}
None => "not read".dimmed(),
};
println!(" {} {}", "Load:".white(), load_colored);
let f = &gpu.frequency;
if f.current.is_some() || f.max.is_some() {
let mhz = |v: Option<u32>| v.map_or("?".to_string(), |m| m.to_string());
println!(
" {} {} {} ({}-{} MHz)",
"Frequency:".white(),
format!("{} MHz", mhz(f.current)).cyan(),
"range:".dimmed(),
mhz(f.min),
mhz(f.max)
);
}
if let Some(governor) = &gpu.frequency.governor {
println!(" {} {}", "Governor:".white(), governor.blue());
}
if let (Some(used), Some(total)) = (gpu.status.memory_used, gpu.status.memory_total) {
println!(
" {} {} / {} MB",
"Memory:".white(),
(used / 1024 / 1024).to_string().cyan(),
total / 1024 / 1024
);
}
if let Some(temp) = gpu.status.temperature {
let temp_str = format!("{:.1}°C", temp);
let temp_colored = if temp > 85.0 {
temp_str.red().bold()
} else if temp > 70.0 {
temp_str.yellow()
} else {
temp_str.green()
};
println!(" {} {}", "Temperature:".white(), temp_colored);
}
if let Some(power) = gpu.status.power_draw {
println!(
" {} {}",
"Power:".white(),
format!("{:.1}W", power).yellow()
);
}
}
}
#[cfg(feature = "cli")]
fn print_cpu_identity(cpu: &ironmonitor::core::cpu::CpuStats) {
let Some(core) = cpu.cores.first() else {
return;
};
let model = core
.model
.as_deref()
.filter(|m| !m.trim().is_empty())
.unwrap_or("unknown");
println!(" {} {}", "Model:".white().bold(), model.green());
if let Some(freq) = &core.frequency {
let mut clock = match freq.current {
Some(mhz) => format!("{mhz} MHz"),
None => "not read — Windows reports the nominal clock, not the current one".to_string(),
};
if let Some(max) = freq.max.filter(|m| *m > 0 && Some(*m) != freq.current) {
clock.push_str(&format!(" (rated {max} MHz)"));
}
println!(" {} {}", "Clock:".white().bold(), clock.green());
}
}
#[cfg(feature = "cli")]
fn print_cpu_info(cpu: &ironmonitor::core::cpu::CpuStats) {
println!("{}", "═══ CPU Information ═══".cyan().bold());
print_cpu_identity(cpu);
println!(
" {} {} (Online: {})",
"Threads:".white().bold(),
cpu.core_count().to_string().green(),
cpu.online_count()
.map_or_else(|| "unknown".to_string(), |n| n.to_string())
.green()
);
let usage = 100.0 - cpu.total.idle;
let usage_str = format!("{:.1}%", usage);
let usage_colored = if usage > 90.0 {
usage_str.red().bold()
} else if usage > 70.0 {
usage_str.yellow()
} else {
usage_str.green()
};
println!(
" {} {} ({}: {:.1}%, {}: {:.1}%, {}: {:.1}%)",
"Usage:".white().bold(),
usage_colored,
"user".dimmed(),
cpu.total.user,
"system".dimmed(),
cpu.total.system,
"idle".dimmed(),
cpu.total.idle
);
println!("\n {}", "Per-Core Usage:".white().bold());
let cores_per_row = 4;
for chunk in cpu.cores.chunks(cores_per_row) {
print!(" ");
for core in chunk {
if core.online != Some(false) {
let (bar, usage_colored) = match core.idle {
Some(idle) => {
let usage = 100.0 - idle;
let bar = create_usage_bar(usage, 10);
let usage_str = format!("{:>5.1}%", usage);
let colored = if usage > 90.0 {
usage_str.red()
} else if usage > 70.0 {
usage_str.yellow()
} else {
usage_str.green()
};
(bar, colored)
}
None => (" ".repeat(10), format!("{:>5}%", "--").dimmed()),
};
print!(
"{}{:>2}{} {} {} ",
"CPU".dimmed(),
core.id,
":".dimmed(),
bar,
usage_colored
);
} else {
print!(
"{}{:>2}{} {} ",
"CPU".dimmed(),
core.id,
":".dimmed(),
"OFFLINE".red()
);
}
}
println!();
}
}
#[cfg(feature = "cli")]
fn create_usage_bar(usage: f32, width: usize) -> String {
let filled = ((usage / 100.0) * width as f32).round() as usize;
let empty = width.saturating_sub(filled);
let bar_char = "█";
let empty_char = "░";
let filled_str = bar_char.repeat(filled);
let empty_str = empty_char.repeat(empty);
let colored_filled = if usage > 90.0 {
filled_str.red()
} else if usage > 70.0 {
filled_str.yellow()
} else {
filled_str.green()
};
format!("{}{}", colored_filled, empty_str.dimmed())
}
#[cfg(feature = "cli")]
fn print_memory_info(memory: &ironmonitor::core::memory::MemoryStats) {
println!("{}", "═══ Memory Information ═══".cyan().bold());
let ram_usage = memory.ram_usage_percent();
let ram_used_gb = memory.ram.used as f64 / 1024.0 / 1024.0;
let ram_total_gb = memory.ram.total as f64 / 1024.0 / 1024.0;
match ram_usage {
Some(usage) => {
let ram_bar = create_usage_bar(usage, 20);
let ram_pct_str = format!("{:.1}%", usage);
let ram_pct_colored = if usage > 90.0 {
ram_pct_str.red().bold()
} else if usage > 75.0 {
ram_pct_str.yellow()
} else {
ram_pct_str.green()
};
println!(
" {} {} {:.2} / {:.2} GB {}",
"RAM:".white().bold(),
ram_bar,
ram_used_gb,
ram_total_gb,
ram_pct_colored
);
}
None => println!(" {} {}", "RAM:".white().bold(), "not read".dimmed()),
}
if memory.swap.total.is_none() {
println!(" {} not reported by this platform", "SWAP:".white().bold());
} else if memory.swap.total_or_zero() > 0 {
let swap_usage = memory.swap_usage_percent_or_zero();
let swap_bar = create_usage_bar(swap_usage, 20);
let swap_used_gb = memory.swap.used_or_zero() as f64 / 1024.0 / 1024.0;
let swap_total_gb = memory.swap.total_or_zero() as f64 / 1024.0 / 1024.0;
let swap_pct_str = format!("{:.1}%", swap_usage);
let swap_pct_colored = if swap_usage > 90.0 {
swap_pct_str.red().bold()
} else if swap_usage > 75.0 {
swap_pct_str.yellow()
} else {
swap_pct_str.green()
};
println!(
" {} {} {:.2} / {:.2} GB {}",
"SWAP:".white().bold(),
swap_bar,
swap_used_gb,
swap_total_gb,
swap_pct_colored
);
}
}
#[cfg(feature = "cli")]
fn print_power_info(
power: &ironmonitor::core::power::PowerStats,
readings: &[&ironmonitor::ontology::resolve::Reading],
) {
println!("{}", "═══ Power Information ═══".cyan().bold());
print_readings_with_reasons(readings, "no power entity is readable here");
if power.rails.is_empty() {
println!();
#[cfg(target_os = "linux")]
let reason = concat!(
"No power rails: this reads INA3221 sensors on i2c, which are ",
"Jetson-class hardware. An ordinary Linux machine has none."
);
#[cfg(target_os = "windows")]
let reason =
"No power rails: this reads battery rails via WMI, and no battery reported one.";
#[cfg(not(any(target_os = "linux", target_os = "windows")))]
let reason = "No power rails: IronMonitor has no rail reader for this platform.";
println!(" {}", reason.yellow());
return;
}
let total_colored = match power.total_watts() {
Some(total) => {
let total_str = format!("{:.2}W", total);
if total > 100.0 {
total_str.red().bold()
} else if total > 50.0 {
total_str.yellow()
} else {
total_str.green()
}
}
None => "not measured".dimmed(),
};
println!(" {} {}", "Total Power:".white().bold(), total_colored);
if !power.rails.is_empty() {
println!("\n {}", "Power Rails:".white().bold());
for (name, rail) in &power.rails {
if rail.online {
let power_colored = match rail.power {
Some(mw) => {
let power_w = mw as f64 / 1000.0;
let power_str = format!("{:.2}W", power_w);
if power_w > 30.0 {
power_str.yellow()
} else {
power_str.green()
}
}
None => "not measured".dimmed(),
};
let volts = rail
.voltage
.map_or("?V".to_string(), |mv| format!("{:.1}V", mv as f64 / 1000.0));
let amps = rail
.current
.map_or("?mA".to_string(), |ma| format!("{:.1}mA", ma as f64));
println!(
" {} {} ({}, {})",
format!("{}:", name).white(),
power_colored,
volts,
amps
);
}
}
}
}
#[cfg(feature = "cli")]
fn print_readings_with_reasons(
readings: &[&ironmonitor::ontology::resolve::Reading],
nothing_known: &str,
) {
use ironmonitor::ontology::Provenance;
if readings.is_empty() {
println!(" {}", nothing_known.yellow());
return;
}
let mut unread = Vec::new();
for r in readings {
let Some(value) = r.value.as_ref() else {
unread.push(*r);
continue;
};
let rendered = match value.as_f64() {
Some(n) => {
let number = if n.fract() == 0.0 {
format!("{n}")
} else {
format!("{n:.1}")
};
match &r.unit {
Some(u) => format!("{number} {u:?}").to_lowercase(),
None => number,
}
}
None => value.to_string().trim_matches('"').to_string(),
};
let qualifier = match r.provenance {
Provenance::Measured => String::new(),
other => format!(" [{other:?}]").to_lowercase(),
};
println!(
" {:<44} {}{}",
format!("{}:", r.id).white(),
rendered.green(),
qualifier
);
}
if !unread.is_empty() {
println!();
println!("{}", " Not readable here:".white().bold());
for r in unread {
let reason = r.note.as_deref().unwrap_or("no reason recorded");
println!(" {:<42} {}", r.id.dimmed(), reason.dimmed());
}
}
}
#[cfg(feature = "cli")]
fn print_temperature_readings(temps: &[&ironmonitor::ontology::resolve::Reading]) {
println!("{}", "═══ Temperature Information ═══".cyan().bold());
print_readings_with_reasons(
temps,
"IronMonitor knows of no temperature entity on this platform",
);
}
#[cfg(feature = "cli")]
fn run_interactive_mode(
mut stats: ironmonitor::IronMonitor,
) -> Result<(), Box<dyn std::error::Error>> {
use crossterm::{
event::{self, Event, KeyCode},
terminal::{disable_raw_mode, enable_raw_mode},
};
use std::time::Duration;
println!("Interactive monitoring mode - Press 'q' to quit");
println!("Updating every {:.1}s\n", stats.interval().as_secs_f64());
enable_raw_mode()?;
loop {
if event::poll(Duration::from_millis(100))? {
if let Event::Key(key) = event::read()? {
if key.code == KeyCode::Char('q') {
break;
}
}
}
print!("\x1B[2J\x1B[1;1H");
let snapshot = stats.snapshot()?;
println!("=== IronMonitor - System Monitoring ===");
println!("Uptime: {:?}\n", snapshot.uptime);
print_gpu_info(&snapshot.gpus);
println!();
print_cpu_info(&snapshot.cpu);
println!();
print_memory_info(&snapshot.memory);
println!();
if let Some(max_temp) = snapshot.temperature.max_temp() {
println!("Max Temperature: {:.1}°C", max_temp);
}
match snapshot.power.total_watts() {
Some(watts) => println!("Total Power: {:.2}W", watts),
None if snapshot.power.rails.is_empty() => {
println!("Total Power: not measured (no power rails on this platform)")
}
None => println!("Total Power: not measured (no rail reported a draw)"),
}
println!("\nPress 'q' to quit");
std::thread::sleep(stats.interval());
}
disable_raw_mode()?;
Ok(())
}
#[cfg(feature = "cli")]
fn print_gpu_info_backend(backend: &ironmonitor::backend::MonitoringBackend) {
println!("{}", "═══ GPU Information ═══".cyan().bold());
let static_info = backend.gpu_static_info();
let dynamic_info = backend.gpu_dynamic_info();
if static_info.is_empty() {
println!(" {}", "No GPUs detected".yellow());
return;
}
for (index, (si_slot, di_slot)) in static_info.iter().zip(dynamic_info.iter()).enumerate() {
let Some(si) = si_slot else {
println!("\n {} GPU {index}: static info not read", "▶".green());
continue;
};
let Some(di) = di_slot else {
println!(
"\n {} {} ({}): sample not read",
"▶".green(),
si.name.white().bold(),
si.vendor.to_string().magenta()
);
continue;
};
println!(
"\n {} {} ({})",
"▶".green(),
si.name.white().bold(),
si.vendor.to_string().magenta()
);
match di.utilization.map(f32::from) {
Some(util) => {
let util_str = format!("{util:.1}%");
let util_colored = if util > 90.0 {
util_str.red().bold()
} else if util > 70.0 {
util_str.yellow()
} else {
util_str.green()
};
println!(
" {} {} {}",
"Load:".white(),
create_usage_bar(util, 15),
util_colored
);
}
None => println!(" {} not read", "Load:".white()),
}
match (di.memory.used, di.memory.total, di.memory.utilization) {
(Some(used), Some(total), Some(pct)) => println!(
" {} {} {} / {} MB",
"Memory:".white(),
create_usage_bar(pct as f32, 15),
(used / 1024 / 1024).to_string().cyan(),
total / 1024 / 1024
),
(Some(used), None, _) => println!(
" {} {} MB used, capacity not reported",
"Memory:".white(),
(used / 1024 / 1024).to_string().cyan()
),
_ => println!(" {} not reported", "Memory:".white()),
}
if let Some(temp) = di.thermal.temperature {
let temp_str = format!("{:.1}°C", temp as f32);
let temp_colored = if temp > 85 {
temp_str.red().bold()
} else if temp > 70 {
temp_str.yellow()
} else {
temp_str.green()
};
println!(" {} {}", "Temperature:".white(), temp_colored);
}
if let Some(power) = di.power.draw {
let power_w = power as f32 / 1000.0;
println!(
" {} {}",
"Power:".white(),
format!("{:.1}W", power_w).yellow()
);
}
if let Some(graphics) = di.clocks.graphics {
if graphics > 0 {
let memory = match di.clocks.memory {
Some(mhz) => format!("{mhz} MHz"),
None => "—".to_string(),
};
println!(
" {} {} MHz (mem: {})",
"Clocks:".white(),
graphics.to_string().cyan(),
memory
);
}
}
}
}
#[cfg(feature = "cli")]
fn print_cpu_info_backend(backend: &ironmonitor::backend::MonitoringBackend) {
println!("{}", "═══ CPU Information ═══".cyan().bold());
if let Some(cpu) = backend.cpu_stats() {
print_cpu_identity(cpu);
println!(
" {} {} (Online: {})",
"Threads:".white().bold(),
cpu.core_count().to_string().green(),
cpu.online_count()
.map_or_else(|| "unknown".to_string(), |n| n.to_string())
.green()
);
let usage = 100.0 - cpu.total.idle;
let usage_str = format!("{:.1}%", usage);
let usage_colored = if usage > 90.0 {
usage_str.red().bold()
} else if usage > 70.0 {
usage_str.yellow()
} else {
usage_str.green()
};
println!(
" {} {} ({}: {:.1}%, {}: {:.1}%, {}: {:.1}%)",
"Usage:".white().bold(),
usage_colored,
"user".dimmed(),
cpu.total.user,
"system".dimmed(),
cpu.total.system,
"idle".dimmed(),
cpu.total.idle
);
println!("\n {}", "Per-Core Usage:".white().bold());
let cores_per_row = 4;
for chunk in cpu.cores.chunks(cores_per_row) {
print!(" ");
for core in chunk {
if core.online != Some(false) {
let (bar, usage_colored) = match core.idle {
Some(idle) => {
let usage = 100.0 - idle;
let bar = create_usage_bar(usage, 10);
let usage_str = format!("{:>5.1}%", usage);
let colored = if usage > 90.0 {
usage_str.red()
} else if usage > 70.0 {
usage_str.yellow()
} else {
usage_str.green()
};
(bar, colored)
}
None => (" ".repeat(10), format!("{:>5}%", "--").dimmed()),
};
print!(
"{}{:>2}{} {} {} ",
"CPU".dimmed(),
core.id,
":".dimmed(),
bar,
usage_colored
);
} else {
print!(
"{}{:>2}{} {} ",
"CPU".dimmed(),
core.id,
":".dimmed(),
"OFFLINE".red()
);
}
}
println!();
}
} else {
println!(" {}", "No CPU data available".yellow());
}
}
#[cfg(feature = "cli")]
fn print_memory_info_backend(backend: &ironmonitor::backend::MonitoringBackend) {
println!("{}", "═══ Memory Information ═══".cyan().bold());
if let Some(memory) = backend.memory_stats() {
let ram_usage = memory.ram_usage_percent();
let ram_used_gb = memory.ram.used as f64 / 1024.0 / 1024.0;
let ram_total_gb = memory.ram.total as f64 / 1024.0 / 1024.0;
match ram_usage {
Some(usage) => {
let ram_bar = create_usage_bar(usage, 20);
let ram_pct_str = format!("{:.1}%", usage);
let ram_pct_colored = if usage > 90.0 {
ram_pct_str.red().bold()
} else if usage > 75.0 {
ram_pct_str.yellow()
} else {
ram_pct_str.green()
};
println!(
" {} {} {:.2} / {:.2} GB {}",
"RAM:".white().bold(),
ram_bar,
ram_used_gb,
ram_total_gb,
ram_pct_colored
);
}
None => println!(" {} {}", "RAM:".white().bold(), "not read".dimmed()),
}
if memory.swap.total.is_none() {
println!(" {} not reported by this platform", "SWAP:".white().bold());
} else if memory.swap.total_or_zero() > 0 {
let swap_usage = memory.swap_usage_percent_or_zero();
let swap_bar = create_usage_bar(swap_usage, 20);
let swap_used_gb = memory.swap.used_or_zero() as f64 / 1024.0 / 1024.0;
let swap_total_gb = memory.swap.total_or_zero() as f64 / 1024.0 / 1024.0;
let swap_pct_str = format!("{:.1}%", swap_usage);
let swap_pct_colored = if swap_usage > 90.0 {
swap_pct_str.red().bold()
} else if swap_usage > 75.0 {
swap_pct_str.yellow()
} else {
swap_pct_str.green()
};
println!(
" {} {} {:.2} / {:.2} GB {}",
"SWAP:".white().bold(),
swap_bar,
swap_used_gb,
swap_total_gb,
swap_pct_colored
);
}
} else {
println!(" {}", "No memory data available".yellow());
}
}
#[cfg(feature = "cli")]
fn print_process_info_backend(
backend: &ironmonitor::backend::MonitoringBackend,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ProcessCategory;
use std::collections::HashMap;
println!("{}", "═══ Process Information ═══".cyan().bold());
let Some(processes) = backend.processes() else {
println!(" {}", "Process list not read".yellow());
return Ok(());
};
if processes.is_empty() {
println!(" {}", "No process data available".yellow());
return Ok(());
}
let mut by_category: HashMap<ProcessCategory, Vec<&ironmonitor::ProcessMonitorInfo>> =
HashMap::new();
for proc in processes.iter() {
by_category.entry(proc.category).or_default().push(proc);
}
println!("\n {}", "Category Summary:".white().bold());
println!(
" {:<18} {:>8} {:>8} {:>10} {:>12}",
"CATEGORY".dimmed(),
"PROCS".dimmed(),
"GPU".dimmed(),
"CPU%".dimmed(),
"MEMORY".dimmed()
);
println!(" {}", "─".repeat(60).dimmed());
let mut categories: Vec<_> = by_category.keys().collect();
categories.sort_by_key(|c| c.display_name());
for category in &categories {
if let Some(procs) = by_category.get(*category) {
let count = procs.len();
let gpu_count = procs
.iter()
.filter(|p| p.is_gpu_process() == Some(true))
.count();
let gpu_known = procs.iter().all(|p| p.is_gpu_process().is_some());
let total_cpu: Option<f32> = procs.iter().map(|p| p.cpu_percent).sum();
let total_mem: u64 = procs.iter().map(|p| p.memory_bytes).sum();
let mem_mb = total_mem as f64 / 1024.0 / 1024.0;
let gpu_indicator = if !gpu_known {
"unknown".dimmed().to_string()
} else if gpu_count > 0 {
format!("{}", gpu_count).magenta().to_string()
} else {
"-".dimmed().to_string()
};
let cpu_colored = match total_cpu {
Some(c) if c > 50.0 => format!("{c:.1}").yellow(),
Some(c) => format!("{c:.1}").green(),
None => "--".dimmed(),
};
let mem_str = format!("{:.1}MB", mem_mb);
let mem_colored = if mem_mb > 1000.0 {
mem_str.yellow()
} else {
mem_str.white()
};
println!(
" {} {:<15} {:>8} {:>8} {:>10} {:>12}",
category.icon(),
category.display_name().white(),
count.to_string().cyan(),
gpu_indicator,
cpu_colored,
mem_colored,
);
}
}
println!();
for category in &[
ProcessCategory::AiMl,
ProcessCategory::GpuCompute,
ProcessCategory::Gaming,
ProcessCategory::Browser,
ProcessCategory::Development,
ProcessCategory::Media,
] {
if let Some(procs) = by_category.get(category) {
if !procs.is_empty() {
let mut sorted: Vec<_> = procs.iter().collect();
sorted.sort_by(|a, b| {
b.cpu_percent
.partial_cmp(&a.cpu_percent)
.unwrap_or(std::cmp::Ordering::Equal)
});
println!(
" {} {} {}",
category.icon(),
category.display_name().white().bold(),
"(top 5):".dimmed()
);
println!(
" {:<8} {:<30} {:>8} {:>10} {:>10}",
"PID".dimmed(),
"NAME".dimmed(),
"CPU%".dimmed(),
"MEM(MB)".dimmed(),
"GPU(MB)".dimmed()
);
for proc in sorted.iter().take(5) {
let gpu_mem = match (proc.is_gpu_process(), proc.gpu_memory_mb()) {
(Some(true), Some(mb)) => format!("{mb:.1}").magenta().to_string(),
(Some(true), None) => "n/a".dimmed().to_string(),
(Some(false), _) => "-".dimmed().to_string(),
(None, _) => "unknown".dimmed().to_string(),
};
let cpu_colored = match proc.cpu_percent {
Some(c) if c > 50.0 => format!("{c:.1}").red(),
Some(c) if c > 20.0 => format!("{c:.1}").yellow(),
Some(c) => format!("{c:.1}").green(),
None => "--".dimmed(),
};
let name = if proc.name.len() > 30 {
&proc.name[..30]
} else {
&proc.name
};
println!(
" {:<8} {:<30} {:>8} {:>10.1} {:>10}",
proc.pid.to_string().cyan(),
name.white(),
cpu_colored,
proc.memory_mb(),
gpu_mem,
);
}
println!();
}
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn print_all_info(
backend: &ironmonitor::backend::MonitoringBackend,
) -> Result<(), Box<dyn std::error::Error>> {
println!("{}", "═══ System Overview ═══".cyan().bold());
let or_unknown = |s: &str| if s.is_empty() { "unknown" } else { s }.to_string();
println!(
" {} {}",
"Host:".white().bold(),
or_unknown(backend.hostname()).green()
);
println!(" {} {}", "OS:".white().bold(), backend.os_info().green());
let uptime = match ironmonitor::backend::MonitoringBackend::system_uptime() {
Some(d) => {
let secs = d.as_secs();
format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
}
None => "unknown".to_string(),
};
println!(" {} {}", "Uptime:".white().bold(), uptime);
println!();
print_cpu_info_backend(backend);
println!();
print_memory_info_backend(backend);
println!();
print_gpu_info_backend(backend);
println!();
println!("{}", "═══ Processes ═══".cyan().bold());
match backend.processes() {
Some(procs) => {
let gpu_known = procs.iter().all(|p| p.is_gpu_process().is_some());
let gpu_text = if gpu_known {
procs
.iter()
.filter(|p| p.is_gpu_process() == Some(true))
.count()
.to_string()
} else {
"unknown".to_string()
};
println!(
" {} {} ({} using GPU)",
"Total:".white().bold(),
procs.len().to_string().cyan(),
gpu_text.magenta()
);
}
None => println!(" {}", "Process list not read".yellow()),
}
Ok(())
}
#[cfg(feature = "cli")]
fn handle_jetson_command(cmd: &JetsonSubcommand) -> Result<(), Box<dyn std::error::Error>> {
#[cfg(not(target_os = "linux"))]
{
let _ = cmd; eprintln!("Error: Jetson commands are only available on Linux");
eprintln!(" These utilities require NVIDIA Jetson hardware (Xavier, Orin, etc.)");
std::process::exit(1);
}
#[cfg(all(target_os = "linux", feature = "jetson-utils"))]
match cmd {
JetsonSubcommand::Clocks { action } => handle_jetson_clocks(action),
JetsonSubcommand::Powermode { action } => handle_nvpmodel(action),
JetsonSubcommand::Swap { action } => handle_swap(action),
}
#[cfg(all(target_os = "linux", not(feature = "jetson-utils")))]
{
let _ = cmd;
eprintln!("Error: this build was compiled without the `jetson-utils` feature");
eprintln!(" Jetson clock, power mode and swap controls are gated behind it");
eprintln!(" because they write to system state; see SECURITY.md");
eprintln!(" Rebuild with: cargo build --features cli,jetson-utils");
std::process::exit(1);
}
}
#[cfg_attr(
not(all(feature = "cli", feature = "jetson-utils", target_os = "linux")),
allow(dead_code)
)]
#[derive(Debug, PartialEq, Eq)]
enum WriteGate {
Refuse {
status: ironmonitor::profile::apply::ApplyStatus,
message: &'static str,
},
Proceed,
}
#[cfg_attr(
not(all(feature = "cli", feature = "jetson-utils", target_os = "linux")),
allow(dead_code)
)]
fn write_gate(confirm: bool) -> WriteGate {
if confirm {
WriteGate::Proceed
} else {
WriteGate::Refuse {
status: ironmonitor::profile::apply::ApplyStatus::NeedsConfirm,
message: "Apply rejected: explicit confirmation required (pass --confirm).",
}
}
}
#[cfg(all(feature = "cli", feature = "jetson-utils", target_os = "linux"))]
fn run_jetson_write<T>(
setting_id: &str,
subsystem: ironmonitor::profile::Subsystem,
requested: &str,
description: &str,
confirm: bool,
action: impl FnOnce() -> ironmonitor::Result<T>,
) -> Result<T, Box<dyn std::error::Error>> {
use ironmonitor::profile::apply::{record_attempt, ApplyStatus};
use ironmonitor::profile::SettingValue;
use ironmonitor::IronError;
let requested = SettingValue::Text(requested.to_string());
if let WriteGate::Refuse { status, message } = write_gate(confirm) {
println!("Would {}. Nothing was written.", description);
record_attempt(setting_id, subsystem, requested, status, message);
return Err(message.into());
}
match action() {
Ok(value) => {
record_attempt(
setting_id,
subsystem,
requested,
ApplyStatus::Applied,
"applied",
);
Ok(value)
}
Err(err) => {
let status = match err {
IronError::PermissionDenied(_) => ApplyStatus::Refused,
_ => ApplyStatus::Failed,
};
record_attempt(setting_id, subsystem, requested, status, &err.to_string());
Err(err.into())
}
}
}
#[cfg(all(feature = "cli", feature = "jetson-utils", target_os = "linux"))]
fn handle_jetson_clocks(action: &JetsonClocksAction) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::profile::Subsystem;
use ironmonitor::utils::clocks;
if !clocks::is_available() {
eprintln!("jetson_clocks is not available on this system");
std::process::exit(1);
}
match action {
JetsonClocksAction::Enable { confirm } => {
run_jetson_write(
"jetson.clocks",
Subsystem::Cpu,
"enable",
"enable jetson_clocks (maximize performance)",
*confirm,
|| {
println!("Enabling jetson_clocks (maximizing performance)...");
clocks::enable()
},
)?;
println!("jetson_clocks enabled successfully");
}
JetsonClocksAction::Disable { confirm } => {
run_jetson_write(
"jetson.clocks",
Subsystem::Cpu,
"disable",
"disable jetson_clocks (restore settings)",
*confirm,
|| {
println!("Disabling jetson_clocks (restoring settings)...");
clocks::disable()
},
)?;
println!("jetson_clocks disabled successfully");
}
JetsonClocksAction::Status => {
let status = clocks::show()?;
println!("=== Jetson Clocks Status ===");
println!("Active: {}", if status.active { "YES" } else { "NO" });
println!("\nConfigured Engines:");
for engine in &status.engines {
println!(" - {}", engine);
}
}
JetsonClocksAction::Store { confirm } => {
run_jetson_write(
"jetson.clocks",
Subsystem::Cpu,
"store",
"store the current jetson_clocks configuration",
*confirm,
|| {
println!("Storing current configuration...");
clocks::store()
},
)?;
println!("Configuration stored successfully");
}
}
Ok(())
}
#[cfg(all(feature = "cli", feature = "jetson-utils", target_os = "linux"))]
fn handle_nvpmodel(action: &NvpmodelAction) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::profile::Subsystem;
use ironmonitor::utils::power_mode;
if !power_mode::is_available() {
eprintln!("nvpmodel is not available on this system");
std::process::exit(1);
}
match action {
NvpmodelAction::Show => {
let mode = power_mode::query()?;
println!("=== Current Power Mode ===");
println!("ID: {}", mode.id);
println!("Name: {}", mode.name);
}
NvpmodelAction::List => {
let status = power_mode::list_modes()?;
println!("=== Available Power Modes ===");
println!("\nCurrent Mode:");
println!(
" ID: {} - {} {}",
status.current.id,
status.current.name,
if status.current.is_default {
"(default)"
} else {
""
}
);
println!("\nAll Modes:");
for mode in &status.modes {
println!(
" ID: {} - {} {}",
mode.id,
mode.name,
if mode.is_default { "(default)" } else { "" }
);
}
println!("\nDefault Mode:");
println!(" ID: {} - {}", status.default.id, status.default.name);
}
NvpmodelAction::Set {
mode_id,
force,
confirm,
} => {
run_jetson_write(
"jetson.powermode",
Subsystem::Cpu,
&format!("set mode ID {} force={}", mode_id, force),
&format!("set the power mode to ID {}", mode_id),
*confirm,
|| {
println!("Setting power mode to ID {}...", mode_id);
power_mode::set_mode(*mode_id, *force)
},
)?;
println!("Power mode set successfully");
let mode = power_mode::query()?;
println!("New mode: {} ({})", mode.name, mode.id);
}
NvpmodelAction::SetName {
name,
force,
confirm,
} => {
run_jetson_write(
"jetson.powermode",
Subsystem::Cpu,
&format!("set name '{}' force={}", name, force),
&format!("set the power mode to '{}'", name),
*confirm,
|| {
println!("Setting power mode to '{}'...", name);
power_mode::set_mode_by_name(name, *force)
},
)?;
println!("Power mode set successfully");
let mode = power_mode::query()?;
println!("New mode: {} ({})", mode.name, mode.id);
}
}
Ok(())
}
#[cfg(all(feature = "cli", feature = "jetson-utils", target_os = "linux"))]
fn handle_swap(action: &SwapAction) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::profile::Subsystem;
use ironmonitor::utils::swap;
match action {
SwapAction::Status => {
let swaps = swap::status()?;
if swaps.is_empty() {
println!("No active swap");
} else {
println!("=== Active Swap ===");
println!(
"{:<30} {:<10} {:<10} {:<10} {:<10}",
"NAME", "TYPE", "SIZE", "USED", "PRIO"
);
println!("{}", "-".repeat(80));
for swap_info in swaps {
println!(
"{:<30} {:<10} {:<10} {:<10} {:<10}",
swap_info.path,
swap_info.swap_type,
format_size(swap_info.size_kb),
format_size(swap_info.used_kb),
swap_info.priority,
);
}
}
}
SwapAction::Create {
path,
size,
auto,
confirm,
} => {
run_jetson_write(
"jetson.swap",
Subsystem::Memory,
&format!("create {} {}G auto={}", path.display(), size, auto),
&format!("create a {} GB swap file at {}", size, path.display()),
*confirm,
|| {
println!("This operation requires sudo privileges");
swap::create(path, *size, *auto)
},
)?;
}
SwapAction::Enable { path, confirm } => {
run_jetson_write(
"jetson.swap",
Subsystem::Memory,
&format!("enable {}", path.display()),
&format!("enable swap file {}", path.display()),
*confirm,
|| {
println!("Enabling swap: {}", path.display());
swap::enable(path)
},
)?;
println!("Swap enabled successfully");
}
SwapAction::Disable { path, confirm } => {
run_jetson_write(
"jetson.swap",
Subsystem::Memory,
&format!("disable {}", path.display()),
&format!("disable swap file {}", path.display()),
*confirm,
|| {
println!("Disabling swap: {}", path.display());
swap::disable(path)
},
)?;
println!("Swap disabled successfully");
}
SwapAction::Remove { path, confirm } => {
run_jetson_write(
"jetson.swap",
Subsystem::Memory,
&format!("remove {}", path.display()),
&format!("disable and delete swap file {}", path.display()),
*confirm,
|| {
println!("Removing swap file: {}", path.display());
println!("This operation requires sudo privileges");
swap::remove(path)
},
)?;
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn format_size(kb: u64) -> String {
if kb < 1024 {
format!("{}K", kb)
} else if kb < 1024 * 1024 {
format!("{:.1}M", kb as f64 / 1024.0)
} else {
format!("{:.1}G", kb as f64 / 1024.0 / 1024.0)
}
}
#[cfg(feature = "cli")]
#[allow(dead_code)]
fn print_process_info(processes: &ironmonitor::core::process::ProcessStats) {
println!("=== Process Information ===");
if processes.processes.is_empty() && processes.total_gpu_memory_kb.is_none() {
println!("Total Processes: unknown");
} else {
println!("Total Processes: {}", processes.process_count());
}
match processes.total_gpu_memory_kb {
Some(kb) => println!("Total GPU Memory: {:.2} MB\n", kb as f64 / 1024.0),
None => println!("Total GPU Memory: unknown\n"),
}
if processes.process_count() > 0 {
println!(
"{:<8} {:<12} {:<8} {:<8} {:<8} {:<10} {:<10} {:<20}",
"PID", "USER", "GPU", "TYPE", "STATE", "CPU%", "GPU MEM", "NAME"
);
println!("{}", "-".repeat(100));
for proc in processes.sorted_by_gpu_memory().iter().take(10) {
println!(
"{:<8} {:<12} {:<8} {:<8} {:<8} {:<10} {:<10} {:<20}",
proc.pid,
proc.user,
proc.gpu,
proc.process_type.as_deref().unwrap_or("unknown"),
proc.state
.map_or_else(|| "unknown".to_string(), String::from),
proc.cpu_percent
.map_or_else(|| "unknown".to_string(), |c| format!("{c:.1}")),
proc.gpu_memory_kb
.map_or_else(|| "unknown".to_string(), format_size),
proc.name,
);
}
}
}
#[cfg(feature = "cli")]
#[allow(dead_code)] fn print_process_info_v2(
monitor: &mut ironmonitor::ProcessMonitor,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ProcessCategory;
println!("{}", "═══ Process Information ═══".cyan().bold());
let category_stats = monitor.category_stats()?;
println!("\n {}", "Category Summary:".white().bold());
println!(
" {:<18} {:>8} {:>8} {:>10} {:>12}",
"CATEGORY".dimmed(),
"PROCS".dimmed(),
"GPU".dimmed(),
"CPU%".dimmed(),
"MEMORY".dimmed()
);
println!(" {}", "─".repeat(60).dimmed());
for stats in &category_stats {
if stats.process_count > 0 {
let gpu_indicator = if stats.gpu_process_count > 0 {
format!("{}", stats.gpu_process_count).magenta().to_string()
} else {
"-".dimmed().to_string()
};
let cpu_colored = match stats.total_cpu_percent {
Some(c) if c > 50.0 => format!("{c:.1}").yellow(),
Some(c) => format!("{c:.1}").green(),
None => "--".dimmed(),
};
let mem_str = format!("{:.1}MB", stats.memory_mb());
let mem_colored = if stats.memory_mb() > 1000.0 {
mem_str.yellow()
} else {
mem_str.white()
};
println!(
" {} {:<15} {:>8} {:>8} {:>10} {:>12}",
stats.category.icon(),
stats.category.display_name().white(),
stats.process_count.to_string().cyan(),
gpu_indicator,
cpu_colored,
mem_colored,
);
}
}
println!();
let grouped = monitor.processes_grouped_by_category()?;
for category in &[
ProcessCategory::AiMl,
ProcessCategory::GpuCompute,
ProcessCategory::Gaming,
ProcessCategory::Browser,
ProcessCategory::Development,
ProcessCategory::Media,
] {
if let Some(procs) = grouped.get(category) {
if !procs.is_empty() {
let mut sorted = procs.clone();
sorted.sort_by(|a, b| {
b.cpu_percent
.partial_cmp(&a.cpu_percent)
.unwrap_or(std::cmp::Ordering::Equal)
});
println!(
" {} {} {}",
category.icon(),
category.display_name().white().bold(),
"(top 5):".dimmed()
);
println!(
" {:<8} {:<30} {:>8} {:>10} {:>10}",
"PID".dimmed(),
"NAME".dimmed(),
"CPU%".dimmed(),
"MEM(MB)".dimmed(),
"GPU(MB)".dimmed()
);
for proc in sorted.iter().take(5) {
let gpu_mem = match (proc.is_gpu_process(), proc.gpu_memory_mb()) {
(Some(true), Some(mb)) => format!("{mb:.1}").magenta().to_string(),
(Some(true), None) => "n/a".dimmed().to_string(),
(Some(false), _) => "-".dimmed().to_string(),
(None, _) => "unknown".dimmed().to_string(),
};
let cpu_colored = match proc.cpu_percent {
Some(c) if c > 50.0 => format!("{c:.1}").red(),
Some(c) if c > 20.0 => format!("{c:.1}").yellow(),
Some(c) => format!("{c:.1}").green(),
None => "--".dimmed(),
};
let name = if proc.name.len() > 30 {
&proc.name[..30]
} else {
&proc.name
};
println!(
" {:<8} {:<30} {:>8} {:>10.1} {:>10}",
proc.pid.to_string().cyan(),
name.white(),
cpu_colored,
proc.memory_mb(),
gpu_mem,
);
}
println!();
}
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn print_engine_info(engines: &ironmonitor::core::engine::EngineStats) {
println!("{}", "═══ Engine Information ═══".cyan().bold());
println!(
" {} {} (Total: {})",
"Engine Groups:".white().bold(),
engines.group_count().to_string().cyan(),
engines.engine_count().to_string().green()
);
if engines.group_count() > 0 {
for (group_name, group_engines) in &engines.groups {
println!("\n {} {}", "▶".green(), group_name.white().bold());
for (engine_name, info) in group_engines {
let status = match info.online {
Some(true) => "ONLINE".green(),
Some(false) => "OFFLINE".red(),
None => "UNKNOWN".yellow(),
};
let current = info
.current
.map_or_else(|| "— MHz".to_string(), |mhz| format!("{mhz} MHz"));
let freq_info = match (info.min, info.max) {
(Some(min), Some(max)) => {
format!("{} ({}-{} MHz)", current.cyan(), min, max)
}
_ => current.cyan().to_string(),
};
println!(" {:<15} {} {}", engine_name.white(), status, freq_info);
}
}
} else {
#[cfg(target_os = "linux")]
println!(
" {}",
concat!(
"No engines detected — /sys/kernel/debug/clk was read and ",
"listed no APE, DLA or NVENC clock. Those exist on Tegra and ",
"Jetson parts; a desktop has none."
)
.yellow()
);
#[cfg(not(target_os = "linux"))]
println!(
" {}",
concat!(
"Not readable on this platform. Engine clocks come from ",
"/sys/kernel/debug/clk, which is Linux-only and present on ",
"Tegra and Jetson parts. For desktop GPU encoder and decoder ",
"utilisation, use `ironmon cli gpu`."
)
.yellow()
);
}
}
#[cfg(feature = "cli")]
fn read_ai_input(reader: &mut impl std::io::BufRead) -> std::io::Result<Option<String>> {
let mut input = String::new();
if reader.read_line(&mut input)? == 0 {
return Ok(None);
}
Ok(Some(input.trim().to_string()))
}
#[cfg(all(test, feature = "cli"))]
mod ai_input_tests {
#[test]
fn blank_lines_are_distinct_from_end_of_input() {
let mut input = std::io::Cursor::new(b"\n memory usage \nquit");
assert_eq!(
super::read_ai_input(&mut input).unwrap(),
Some(String::new())
);
assert_eq!(
super::read_ai_input(&mut input).unwrap(),
Some("memory usage".into())
);
assert_eq!(
super::read_ai_input(&mut input).unwrap(),
Some("quit".into())
);
assert_eq!(super::read_ai_input(&mut input).unwrap(), None);
}
}
#[cfg(all(test, feature = "cli"))]
mod jetson_write_gate_tests {
use super::{write_gate, WriteGate};
use ironmonitor::profile::apply::ApplyStatus;
#[test]
fn unconfirmed_write_is_refused_and_audited_as_needs_confirm() {
match write_gate(false) {
WriteGate::Refuse { status, message } => {
assert_eq!(status, ApplyStatus::NeedsConfirm);
assert!(message.contains("--confirm"), "message was: {message}");
}
WriteGate::Proceed => panic!("a write without --confirm must not proceed"),
}
}
#[test]
fn confirmed_write_may_proceed() {
assert_eq!(write_gate(true), WriteGate::Proceed);
}
}
#[cfg(feature = "cli")]
fn handle_ai_query(query: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::agent::{Agent, AgentConfig};
use std::io::{self, Write};
let config = match AgentConfig::auto_detect() {
Ok(cfg) => {
if let Some(ref backend) = cfg.backend {
eprintln!("[*] Using backend: {}", backend.backend_type.display_name());
}
cfg
}
Err(e) => {
eprintln!("[!] No AI backends available: {}", e);
eprintln!("[!] To use AI features, install Ollama (https://ollama.com) or set an API key (OPENAI_API_KEY, GITHUB_TOKEN, etc.)");
return Err(Box::new(std::io::Error::new(
std::io::ErrorKind::NotFound,
"No AI backend configured",
)));
}
}
.with_caching(true)
.with_cache_size(50)
.with_timeout(Duration::from_secs(30));
let mut agent = Agent::new(config)?;
if let Some(question) = query {
println!("[AI Monitor]");
println!("Question: {}\n", question);
let response = agent.ask_with_control(
question,
&ironmonitor::agent::tool_runtime::RunControl::default(),
)?;
println!("{}", response.response);
if response.from_cache {
println!("\n[CACHE] (from cache, <1ms)");
} else {
println!("\n[TIME] ({}ms)", response.inference_time_ms);
}
} else {
println!("[AI Monitor - Interactive Mode]");
println!("Ask questions about your system state. Type 'quit' or 'exit' to leave.\n");
loop {
print!("You: ");
io::stdout().flush()?;
let Some(input) = read_ai_input(&mut io::stdin().lock())? else {
break;
};
if input.is_empty() {
continue;
}
if input.eq_ignore_ascii_case("quit") || input.eq_ignore_ascii_case("exit") {
println!("Goodbye!");
break;
}
match agent.ask_with_control(
&input,
&ironmonitor::agent::tool_runtime::RunControl::default(),
) {
Ok(response) => {
println!("\n[Agent]: {}\n", response.response);
if response.from_cache {
println!("[CACHE] (from cache, <1ms)\n");
} else {
println!("[TIME] ({}ms)\n", response.inference_time_ms);
}
}
Err(e) => {
eprintln!("Error: {}\n", e);
}
}
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn handle_daemon_command(
config_path: Option<&str>,
sample_config: bool,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::daemon::{DaemonConfig, MonitoringDaemon};
if sample_config {
print!("{}", DaemonConfig::sample_toml());
return Ok(());
}
let daemon = match config_path {
Some(path) => MonitoringDaemon::from_config_file(path)?,
None => MonitoringDaemon::new(DaemonConfig::default()),
};
daemon.validate()?;
let config = daemon.config();
println!("{}", "═══ IronMonitor Monitoring Daemon ═══".cyan().bold());
println!(
" {} {}",
"Listening:".white().bold(),
daemon.listen_address().cyan()
);
println!(
" {} {}s",
"Poll interval:".white().bold(),
config.poll_interval_secs
);
println!(
" {} {}",
"Authentication:".white().bold(),
if config.api_key.is_some() {
"api key required".green()
} else {
"anonymous (loopback only)".yellow()
}
);
if let Some(ref pid) = config.pid_file {
println!(" {} {}", "PID file:".white().bold(), pid);
}
println!();
println!("{}", "Press Ctrl+C to stop.".yellow().italic());
let runtime = tokio::runtime::Runtime::new()?;
runtime.block_on(async { daemon.run().await })?;
Ok(())
}
#[cfg(feature = "cli")]
fn handle_serve_command(
port: u16,
bind: &str,
log_requests: bool,
api_key_file: Option<&str>,
cors_origins: &[String],
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::http_server::{
is_loopback_address, validate_cors_origin, HttpServer, HttpServerConfig,
};
use std::io::Write;
for origin in cors_origins {
validate_cors_origin(origin)?;
}
let api_key = read_api_key(api_key_file)?;
let keyed = api_key.is_some();
let loopback = is_loopback_address(bind);
let config = HttpServerConfig {
bind_address: bind.to_string(),
port,
request_logging: log_requests,
cors_enabled: !cors_origins.is_empty(),
cors_origins: cors_origins.to_vec(),
api_key,
..Default::default()
};
let server = HttpServer::new(config)?;
let bound = server.bind()?;
let addr = bound.local_addr();
{
let mut out = std::io::stdout().lock();
writeln!(
out,
"{}",
serde_json::json!({ "listening": addr.to_string() })
)?;
out.flush()?;
}
eprintln!("{}", "═══ IronMonitor HTTP Server ═══".cyan().bold());
eprintln!(" {} http://{}", "Listening:".white().bold(), addr);
eprintln!(
" {} http://{}/api/v1/metrics/prometheus",
"Prometheus:".white().bold(),
addr
);
eprintln!(
" {} http://{}/api/v1/describe",
"Schema:".white().bold(),
addr
);
eprintln!(
" {} http://{}/api/v1/health",
"Health:".white().bold(),
addr
);
eprintln!(
" {} {}",
"Authentication:".white().bold(),
if keyed {
"bearer key required (except /api/v1/health)"
} else {
"none"
}
);
if cors_origins.is_empty() {
eprintln!(
" {} off (no CORS headers are sent)",
"CORS:".white().bold()
);
} else {
eprintln!(" {} {}", "CORS:".white().bold(), cors_origins.join(", "));
}
if !loopback && !keyed {
eprintln!(
"{}",
"WARNING: bound to a non-loopback address with NO API KEY. Full hardware \
telemetry is readable by anything that can reach this port. Set \
--api-key-file or IRONMON_API_KEY."
.yellow()
.bold()
);
} else if !loopback {
eprintln!(
" {} bound to a routable address; requests need the bearer key",
"Note:".white().bold()
);
}
eprintln!();
eprintln!("{}", "Press Ctrl+C to stop.".yellow().italic());
let runtime = tokio::runtime::Runtime::new()?;
runtime.block_on(async { server.serve(bound).await })?;
Ok(())
}
fn read_api_key(file: Option<&str>) -> Result<Option<String>, Box<dyn std::error::Error>> {
let from_env = std::env::var("IRONMON_API_KEY").ok();
match (file, from_env) {
(Some(_), Some(_)) => Err("set --api-key-file or IRONMON_API_KEY, not both".into()),
(Some(path), None) => {
let raw = std::fs::read_to_string(path)
.map_err(|e| format!("cannot read API key file {path}: {e}"))?;
let key = raw.trim();
if key.is_empty() {
return Err(format!(
"API key file {path} is empty; refusing to start an open server"
)
.into());
}
Ok(Some(key.to_string()))
}
(None, Some(value)) => {
let key = value.trim();
if key.is_empty() {
return Err(
"IRONMON_API_KEY is set but empty; refusing to start an open server".into(),
);
}
Ok(Some(key.to_string()))
}
(None, None) => Ok(None),
}
}
#[cfg(feature = "cli")]
fn handle_record_command(action: &RecordSubcommand) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::tsdb::{
format_size, parse_size, MetricsRecorder, ProcessSnapshot, SystemSnapshot, TimeSeriesDb,
};
use std::io::{self, Write};
match action {
RecordSubcommand::Start {
database,
max_size,
interval,
max_processes,
format,
} => {
let max_bytes = parse_size(max_size)?;
let interval_duration = Duration::from_secs_f64(*interval);
println!("{}", "═══ Starting Metrics Recording ═══".cyan().bold());
println!(
" {} {}",
"Database:".white().bold(),
database.display().to_string().green()
);
println!(
" {} {}",
"Max Size:".white().bold(),
format_size(max_bytes).yellow()
);
println!(
" {} {}s",
"Interval:".white().bold(),
interval.to_string().cyan()
);
println!(
" {} {}",
"Max Processes:".white().bold(),
max_processes.to_string().cyan()
);
println!();
println!("{}", "Press Ctrl+C to stop recording...".yellow().italic());
println!();
let mut recorder =
MetricsRecorder::new(database, max_bytes, interval_duration, *max_processes)?;
let collector =
ironmonitor::pipeline::Collector::spawn(ironmonitor::pipeline::CollectorConfig {
interval: interval_duration,
collect_processes: *max_processes > 0,
..Default::default()
});
let snapshots = collector.handle();
let warmup_deadline = std::time::Instant::now() + Duration::from_secs(30);
while snapshots.latest().gpu_static.is_empty()
&& snapshots.latest().processes.is_empty()
&& std::time::Instant::now() < warmup_deadline
{
std::thread::sleep(Duration::from_millis(20));
}
let running = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
let r = running.clone();
ctrlc::set_handler(move || {
r.store(false, std::sync::atomic::Ordering::SeqCst);
})
.expect("Error setting Ctrl-C handler");
let mut record_count = 0u64;
let start_time = std::time::Instant::now();
while running.load(std::sync::atomic::Ordering::SeqCst) {
let iteration_start = std::time::Instant::now();
let state = snapshots.latest();
let timestamp = ironmonitor::tsdb::TimeSeriesDb::now_millis();
let cpu_per_core: Vec<Option<f32>> = state
.cpu
.as_ref()
.map(|c| {
c.cores
.iter()
.map(|core| core.idle.map(|idle| 100.0 - idle))
.collect()
})
.unwrap_or_default();
let cpu_percent = state.cpu_utilization();
let (memory_used, memory_total, swap_used, swap_total) = state
.memory
.as_ref()
.map(|m| {
(
Some(m.ram.used * 1024),
Some(m.ram.total * 1024),
m.swap.used.map(|v| v * 1024),
m.swap.total.map(|v| v * 1024),
)
})
.unwrap_or((None, None, None, None));
let mut gpu_percent = Vec::new();
let mut gpu_memory_used = Vec::new();
let mut gpu_temperature = Vec::new();
let mut gpu_power_mw = Vec::new();
for gpu in &state.gpu_dynamic {
match gpu {
Some(g) => {
gpu_percent.push(g.utilization.map(f32::from));
gpu_memory_used.push(g.memory.used);
gpu_temperature.push(g.thermal.temperature.map(|t| t as f32));
gpu_power_mw.push(g.power.draw);
}
None => {
gpu_percent.push(None);
gpu_memory_used.push(None);
gpu_temperature.push(None);
gpu_power_mw.push(None);
}
}
}
let mut ranked: Vec<_> = state.processes.iter().collect();
ranked.sort_by(|a, b| {
b.cpu_percent
.partial_cmp(&a.cpu_percent)
.unwrap_or(std::cmp::Ordering::Equal)
});
let processes: Vec<ProcessSnapshot> = ranked
.iter()
.take(*max_processes)
.map(|p| ProcessSnapshot {
pid: p.pid,
name: p.name.clone(),
cpu_percent: p.cpu_percent,
memory_bytes: p.memory_bytes,
gpu_memory_bytes: p.total_gpu_memory_bytes,
gpu_percent: p.gpu_usage_percent,
disk_read_bps: None,
disk_write_bps: None,
net_rx_bps: None,
net_tx_bps: None,
})
.collect();
let net_rx_bps = state.total_rx_rate().map(|r| r as u64);
let net_tx_bps = state.total_tx_rate().map(|r| r as u64);
let snapshot = SystemSnapshot {
timestamp,
cpu_percent,
cpu_per_core,
memory_used,
memory_total,
swap_used,
swap_total,
gpu_percent,
gpu_memory_used,
gpu_temperature,
gpu_power_mw,
net_rx_bps,
net_tx_bps,
processes,
};
recorder.record_snapshot(snapshot)?;
record_count += 1;
if *format == "text" {
let elapsed = start_time.elapsed().as_secs();
let stats = recorder.stats();
print!(
"\r{} {} records | {} | {:.1}% full | {} elapsed",
"Recording:".green(),
record_count.to_string().cyan(),
format_size(stats.current_size).yellow(),
stats.usage_percent(),
format_duration(elapsed)
);
io::stdout().flush()?;
} else {
println!(
"{{\"record\":{},\"size\":{},\"timestamp\":{}}}",
record_count,
recorder.stats().current_size,
timestamp
);
}
let spent = iteration_start.elapsed();
std::thread::sleep(interval_duration.saturating_sub(spent));
}
println!();
println!();
println!("{}", "Recording stopped.".yellow());
recorder.close()?;
let stats = recorder.stats();
println!("{}", "═══ Recording Summary ═══".cyan().bold());
println!(
" {} {}",
"Total Records:".white().bold(),
record_count.to_string().green()
);
println!(
" {} {}",
"Database Size:".white().bold(),
format_size(stats.current_size).yellow()
);
if let Some(span) = stats.time_span() {
println!(" {} {}", "Time Span:".white().bold(), span.cyan());
}
}
RecordSubcommand::Info { database } => {
if !database.exists() {
println!(
"{} Database file not found: {}",
"Error:".red().bold(),
database.display()
);
return Ok(());
}
let db = TimeSeriesDb::new(database, 0)?;
let stats = db.stats();
println!("{}", "═══ Database Information ═══".cyan().bold());
println!(
" {} {}",
"Path:".white().bold(),
stats.path.display().to_string().green()
);
println!(
" {} {}",
"Max Size:".white().bold(),
format_size(stats.max_size).yellow()
);
println!(
" {} {} ({:.1}%)",
"Current Size:".white().bold(),
format_size(stats.current_size).cyan(),
stats.usage_percent()
);
println!(
" {} {}",
"Record Count:".white().bold(),
stats.record_count.to_string().green()
);
if let Some(first) = stats.first_timestamp {
let dt = chrono::DateTime::from_timestamp_millis(first as i64)
.map(|d| d.format("%Y-%m-%d %H:%M:%S").to_string())
.unwrap_or_else(|| "Unknown".to_string());
println!(" {} {}", "First Record:".white().bold(), dt.cyan());
}
if let Some(last) = stats.last_timestamp {
let dt = chrono::DateTime::from_timestamp_millis(last as i64)
.map(|d| d.format("%Y-%m-%d %H:%M:%S").to_string())
.unwrap_or_else(|| "Unknown".to_string());
println!(" {} {}", "Last Record:".white().bold(), dt.cyan());
}
if let Some(span) = stats.time_span() {
println!(" {} {}", "Time Span:".white().bold(), span.magenta());
}
let bar_width = 40;
let filled = (stats.usage_percent() / 100.0 * bar_width as f32) as usize;
let empty = bar_width - filled;
let bar = format!("{}{}", "█".repeat(filled), "░".repeat(empty));
let bar_colored = if stats.usage_percent() > 90.0 {
bar.red()
} else if stats.usage_percent() > 70.0 {
bar.yellow()
} else {
bar.green()
};
println!(" {} [{}]", "Usage:".white().bold(), bar_colored);
}
RecordSubcommand::Query {
database,
start,
end,
format,
limit,
} => {
if !database.exists() {
println!(
"{} Database file not found: {}",
"Error:".red().bold(),
database.display()
);
return Ok(());
}
let mut db = TimeSeriesDb::new(database, 0)?;
let now = TimeSeriesDb::now_millis();
let start_time = if let Some(s) = start {
parse_time_spec(s, now)?
} else {
0 };
let end_time = if let Some(e) = end {
parse_time_spec(e, now)?
} else {
now };
let mut snapshots = db.query_range(start_time, end_time)?;
if let Some(l) = limit {
snapshots.truncate(*l);
}
if *format == "json" {
println!("{}", serde_json::to_string_pretty(&snapshots)?);
} else {
println!("{}", "═══ Query Results ═══".cyan().bold());
println!(
" {} {} records",
"Found:".white().bold(),
snapshots.len().to_string().green()
);
println!();
for snapshot in snapshots.iter().take(20) {
let dt = chrono::DateTime::from_timestamp_millis(snapshot.timestamp as i64)
.map(|d| d.format("%Y-%m-%d %H:%M:%S").to_string())
.unwrap_or_else(|| "Unknown".to_string());
println!(" {} {}", "Time:".white().bold(), dt.cyan());
let cpu = match snapshot.cpu_percent {
Some(p) => format!("{p:.1}%"),
None => "not read".to_string(),
};
let mem = match (snapshot.memory_used, snapshot.memory_total) {
(Some(used), Some(total)) if total > 0 => {
format!("{:.1}%", (used as f64 / total as f64) * 100.0)
}
_ => "not read".to_string(),
};
println!(" CPU: {cpu} MEM: {mem}");
if !snapshot.gpu_percent.is_empty() {
for (i, gpu) in snapshot.gpu_percent.iter().enumerate() {
let util = match gpu {
Some(u) => format!("{:.1}%", u),
None => "not read".to_string(),
};
let temp = match snapshot.gpu_temperature.get(i).copied().flatten() {
Some(t) => format!("{:.0}°C", t),
None => "no sensor".to_string(),
};
println!(" GPU{}: {} Temp: {}", i, util, temp);
}
}
println!();
}
if snapshots.len() > 20 {
println!(" {} (showing 20 of {})", "...".dimmed(), snapshots.len());
}
}
}
RecordSubcommand::Export {
database,
output,
format,
} => {
if !database.exists() {
println!(
"{} Database file not found: {}",
"Error:".red().bold(),
database.display()
);
return Ok(());
}
let mut db = TimeSeriesDb::new(database, 0)?;
let snapshots = db.read_all_system_snapshots()?;
println!("{}", "═══ Exporting Data ═══".cyan().bold());
println!(
" {} {} records",
"Records:".white().bold(),
snapshots.len().to_string().green()
);
println!(
" {} {}",
"Output:".white().bold(),
output.display().to_string().yellow()
);
if *format == "csv" {
let mut file = std::fs::File::create(output)?;
writeln!(
file,
"timestamp,cpu_percent,memory_used,memory_total,swap_used,swap_total,net_rx_bps,net_tx_bps"
)?;
for s in &snapshots {
writeln!(
file,
"{},{},{},{},{},{},{},{}",
s.timestamp,
s.cpu_percent.map(|v| format!("{v:.2}")).unwrap_or_default(),
s.memory_used.map(|v| v.to_string()).unwrap_or_default(),
s.memory_total.map(|v| v.to_string()).unwrap_or_default(),
s.swap_used.map(|v| v.to_string()).unwrap_or_default(),
s.swap_total.map(|v| v.to_string()).unwrap_or_default(),
s.net_rx_bps.map(|v| v.to_string()).unwrap_or_default(),
s.net_tx_bps.map(|v| v.to_string()).unwrap_or_default()
)?;
}
} else {
let file = std::fs::File::create(output)?;
serde_json::to_writer_pretty(file, &snapshots)?;
}
println!(
" {} {}",
"Status:".white().bold(),
"Export complete!".green()
);
}
RecordSubcommand::Clear { database, force } => {
if !database.exists() {
println!(
"{} Database file not found: {}",
"Info:".yellow().bold(),
database.display()
);
return Ok(());
}
if !force {
print!(
"{} Delete database {}? [y/N]: ",
"Confirm:".yellow().bold(),
database.display()
);
io::stdout().flush()?;
let mut input = String::new();
io::stdin().read_line(&mut input)?;
if !input.trim().eq_ignore_ascii_case("y") {
println!("{}", "Cancelled.".yellow());
return Ok(());
}
}
std::fs::remove_file(database)?;
println!(
"{} Database deleted: {}",
"Success:".green().bold(),
database.display()
);
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn print_collects_nothing_notice() {
println!(
"{} {}",
"Note:".yellow().bold(),
"IronMonitor collects and transmits nothing.".white().bold()
);
println!(
" {}",
concat!(
"There is no telemetry endpoint in this program and no code that ",
"reports any of these categories to its authors. The settings here ",
"record a preference that a future collector would have to honour; ",
"they do not switch anything on or off today."
)
.dimmed()
);
println!(
" {}",
concat!(
"The only network requests IronMonitor makes are to AI backends you ",
"configure and point at yourself."
)
.dimmed()
);
println!(
" {}",
concat!(
"Storage you set up yourself is not telemetry: `ironmon record` ",
"writes a local metrics file, `ironmon serve` publishes metrics for ",
"your own scraper, and the optional fleet store appends to a table ",
"you configure. You choose those destinations; nothing goes anywhere ",
"you did not name."
)
.dimmed()
);
println!();
}
fn handle_privacy_command(action: &PrivacySubcommand) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::consent::{ConsentManager, ConsentScope};
match action {
PrivacySubcommand::Status => {
let manager = ConsentManager::load()?;
println!(
"{}",
"╔════════════════════════════════════════════════════════════════╗".cyan()
);
println!(
"{}",
"║ IronMonitor - Privacy Status ║".cyan()
);
println!(
"{}",
"╚════════════════════════════════════════════════════════════════╝".cyan()
);
println!();
let no_telemetry = std::env::var("IRONMON_NO_TELEMETRY").is_ok();
let offline = std::env::var("IRONMON_OFFLINE").is_ok();
if no_telemetry || offline {
println!("{}", "Session Flags:".white().bold());
if offline {
println!(" {} Offline mode active (--offline)", "⦿".yellow());
} else if no_telemetry {
println!(
" {} Telemetry disabled for this session (--no-telemetry)",
"⦿".yellow()
);
}
println!();
}
print_collects_nothing_notice();
println!("{}", "Recorded preferences:".white().bold());
println!("─────────────────────────────────────────────────────────────────");
let records = manager.get_all_consents();
for scope in [
ConsentScope::BasicTelemetry,
ConsentScope::HardwareInfo,
ConsentScope::PerformanceMetrics,
ConsentScope::DetailedDiagnostics,
ConsentScope::Analytics,
] {
let status = match records.get(&scope).map(|r| r.granted) {
Some(true) => format!("{} granted", "●".green()),
Some(false) => format!("{} denied", "○".red()),
None => format!("{} unanswered", "·".yellow()),
};
println!(
" {:<30} {:<20} {}",
scope.name(),
status,
"(nothing implemented)".dimmed()
);
}
println!();
let sandbox = ironmonitor::sandbox::SandboxDetector::new().detect();
if sandbox.is_sandboxed() {
println!(
concat!(
"{} every category is refused regardless of the answers ",
"above, because this looks like a {}."
),
"Override:".yellow().bold(),
sandbox.summary().to_lowercase()
);
println!(
" {}",
concat!(
"Detection is a heuristic and can be wrong; nothing is ",
"collected here either way."
)
.dimmed()
);
println!();
} else if no_telemetry || offline {
println!(
"{} every category is refused for this session by the flag above.",
"Override:".yellow().bold()
);
println!();
}
println!("{}", "Commands:".white().bold());
println!(" ironmon privacy opt-out # Record a denial for every category");
println!(" ironmon privacy opt-in # Record consent for every category");
println!(" ironmon privacy review # Review settings interactively");
println!(" ironmon privacy info # Show what each category would cover");
println!();
println!("{}", "Session Flags:".white().bold());
println!(" ironmon --no-telemetry # Deny every category for one session");
println!(" ironmon --offline # Also keep agent backends off the network");
}
PrivacySubcommand::OptOut => {
let mut manager = ConsentManager::load()?;
manager.revoke_all()?;
println!(
"{}",
"╔════════════════════════════════════════════════════════════════╗".green()
);
println!(
"{}",
"║ Preferences Recorded: Everything Denied ║".green()
);
println!(
"{}",
"╚════════════════════════════════════════════════════════════════╝".green()
);
println!();
println!("A denial has been recorded for every category and saved.");
println!();
print_collects_nothing_notice();
println!("You can change these preferences at any time with:");
println!(" ironmon privacy opt-in");
println!(" ironmon privacy review");
}
PrivacySubcommand::OptIn => {
let mut manager = ConsentManager::load()?;
println!(
"{}",
"╔════════════════════════════════════════════════════════════════╗".cyan()
);
println!(
"{}",
"║ Preferences Recorded: Everything Consented ║".cyan()
);
println!(
"{}",
"╚════════════════════════════════════════════════════════════════╝".cyan()
);
println!();
println!("Recording consent for every category...");
println!();
for scope in [
ConsentScope::BasicTelemetry,
ConsentScope::HardwareInfo,
ConsentScope::PerformanceMetrics,
ConsentScope::DetailedDiagnostics,
ConsentScope::Analytics,
] {
manager.record_consent(scope, true)?;
println!(" {} {} consented to", "✓".green(), scope.name());
}
println!();
println!("{}", "Consent recorded for every category.".green());
println!();
print_collects_nothing_notice();
println!("You can review or change these preferences at any time with:");
println!(" ironmon privacy status");
println!(" ironmon privacy review");
}
PrivacySubcommand::Review => {
let mut manager = ConsentManager::load()?;
manager.request_all_consents()?;
}
PrivacySubcommand::Info => {
println!(
"{}",
"╔════════════════════════════════════════════════════════════════╗".cyan()
);
println!(
"{}",
"║ Data Collection Categories ║".cyan()
);
println!(
"{}",
"╚════════════════════════════════════════════════════════════════╝".cyan()
);
println!();
print_collects_nothing_notice();
for scope in [
ConsentScope::BasicTelemetry,
ConsentScope::HardwareInfo,
ConsentScope::PerformanceMetrics,
ConsentScope::DetailedDiagnostics,
ConsentScope::Analytics,
] {
println!("{}", format!("═══ {} ═══", scope.name()).yellow().bold());
println!();
println!("{}", "Description:".white().bold());
println!(" {}", scope.description());
println!();
println!("{}", "Would cover:".white().bold());
for point in scope.data_points() {
println!(" • {}", point);
}
println!();
}
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn parse_time_spec(spec: &str, now: u64) -> Result<u64, Box<dyn std::error::Error>> {
let spec = spec.trim();
if spec.ends_with('m') || spec.ends_with('M') {
let minutes: u64 = spec[..spec.len() - 1].parse()?;
return Ok(now.saturating_sub(minutes * 60 * 1000));
}
if spec.ends_with('h') || spec.ends_with('H') {
let hours: u64 = spec[..spec.len() - 1].parse()?;
return Ok(now.saturating_sub(hours * 60 * 60 * 1000));
}
if spec.ends_with('d') || spec.ends_with('D') {
let days: u64 = spec[..spec.len() - 1].parse()?;
return Ok(now.saturating_sub(days * 24 * 60 * 60 * 1000));
}
let ts: u64 = spec.parse()?;
if ts < 10_000_000_000 {
Ok(ts * 1000)
} else {
Ok(ts)
}
}
#[cfg(feature = "cli")]
fn format_duration(secs: u64) -> String {
if secs < 60 {
format!("{}s", secs)
} else if secs < 3600 {
format!("{}m {}s", secs / 60, secs % 60)
} else {
format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
}
}
#[cfg(feature = "cli")]
fn handle_get_command(id: &str, format: &str) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ontology::resolve;
let Some(reading) = resolve::get(id) else {
eprintln!("Unknown entity id: {id}");
eprintln!(
"Try `ironmon describe --search {}`.",
id.split('.').next().unwrap_or(id)
);
std::process::exit(1);
};
if format.eq_ignore_ascii_case("json") {
println!("{}", serde_json::to_string_pretty(&reading)?);
} else {
match &reading.value {
Some(v) => {
let rendered = v
.as_str()
.map(str::to_string)
.unwrap_or_else(|| v.to_string());
let unit = reading
.unit
.map(|u| format!(" {}", u.as_str()))
.unwrap_or_default();
println!("{rendered}{unit} [{}]", reading.provenance.as_str());
}
None => {
println!("unavailable");
if let Some(note) = &reading.note {
println!(" {note}");
}
}
}
}
if reading.value.is_none() {
std::process::exit(2);
}
Ok(())
}
fn handle_snapshot_command(
domain: Option<&str>,
resolved_only: bool,
validate: bool,
format: &str,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ontology::{resolve, Domain};
let mut readings = resolve::snapshot();
if let Some(d) = domain {
let Some(parsed) = Domain::parse(d) else {
eprintln!("Unknown domain {d:?}. Known domains:");
for known in Domain::ALL {
eprintln!(" {}", known.as_str());
}
std::process::exit(1);
};
let prefix = format!("{}.", parsed.as_str());
readings.retain(|r| r.id.starts_with(&prefix));
}
if resolved_only {
readings.retain(|r| r.value.is_some());
}
let problems = if validate {
resolve::validate(&readings)
} else {
Vec::new()
};
if format.eq_ignore_ascii_case("json-ld") || format.eq_ignore_ascii_case("jsonld") {
let stamp = chrono::Utc::now().to_rfc3339();
let doc = ironmonitor::ontology::jsonld::document(&readings, &stamp);
println!("{}", serde_json::to_string_pretty(&doc)?);
} else if format.eq_ignore_ascii_case("json") {
let doc = resolve::snapshot_document(&readings, &problems);
println!("{}", serde_json::to_string_pretty(&doc)?);
} else {
for r in &readings {
match &r.value {
Some(v) => {
let rendered = v
.as_str()
.map(str::to_string)
.unwrap_or_else(|| v.to_string());
let unit = r
.unit
.map(|u| format!(" {}", u.as_str()))
.unwrap_or_default();
println!(
"{:<44} {:<14} {rendered}{unit}",
r.id,
r.provenance.as_str()
);
}
None => println!(
"{:<44} {:<14} — {}",
r.id,
"unavailable",
r.note.as_deref().unwrap_or("no reason given")
),
}
}
let resolved = readings.iter().filter(|r| r.value.is_some()).count();
println!();
println!(
"{resolved} resolved, {} unavailable",
readings.len() - resolved
);
}
if !problems.is_empty() {
eprintln!("\n{} impossible reading(s):", problems.len());
for p in &problems {
eprintln!(" {p}");
}
std::process::exit(3);
}
Ok(())
}
fn emit_command_catalog(format: &str) -> Result<(), Box<dyn std::error::Error>> {
let root = Cli::command();
fn describe(cmd: &clap::Command) -> serde_json::Value {
let args: Vec<serde_json::Value> = cmd
.get_arguments()
.filter(|a| a.get_id() != "help" && a.get_id() != "version")
.map(|a| {
serde_json::json!({
"name": a.get_id().as_str(),
"long": a.get_long(),
"short": a.get_short().map(|c| c.to_string()),
"help": a.get_help().map(|h| h.to_string()),
"required": a.is_required_set(),
"takes_value": a.get_num_args().map(|n| n.takes_values()).unwrap_or(false),
"default": a.get_default_values()
.first()
.map(|v| v.to_string_lossy().to_string()),
})
})
.collect();
let subcommands: Vec<serde_json::Value> = cmd
.get_subcommands()
.filter(|s| s.get_name() != "help")
.map(describe)
.collect();
serde_json::json!({
"name": cmd.get_name(),
"about": cmd.get_about().map(|a| a.to_string()),
"args": args,
"subcommands": subcommands,
})
}
let catalog = describe(&root);
if format.eq_ignore_ascii_case("json") {
println!("{}", serde_json::to_string_pretty(&catalog)?);
return Ok(());
}
fn print_tree(node: &serde_json::Value, depth: usize) {
let indent = " ".repeat(depth);
let name = node["name"].as_str().unwrap_or("?");
let about = node["about"].as_str().unwrap_or("");
println!("{indent}{name} {about}");
for arg in node["args"].as_array().into_iter().flatten() {
let long = arg["long"]
.as_str()
.map(|l| format!("--{l}"))
.unwrap_or_default();
let takes = if arg["takes_value"].as_bool().unwrap_or(false) {
" <value>"
} else {
""
};
let help = arg["help"].as_str().unwrap_or("");
if !long.is_empty() {
println!("{indent} {long}{takes} {help}");
}
}
for sub in node["subcommands"].as_array().into_iter().flatten() {
print_tree(sub, depth + 1);
}
}
print_tree(&catalog, 0);
Ok(())
}
#[cfg(feature = "gui")]
fn handle_gui_script_command(source: &str) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::gui::headless;
let text = if source == "-" {
use std::io::Read;
let mut buf = String::new();
std::io::stdin().read_to_string(&mut buf)?;
buf
} else {
std::fs::read_to_string(source)
.map_err(|e| format!("could not read script {source:?}: {e}"))?
};
let steps = match headless::parse_script(&text) {
Ok(s) => s,
Err(e) => {
eprintln!("{e}");
std::process::exit(2);
}
};
if steps.is_empty() {
eprintln!("the script contains no steps");
std::process::exit(2);
}
let ctx = headless::themed_context();
let mut app = ironmonitor::gui::app::IronMonitorApp::with_context(&ctx);
let result = headless::run_script(&mut app, &ctx, &steps);
for capture in &result.captures {
println!("{capture}");
println!();
}
if result.failures.is_empty() {
eprintln!("{} step(s) ok", steps.len());
return Ok(());
}
eprintln!("{} assertion(s) failed:", result.failures.len());
for failure in &result.failures {
eprintln!(" {failure}");
}
std::process::exit(1);
}
fn handle_tune_command(
watch: Option<u64>,
apply: bool,
confirm: bool,
max_risk: &str,
force_case: Option<&str>,
format: &str,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::profile::SettingRisk;
use ironmonitor::tuning::serve::{self, Mode};
use ironmonitor::tuning::{Classification, Method, UseCase};
let ceiling = match max_risk.trim().to_ascii_lowercase().as_str() {
"safe" => SettingRisk::Safe,
"moderate" => SettingRisk::Moderate,
"dangerous" => {
eprintln!(
"--max-risk dangerous is not accepted. Those settings touch power, thermal, \
voltage or MSRs and can destabilize hardware; IronMonitor does not write them from \
an unattended loop. Use `ironmon profile set` with --confirm for a single \
deliberate change."
);
std::process::exit(2);
}
other => {
eprintln!("Unknown risk tier {other:?}. Known tiers: safe, moderate.");
std::process::exit(2);
}
};
if apply && !confirm {
eprintln!(
"--apply requires --confirm. Nothing was written. Run without --apply to see the \
recommendations first."
);
std::process::exit(2);
}
let mode = if apply {
Mode::Apply { ceiling, confirm }
} else {
Mode::Recommend
};
let classify = |()| -> Classification {
match force_case {
Some(name) => match UseCase::parse(name) {
Some(use_case) => Classification {
use_case,
confidence: 1.0,
method: Method::Signals,
evidence: vec![format!("use case forced to {name:?} on the command line")],
},
None => {
eprintln!(
"Unknown use case {name:?}. Known: ai_training, ai_inference, gaming, \
interactive, idle."
);
std::process::exit(2);
}
},
None => ironmonitor::tuning::classify(&serve::collect_signals()),
}
};
let started = std::time::Instant::now();
let json = format.eq_ignore_ascii_case("json");
let emit = |cycle: &serve::Cycle| {
if json {
match serde_json::to_string_pretty(cycle) {
Ok(s) => println!("{s}"),
Err(e) => eprintln!("failed to serialize cycle: {e}"),
}
} else {
print_tune_cycle(cycle);
}
};
match watch {
None => {
let cycle = serve::cycle_with(mode, started, classify(()));
emit(&cycle);
}
Some(secs) => {
if secs == 0 {
eprintln!("--watch needs a non-zero interval.");
std::process::exit(2);
}
if !json {
println!(
"Watching every {secs}s in {} mode. Ctrl-C to stop.\n",
if apply { "apply" } else { "recommend" }
);
}
let running = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
let flag = running.clone();
let _ = ctrlc::set_handler(move || {
flag.store(false, std::sync::atomic::Ordering::SeqCst);
});
serve::run(
mode,
std::time::Duration::from_secs(secs),
|c| emit(c),
|| !running.load(std::sync::atomic::Ordering::SeqCst),
);
}
}
Ok(())
}
fn print_tune_cycle(cycle: &ironmonitor::tuning::serve::Cycle) {
use ironmonitor::tuning::Method;
let c = &cycle.plan.classification;
let method = match &c.method {
Method::Signals => "signals".to_string(),
Method::Model { backend } => format!("model ({backend})"),
};
println!(
"Use case: {} (confidence {:.0}%, from {method})",
c.use_case.as_str(),
c.confidence * 100.0
);
for e in &c.evidence {
println!(" · {e}");
}
if cycle.plan.recommendations.is_empty() {
println!("\nNo changes recommended.");
} else {
println!("\nRecommended ({}):", cycle.plan.recommendations.len());
for r in &cycle.plan.recommendations {
println!(
" {} [{:?}]\n {} -> {}\n basis: {}\n why: {}",
r.display_name, r.risk, r.current, r.proposed, r.basis, r.rationale
);
}
}
if !cycle.applied.is_empty() {
println!("\nApplied:");
for a in &cycle.applied {
println!(" {} — {} ({})", a.setting_id, a.status, a.message);
}
}
if !cycle.withheld.is_empty() {
println!("\nWithheld:");
for w in &cycle.withheld {
println!(" {} — {}", w.setting_id, w.reason);
}
}
if !cycle.plan.skipped.is_empty() {
println!("\nConsidered and skipped:");
for s in &cycle.plan.skipped {
println!(" {} — {}", s.setting_id, s.reason);
}
}
println!();
}
#[cfg(feature = "gui")]
fn handle_gui_frame_command(tab: &str) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::gui::headless;
let ctx = headless::themed_context();
let mut app = ironmonitor::gui::app::IronMonitorApp::with_context(&ctx);
if let Err(available) = app.select_tab_by_name(tab) {
eprintln!("Unknown tab {tab:?}. Available tabs:");
for name in available {
eprintln!(" {name}");
}
std::process::exit(1);
}
app.await_first_agents_scan(std::time::Duration::from_secs(5));
const SETTLE_DEADLINE: std::time::Duration = std::time::Duration::from_secs(30);
let lines = headless::painted_text_until(
&ctx,
SETTLE_DEADLINE,
&mut app,
|app, ctx| app.pump_background_loaders(ctx),
|app, lines| !headless::frame_is_still_loading(lines) && !app.has_pending_load(),
|app, ui| app.draw_current_tab(ui),
);
if headless::frame_is_still_loading(&lines) {
eprintln!(
"note: the {tab} tab was still loading after {}s; the text below is \
whatever it had painted by then",
SETTLE_DEADLINE.as_secs()
);
}
if lines.is_empty() {
eprintln!(
"the {tab} tab painted no text at all — that is a blank tab, not an \
empty one"
);
std::process::exit(2);
}
for line in lines {
println!("{line}");
}
Ok(())
}
fn handle_tui_script_command(
source: &str,
width: u16,
height: u16,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::tui::headless;
let text = if source == "-" {
use std::io::Read;
let mut buf = String::new();
std::io::stdin().read_to_string(&mut buf)?;
buf
} else {
std::fs::read_to_string(source)
.map_err(|e| format!("could not read script {source:?}: {e}"))?
};
let steps = match headless::parse_script(&text) {
Ok(s) => s,
Err(e) => {
eprintln!("{e}");
std::process::exit(2);
}
};
if steps.is_empty() {
eprintln!("the script contains no steps");
std::process::exit(2);
}
let mut app = ironmonitor::tui::App::new()?;
app.update()?;
app.await_first_inference_poll(std::time::Duration::from_secs(3));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while std::time::Instant::now() < deadline {
if app.sync_snapshot() && !app.snapshot_is_warmup() {
break;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
let result = headless::run_script(&mut app, &steps, width, height);
for capture in &result.captures {
println!("{capture}");
println!();
}
if result.failures.is_empty() {
eprintln!("{} step(s) ok", steps.len());
return Ok(());
}
eprintln!("{} assertion(s) failed:", result.failures.len());
for failure in &result.failures {
eprintln!(" {failure}");
}
std::process::exit(1);
}
fn handle_tui_frame_command(
tab: Option<&str>,
width: u16,
height: u16,
) -> Result<(), Box<dyn std::error::Error>> {
let mut app = ironmonitor::tui::App::new()?;
app.update()?;
app.await_first_inference_poll(std::time::Duration::from_secs(3));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
let mut have_snapshot = false;
while std::time::Instant::now() < deadline {
if app.sync_snapshot() && !app.snapshot_is_warmup() {
have_snapshot = true;
break;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
while app.poll_net_context() && std::time::Instant::now() < deadline {
std::thread::sleep(std::time::Duration::from_millis(50));
}
if !have_snapshot {
eprintln!(concat!(
"warning: no complete snapshot arrived within 10s. The frame below ",
"may show the collector's warm-up pass, which carries no GPUs, ",
"processes or connections - do not read those as absent hardware."
));
}
if let Some(requested) = tab {
let resolved = requested
.parse::<usize>()
.ok()
.filter(|i| *i < app.tabs.len())
.or_else(|| {
app.tabs
.iter()
.position(|t| t.eq_ignore_ascii_case(requested))
});
match resolved {
Some(index) => app.selected_tab = index,
None => {
eprintln!("Unknown tab {requested:?}. Available tabs:");
for (i, name) in app.tabs.iter().enumerate() {
eprintln!(" {i} {name}");
}
std::process::exit(1);
}
}
}
for line in ironmonitor::tui::headless::render_rows(&app, width, height) {
println!("{line}");
}
Ok(())
}
fn handle_describe_command(
commands: bool,
writable: bool,
domain: Option<&str>,
search: Option<&str>,
id: Option<&str>,
format: &str,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ontology::{Domain, Ontology};
if commands {
return emit_command_catalog(format);
}
let ontology = Ontology::build();
let selected: Vec<&ironmonitor::ontology::Entity> = if writable {
ontology
.entities
.values()
.filter(|e| e.writable_via.is_some())
.collect()
} else if let Some(id) = id {
match ontology.get(id) {
Some(e) => vec![e],
None => {
eprintln!("No entity with id {id:?}.");
eprintln!(
"Try `ironmon describe --search {}`.",
id.split('.').next().unwrap_or(id)
);
std::process::exit(1);
}
}
} else if let Some(needle) = search {
ontology.search(needle)
} else if let Some(d) = domain {
let Some(parsed) = Domain::parse(d) else {
eprintln!("Unknown domain {d:?}. Known domains:");
for known in Domain::ALL {
eprintln!(" {}", known.as_str());
}
std::process::exit(1);
};
ontology.in_domain(parsed)
} else {
ontology.entities.values().collect()
};
if format.eq_ignore_ascii_case("json") {
let doc = ontology.describe_document(selected.iter().copied());
println!("{}", serde_json::to_string_pretty(&doc)?);
return Ok(());
}
println!("ironmon ontology v{}", ontology.version);
println!(
"{} entit{}\n",
selected.len(),
if selected.len() == 1 { "y" } else { "ies" }
);
let mut current_domain = None;
for e in &selected {
if current_domain != Some(e.domain) {
println!("== {} ==", e.domain.as_str());
current_domain = Some(e.domain);
}
let unit = e.unit.map(|u| u.as_str()).unwrap_or("-");
println!(
" {:<40} {:<12} {:<10} {:<14}{}",
e.id,
e.kind.as_str(),
unit,
e.provenance.as_str(),
if e.nullable { " nullable" } else { "" }
);
println!(" {}", e.description);
if !e.derived_from.is_empty() {
println!(" derived from: {}", e.derived_from.join(", "));
}
}
println!();
println!("provenance: measured = sampled now | specification = published constant");
println!(" derived = computed | unavailable = not obtainable here");
println!("Only `measured` values may be treated as live observations.");
Ok(())
}
fn handle_profile_command(action: &ProfileSubcommand) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::profile::{ProfileInspector, Subsystem};
let mut inspector = ProfileInspector::new();
match action {
ProfileSubcommand::List { json } => {
let snapshot = inspector.snapshot_all();
if *json {
let summary: Vec<_> = Subsystem::ALL
.iter()
.map(|s| {
if let Some(reason) = snapshot.errors.get(s) {
return serde_json::json!({
"subsystem": s.as_str(),
"group_count": serde_json::Value::Null,
"setting_count": serde_json::Value::Null,
"error": reason,
});
}
let groups = snapshot.providers.get(s).cloned().unwrap_or_default();
serde_json::json!({
"subsystem": s.as_str(),
"group_count": groups.len(),
"setting_count": groups.iter().map(|g| g.settings.len()).sum::<usize>(),
"error": serde_json::Value::Null,
})
})
.collect();
println!("{}", serde_json::to_string_pretty(&summary)?);
} else {
println!("{}", "Hardware Profile Inspector".bold().cyan());
println!("Subsystems with readable profile data:\n");
for sub in Subsystem::ALL {
if let Some(reason) = snapshot.errors.get(sub) {
println!(" {:<10} not read: {}", sub.as_str().bold(), reason);
continue;
}
let groups = snapshot.providers.get(sub);
let (group_count, setting_count) = match groups {
Some(g) => (g.len(), g.iter().map(|x| x.settings.len()).sum::<usize>()),
None => (0, 0),
};
println!(
" {:<10} {} groups, {} settings",
sub.as_str().bold(),
group_count,
setting_count
);
}
println!();
println!(
"Use {} for details.",
"ironmon profile show <subsystem>".italic()
);
}
}
ProfileSubcommand::Show { subsystem, json } => {
let sub = Subsystem::parse(subsystem).ok_or_else(|| {
format!(
"Unknown subsystem: {} (valid: gpu, cpu, nvme, display, memory)",
subsystem
)
})?;
let groups = inspector
.snapshot(sub)
.map_err(|reason| format!("{}: not read: {}", sub.as_str(), reason))?;
if *json {
println!("{}", serde_json::to_string_pretty(&groups)?);
} else {
print_profile_groups(sub, &groups);
}
}
ProfileSubcommand::Search { query, json } => {
let snapshot = inspector.snapshot_all();
let hits = snapshot.search(query);
if *json {
let out: Vec<_> = hits
.iter()
.map(|(sub, group, setting)| {
serde_json::json!({
"subsystem": sub.as_str(),
"device": &group.device,
"profile": &group.display_name,
"setting": setting,
})
})
.collect();
println!("{}", serde_json::to_string_pretty(&out)?);
} else {
println!(
"{} matches for {:?}:\n",
hits.len().to_string().bold(),
query
);
for (sub, group, setting) in hits {
println!(
" [{}] {} / {}",
sub.as_str().cyan(),
group.device,
group.display_name.dimmed()
);
println!(
" {} = {}{}",
setting.display_name.bold(),
setting.value,
setting
.unit
.as_deref()
.map(|u| format!(" {}", u))
.unwrap_or_default()
);
}
}
}
ProfileSubcommand::Set {
setting_id,
value,
confirm,
json,
} => {
let parsed = parse_setting_value(value);
let outcome = ironmonitor::profile::apply::apply_setting(setting_id, parsed, *confirm);
if *json {
println!("{}", serde_json::to_string_pretty(&outcome)?);
} else {
let status_color = match outcome.status {
ironmonitor::profile::apply::ApplyStatus::Applied => "applied".green(),
ironmonitor::profile::apply::ApplyStatus::Refused => "refused".red(),
ironmonitor::profile::apply::ApplyStatus::Failed => "failed".red(),
ironmonitor::profile::apply::ApplyStatus::NotWritable => {
"not writable".yellow()
}
ironmonitor::profile::apply::ApplyStatus::NeedsConfirm => {
"needs --confirm".yellow()
}
};
println!("status: {}", status_color);
println!("setting: {}", outcome.setting_id.bold());
println!("requested: {}", outcome.requested);
println!("message: {}", outcome.message);
println!(
"audit log: {}",
ironmonitor::profile::apply::audit_log_path().display()
);
}
if !matches!(
outcome.status,
ironmonitor::profile::apply::ApplyStatus::Applied
) {
std::process::exit(1);
}
}
ProfileSubcommand::Schemes { json } => {
#[cfg(windows)]
{
let schemes = ironmonitor::profile::cpu::enumerate_power_schemes();
if *json {
let arr: Vec<_> = schemes
.iter()
.map(|(g, n)| serde_json::json!({"guid": g, "name": n}))
.collect();
println!("{}", serde_json::to_string_pretty(&arr)?);
} else if schemes.is_empty() {
println!("(no power schemes enumerable)");
} else {
println!(
"{} available Windows power scheme(s):\n",
schemes.len().to_string().bold()
);
for (guid, name) in schemes {
let name = name.as_deref().unwrap_or("(name not read)");
println!(" {} {}", guid.cyan(), name.bold());
}
println!(
"\nApply with: {} {} <guid> --confirm",
"ironmon profile set".italic(),
"active_scheme_guid".italic()
);
}
}
#[cfg(not(windows))]
{
let _ = json;
eprintln!("Power scheme enumeration is only available on Windows.");
std::process::exit(2);
}
}
ProfileSubcommand::Writable { json } => {
let ids = ironmonitor::profile::apply::writable_setting_ids();
if *json {
println!("{}", serde_json::to_string_pretty(&ids)?);
} else if ids.is_empty() {
println!("(no writable handlers registered for this build)");
} else {
println!("{} writable setting id(s):", ids.len().to_string().bold());
for id in ids {
println!(" · {}", id);
}
println!(
"\nUse: {} {} <value> --confirm",
"ironmon profile set".italic(),
"<id>".italic()
);
}
}
ProfileSubcommand::Bench { json } => {
let report = ironmonitor::profile::bench::run_bench();
if *json {
println!("{}", serde_json::to_string_pretty(&report)?);
} else {
println!(
"Provider benchmark — total {:.1} ms, {} group(s), {} setting(s)\n",
report.total_elapsed_ms, report.total_groups, report.total_settings
);
println!(
" {:<10} {:>10} {:>8} {:>10} {:>14}",
"subsystem".bold(),
"elapsed".bold(),
"groups".bold(),
"settings".bold(),
"settings/ms".bold()
);
let mut providers = report.providers.clone();
providers.sort_by(|a, b| {
b.elapsed_ms
.partial_cmp(&a.elapsed_ms)
.unwrap_or(std::cmp::Ordering::Equal)
});
for p in providers {
if let Some(reason) = &p.error {
println!(
" {:<10} {:>8.2} ms not read: {}",
p.subsystem.as_str(),
p.elapsed_ms,
reason
);
continue;
}
println!(
" {:<10} {:>8.2} ms {:>8} {:>10} {:>14.2}",
p.subsystem.as_str(),
p.elapsed_ms,
p.group_count,
p.setting_count,
p.settings_per_ms
);
}
}
}
ProfileSubcommand::Watch {
interval,
ticks,
subsystem,
} => {
use ironmonitor::profile::diff::diff_snapshots;
use ironmonitor::profile::{ProfileSnapshot, Subsystem};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
let interval_ms = (interval * 1000.0).max(100.0) as u64;
let running = Arc::new(AtomicBool::new(true));
let r2 = running.clone();
let _ = ctrlc::set_handler(move || {
r2.store(false, Ordering::SeqCst);
});
let filter_sub: Option<Subsystem> = match subsystem {
Some(s) => match Subsystem::parse(s) {
Some(parsed) => Some(parsed),
None => {
eprintln!(
"Unknown subsystem {:?}. Valid: gpu, cpu, nvme, display, memory",
s
);
std::process::exit(2);
}
},
None => None,
};
println!(
"Watching {} subsystem(s) every {}s. Press Ctrl-C to stop.",
filter_sub
.map(|s| s.as_str().to_string())
.unwrap_or_else(|| "all".into()),
interval
);
let snapshot =
|inspector: &mut ironmonitor::profile::ProfileInspector| -> ProfileSnapshot {
match filter_sub {
Some(sub) => {
let mut providers = std::collections::BTreeMap::new();
let mut errors = std::collections::BTreeMap::new();
match inspector.snapshot(sub) {
Ok(groups) => {
providers.insert(sub, groups);
}
Err(reason) => {
errors.insert(sub, reason);
}
}
ProfileSnapshot {
timestamp: 0,
providers,
errors,
}
}
None => inspector.snapshot_all(),
}
};
let mut prev = snapshot(&mut inspector);
let mut tick = 0u32;
while running.load(Ordering::SeqCst) {
std::thread::sleep(std::time::Duration::from_millis(interval_ms));
if !running.load(Ordering::SeqCst) {
break;
}
let cur = snapshot(&mut inspector);
let d = diff_snapshots(&prev, &cur);
if !d.is_empty() {
let when = chrono::Local::now().format("%H:%M:%S");
println!(
"\n[{}] {} change(s):",
when.to_string().dimmed(),
d.total_changes().to_string().bold()
);
for c in &d.changed {
println!(
" ~ [{}] {} :: {}: {} → {}",
c.subsystem.as_str().cyan(),
c.device,
c.display_name,
c.before.to_string().red(),
c.after.to_string().green()
);
}
for a in &d.added {
println!(
" + [{}] {} :: {} = {}",
a.subsystem.as_str().cyan(),
a.device,
a.display_name,
a.value.to_string().green()
);
}
for r in &d.removed {
println!(
" - [{}] {} :: {} (was {})",
r.subsystem.as_str().cyan(),
r.device,
r.display_name,
r.value.to_string().red()
);
}
}
prev = cur;
tick = tick.saturating_add(1);
if *ticks > 0 && tick >= *ticks {
break;
}
}
println!("\nStopped after {} tick(s).", tick);
}
ProfileSubcommand::Audit { lines, json } => {
let path = ironmonitor::profile::apply::audit_log_path();
let content = match std::fs::read_to_string(&path) {
Ok(c) => c,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => String::new(),
Err(e) => {
eprintln!("Could not read audit log {}: {e}", path.display());
std::process::exit(1);
}
};
let all: Vec<&str> = content.lines().collect();
let tail = if all.len() > *lines {
&all[all.len() - lines..]
} else {
&all[..]
};
if *json {
let parsed: Vec<serde_json::Value> = tail
.iter()
.map(|l| {
serde_json::from_str(l)
.unwrap_or_else(|_| serde_json::json!({ "unparsed": true, "line": l }))
})
.collect();
println!("{}", serde_json::to_string_pretty(&parsed)?);
} else {
println!("Audit log: {}", path.display().to_string().italic());
if tail.is_empty() {
println!("(no entries)");
}
for line in tail {
if let Ok(v) =
serde_json::from_str::<ironmonitor::profile::apply::ApplyOutcome>(line)
{
let st = match v.status {
ironmonitor::profile::apply::ApplyStatus::Applied => "applied".green(),
ironmonitor::profile::apply::ApplyStatus::Refused => "refused".red(),
ironmonitor::profile::apply::ApplyStatus::Failed => "failed".red(),
ironmonitor::profile::apply::ApplyStatus::NotWritable => {
"not writable".yellow()
}
ironmonitor::profile::apply::ApplyStatus::NeedsConfirm => {
"needs confirm".yellow()
}
};
println!(
" [{}] {:>12} {} = {}",
v.timestamp.to_string().dimmed(),
st,
v.setting_id.bold(),
v.requested
);
} else {
println!(" {}", line);
}
}
}
}
ProfileSubcommand::Deviations { json } => {
let snapshot = inspector.snapshot_all();
let report = ironmonitor::profile::deviation::deviation_report(&snapshot);
let (devs, coverage) = (report.deviations, report.coverage);
if *json {
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!({
"deviations": devs,
"coverage": coverage,
}))?
);
} else if devs.is_empty() {
println!(
"None of the {} setting(s) that declare a default differs from it.",
coverage.comparable.to_string().bold()
);
if coverage.unchecked() > 0 {
println!(
"{}",
format!(
" {} of {} settings declare no default, so this says nothing about them.",
coverage.unchecked(),
coverage.settings
)
.dimmed()
);
}
} else {
println!(
"{} of {} setting(s) that declare a default differ from it:\n",
devs.len().to_string().bold(),
coverage.comparable
);
for d in devs {
let risk = match d.risk {
ironmonitor::profile::SettingRisk::Dangerous => "[dangerous]".red(),
ironmonitor::profile::SettingRisk::Moderate => "[moderate]".yellow(),
ironmonitor::profile::SettingRisk::Safe => "[safe]".green(),
ironmonitor::profile::SettingRisk::Informational => "[info]".dimmed(),
};
println!(
" {} [{}] {} :: {}",
risk,
d.subsystem.as_str().cyan(),
d.device,
d.display_name.bold()
);
println!(
" default: {} current: {}",
d.default.to_string().dimmed(),
d.current.to_string().yellow()
);
}
if coverage.unchecked() > 0 {
println!();
println!(
"{}",
format!(
" {} of {} settings declare no default and were not checked.",
coverage.unchecked(),
coverage.settings
)
.dimmed()
);
}
}
}
ProfileSubcommand::Explain { setting_id, json } => {
let snapshot = inspector.snapshot_all();
match ironmonitor::profile::explain::explain(&snapshot, setting_id) {
Some(exp) => {
if *json {
println!("{}", serde_json::to_string_pretty(&exp)?);
} else {
println!("{}", exp.setting.display_name.bold().cyan());
println!(" id: {}", exp.setting.id.italic());
println!(
" scope: [{}] {} / {}",
exp.subsystem.as_str(),
exp.device,
exp.profile.dimmed()
);
println!(
" value: {}{}",
exp.setting.value.to_string().bold(),
exp.setting
.unit
.as_deref()
.map(|u| format!(" {}", u))
.unwrap_or_default()
);
if let Some(default) = &exp.setting.default {
println!(" default: {}", default);
}
if let Some((min, max)) = &exp.setting.range {
println!(" range: [{}, {}]", min, max);
}
if let Some(choices) = &exp.setting.choices {
let names: Vec<String> =
choices.iter().map(|(n, _)| n.clone()).collect();
println!(" choices: {}", names.join(", "));
}
let risk = match exp.setting.risk {
ironmonitor::profile::SettingRisk::Dangerous => "dangerous".red(),
ironmonitor::profile::SettingRisk::Moderate => "moderate".yellow(),
ironmonitor::profile::SettingRisk::Safe => "safe".green(),
ironmonitor::profile::SettingRisk::Informational => "info".dimmed(),
};
println!(" risk: {}", risk);
println!(" source: {}", exp.setting.source.italic());
if let Some(desc) = &exp.setting.description {
println!("\n {}", desc);
}
if !exp.related.is_empty() {
println!("\n {}", "Related settings:".bold());
for r in &exp.related {
println!(" · {:<32} = {}", r.id, r.value.to_string().bold());
}
}
}
}
None => {
let cands = ironmonitor::profile::explain::candidates(&snapshot, setting_id);
if cands.is_empty() {
eprintln!("No setting matches id {:?}", setting_id);
std::process::exit(1);
} else {
eprintln!("No exact match for {:?}. Did you mean:", setting_id);
for c in cands {
eprintln!(" · {}", c);
}
std::process::exit(1);
}
}
}
}
ProfileSubcommand::Active { matched, json } => {
let entries = if *matched {
ironmonitor::profile::active::matched_active_profiles()?
} else {
ironmonitor::profile::active::active_profiles_for_processes()?
};
let drs_checked = entries.iter().any(|e| e.has_nvidia_drs_profile.is_some());
if *json {
println!("{}", serde_json::to_string_pretty(&entries)?);
} else {
let total = entries.len();
if drs_checked {
let matched_count = entries.iter().filter(|e| e.has_any_profile()).count();
println!(
"{} of {} processes have a name referenced in the NVIDIA DRS database\n",
matched_count.to_string().bold(),
total.to_string().bold()
);
} else {
println!(
"NVIDIA driver profiles not checked (DRS database unavailable here); {} processes listed\n",
total.to_string().bold()
);
}
for e in entries {
let marker = match e.has_nvidia_drs_profile {
Some(true) => "✓".green().to_string(),
Some(false) => "·".dimmed().to_string(),
None => "?".dimmed().to_string(),
};
println!(
" {} {:>6} {}",
marker,
e.pid.to_string().dimmed(),
if e.has_any_profile() {
e.name.bold().to_string()
} else {
e.name.dimmed().to_string()
}
);
}
}
}
ProfileSubcommand::Diff {
baseline,
against,
json,
} => {
use ironmonitor::profile::diff::diff_snapshots;
use ironmonitor::profile::ProfileSnapshot;
let baseline_str = std::fs::read_to_string(baseline)?;
let baseline_snap: ProfileSnapshot = serde_json::from_str(&baseline_str)?;
let current_snap = if let Some(path) = against {
let s = std::fs::read_to_string(path)?;
serde_json::from_str::<ProfileSnapshot>(&s)?
} else {
inspector.snapshot_all()
};
let d = diff_snapshots(&baseline_snap, ¤t_snap);
if *json {
println!("{}", serde_json::to_string_pretty(&d)?);
} else if d.is_empty() {
println!("{}", "No changes between snapshots.".green());
} else {
println!(
"{} change(s) detected\n",
d.total_changes().to_string().bold()
);
if !d.added_groups.is_empty() {
println!("{}", "Added groups:".green().bold());
for g in &d.added_groups {
println!(
" + [{}] {} / {} ({} settings)",
g.subsystem.as_str().cyan(),
g.device,
g.profile.dimmed(),
g.setting_count
);
}
println!();
}
if !d.removed_groups.is_empty() {
println!("{}", "Removed groups:".red().bold());
for g in &d.removed_groups {
println!(
" - [{}] {} / {} ({} settings)",
g.subsystem.as_str().cyan(),
g.device,
g.profile.dimmed(),
g.setting_count
);
}
println!();
}
if !d.changed.is_empty() {
println!("{}", "Changed:".yellow().bold());
for c in &d.changed {
println!(
" ~ [{}] {} / {} :: {}",
c.subsystem.as_str().cyan(),
c.device,
c.profile.dimmed(),
c.display_name.bold()
);
println!(
" {} → {}",
c.before.to_string().red(),
c.after.to_string().green()
);
}
println!();
}
if !d.added.is_empty() {
println!("{}", "Added settings:".green().bold());
for a in &d.added {
println!(
" + [{}] {} / {} :: {} = {}",
a.subsystem.as_str().cyan(),
a.device,
a.profile.dimmed(),
a.display_name,
a.value.to_string().bold()
);
}
println!();
}
if !d.removed.is_empty() {
println!("{}", "Removed settings:".red().bold());
for r in &d.removed {
println!(
" - [{}] {} / {} :: {} (was {})",
r.subsystem.as_str().cyan(),
r.device,
r.profile.dimmed(),
r.display_name,
r.value
);
}
}
}
}
ProfileSubcommand::Dump { json, output } => {
let snapshot = inspector.snapshot_all();
if *json {
let serialized = serde_json::to_string_pretty(&snapshot)?;
if let Some(path) = output {
std::fs::write(path, serialized)?;
println!("Wrote profile snapshot to {}", path.display());
} else {
println!("{}", serialized);
}
} else {
let mut sink = String::new();
use std::fmt::Write;
writeln!(
sink,
"Hardware Profile Snapshot ({} groups, {} settings)\n",
snapshot.total_groups(),
snapshot.total_settings()
)?;
for (sub, reason) in &snapshot.errors {
writeln!(sink, "=== {} ===", sub.as_str().to_uppercase())?;
writeln!(sink, " not read: {}\n", reason)?;
}
for (sub, groups) in &snapshot.providers {
writeln!(sink, "=== {} ===", sub.as_str().to_uppercase())?;
for group in groups {
writeln!(sink, "\n[{}] {}", group.device, group.display_name)?;
writeln!(sink, " source: {}", group.source)?;
for s in &group.settings {
writeln!(
sink,
" {:<32} = {}{}",
s.id,
s.value,
s.unit
.as_deref()
.map(|u| format!(" {}", u))
.unwrap_or_default()
)?;
}
for n in &group.notes {
writeln!(sink, " note: {}", n)?;
}
}
writeln!(sink)?;
}
if let Some(path) = output {
std::fs::write(path, &sink)?;
println!("Wrote profile snapshot to {}", path.display());
} else {
print!("{}", sink);
}
}
}
}
Ok(())
}
#[cfg(feature = "cli")]
fn print_profile_groups(
sub: ironmonitor::profile::Subsystem,
groups: &[ironmonitor::profile::ProfileGroup],
) {
if groups.is_empty() {
println!("(no profile data for {})", sub);
return;
}
println!("{}", format!("== {} ==", sub).bold().cyan());
for group in groups {
println!();
println!("{} {}", "▸".cyan(), group.device.bold(),);
println!(
" {} {} {} {}",
"profile:".dimmed(),
group.display_name,
"source:".dimmed(),
group.source.italic()
);
for s in &group.settings {
let unit = s
.unit
.as_deref()
.map(|u| format!(" {}", u))
.unwrap_or_default();
let risk = match s.risk {
ironmonitor::profile::SettingRisk::Informational => String::new(),
ironmonitor::profile::SettingRisk::Safe => " [safe]".green().to_string(),
ironmonitor::profile::SettingRisk::Moderate => " [moderate]".yellow().to_string(),
ironmonitor::profile::SettingRisk::Dangerous => " [dangerous]".red().to_string(),
};
println!(
" {:<28} = {}{}{}",
s.display_name,
s.value.to_string().bold(),
unit,
risk,
);
}
for n in &group.notes {
println!(" {} {}", "•".dimmed(), n.dimmed());
}
}
}
#[cfg(feature = "cli")]
fn parse_setting_value(raw: &str) -> ironmonitor::profile::SettingValue {
use ironmonitor::profile::SettingValue;
let lower = raw.trim().to_ascii_lowercase();
match lower.as_str() {
"true" | "yes" | "on" | "enabled" | "enable" => return SettingValue::Bool(true),
"false" | "no" | "off" | "disabled" | "disable" => return SettingValue::Bool(false),
_ => {}
}
if let Ok(i) = raw.parse::<i64>() {
return SettingValue::Int(i);
}
if let Ok(u) = raw.parse::<u64>() {
return SettingValue::Uint(u);
}
if let Ok(f) = raw.parse::<f64>() {
return SettingValue::Float(f);
}
SettingValue::Text(raw.to_string())
}
#[cfg(not(feature = "cli"))]
fn main() {
eprintln!("CLI features not enabled. Please compile with --features cli");
std::process::exit(1);
}
fn handle_ids_command(
baseline_path: &std::path::Path,
watch: &[std::path::PathBuf],
format: &str,
) -> Result<(), Box<dyn std::error::Error>> {
use ironmonitor::ids::{file, network, triage, ScanStatus};
#[derive(serde::Serialize, serde::Deserialize, Default)]
struct Baselines {
#[serde(default)]
network: network::Baseline,
#[serde(default)]
files: file::Baseline,
}
let existing: Baselines = match std::fs::read_to_string(baseline_path) {
Ok(text) => serde_json::from_str(&text).map_err(|e| {
format!(
"baseline at {} is not readable: {e}",
baseline_path.display()
)
})?,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Baselines::default(),
Err(e) => return Err(format!("baseline at {}: {e}", baseline_path.display()).into()),
};
let net = network::scan(&existing.network);
let files = file::scan(watch, &existing.files);
let record_needed = matches!(net, ScanStatus::NoBaseline { .. })
|| matches!(files, ScanStatus::NoBaseline { .. });
if record_needed {
let fresh = Baselines {
network: if matches!(net, ScanStatus::NoBaseline { .. }) {
network::record()?
} else {
existing.network.clone()
},
files: if matches!(files, ScanStatus::NoBaseline { .. }) {
file::record(watch)
} else {
existing.files.clone()
},
};
if let Some(parent) = baseline_path.parent() {
if !parent.as_os_str().is_empty() {
std::fs::create_dir_all(parent)?;
}
}
std::fs::write(baseline_path, serde_json::to_string_pretty(&fresh)?)?;
}
let mut findings = Vec::new();
findings.extend(net.findings().iter().cloned());
findings.extend(files.findings().iter().cloned());
let ranked = triage::rank(findings.clone());
let counts = triage::counts(&findings);
if format == "json" {
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!({
"network": net,
"files": files,
"ranked": ranked,
"counts": counts,
}))?
);
} else {
print_ids_status("network", &net);
print_ids_status("files", &files);
if !ranked.ranked.is_empty() {
println!();
for f in &ranked.ranked {
println!(
"[{:?}/{:?}] {} — {}",
f.severity, f.confidence, f.rule, f.title
);
for e in &f.evidence {
match &e.expected {
Some(exp) => println!(" {} = {} (was {})", e.kind, e.observed, exp),
None => println!(" {} = {}", e.kind, e.observed),
}
}
}
println!();
println!(
"{} finding(s); {} rest on a heuristic rather than a direct observation",
findings.len(),
counts.possible_only
);
}
}
if matches!(net, ScanStatus::Failed { .. }) || matches!(files, ScanStatus::Failed { .. }) {
std::process::exit(2);
}
if !findings.is_empty() {
std::process::exit(1);
}
Ok(())
}
fn print_ids_status(label: &str, status: &ironmonitor::ids::ScanStatus) {
use ironmonitor::ids::ScanStatus;
match status {
ScanStatus::NoBaseline { recorded, reason } => {
println!("{label}: no baseline — {recorded} recorded now. {reason}");
}
ScanStatus::Clean { checked } => {
println!("{label}: clean over {checked} checked");
}
ScanStatus::Findings { checked, findings } => {
println!(
"{label}: {} finding(s) over {checked} checked",
findings.len()
);
}
ScanStatus::Failed { reason } => {
println!("{label}: scan failed — {reason}");
}
}
}
fn handle_status_command(
ascii: bool,
no_color: bool,
format: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let readings = ironmonitor::ontology::resolve::snapshot();
if format.eq_ignore_ascii_case("json") {
let lines: Vec<serde_json::Value> = ironmonitor::fetch::summary(&readings)
.into_iter()
.map(|l| {
serde_json::json!({
"label": l.label,
"value": l.value,
"reason": l.reason,
})
})
.collect();
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!(lines))?
);
} else if ascii {
let colour = !no_color && std::io::IsTerminal::is_terminal(&std::io::stdout());
print!("{}", ironmonitor::fetch::render(&readings, colour));
} else {
let colour = !no_color && std::io::IsTerminal::is_terminal(&std::io::stdout());
print!("{}", ironmonitor::fetch::render_plain(&readings, colour));
}
Ok(())
}