feat(admin-cli): add health-history commands for switch, power-shelf, rack, and machine

crates/admin-cli/src/health_utils.rs

@@ -17,7 +17,8 @@
 
 use ::rpc::admin_cli::OutputFormat;
 use ::rpc::forge::{self as forgerpc};
-use prettytable::{Table, row};
+use prettytable::{Cell, Row, Table, row};
+use serde::Serialize;
 
 use crate::errors::{CarbideCliError, CarbideCliResult};
 use crate::machine::{HealthReportTemplates, get_empty_template, get_health_report};
@@ -67,6 +68,82 @@ pub(crate) fn display_health_reports(
     Ok(())
 }
 
+/// One row of an object's health history, summarized for tabular display.
+#[derive(Serialize)]
+struct HealthHistoryRecordView {
+    time: String,
+    source: String,
+    status: String,
+    alerts: Vec<String>,
+}
+
+impl From<&forgerpc::HealthHistoryRecord> for HealthHistoryRecordView {
+    fn from(record: &forgerpc::HealthHistoryRecord) -> Self {
+        let health = record.health.as_ref();
+        let source = health.map(|h| h.source.clone()).unwrap_or_default();
+        let alerts: Vec<String> = health
+            .map(|h| h.alerts.iter().map(|alert| alert.id.clone()).collect())
+            .unwrap_or_default();
+        let status = if alerts.is_empty() {
+            "Healthy"
+        } else {
+            "Alerting"
+        }
+        .to_string();
+        Self {
+            time: record.time.map(|time| time.to_string()).unwrap_or_default(),
+            source,
+            status,
+            alerts,
+        }
+    }
+}
+
+fn health_history_table(records: &[HealthHistoryRecordView]) -> Table {
+    let mut table = Table::new();
+    table.set_titles(Row::new(
+        ["Time", "Source", "Status", "Alerts"]
+            .into_iter()
+            .map(Cell::new)
+            .collect(),
+    ));
+    for record in records {
+        let alerts = if record.alerts.is_empty() {
+            "-".to_string()
+        } else {
+            record.alerts.join(", ")
+        };
+        table.add_row(row![record.time, record.source, record.status, alerts]);
+    }
+    table
+}
+
+/// Display an object's health history in the requested output format. Shared by
+/// the per-resource `health-history` subcommands, whose only difference is the
+/// RPC that produced `history`.
+pub(crate) fn display_health_history(
+    object_id: &str,
+    history: Vec<forgerpc::HealthHistoryRecord>,
+    output_format: OutputFormat,
+) -> CarbideCliResult<()> {
+    if history.is_empty() {
+        println!("No health history found for {object_id}");
+        return Ok(());
+    }
+
+    let records: Vec<HealthHistoryRecordView> =
+        history.iter().map(HealthHistoryRecordView::from).collect();
+    match output_format {
+        OutputFormat::Json => println!("{}", serde_json::to_string_pretty(&records)?),
+        OutputFormat::Yaml => println!("{}", serde_yaml::to_string(&records)?),
+        OutputFormat::Csv => {
+            health_history_table(&records).to_csv(std::io::stdout())?;
+        }
+        OutputFormat::AsciiTable => health_history_table(&records).printstd(),
+    }
+    Ok(())
+}
+
 /// Resolve a health report from either a template or raw JSON.
 pub(crate) fn resolve_health_report(
     template: Option<HealthReportTemplates>,

crates/admin-cli/src/machine/health_history.rs

@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use carbide_uuid::machine::MachineId;
+use clap::Parser;
+
+use crate::cfg::run::Run;
+use crate::cfg::runtime::RuntimeContext;
+use crate::errors::CarbideCliResult;
+use crate::health_utils::display_health_history;
+
+#[derive(Parser, Debug)]
+#[command(after_long_help = "\
+EXAMPLES:
+
+Show health history for a machine:
+    $ nico-admin-cli machine health-history fm100ht038bg3qsho433vkg684heguv282qaggmrsh2ugn1qk096n2c6hcg
+
+")]
+pub(crate) struct Args {
+    #[clap(help = "Machine ID to show health history for")]
+    machine_id: MachineId,
+}
+
+impl Run for Args {
+    async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
+        let history = ctx
+            .api_client
+            .get_machine_health_history(self.machine_id)
+            .await?;
+        display_health_history(&self.machine_id.to_string(), history, ctx.config.format)
+    }
+}

crates/admin-cli/src/machine/mod.rs

@@ -19,6 +19,7 @@ mod auto_update;
 mod common;
 mod force_delete;
 mod hardware_info;
+mod health_history;
 mod health_report;
 mod metadata;
 pub(crate) mod network;
@@ -27,6 +28,9 @@ mod positions;
 mod reboot;
 mod show;
 
+#[cfg(test)]
+mod tests;
+
 // Cross-module re-exports.
 pub(crate) use auto_update::args::Args as MachineAutoupdate;
 use clap::Parser;
@@ -83,4 +87,6 @@ pub(crate) enum Cmd {
     Positions(positions::Args),
     #[clap(subcommand, about = "Update/show NVLink info for an MNNVL machine")]
     NvlinkInfo(nvlink_info::Args),
+    #[clap(about = "Show machine health history")]
+    HealthHistory(health_history::Args),
 }

crates/admin-cli/src/machine/tests.rs

