@gtadi/k8s-node-debugger 1.0.1 → 1.0.2

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.0.2",
   "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

@@ -256,6 +256,7 @@ 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',
 ]);
 
 function buildProbePanel(probe) {
@@ -385,6 +386,9 @@ function tryFancyRender(id, output, container) {
     'kubelet-logs':    () => renderKubeletLogsView(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),
   };
   if (!renderers[id]) return false;
   try { renderers[id](); return true; } catch (e) { console.error('[fancy render]', id, e); return false; }

package/public/health-view.js

@@ -451,6 +451,415 @@
     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);
+  }
+
   /* ── Exports ─────────────────────────────────────────────────────────── */
   window.renderMemInfoView     = renderMemInfoView;
   window.renderMemPressureView = renderMemPressureView;
@@ -458,5 +867,8 @@
   window.renderKubeletLogsView = renderKubeletLogsView;
   window.renderDiskView        = renderDiskView;
   window.renderCpuView         = renderCpuView;
+  window.renderGpuInfoView         = renderGpuInfoView;
+  window.renderGpuHealthView       = renderGpuHealthView;
+  window.renderGpuProcessesView    = renderGpuProcessesView;
 
 })();

package/public/style.css

@@ -864,3 +864,53 @@ 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); }

package/src/probes.js

@@ -229,6 +229,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 +239,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."',
     ],
   },
 ];