Add node health rail

Author: rootsec1

dev/kubeSnapshot.ts

@@ -54,6 +54,7 @@ type KubeItem = {
     runtimeClassName?: string;
     schedulerName?: string;
     schedulingGates?: Array<{ name?: string }>;
+    podCIDR?: string;
     imagePullSecrets?: Array<{ name?: string }>;
     selector?: Record<string, string> | {
       matchExpressions?: unknown[];
@@ -79,6 +80,7 @@ type KubeItem = {
     };
     scope?: string;
     template?: { spec?: { containers?: KubeContainerSpec[] } };
+    taints?: KubeTaint[];
     rules?: Array<{
       backendRefs?: KubeGatewayBackendRef[];
       host?: string;
@@ -99,6 +101,8 @@ type KubeItem = {
     hostIP?: string;
     qosClass?: string;
     startTime?: string;
+    allocatable?: Record<string, string | number>;
+    capacity?: Record<string, string | number>;
     currentHealthy?: number;
     desiredHealthy?: number;
     disruptionsAllowed?: number;
@@ -117,6 +121,14 @@ type KubeItem = {
     initContainerStatuses?: KubeContainerStatus[];
     reason?: string;
     message?: string;
+    nodeInfo?: {
+      architecture?: string;
+      containerRuntimeVersion?: string;
+      kernelVersion?: string;
+      kubeletVersion?: string;
+      operatingSystem?: string;
+      osImage?: string;
+    };
   };
 };
 
@@ -189,6 +201,12 @@ type KubeToleration = {
   value?: string;
 };
 
+type KubeTaint = {
+  effect?: string;
+  key?: string;
+  value?: string;
+};
+
 type KubeLimitRangeItem = {
   default?: Record<string, string | number>;
   defaultRequest?: Record<string, string | number>;
@@ -370,17 +388,18 @@ export async function readResourceDetails(target: { kind: string; name: string;
     return readEventDetails(target);
   }
 
-  const [yaml, describe, events, pod, crd, logs, previousLogs] = await Promise.all([
+  const [yaml, describe, events, pod, node, crd, logs, previousLogs] = await Promise.all([
     readResourceYaml(target).catch((error) => errorMessage(error)),
     readResourceDescribe(target).catch((error) => errorMessage(error)),
     readResourceEvents(target).catch(() => []),
     target.kind === "Pod" ? readPodDetails(target).catch(() => undefined) : undefined,
+    target.kind === "Node" ? readNodeDetails(target).catch(() => undefined) : undefined,
     target.kind === "CustomResourceDefinition" ? readCrdDetails(target).catch(() => undefined) : undefined,
     target.kind === "Pod" ? readPodLogs(target).catch((error) => errorMessage(error)) : "",
     target.kind === "Pod" ? readPodLogs(target, true).catch(() => "") : "",
   ]);
 
-  return { yaml, describe, events, logs, previousLogs, pod, crd };
+  return { yaml, describe, events, logs, previousLogs, pod, node, crd };
 }
 
 export async function runPodAction(input: {
@@ -684,6 +703,42 @@ async function readPodDetails(target: { name: string; namespace: string; cluster
   };
 }
 
+async function readNodeDetails(target: { kind: string; name: string; namespace: string; cluster: string }) {
+  const node = await readResourceJson<KubeItem>(target);
+  const nodeInfo = node.status?.nodeInfo ?? {};
+
+  return {
+    conditions: (node.status?.conditions ?? []).map((condition) => ({
+      type: condition.type ?? "Condition",
+      status: condition.status ?? "Unknown",
+      reason: condition.reason ?? "",
+      message: condition.message ?? "",
+    })),
+    capacity: stringRecord(node.status?.capacity),
+    allocatable: stringRecord(node.status?.allocatable),
+    kubeletVersion: nodeInfo.kubeletVersion ?? "",
+    osImage: nodeInfo.osImage ?? "",
+    architecture: nodeInfo.architecture ?? "",
+    containerRuntimeVersion: nodeInfo.containerRuntimeVersion ?? "",
+    kernelVersion: nodeInfo.kernelVersion ?? "",
+    operatingSystem: nodeInfo.operatingSystem ?? "",
+    podCidr: node.spec?.podCIDR ?? "",
+    providerId: node.spec?.providerID ?? "",
+    unschedulable: Boolean(node.spec?.unschedulable),
+    taints: (node.spec?.taints ?? []).flatMap((taint) => {
+      if (!taint.key) {
+        return [];
+      }
+      const keyValue = taint.value ? `${taint.key}=${taint.value}` : taint.key;
+      return taint.effect ? [`${keyValue}:${taint.effect}`] : [keyValue];
+    }),
+  };
+}
+
+function stringRecord(record: Record<string, string | number> | undefined) {
+  return Object.fromEntries(Object.entries(record ?? {}).map(([key, value]) => [key, String(value)]));
+}
+
 async function readCrdDetails(target: { kind: string; name: string; namespace: string; cluster: string }) {
   return crdDetails(await readResourceJson<KubeItem>(target));
 }

docs/spec.md

@@ -5,7 +5,7 @@ Kite is a native Kubernetes GUI focused on interface quality, speed, and local-f
 ## What
 
 - Tauri 2 desktop app with Rust backend and React frontend.
-- Multi-cluster Kubernetes cockpit with kubeconfig context switching, scoped resource exploration, pinned resources, keyboard-operable windowed sortable signal-aware inventory with selected-pod log jump actions, inline pod and service backend diagnostics, namespace ResourceQuota and LimitRange constraint visibility, HPA scale-target links, pod ServiceAccount identity links, ConfigMap/Secret/PVC/ServiceAccount consumer links, PriorityClass and RuntimeClass placement links, PodDisruptionBudget availability links, NetworkPolicy-to-pod visibility, exact Ingress/HTTPRoute-to-service topology links, CRD group/scope/version inspection, pod-to-node and node-to-pod debugging jumps, pod-level status diagnostics, pod placement constraints, pod condition diagnostics, newest-first warning-prioritized pod events, exec and port-forward handoff, guarded pod actions, guarded workload rollout restart, searchable log workflows, YAML/diff inspection, and a simple visual control-plane map.
+- Multi-cluster Kubernetes cockpit with kubeconfig context switching, scoped resource exploration, pinned resources, keyboard-operable windowed sortable signal-aware inventory with selected-pod log jump actions, inline pod and service backend diagnostics, namespace ResourceQuota and LimitRange constraint visibility, HPA scale-target links, pod ServiceAccount identity links, ConfigMap/Secret/PVC/ServiceAccount consumer links, PriorityClass and RuntimeClass placement links, PodDisruptionBudget availability links, NetworkPolicy-to-pod visibility, exact Ingress/HTTPRoute-to-service topology links, CRD group/scope/version inspection, pod-to-node and node-to-pod debugging jumps, node condition/capacity inspection, pod-level status diagnostics, pod placement constraints, pod condition diagnostics, newest-first warning-prioritized pod events, exec and port-forward handoff, guarded pod actions, guarded workload rollout restart, searchable log workflows, YAML/diff inspection, and a simple visual control-plane map.
 - UI-first design system inspired by Endex's dense enterprise sections: dark green-black glass, thin grid lines, pale telemetry surfaces, emerald accents, and precise motion.
 
 ## Why

src-tauri/src/kube_commands.rs

@@ -28,8 +28,8 @@ use serde::Deserialize;
 
 use crate::models::{
     ActionPreview, ActionRisk, ActionTarget, ClusterSummary, ContainerDetails, ContainerProbe, CrdDetails, CrdVersionDetails, HealthState,
-    KubeContextSummary, LiveSnapshot, NamespaceHeat, PodActionResult, PodActionStatus, PodCondition, PodDetails, PodSchedulingDetails,
-    ResourceDetails, ResourceEvent, ResourceReference, ResourceSummary,
+    KubeContextSummary, LiveSnapshot, NamespaceHeat, NodeCondition, NodeDetails, PodActionResult, PodActionStatus, PodCondition,
+    PodDetails, PodSchedulingDetails, ResourceDetails, ResourceEvent, ResourceReference, ResourceSummary,
 };
 
 #[derive(Debug, Deserialize)]
@@ -290,6 +290,11 @@ pub async fn resource_details(target: ActionTarget) -> ResourceDetails {
     } else {
         None
     };
+    let node = if target.kind == "Node" {
+        node_details(&target).await.ok()
+    } else {
+        None
+    };
     let crd = if target.kind == "CustomResourceDefinition" {
         crd_definition_details(&target).await.ok()
     } else {
@@ -306,7 +311,7 @@ pub async fn resource_details(target: ActionTarget) -> ResourceDetails {
         String::new()
     };
 
-    ResourceDetails { yaml, describe, events, logs, previous_logs, pod, crd }
+    ResourceDetails { yaml, describe, events, logs, previous_logs, pod, node, crd }
 }
 
 async fn event_details(target: ActionTarget) -> ResourceDetails {
@@ -334,6 +339,7 @@ fn event_resource_details(yaml: String, describe: String, json: &str) -> Resourc
         logs: String::new(),
         previous_logs: String::new(),
         pod: None,
+        node: None,
         crd: None,
     }
 }
@@ -550,6 +556,7 @@ async fn helm_details(target: ActionTarget) -> ResourceDetails {
         logs: String::new(),
         previous_logs: String::new(),
         pod: None,
+        node: None,
         crd: None,
     }
 }
@@ -560,6 +567,69 @@ async fn crd_definition_details(target: &ActionTarget) -> Result<CrdDetails, Str
     crd_definition_details_from_value(&value).ok_or_else(|| "Unable to parse CRD definition details.".to_string())
 }
 
+async fn node_details(target: &ActionTarget) -> Result<NodeDetails, String> {
+    let json = kubectl(resource_json_args(target)).await?;
+    let value = serde_json::from_str::<serde_json::Value>(&json).map_err(|error| format!("Invalid node JSON: {error}"))?;
+    Ok(node_details_from_value(&value))
+}
+
+fn node_details_from_value(value: &serde_json::Value) -> NodeDetails {
+    let status = value.get("status").unwrap_or(&serde_json::Value::Null);
+    let spec = value.get("spec").unwrap_or(&serde_json::Value::Null);
+    let node_info = status.get("nodeInfo").unwrap_or(&serde_json::Value::Null);
+
+    NodeDetails {
+        conditions: node_conditions(status),
+        capacity: string_map_field(status, "capacity"),
+        allocatable: string_map_field(status, "allocatable"),
+        kubelet_version: text_field(node_info, "kubeletVersion", ""),
+        os_image: text_field(node_info, "osImage", ""),
+        architecture: text_field(node_info, "architecture", ""),
+        container_runtime_version: text_field(node_info, "containerRuntimeVersion", ""),
+        kernel_version: text_field(node_info, "kernelVersion", ""),
+        operating_system: text_field(node_info, "operatingSystem", ""),
+        pod_cidr: text_field(spec, "podCIDR", ""),
+        provider_id: text_field(spec, "providerID", ""),
+        unschedulable: bool_field(spec, "unschedulable"),
+        taints: node_taints(spec),
+    }
+}
+
+fn node_conditions(status: &serde_json::Value) -> Vec<NodeCondition> {
+    status
+        .get("conditions")
+        .and_then(|conditions| conditions.as_array())
+        .map(Vec::as_slice)
+        .unwrap_or(&[])
+        .iter()
+        .map(|condition| NodeCondition {
+            type_: text_field(condition, "type", "Condition"),
+            status: text_field(condition, "status", "Unknown"),
+            reason: text_field(condition, "reason", ""),
+            message: text_field(condition, "message", ""),
+        })
+        .collect()
+}
+
+fn node_taints(spec: &serde_json::Value) -> Vec<String> {
+    spec.get("taints")
+        .and_then(|taints| taints.as_array())
+        .map(Vec::as_slice)
+        .unwrap_or(&[])
+        .iter()
+        .filter_map(|taint| {
+            let key = text_field(taint, "key", "");
+            if key.is_empty() {
+                return None;
+            }
+            let value = text_field(taint, "value", "");
+            let effect = text_field(taint, "effect", "");
+            let key_value = if value.is_empty() { key } else { format!("{key}={value}") };
+            Some(if effect.is_empty() { key_value } else { format!("{key_value}:{effect}") })
+        })
+        .collect()
+}
+
 fn crd_definition_details_from_value(value: &serde_json::Value) -> Option<CrdDetails> {
     let spec = value.get("spec")?;
     let names = spec.get("names").unwrap_or(&serde_json::Value::Null);
@@ -4924,6 +4994,51 @@ mod tests {
         assert_eq!(resource_event(&missing_count).count, 1);
     }
 
+    #[test]
+    fn node_details_preserve_conditions_capacity_and_taints() {
+        let node = serde_json::json!({
+            "spec": {
+                "podCIDR": "10.42.0.0/24",
+                "providerID": "kind://docker/kite/node/kite-control-plane",
+                "unschedulable": true,
+                "taints": [
+                    { "key": "node-role.kubernetes.io/control-plane", "effect": "NoSchedule" },
+                    { "key": "dedicated", "value": "debug", "effect": "NoExecute" }
+                ]
+            },
+            "status": {
+                "capacity": { "cpu": "8", "memory": "16Gi", "pods": 110 },
+                "allocatable": { "cpu": "7800m", "memory": "14Gi", "pods": 100 },
+                "nodeInfo": {
+                    "kubeletVersion": "v1.31.0",
+                    "osImage": "Debian GNU/Linux 12",
+                    "architecture": "arm64",
+                    "containerRuntimeVersion": "containerd://1.7.20"
+                },
+                "conditions": [
+                    { "type": "Ready", "status": "True", "reason": "KubeletReady", "message": "kubelet is posting ready status" },
+                    { "type": "DiskPressure", "status": "False", "reason": "KubeletHasNoDiskPressure" }
+                ]
+            }
+        });
+
+        let details = node_details_from_value(&node);
+
+        assert_eq!(details.kubelet_version, "v1.31.0");
+        assert_eq!(details.capacity.get("pods").map(String::as_str), Some("110"));
+        assert_eq!(details.allocatable.get("cpu").map(String::as_str), Some("7800m"));
+        assert!(details.unschedulable);
+        assert_eq!(
+            details.taints,
+            [
+                "node-role.kubernetes.io/control-plane:NoSchedule".to_string(),
+                "dedicated=debug:NoExecute".to_string(),
+            ]
+        );
+        assert_eq!(details.conditions[0].type_, "Ready");
+        assert_eq!(details.conditions[1].reason, "KubeletHasNoDiskPressure");
+    }
+
     #[test]
     fn event_resource_details_returns_selected_event_payload() {
         let json = serde_json::json!({

src-tauri/src/models.rs

@@ -85,6 +85,7 @@ pub struct ResourceDetails {
     pub logs: String,
     pub previous_logs: String,
     pub pod: Option<PodDetails>,
+    pub node: Option<NodeDetails>,
     pub crd: Option<CrdDetails>,
 }
 
@@ -148,6 +149,34 @@ pub struct PodSchedulingDetails {
     pub runtime_class_name: String,
 }
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NodeDetails {
+    pub conditions: Vec<NodeCondition>,
+    pub capacity: BTreeMap<String, String>,
+    pub allocatable: BTreeMap<String, String>,
+    pub kubelet_version: String,
+    pub os_image: String,
+    pub architecture: String,
+    pub container_runtime_version: String,
+    pub kernel_version: String,
+    pub operating_system: String,
+    pub pod_cidr: String,
+    pub provider_id: String,
+    pub unschedulable: bool,
+    pub taints: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NodeCondition {
+    #[serde(rename = "type")]
+    pub type_: String,
+    pub status: String,
+    pub reason: String,
+    pub message: String,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ContainerDetails {