@gtadi/k8s-node-debugger 1.0.1 → 1.1.0

package/README.md

@@ -22,16 +22,37 @@ node bin/k8s-node-debugger.js <node-name>
 
 ![Node Health view](https://raw.githubusercontent.com/goutamtadi1/k8s-node-debugger/main/docs/screenshot-health.png)
 
+### GPU Health — temperature, power, utilization, memory, ECC errors, clock throttle
+
+![GPU Health view](https://raw.githubusercontent.com/goutamtadi1/k8s-node-debugger/main/docs/screenshot-gpu-health.png)
+
+### GPU Status — driver version, CUDA, per-GPU metrics, processes
+
+![GPU Status view](https://raw.githubusercontent.com/goutamtadi1/k8s-node-debugger/main/docs/screenshot-gpu-status.png)
+
 ## Install
 
+```bash
+npm install -g @gtadi/k8s-node-debugger
+```
+
+Or run without installing:
+
+```bash
+npx @gtadi/k8s-node-debugger <node-name>
+```
+
+Requires `kubectl` on your PATH with an active kubeconfig. The debug image (`nicolaka/netshoot`) is pulled from Docker Hub on first use.
+
+### From source
+
 ```bash
 git clone git@github.com:goutamtadi1/k8s-node-debugger.git
 cd k8s-node-debugger
 npm install
+node bin/k8s-node-debugger.js <node-name>
 ```
 
-Requires `kubectl` on your PATH with an active kubeconfig. The debug image (`nicolaka/netshoot`) is pulled from Docker Hub on first use.
-
 ## Usage
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtadi/k8s-node-debugger",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Spin up a privileged debug pod on a target Kubernetes node and inspect its network stack (iptables, resolv.conf, conntrack, routes, sockets) from a browser UI.",
   "bin": {
     "k8s-node-debugger": "bin/k8s-node-debugger.js"

package/public/app.js

@@ -191,6 +191,7 @@ function buildSidebar(probes) {
       'Health':    { panelId: 'health',    label: 'Node Health' },
       'Firewall':  { panelId: 'firewall',  label: 'Firewall' },
       'Conntrack': { panelId: 'conntrack', label: 'Conntrack' },
+      'Storage':   { panelId: 'storage',   label: 'Storage' },
     };
     if (GROUP_PANELS[grp]) {
       const { panelId, label } = GROUP_PANELS[grp];
@@ -250,12 +251,15 @@ function navItem(id, label, type) {
 const HEALTH_ORDER    = ['cpu-stat', 'mem-info', 'disk-usage', 'mem-pressure', 'oom-kills', 'kubelet-logs'];
 const FIREWALL_ORDER  = ['iptables', 'iptables-nat', 'nftables', 'ipvs'];
 const CONNTRACK_ORDER = ['conntrack', 'conntrack-stats', 'conntrack-count'];
+const STORAGE_ORDER   = ['storage-partitions', 'storage-du-tree', 'storage-containers'];
 
 // Probes that get a rich custom renderer instead of a plain <pre>.
 const FANCY_PROBES = new Set([
   'iptables', 'iptables-nat',
   'conntrack', 'conntrack-stats', 'conntrack-count',
   'mem-info', 'mem-pressure', 'oom-kills', 'kubelet-logs', 'disk-usage', 'cpu-stat',
+  'gpu-info', 'gpu-health', 'gpu-processes',
+  'storage-partitions', 'storage-du-tree', 'storage-containers',
 ]);
 
 function buildProbePanel(probe) {
@@ -383,8 +387,14 @@ function tryFancyRender(id, output, container) {
     'mem-pressure':    () => renderMemPressureView(output, container),
     'oom-kills':       () => renderOomKillsView(output, container),
     'kubelet-logs':    () => renderKubeletLogsView(output, container),
-    'disk-usage':      () => renderDiskView(output, container),
-    'cpu-stat':        () => renderCpuView(output, container),
+    'disk-usage':           () => renderDiskView(output, container),
+    'cpu-stat':             () => renderCpuView(output, container),
+    'gpu-info':             () => renderGpuInfoView(output, container),
+    'gpu-health':           () => renderGpuHealthView(output, container),
+    'gpu-processes':        () => renderGpuProcessesView(output, container),
+    'storage-partitions':   () => renderStoragePartitionsView(output, container),
+    'storage-du-tree':      () => renderStorageDuTreeView(output, container),
+    'storage-containers':   () => renderStorageContainersView(output, container),
   };
   if (!renderers[id]) return false;
   try { renderers[id](); return true; } catch (e) { console.error('[fancy render]', id, e); return false; }
@@ -518,10 +528,11 @@ async function init() {
   session = await api('/api/session');
   const nodes = await api('/api/nodes');
 
-  const GROUP_IDS = new Set(['Health', 'Firewall', 'Conntrack']);
+  const GROUP_IDS = new Set(['Health', 'Firewall', 'Conntrack', 'Storage']);
   const healthProbes    = session.probes.filter(p => p.group === 'Health');
   const firewallProbes  = session.probes.filter(p => p.group === 'Firewall');
   const conntrackProbes = session.probes.filter(p => p.group === 'Conntrack');
+  const storageProbes   = session.probes.filter(p => p.group === 'Storage');
   const otherProbes     = session.probes.filter(p => !GROUP_IDS.has(p.group));
 
   buildSidebar(session.probes);
@@ -529,6 +540,7 @@ async function init() {
   buildGroupPanel('health',    'Node Health', healthProbes,    HEALTH_ORDER);
   buildGroupPanel('firewall',  'Firewall',    firewallProbes,  FIREWALL_ORDER);
   buildGroupPanel('conntrack', 'Conntrack',   conntrackProbes, CONNTRACK_ORDER);
+  buildGroupPanel('storage',   'Storage',     storageProbes,   STORAGE_ORDER);
 
   renderOverview(nodes);
   showPanel('overview');

package/public/health-view.js

@@ -451,6 +451,670 @@
     container.appendChild(wrap);
   }
 
+  /* ══════════════════════════════════════════════════════════════════════
+   * GPU status — nvidia-smi plain text table
+   * ══════════════════════════════════════════════════════════════════════ */
+  function renderGpuInfoView(raw, container) {
+    if (!raw.includes('NVIDIA-SMI')) { container.className = 'output'; container.textContent = raw; return; }
+
+    const lines = raw.split('\n');
+
+    // Version header
+    const verLine   = lines.find(l => l.includes('NVIDIA-SMI')) || '';
+    const smiVer    = verLine.match(/NVIDIA-SMI\s+(\S+)/)?.[1]       || '—';
+    const driverVer = verLine.match(/Driver Version:\s+(\S+)/)?.[1]  || '—';
+    const cudaVer   = verLine.match(/CUDA Version:\s+(\S+)/)?.[1]    || '—';
+
+    // Collect GPU data: groups of 3 content lines between |====| ... +---+
+    const gpus = [];
+    let inGpu = false, buf = [];
+    for (const line of lines) {
+      if (/^\|[=]+\|?$/.test(line.trim())) { inGpu = true; buf = []; continue; }
+      if (inGpu && line.startsWith('+')) {
+        if (buf.length >= 2) {
+          const g = parseNvidiaSmiGpuBlock(buf);
+          if (g) gpus.push(g);
+        }
+        inGpu = false; buf = []; continue;
+      }
+      if (inGpu && line.startsWith('|') && !line.includes('Processes:') &&
+          !line.includes('No running') && !line.includes('GPU   GI') && !line.includes('GPU  GI')) {
+        buf.push(line);
+      }
+    }
+
+    // Processes
+    let noProcs = raw.includes('No running processes found');
+    const procs = [];
+    if (!noProcs) {
+      const procRe = /\|\s+(\d+)\s+\S+\s+\S+\s+(\d+)\s+(\S+)\s+(.*?)\s+(\d+)MiB\s+\|/;
+      let inP = false;
+      for (const line of lines) {
+        if (line.includes('Processes:')) { inP = true; continue; }
+        if (inP && /^\|[=]+/.test(line)) continue;
+        if (inP && line.startsWith('+')) break;
+        if (inP) {
+          if (line.includes('No running')) { noProcs = true; break; }
+          const m = line.match(procRe);
+          if (m) procs.push({ gpu: m[1], pid: m[2], type: m[3], name: m[4].trim(), mem: m[5] });
+        }
+      }
+    }
+
+    function tempCls(t)  { return t >= 85 ? 'hv-crit' : t >= 70 ? 'hv-warn' : 'hv-ok'; }
+    function pctCls(v)   { return v >= 90 ? 'hv-crit' : v >= 70 ? 'hv-warn' : 'hv-ok'; }
+    function powerCls2(d,c) { if (!c) return 'hv-ok'; const r=d/c; return r>=0.95?'hv-crit':r>=0.80?'hv-warn':'hv-ok'; }
+
+    function memBar(used, total) {
+      if (!total) return '';
+      const pct = Math.min(Math.round(used/total*100),100);
+      const cls = pctCls(pct);
+      return `<div class="gpu-health-metric">
+        <div class="gpu-health-metric-hdr">
+          <span class="gpu-health-lbl">Memory</span>
+          <span class="gpu-health-val ${cls}">${pct}%</span>
+        </div>
+        <div class="hv-gauge-bar gpu-health-bar"><div class="hv-gauge-fill ${cls}" style="width:${pct}%"></div></div>
+        <div class="gpu-health-sub">${used} MiB used · ${total} MiB total</div>
+      </div>`;
+    }
+
+    function pwrBar(draw, cap) {
+      if (!cap) return '';
+      const pct = Math.min(Math.round(draw/cap*100),100);
+      const cls = powerCls2(draw, cap);
+      return `<div class="gpu-health-metric">
+        <div class="gpu-health-metric-hdr">
+          <span class="gpu-health-lbl">Power</span>
+          <span class="gpu-health-val ${cls}">${draw} W / ${cap} W</span>
+        </div>
+        <div class="hv-gauge-bar gpu-health-bar"><div class="hv-gauge-fill ${cls}" style="width:${pct}%"></div></div>
+      </div>`;
+    }
+
+    const gpuCards = gpus.map(g => `
+      <div class="gpu-health-card">
+        <div class="gpu-health-hdr">
+          <span class="gpu-proc-idx">GPU ${h(g.index)}</span>
+          <span class="gpu-health-name">${h(g.name)}</span>
+        </div>
+        <div class="gpu-health-row">
+          <div class="gpu-health-cell">
+            <span class="gpu-health-lbl">GPU Temp</span>
+            <span class="gpu-health-val ${tempCls(g.temp)}">${g.temp}°C</span>
+          </div>
+          <div class="gpu-health-cell">
+            <span class="gpu-health-lbl">Perf</span>
+            <span class="gpu-health-val">${h(g.perf)}</span>
+          </div>
+          <div class="gpu-health-cell">
+            <span class="gpu-health-lbl">GPU Util</span>
+            <span class="gpu-health-val ${pctCls(g.utilGpu)}">${g.utilGpu}%</span>
+          </div>
+          <div class="gpu-health-cell">
+            <span class="gpu-health-lbl">Fan</span>
+            <span class="gpu-health-val">${g.fan !== null ? g.fan + '%' : '—'}</span>
+          </div>
+        </div>
+        ${memBar(g.memUsed, g.memTotal)}
+        ${pwrBar(g.pwrDraw, g.pwrCap)}
+        <div class="gpu-info-meta">
+          <div class="gpu-info-meta-row">
+            <span class="gpu-health-lbl">Bus ID</span>
+            <span class="gpu-info-meta-val">${h(g.busId)}</span>
+          </div>
+          <div class="gpu-info-meta-row">
+            <span class="gpu-health-lbl">Persistence</span>
+            <span class="gpu-info-meta-val ${g.persistence === 'On' ? 'hv-ok' : ''}">${h(g.persistence)}</span>
+          </div>
+          <div class="gpu-info-meta-row">
+            <span class="gpu-health-lbl">Compute Mode</span>
+            <span class="gpu-info-meta-val">${h(g.computeMode)}</span>
+          </div>
+          ${g.migMode ? `<div class="gpu-info-meta-row">
+            <span class="gpu-health-lbl">MIG Mode</span>
+            <span class="gpu-info-meta-val">${h(g.migMode)}</span>
+          </div>` : ''}
+        </div>
+      </div>`).join('');
+
+    const procsHtml = noProcs
+      ? '<div class="gpu-info-no-procs">No running processes.</div>'
+      : `<div class="hv-top-table-wrap"><table class="hv-top-table">
+          <thead><tr><th>GPU</th><th>PID</th><th>Type</th><th>Process</th><th>GPU Mem</th></tr></thead>
+          <tbody>${procs.map(p => `<tr>
+            <td><span class="gpu-proc-idx">GPU ${h(p.gpu)}</span></td>
+            <td class="gpu-proc-pid">${h(p.pid)}</td>
+            <td><span class="gpu-proc-type gpu-proc-type-${h(p.type.toLowerCase())}">${h(p.type)}</span></td>
+            <td class="gpu-proc-cmd">${h(p.name)}</td>
+            <td class="gpu-proc-mem">${h(p.mem)} MiB</td>
+          </tr>`).join('')}</tbody>
+        </table></div>`;
+
+    const wrap = document.createElement('div');
+    wrap.className = 'hv-wrap gpu-health-grid';
+    wrap.innerHTML = `
+      <div class="gpu-info-versions">
+        <div class="gpu-info-ver-item"><span class="gpu-health-lbl">NVIDIA-SMI</span><span class="gpu-info-ver-val">${h(smiVer)}</span></div>
+        <div class="gpu-info-ver-item"><span class="gpu-health-lbl">Driver</span><span class="gpu-info-ver-val">${h(driverVer)}</span></div>
+        <div class="gpu-info-ver-item"><span class="gpu-health-lbl">CUDA</span><span class="gpu-info-ver-val">${h(cudaVer)}</span></div>
+      </div>
+      ${gpuCards}
+      <div class="gpu-info-procs-section">
+        <div class="gpu-info-procs-title">Processes</div>
+        ${procsHtml}
+      </div>`;
+
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
+  function parseNvidiaSmiGpuBlock(lines) {
+    // Line 0: |  idx  name  persistence  | bus_id  disp_a  |  ecc  |
+    // Line 1: |  fan  tempC  perf  drawW/capW  |  usedMiB/totalMiB  |  util%  compute  |
+    // Line 2: |  ...  |  ...  |  mig  |
+    const l0 = lines[0] || '', l1 = lines[1] || '', l2 = lines[2] || '';
+    const m0 = l0.match(/\|\s+(\d+)\s+(.*?)\s+(On|Off)\s+\|\s+(\S+)\s+(On|Off)\s+\|\s+(\S+)\s+\|/);
+    const m1 = l1.match(/\|\s*(N\/A|\d+)\s+(\d+)C\s+(\S+)\s+(\d+)W\s*\/\s*(\d+)W\s+\|\s+(\d+)MiB\s*\/\s*(\d+)MiB\s+\|\s+(\d+)%\s+(\S+)\s+\|/);
+    if (!m0 || !m1) return null;
+    const m2 = l2.match(/\|\s*\|\s*\|\s+(\S+)\s+\|/);
+    return {
+      index:       m0[1],
+      name:        m0[2].trim(),
+      persistence: m0[3],
+      busId:       m0[4],
+      dispA:       m0[5],
+      ecc:         m0[6],
+      fan:         m1[1] === 'N/A' ? null : parseInt(m1[1]),
+      temp:        parseInt(m1[2]),
+      perf:        m1[3],
+      pwrDraw:     parseInt(m1[4]),
+      pwrCap:      parseInt(m1[5]),
+      memUsed:     parseInt(m1[6]),
+      memTotal:    parseInt(m1[7]),
+      utilGpu:     parseInt(m1[8]),
+      computeMode: m1[9],
+      migMode:     m2?.[1] || null,
+    };
+  }
+
+  /* ══════════════════════════════════════════════════════════════════════
+   * GPU health — nvidia-smi --query-gpu CSV
+   * Columns: index, name, temp.gpu, temp.mem, power.draw, power.limit,
+   *          util.gpu, util.mem, mem.used, mem.free, mem.total,
+   *          ecc.corrected, ecc.uncorrected, throttle_reasons
+   * ══════════════════════════════════════════════════════════════════════ */
+  function renderGpuHealthView(raw, container) {
+    const lines = raw.split('\n').map(l => l.trim()).filter(l => l);
+    if (!lines.length) { container.textContent = raw; return; }
+
+    const THROTTLE_REASONS = [
+      [0x02,  'App Clock Setting'],
+      [0x04,  'SW Power Cap'],
+      [0x08,  'HW Slowdown'],
+      [0x10,  'Sync Boost'],
+      [0x20,  'SW Thermal Slowdown'],
+      [0x40,  'HW Thermal Slowdown'],
+      [0x80,  'HW Power Brake'],
+      [0x100, 'Display Clock Setting'],
+    ];
+
+    function pn(s) { const n = parseFloat(s); return isNaN(n) ? null : n; }
+    function strip(s, u) { return pn((s || '').replace(u, '')); }
+
+    const gpus = lines.map(line => {
+      const p = line.split(',').map(s => s.trim());
+      return {
+        index:          p[0],
+        name:           p[1],
+        tempGpu:        pn(p[2]),
+        tempMem:        pn(p[3]),
+        powerDraw:      strip(p[4], ' W'),
+        powerLimit:     strip(p[5], ' W'),
+        utilGpu:        strip(p[6], ' %'),
+        utilMem:        strip(p[7], ' %'),
+        memUsed:        strip(p[8], ' MiB'),
+        memTotal:       strip(p[10], ' MiB'),
+        eccCorrected:   pn(p[11]),
+        eccUncorrected: pn(p[12]),
+        throttleRaw:    (p[13] || '').trim(),
+      };
+    });
+
+    function tempCls(t)    { return t === null ? '' : t >= 85 ? 'hv-crit' : t >= 70 ? 'hv-warn' : 'hv-ok'; }
+    function pctCls(v)     { return v === null ? '' : v >= 90 ? 'hv-crit' : v >= 70 ? 'hv-warn' : 'hv-ok'; }
+    function powerCls(d,l) { if (d === null || !l) return 'hv-ok'; const r = d/l; return r >= 0.95 ? 'hv-crit' : r >= 0.80 ? 'hv-warn' : 'hv-ok'; }
+
+    function decodeThrottle(raw) {
+      if (!raw || raw === 'N/A') return [];
+      const val = parseInt(raw, 16);
+      if (isNaN(val) || val === 0 || val === 1) return [];
+      return THROTTLE_REASONS.filter(([mask]) => val & mask).map(([, name]) => name);
+    }
+
+    function bar(pct, cls) {
+      return `<div class="hv-gauge-bar gpu-health-bar"><div class="hv-gauge-fill ${cls}" style="width:${pct}%"></div></div>`;
+    }
+
+    const wrap = document.createElement('div');
+    wrap.className = 'hv-wrap gpu-health-grid';
+
+    wrap.innerHTML = gpus.map(g => {
+      const memPct   = (g.memUsed !== null && g.memTotal) ? Math.min(Math.round(g.memUsed / g.memTotal * 100), 100) : null;
+      const pwrPct   = (g.powerDraw !== null && g.powerLimit) ? Math.min(Math.round(g.powerDraw / g.powerLimit * 100), 100) : null;
+      const memCls   = pctCls(memPct);
+      const pwrCls   = powerCls(g.powerDraw, g.powerLimit);
+      const throttled = decodeThrottle(g.throttleRaw);
+      const eccBad   = g.eccUncorrected !== null && g.eccUncorrected > 0;
+      const eccWarn  = !eccBad && g.eccCorrected !== null && g.eccCorrected > 0;
+
+      return `
+        <div class="gpu-health-card">
+          <div class="gpu-health-hdr">
+            <span class="gpu-proc-idx">GPU ${h(g.index)}</span>
+            <span class="gpu-health-name">${h(g.name)}</span>
+          </div>
+
+          <div class="gpu-health-row">
+            <div class="gpu-health-cell">
+              <span class="gpu-health-lbl">GPU temp</span>
+              <span class="gpu-health-val ${tempCls(g.tempGpu)}">${g.tempGpu !== null ? g.tempGpu + '°C' : '—'}</span>
+            </div>
+            <div class="gpu-health-cell">
+              <span class="gpu-health-lbl">Mem temp</span>
+              <span class="gpu-health-val ${tempCls(g.tempMem)}">${g.tempMem !== null ? g.tempMem + '°C' : '—'}</span>
+            </div>
+            <div class="gpu-health-cell">
+              <span class="gpu-health-lbl">GPU util</span>
+              <span class="gpu-health-val ${pctCls(g.utilGpu)}">${g.utilGpu !== null ? g.utilGpu + '%' : '—'}</span>
+            </div>
+            <div class="gpu-health-cell">
+              <span class="gpu-health-lbl">Mem util</span>
+              <span class="gpu-health-val ${pctCls(g.utilMem)}">${g.utilMem !== null ? g.utilMem + '%' : '—'}</span>
+            </div>
+          </div>
+
+          <div class="gpu-health-metric">
+            <div class="gpu-health-metric-hdr">
+              <span class="gpu-health-lbl">Memory</span>
+              <span class="gpu-health-val ${memCls}">${memPct !== null ? memPct + '%' : '—'}</span>
+            </div>
+            ${memPct !== null ? bar(memPct, memCls) : ''}
+            <div class="gpu-health-sub">${g.memUsed !== null ? Math.round(g.memUsed) + ' MiB used' : ''} ${g.memTotal ? '· ' + Math.round(g.memTotal) + ' MiB total' : ''}</div>
+          </div>
+
+          <div class="gpu-health-metric">
+            <div class="gpu-health-metric-hdr">
+              <span class="gpu-health-lbl">Power</span>
+              <span class="gpu-health-val ${pwrCls}">${g.powerDraw !== null ? g.powerDraw.toFixed(1) + ' W' : '—'}${g.powerLimit ? ' / ' + g.powerLimit.toFixed(0) + ' W' : ''}</span>
+            </div>
+            ${pwrPct !== null ? bar(pwrPct, pwrCls) : ''}
+          </div>
+
+          <div class="gpu-health-ecc ${eccBad ? 'gpu-health-ecc-bad' : eccWarn ? 'gpu-health-ecc-warn' : 'gpu-health-ecc-ok'}">
+            <span class="gpu-health-lbl">ECC errors</span>
+            <span class="gpu-health-ecc-vals">
+              <span title="Corrected (volatile)">${g.eccCorrected ?? '—'} corrected</span>
+              <span class="${eccBad ? 'hv-crit' : ''}" title="Uncorrected (volatile)">${g.eccUncorrected ?? '—'} uncorrected</span>
+            </span>
+          </div>
+
+          ${throttled.length ? `
+          <div class="gpu-health-throttle">
+            <span class="gpu-health-lbl gpu-health-throttle-lbl">Clock throttled</span>
+            <div class="gpu-health-throttle-tags">${throttled.map(r => `<span class="gpu-health-throttle-tag">${h(r)}</span>`).join('')}</div>
+          </div>` : ''}
+        </div>`;
+    }).join('');
+
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
+  /* ══════════════════════════════════════════════════════════════════════
+   * GPU processes — nvidia-smi pmon or --query-compute-apps
+   * ══════════════════════════════════════════════════════════════════════ */
+  function renderGpuProcessesView(raw, container) {
+    const lines = raw.split('\n').map(l => l.trim()).filter(l => l);
+    if (!lines.length) { container.textContent = raw; return; }
+
+    const wrap = document.createElement('div');
+    wrap.className = 'hv-wrap';
+
+    // pmon format: header lines start with '#'
+    if (lines[0].startsWith('# gpu')) {
+      const dataLines = lines.filter(l => !l.startsWith('#'));
+      const active = dataLines.filter(l => {
+        const parts = l.split(/\s+/);
+        return parts[1] && parts[1] !== '-';
+      });
+
+      if (!active.length) {
+        const idleHtml = dataLines.map(l => {
+          const parts = l.split(/\s+/);
+          return `<div class="gpu-proc-idle-row">
+            <span class="gpu-proc-idx">GPU ${h(parts[0] || '?')}</span>
+            <span class="gpu-proc-idle-lbl">No active processes</span>
+          </div>`;
+        }).join('');
+        wrap.innerHTML = `<div class="gpu-proc-idle">${idleHtml}</div>`;
+      } else {
+        function metricCell(v) {
+          const n = parseFloat(v);
+          const cls = (!isNaN(n) && n > 0)
+            ? (n >= 80 ? 'hv-crit' : n >= 40 ? 'hv-warn' : 'gpu-proc-active') : '';
+          return `<td class="${cls}">${h(v === '-' ? '—' : v + '%')}</td>`;
+        }
+        const tableRows = active.map(l => {
+          const [gpu, pid, type, sm, mem, enc, dec, , , ...cmdParts] = l.split(/\s+/);
+          const cmd = cmdParts.join(' ') || '—';
+          return `<tr>
+            <td><span class="gpu-proc-idx">GPU ${h(gpu)}</span></td>
+            <td class="gpu-proc-pid">${h(pid)}</td>
+            <td><span class="gpu-proc-type gpu-proc-type-${h((type || '').toLowerCase())}">${h(type || '—')}</span></td>
+            ${metricCell(sm)} ${metricCell(mem)} ${metricCell(enc)} ${metricCell(dec)}
+            <td class="gpu-proc-cmd">${h(cmd)}</td>
+          </tr>`;
+        }).join('');
+        wrap.innerHTML = `
+          <div class="hv-top-table-wrap">
+            <table class="hv-top-table">
+              <thead><tr>
+                <th>GPU</th><th>PID</th><th>Type</th>
+                <th>SM %</th><th>Mem %</th><th>Enc %</th><th>Dec %</th>
+                <th>Process</th>
+              </tr></thead>
+              <tbody>${tableRows}</tbody>
+            </table>
+          </div>`;
+      }
+
+    } else {
+      // --query-compute-apps CSV: pid, used_gpu_memory, name
+      const rows = lines
+        .map(l => { const p = l.split(',').map(s => s.trim()); return { pid: p[0], mem: p[1], name: p[2] }; })
+        .filter(r => r.pid && r.pid !== '-');
+
+      if (!rows.length) {
+        wrap.innerHTML = '<div class="gpu-proc-idle"><div class="gpu-proc-idle-row"><span class="gpu-proc-idle-lbl">No GPU compute processes running.</span></div></div>';
+      } else {
+        const tableRows = rows.map(r => `<tr>
+          <td class="gpu-proc-pid">${h(r.pid)}</td>
+          <td class="gpu-proc-mem">${h(r.mem)}</td>
+          <td class="gpu-proc-cmd">${h(r.name)}</td>
+        </tr>`).join('');
+        wrap.innerHTML = `
+          <div class="hv-top-table-wrap">
+            <table class="hv-top-table">
+              <thead><tr><th>PID</th><th>GPU Memory</th><th>Process</th></tr></thead>
+              <tbody>${tableRows}</tbody>
+            </table>
+          </div>`;
+      }
+    }
+
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
+  /* ══════════════════════════════════════════════════════════════════════
+   * Storage — Partition overview (filtered df -hT)
+   * ══════════════════════════════════════════════════════════════════════ */
+  function renderStoragePartitionsView(raw, container) {
+    const lines = raw.split('\n').filter(l => l.trim());
+    if (lines.length < 2) { container.textContent = raw; return; }
+
+    const rows = [];
+    for (const line of lines.slice(1)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 7) continue;
+      const [fs, type, size, used, avail, usePct, ...rest] = parts;
+      const mount = rest.join(' ');
+      const p = parseInt(usePct);
+      rows.push({ fs, type, size, used, avail, pct: isNaN(p) ? 0 : p, mount });
+    }
+
+    if (!rows.length) { container.textContent = raw; return; }
+
+    const wrap = document.createElement('div');
+    wrap.className = 'hv-wrap';
+
+    const rowsHtml = rows.map(r => {
+      const cls = colorCls(r.pct);
+      return `
+        <div class="hv-disk-row">
+          <div class="hv-disk-header">
+            <span class="hv-disk-mount">${h(r.mount)}</span>
+            <span class="hv-disk-fs">${h(r.fs)} <span style="opacity:0.5;font-size:11px">${h(r.type)}</span></span>
+            <div class="hv-disk-sizes">
+              <span class="hv-disk-pct ${cls}">${r.pct}%</span>
+              <span class="hv-disk-nums">${h(r.used)} used · ${h(r.avail)} free · ${h(r.size)} total</span>
+            </div>
+          </div>
+          <div class="hv-disk-bar"><div class="hv-disk-fill ${cls}" style="width:${r.pct}%"></div></div>
+        </div>`;
+    }).join('');
+
+    wrap.innerHTML = `<div class="hv-disk-list">${rowsHtml}</div>`;
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
+  /* ══════════════════════════════════════════════════════════════════════
+   * Storage — du tree drill-down
+   * ══════════════════════════════════════════════════════════════════════ */
+  function renderStorageDuTreeView(raw, container) {
+    const SECTION_LABELS = {
+      stateful:  '/mnt/stateful_partition',
+      var:       '/var',
+      varlib:    '/var/lib',
+      containerd: '/var/lib/containerd',
+    };
+
+    const sections = {};
+    let cur = null;
+    for (const line of raw.split('\n')) {
+      const sec = line.match(/^=(stateful|var|varlib|containerd)=$/);
+      if (sec) { cur = sec[1]; sections[cur] = []; continue; }
+      if (cur && line.trim()) sections[cur].push(line.trim());
+    }
+
+    function parseHumanSize(s) {
+      const m = (s || '').trim().match(/^([0-9.]+)\s*([KMGTP]?)/i);
+      if (!m) return 0;
+      const n = parseFloat(m[1]);
+      const mul = { '': 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4 }[m[2].toUpperCase()] || 1;
+      return n * mul;
+    }
+
+    const wrap = document.createElement('div');
+    wrap.className = 'hv-wrap';
+
+    const order = ['stateful', 'var', 'varlib', 'containerd'];
+    const sectionsHtml = order.filter(k => sections[k]?.length).map(key => {
+      const entries = sections[key]
+        .map(line => { const [size, ...pathParts] = line.split(/\t/); return { size: size.trim(), path: pathParts.join('\t').trim() }; })
+        .filter(e => e.size && e.path);
+
+      if (!entries.length) return '';
+
+      const maxBytes = Math.max(...entries.map(e => parseHumanSize(e.size)), 1);
+
+      const rowsHtml = entries.slice(0, 20).map(e => {
+        const bytes = parseHumanSize(e.size);
+        const pct = Math.min(Math.round(bytes / maxBytes * 100), 100);
+        const cls = pct >= 80 ? 'hv-crit' : pct >= 50 ? 'hv-warn' : 'hv-ok';
+        const name = e.path.replace(/^.*\//, '') || e.path;
+        return `
+          <div class="st-du-row">
+            <div class="st-du-header">
+              <span class="st-du-name" title="${h(e.path)}">${h(name)}</span>
+              <span class="st-du-size ${pct >= 60 ? cls : ''}">${h(e.size)}</span>
+            </div>
+            <div class="hv-gauge-bar"><div class="hv-gauge-fill ${cls}" style="width:${pct}%"></div></div>
+          </div>`;
+      }).join('');
+
+      return `
+        <div class="st-du-section">
+          <div class="st-du-section-title">${h(SECTION_LABELS[key] || key)}</div>
+          <div class="st-du-rows">${rowsHtml}</div>
+        </div>`;
+    }).join('');
+
+    wrap.innerHTML = sectionsHtml || '<div class="hv-info-note">No du data available — path may not exist on this node.</div>';
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
+  /* ══════════════════════════════════════════════════════════════════════
+   * Storage — Top containers by snapshot disk usage
+   * Parses three sections from the compound command:
+   *   =SNAPS=  du -d 1 …/snapshots  (bytes\tpath)
+   *   =MOUNTS= mount | grep snapshots
+   *   =CRICTL= crictl ps -a
+   * ══════════════════════════════════════════════════════════════════════ */
+  function renderStorageContainersView(raw, container) {
+    const sections = {};
+    let cur = null;
+    for (const line of raw.split('\n')) {
+      const sec = line.match(/^=(SNAPS|MOUNTS|CRICTL)=$/);
+      if (sec) { cur = sec[1]; sections[cur] = []; continue; }
+      if (cur && line.trim()) sections[cur].push(line);
+    }
+
+    // 1. Parse snapshot sizes: "1234567\t/path/snapshots/932" → snapId → KB
+    const snapKb = new Map();
+    for (const line of (sections.SNAPS || [])) {
+      const m = line.match(/^(\d+)\s+.*\/(\d+)\s*$/);
+      if (m) snapKb.set(m[2], parseInt(m[1]));
+    }
+
+    // 2. Build snapId → containerHash from overlay mount lines.
+    //    Mount target contains: /k8s.io/{64-char-hash}/rootfs
+    //    Mount options contain: snapshots/NNN/ references
+    const snapToHash = new Map();
+    for (const line of (sections.MOUNTS || [])) {
+      const hashM = line.match(/\/k8s\.io\/([a-f0-9]{64})\//);
+      if (!hashM) continue;
+      const hash = hashM[1];
+      for (const m of line.matchAll(/snapshots\/(\d+)\//g)) {
+        if (!snapToHash.has(m[1])) snapToHash.set(m[1], hash);
+      }
+    }
+
+    // 3. Parse crictl ps -a using header positions for fixed-width columns.
+    const hashToInfo = new Map();
+    const crictlLines = (sections.CRICTL || []).filter(l => l.trim());
+    if (crictlLines.length > 1) {
+      const header = crictlLines[0];
+      const colStarts = {
+        CONTAINER: header.indexOf('CONTAINER'),
+        IMAGE:     header.indexOf('IMAGE'),
+        STATE:     header.indexOf('STATE'),
+        NAME:      header.indexOf('NAME'),
+        POD:       header.lastIndexOf('POD'),
+      };
+      for (const line of crictlLines.slice(1)) {
+        if (line.startsWith('CONTAINER')) continue;
+        function col(start, end) {
+          return end > start ? line.substring(start, end).trim() : line.substring(start).trim();
+        }
+        const id    = col(colStarts.CONTAINER, colStarts.IMAGE);
+        const state = col(colStarts.STATE, colStarts.NAME);
+        const name  = col(colStarts.NAME, colStarts.POD);
+        const pod   = line.substring(colStarts.POD).trim();
+        if (!id) continue;
+        const info = { state, name, pod: pod || name };
+        hashToInfo.set(id, info);
+        if (id.length > 12) hashToInfo.set(id.substring(0, 12), info);
+      }
+    }
+
+    // 4. Build ranked rows: snapId sorted by KB desc → join hash → join container info
+    const rows = [...snapKb.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 25)
+      .map(([snapId, kb]) => {
+        const hash = snapToHash.get(snapId);
+        const info = hash
+          ? (hashToInfo.get(hash) || hashToInfo.get(hash.substring(0, 12)))
+          : null;
+        return { snapId, kb, hash, info };
+      });
+
+    const wrap = document.createElement('div');
+    wrap.className = 'hv-wrap';
+
+    if (!rows.length) {
+      wrap.innerHTML = '<div class="hv-info-note">No containerd overlayfs snapshot data found. The snapshotter path may differ on this node.</div>';
+      container.innerHTML = '';
+      container.appendChild(wrap);
+      return;
+    }
+
+    const totalKb = [...snapKb.values()].reduce((a, b) => a + b, 0);
+    const mappedCount = rows.filter(r => r.info).length;
+    const maxKb = rows[0].kb || 1;
+
+    const listHtml = rows.map((r, i) => {
+      const pct = Math.min(Math.round(r.kb / maxKb * 100), 100);
+      const cls  = r.kb >= maxKb * 0.5 ? 'hv-crit' : r.kb >= maxKb * 0.2 ? 'hv-warn' : 'hv-ok';
+      const stateCls = r.info?.state === 'Running' ? 'hv-ok' : r.info?.state ? 'hv-warn' : '';
+      const podLabel  = r.info?.pod  || (r.hash ? r.hash.substring(0, 16) + '…' : '—');
+      const nameLabel = r.info?.name || '';
+      return `
+        <div class="st-cont-row">
+          <div class="st-cont-header">
+            <span class="st-cont-rank">#${i + 1}</span>
+            <div class="st-cont-names">
+              <span class="st-cont-pod">${h(podLabel)}</span>
+              ${nameLabel ? `<span class="st-cont-name">${h(nameLabel)}</span>` : ''}
+            </div>
+            ${r.info?.state ? `<span class="st-cont-state ${stateCls}">${h(r.info.state)}</span>` : ''}
+            <span class="st-cont-size ${cls}">${hBytes(r.kb)}</span>
+          </div>
+          <div class="hv-gauge-bar st-cont-bar">
+            <div class="hv-gauge-fill ${cls}" style="width:${pct}%"></div>
+          </div>
+          <div class="st-cont-meta">
+            <span class="st-cont-meta-tag">snap #${h(r.snapId)}</span>
+            ${r.hash ? `<span class="st-cont-meta-tag">${h(r.hash.substring(0, 20))}…</span>` : '<span class="st-cont-meta-unmapped">unmapped</span>'}
+          </div>
+        </div>`;
+    }).join('');
+
+    wrap.innerHTML = `
+      <div class="hv-info-note">
+        Containerd overlayfs snapshot layers ranked by disk usage. Active layers are mapped to pods via overlay mounts and crictl.
+        Prune dangling images with: <code>nsenter -t 1 -m -u -i -n -p -- crictl rmi --prune</code>
+      </div>
+      <div class="st-summary">
+        <div class="hv-grid-item">
+          <div class="hv-grid-label">Snapshots tracked</div>
+          <div class="hv-grid-val">${snapKb.size}</div>
+        </div>
+        <div class="hv-grid-item">
+          <div class="hv-grid-label">Mapped to pods</div>
+          <div class="hv-grid-val">${mappedCount} / ${rows.length}</div>
+        </div>
+        <div class="hv-grid-item">
+          <div class="hv-grid-label">Total snapshot storage</div>
+          <div class="hv-grid-val">${hBytes(totalKb)}</div>
+        </div>
+      </div>
+      <div class="st-cont-list">${listHtml}</div>`;
+
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
   /* ── Exports ─────────────────────────────────────────────────────────── */
   window.renderMemInfoView     = renderMemInfoView;
   window.renderMemPressureView = renderMemPressureView;
@@ -458,5 +1122,11 @@
   window.renderKubeletLogsView = renderKubeletLogsView;
   window.renderDiskView        = renderDiskView;
   window.renderCpuView         = renderCpuView;
+  window.renderGpuInfoView              = renderGpuInfoView;
+  window.renderGpuHealthView            = renderGpuHealthView;
+  window.renderGpuProcessesView         = renderGpuProcessesView;
+  window.renderStoragePartitionsView    = renderStoragePartitionsView;
+  window.renderStorageDuTreeView        = renderStorageDuTreeView;
+  window.renderStorageContainersView    = renderStorageContainersView;
 
 })();

package/public/style.css

@@ -864,3 +864,138 @@ kbd {
 .conn-empty { color: var(--fg-dim); font-style: italic; font-size: 13px; padding: 6px 0; }
 .conn-loading { color: var(--accent); font-size: 14px; padding: 20px; text-align: center; }
 .conn-error { color: var(--err); font-size: 13px; padding: 10px; }
+
+/* ── GPU info view (nvidia-smi table) ──────────────────────────────────── */
+.gpu-info-versions { display: flex; gap: 24px; padding: 12px 16px; background: var(--bg-2); border: 1px solid var(--border); border-radius: 8px; flex-wrap: wrap; }
+.gpu-info-ver-item { display: flex; flex-direction: column; gap: 3px; }
+.gpu-info-ver-val { font-family: var(--mono); font-size: 14px; font-weight: 600; color: var(--accent); }
+.gpu-info-meta { display: grid; grid-template-columns: repeat(auto-fill, minmax(160px, 1fr)); gap: 8px; padding: 10px 12px; background: var(--bg-3); border-radius: 6px; border: 1px solid var(--border); }
+.gpu-info-meta-row { display: flex; flex-direction: column; gap: 3px; }
+.gpu-info-meta-val { font-family: var(--mono); font-size: 12px; color: var(--fg); }
+.gpu-info-procs-section { display: flex; flex-direction: column; gap: 8px; }
+.gpu-info-procs-title { font-size: 11px; font-weight: 600; text-transform: uppercase; letter-spacing: .08em; color: var(--fg-dim); }
+.gpu-info-no-procs { font-size: 13px; color: var(--fg-dim); padding: 10px 14px; background: var(--bg-2); border: 1px solid var(--border); border-radius: 6px; }
+
+/* ── GPU health view ────────────────────────────────────────────────────── */
+.gpu-health-grid { display: flex; flex-direction: column; gap: 16px; }
+.gpu-health-card { background: var(--bg-2); border: 1px solid var(--border); border-radius: 10px; padding: 18px 20px; display: flex; flex-direction: column; gap: 14px; }
+.gpu-health-hdr { display: flex; align-items: center; gap: 10px; }
+.gpu-health-name { font-size: 14px; font-weight: 600; color: var(--fg); }
+.gpu-health-row { display: flex; gap: 0; flex-wrap: wrap; background: var(--bg-3); border-radius: 7px; overflow: hidden; border: 1px solid var(--border); }
+.gpu-health-cell { flex: 1; min-width: 80px; display: flex; flex-direction: column; align-items: center; padding: 10px 8px; gap: 4px; border-right: 1px solid var(--border); }
+.gpu-health-cell:last-child { border-right: none; }
+.gpu-health-lbl { font-size: 10px; font-weight: 600; text-transform: uppercase; letter-spacing: .06em; color: var(--fg-dim); }
+.gpu-health-val { font-size: 18px; font-weight: 700; font-family: var(--mono); }
+.gpu-health-metric { display: flex; flex-direction: column; gap: 5px; }
+.gpu-health-metric-hdr { display: flex; justify-content: space-between; align-items: baseline; }
+.gpu-health-metric .gpu-health-lbl { font-size: 11px; }
+.gpu-health-metric .gpu-health-val { font-size: 14px; }
+.gpu-health-bar { height: 8px; }
+.gpu-health-sub { font-size: 11px; color: var(--fg-dim); font-family: var(--mono); }
+.gpu-health-ecc { display: flex; align-items: center; justify-content: space-between; padding: 8px 10px; border-radius: 6px; font-size: 12px; }
+.gpu-health-ecc-ok   { background: #0d2b16; border: 1px solid #1e5c3a; }
+.gpu-health-ecc-warn { background: #2b2000; border: 1px solid #5a4500; }
+.gpu-health-ecc-bad  { background: #2b0d0d; border: 1px solid #5c2020; }
+.gpu-health-ecc-vals { display: flex; gap: 14px; font-family: var(--mono); color: var(--fg-dim); }
+.gpu-health-throttle { display: flex; flex-direction: column; gap: 6px; padding: 8px 10px; background: #2b2000; border: 1px solid #5a4500; border-radius: 6px; }
+.gpu-health-throttle-lbl { color: #d29922; }
+.gpu-health-throttle-tags { display: flex; gap: 6px; flex-wrap: wrap; }
+.gpu-health-throttle-tag { padding: 2px 8px; background: #3d2e00; border: 1px solid #5a4500; border-radius: 4px; font-size: 11px; color: #d29922; font-family: var(--mono); }
+
+/* ── GPU processes view ─────────────────────────────────────────────────── */
+.gpu-proc-idle { display: flex; flex-direction: column; gap: 8px; }
+.gpu-proc-idle-row { display: flex; align-items: center; gap: 12px; padding: 10px 14px; background: var(--bg-2); border: 1px solid var(--border); border-radius: 8px; }
+.gpu-proc-idle-lbl { font-size: 13px; color: var(--fg-dim); }
+.gpu-proc-idx { display: inline-block; padding: 2px 8px; border-radius: 5px; font-size: 11px; font-weight: 700; font-family: var(--mono); background: #0d1f3c; color: var(--accent); border: 1px solid #1e3a6e; }
+.gpu-proc-pid { font-family: var(--mono); font-size: 12px; color: var(--fg-dim); }
+.gpu-proc-mem { font-family: var(--mono); font-size: 12px; }
+.gpu-proc-type { display: inline-block; padding: 1px 6px; border-radius: 4px; font-size: 11px; font-weight: 600; font-family: var(--mono); background: var(--bg-3); color: var(--fg-dim); border: 1px solid var(--border); }
+.gpu-proc-type-c { background: #0d2b16; color: #3fb950; border-color: #1e5c3a; }
+.gpu-proc-type-g { background: #0d1f3c; color: var(--accent); border-color: #1e3a6e; }
+.gpu-proc-cmd { color: var(--fg-dim); font-size: 12px; font-family: var(--mono); }
+.gpu-proc-active { color: var(--ok); font-family: var(--mono); }
+
+/* ── Storage views ──────────────────────────────────────────────────────── */
+
+/* du tree drill-down */
+.st-du-section { margin-bottom: 20px; }
+.st-du-section-title {
+  font-size: 11px; font-weight: 700; text-transform: uppercase;
+  letter-spacing: .08em; color: var(--accent); font-family: var(--mono);
+  padding: 6px 0 8px;
+  border-bottom: 1px solid var(--border); margin-bottom: 10px;
+}
+.st-du-rows { display: flex; flex-direction: column; gap: 7px; }
+.st-du-row { display: flex; flex-direction: column; gap: 4px; }
+.st-du-header { display: flex; align-items: center; gap: 10px; }
+.st-du-name {
+  flex: 1; font-family: var(--mono); font-size: 12.5px;
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+  color: var(--fg);
+}
+.st-du-size {
+  font-family: var(--mono); font-size: 12.5px; font-weight: 600;
+  color: var(--fg-dim); flex-shrink: 0; min-width: 60px; text-align: right;
+}
+.st-du-size.hv-crit { color: var(--err); }
+.st-du-size.hv-warn { color: #d29922; }
+
+/* summary grid */
+.st-summary {
+  display: flex; gap: 12px; flex-wrap: wrap;
+  margin-bottom: 18px;
+}
+.st-summary .hv-grid-item {
+  flex: 1; min-width: 140px;
+  background: var(--bg-2); border: 1px solid var(--border);
+  border-radius: 8px; padding: 10px 14px;
+}
+
+/* container ranked list */
+.st-cont-list { display: flex; flex-direction: column; gap: 10px; }
+.st-cont-row {
+  background: var(--bg-2); border: 1px solid var(--border);
+  border-radius: 8px; padding: 11px 14px;
+  display: flex; flex-direction: column; gap: 6px;
+}
+.st-cont-header {
+  display: flex; align-items: center; gap: 10px; flex-wrap: wrap;
+}
+.st-cont-rank {
+  font-family: var(--mono); font-size: 11px; font-weight: 700;
+  color: var(--fg-dim); min-width: 26px; flex-shrink: 0;
+}
+.st-cont-names { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 2px; }
+.st-cont-pod {
+  font-family: var(--mono); font-size: 13px; font-weight: 600;
+  color: var(--fg); white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+}
+.st-cont-name {
+  font-size: 11px; color: var(--fg-dim); font-family: var(--mono);
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+}
+.st-cont-state {
+  font-size: 11px; font-weight: 700; font-family: var(--mono);
+  padding: 2px 7px; border-radius: 4px;
+  background: var(--bg-3); border: 1px solid var(--border);
+  color: var(--fg-dim); flex-shrink: 0;
+}
+.st-cont-state.hv-ok  { background: #0d2b16; color: var(--ok); border-color: #1e5c3a; }
+.st-cont-state.hv-warn { background: #2b2000; color: #d29922; border-color: #5a4500; }
+.st-cont-size {
+  font-family: var(--mono); font-size: 13px; font-weight: 700;
+  flex-shrink: 0; color: var(--fg);
+}
+.st-cont-size.hv-crit { color: var(--err); }
+.st-cont-size.hv-warn { color: #d29922; }
+.st-cont-size.hv-ok   { color: var(--ok); }
+.st-cont-bar { margin: 0; }
+.st-cont-meta { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.st-cont-meta-tag {
+  font-family: var(--mono); font-size: 11px; color: var(--fg-dim);
+  background: var(--bg-3); border: 1px solid var(--border);
+  padding: 1px 7px; border-radius: 4px;
+}
+.st-cont-meta-unmapped {
+  font-size: 11px; color: var(--fg-dim); font-style: italic; opacity: 0.6;
+}

package/src/probes.js

@@ -220,6 +220,39 @@ const PROBES = [
     ],
   },
 
+  // ── Storage ─────────────────────────────────────────────────────────
+  {
+    id: 'storage-partitions',
+    label: 'Partitions',
+    group: 'Storage',
+    desc: 'Real physical host partitions (tmpfs, devtmpfs, shm, overlay filtered out). Identifies the true data-hosting disk.',
+    commands: [
+      "nsenter -t 1 -m -- df -hT 2>/dev/null | grep -vE '^tmpfs|^devtmpfs|^overlay|^shm'",
+      "df -hT | grep -vE '^tmpfs|^devtmpfs|^overlay|^shm'",
+    ],
+  },
+  {
+    id: 'storage-du-tree',
+    label: 'Folder drill-down',
+    group: 'Storage',
+    desc: 'Layered du drill-down — stateful partition → /var → /var/lib → containerd — to pinpoint space consumers at each level.',
+    commands: [
+      "echo '=stateful='; nsenter -t 1 -m -- du -h -d 1 /mnt/stateful_partition 2>/dev/null | sort -h -r; echo '=var='; nsenter -t 1 -m -- du -h -d 1 /mnt/stateful_partition/var 2>/dev/null | sort -h -r; echo '=varlib='; nsenter -t 1 -m -- du -h -d 1 /mnt/stateful_partition/var/lib 2>/dev/null | sort -h -r; echo '=containerd='; nsenter -t 1 -m -- du -h -d 1 /mnt/stateful_partition/var/lib/containerd 2>/dev/null | sort -h -r",
+      "echo '=stateful='; du -h -d 1 /mnt/stateful_partition 2>/dev/null | sort -h -r; echo '=var='; du -h -d 1 /mnt/stateful_partition/var 2>/dev/null | sort -h -r; echo '=varlib='; du -h -d 1 /mnt/stateful_partition/var/lib 2>/dev/null | sort -h -r; echo '=containerd='; du -h -d 1 /mnt/stateful_partition/var/lib/containerd 2>/dev/null | sort -h -r",
+      "echo '=varlib='; du -h -d 1 /var/lib 2>/dev/null | sort -h -r; echo '=containerd='; du -h -d 1 /var/lib/containerd 2>/dev/null | sort -h -r",
+    ],
+  },
+  {
+    id: 'storage-containers',
+    label: 'Top containers',
+    group: 'Storage',
+    desc: 'Ranked list of containers by disk usage. Maps containerd snapshot sizes to pod names via overlay mounts and crictl.',
+    commands: [
+      "echo '=SNAPS='; nsenter -t 1 -m -- du -d 1 /var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots 2>/dev/null | sort -rn | head -40; echo '=MOUNTS='; nsenter -t 1 -m -- mount 2>/dev/null | grep snapshots; echo '=CRICTL='; nsenter -t 1 -m -u -i -n -p -- crictl ps -a 2>/dev/null",
+      "echo '=SNAPS='; du -d 1 /var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots 2>/dev/null | sort -rn | head -40; echo '=MOUNTS='; mount 2>/dev/null | grep snapshots; echo '=CRICTL='; crictl ps -a 2>/dev/null",
+    ],
+  },
+
   // ── GPU ─────────────────────────────────────────────────────────────
   {
     id: 'gpu-info',
@@ -229,6 +262,7 @@ const PROBES = [
     commands: [
       'nvidia-smi',
       'nsenter --mount=/proc/1/ns/mnt -- nvidia-smi 2>/dev/null',
+      'echo "nvidia-smi not available — no GPU detected on this node."',
     ],
   },
   {
@@ -238,16 +272,21 @@ const PROBES = [
     desc: 'Processes currently consuming GPU memory.',
     commands: [
       'nvidia-smi --query-compute-apps=pid,used_gpu_memory,name --format=csv,noheader 2>/dev/null | sort -t, -k2 -rn | head -30',
+      'nsenter --mount=/proc/1/ns/mnt -- nvidia-smi --query-compute-apps=pid,used_gpu_memory,name --format=csv,noheader | sort -t, -k2 -rn | head -30',
       'nvidia-smi pmon -s u -c 1 2>/dev/null',
+      'nsenter --mount=/proc/1/ns/mnt -- nvidia-smi pmon -s u -c 1',
+      'echo "nvidia-smi not available — no GPU detected on this node."',
     ],
   },
   {
-    id: 'gpu-dcgm',
-    label: 'DCGM health',
+    id: 'gpu-health',
+    label: 'GPU health',
     group: 'GPU',
-    desc: 'DCGM (Data Center GPU Manager) health check. Requires dcgmi to be installed.',
+    desc: 'Per-GPU temperature, power, utilization, memory, ECC errors, and clock throttle reasons.',
     commands: [
-      'dcgmi health -g 0 -j 2>/dev/null || dcgmi health -g 0 2>/dev/null || echo "dcgmi not available — DCGM is not installed on this node."',
+      'nvidia-smi --query-gpu=index,name,temperature.gpu,temperature.memory,power.draw,power.limit,utilization.gpu,utilization.memory,memory.used,memory.free,memory.total,ecc.errors.corrected.volatile.total,ecc.errors.uncorrected.volatile.total,clocks_throttle_reasons.active --format=csv,noheader 2>/dev/null',
+      'nsenter --mount=/proc/1/ns/mnt -- nvidia-smi --query-gpu=index,name,temperature.gpu,temperature.memory,power.draw,power.limit,utilization.gpu,utilization.memory,memory.used,memory.free,memory.total,ecc.errors.corrected.volatile.total,ecc.errors.uncorrected.volatile.total,clocks_throttle_reasons.active --format=csv,noheader',
+      'echo "nvidia-smi not available — no GPU detected on this node."',
     ],
   },
 ];