@@ -0,0 +1,42 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use carbide_uuid::machine::MachineId;
+use clap::CommandFactory;
+
+use super::*;
+use crate::test_support::parse_leaf;
+
+const SAMPLE_MACHINE_ID: &str = "fm100ht038bg3qsho433vkg684heguv282qaggmrsh2ugn1qk096n2c6hcg";
+
+#[test]
+fn verify_cmd_structure() {
+    Cmd::command().debug_assert();
+}
+
+#[test]
+fn parse_health_history_command() {
+    let matches = parse_leaf::<Cmd>(
+        &["machine", "health-history", SAMPLE_MACHINE_ID],
+        &["health-history"],
+    )
+    .expect("health-history should parse");
+    let machine_id = matches
+        .get_one::<MachineId>("machine_id")
+        .expect("machine ID is required");
+    assert_eq!(machine_id, &SAMPLE_MACHINE_ID.parse::<MachineId>().unwrap());
+}

crates/admin-cli/src/power_shelf/health_history.rs

@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use carbide_uuid::power_shelf::PowerShelfId;
+use clap::Parser;
+
+use crate::cfg::run::Run;
+use crate::cfg::runtime::RuntimeContext;
+use crate::errors::CarbideCliResult;
+use crate::health_utils::display_health_history;
+
+#[derive(Parser, Debug)]
+#[command(after_long_help = "\
+EXAMPLES:
+
+Show health history for a power shelf:
+    $ nico-admin-cli power-shelf health-history ps100ht038bg3qsho433vkg684heguv282qaggmrsh2ugn1qk096n2c6hcg
+
+")]
+pub(crate) struct Args {
+    #[clap(help = "Power shelf ID to show health history for")]
+    power_shelf_id: PowerShelfId,
+}
+
+impl Run for Args {
+    async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
+        let history = ctx
+            .api_client
+            .get_power_shelf_health_history(self.power_shelf_id)
+            .await?;
+        display_health_history(&self.power_shelf_id.to_string(), history, ctx.config.format)
+    }
+}

crates/admin-cli/src/power_shelf/mod.rs

@@ -18,6 +18,7 @@
 mod decommission;
 mod delete;
 mod force_delete;
+mod health_history;
 mod health_report;
 mod list;
 mod maintenance;
@@ -58,4 +59,6 @@ pub(crate) enum Cmd {
         visible_alias = "hr"
     )]
     HealthReport(health_report::Args),
+    #[clap(about = "Show power shelf health history")]
+    HealthHistory(health_history::Args),
 }

crates/admin-cli/src/power_shelf/tests.rs

@@ -31,15 +31,8 @@ use clap::CommandFactory;
 use super::*;
 use crate::test_support::parse_leaf;
 
-/// Sample power-shelf id used in CLI parse tests. Must round-trip through
-/// `PowerShelfId::from_str`, which `clap` uses to coerce identifier arguments.
 const SAMPLE_PS_ID_1: &str = "ps100htjtiaehv1n5vh67tbmqq4eabcjdng40f7jupsadbedhruh6rag1l0";
 
-// verify_cmd_structure runs a baseline clap debug_assert()
-// to do basic command configuration checking and validation,
-// ensuring things like unique argument definitions, group
-// configurations, argument references, etc. Things that would
-// otherwise be missed until runtime.
 #[test]
 fn verify_cmd_structure() {
     Cmd::command().debug_assert();
@@ -63,6 +56,22 @@ fn parse_decommission_lifecycle_commands() {
     );
 }
 
+#[test]
+fn parse_health_history_command() {
+    let matches = parse_leaf::<Cmd>(
+        &["power-shelf", "health-history", SAMPLE_PS_ID_1],
+        &["health-history"],
+    )
+    .expect("health-history should parse");
+    let power_shelf_id = matches
+        .get_one::<PowerShelfId>("power_shelf_id")
+        .expect("power shelf ID is required");
+    assert_eq!(
+        power_shelf_id,
+        &SAMPLE_PS_ID_1.parse::<PowerShelfId>().unwrap()
+    );
+}
+
 #[test]
 fn parse_force_delete_cleanup_flags() {
     scenarios!(

crates/admin-cli/src/rack/health_history.rs

@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use carbide_uuid::rack::RackId;
+use clap::Parser;
+
+use crate::cfg::run::Run;
+use crate::cfg::runtime::RuntimeContext;
+use crate::errors::CarbideCliResult;
+use crate::health_utils::display_health_history;
+
+#[derive(Parser, Debug)]
+#[command(after_long_help = "\
+EXAMPLES:
+
+Show health history for a rack:
+    $ nico-admin-cli rack health-history ipp6-b03-gb-nvl-124-mini2
+
+")]
+pub(crate) struct Args {
+    #[clap(help = "Rack ID to show health history for")]
+    rack_id: RackId,
+}
+
+impl Run for Args {
+    async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
+        let history = ctx
+            .api_client
+            .get_rack_health_history(self.rack_id.clone())
+            .await?;
+        display_health_history(self.rack_id.as_ref(), history, ctx.config.format)
+    }
+}

crates/admin-cli/src/rack/mod.rs

@@ -17,13 +17,17 @@
 
 mod delete;
 mod force_delete;
+mod health_history;
 mod list;
 mod maintenance;
 mod metadata;
 mod profile;
 mod show;
 mod state_history;
 
+#[cfg(test)]
+mod tests;
+
 use clap::Parser;
 
 use crate::cfg::dispatch::Dispatch;
@@ -46,4 +50,6 @@ pub(crate) enum Cmd {
     Maintenance(maintenance::Args),
     #[clap(about = "Show rack state history")]
     StateHistory(state_history::Args),
+    #[clap(about = "Show rack health history")]
+    HealthHistory(health_history::Args),
 }