@gtadi/k8s-node-debugger 1.0.2 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtadi/k8s-node-debugger",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "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,6 +251,7 @@ 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([
@@ -257,6 +259,7 @@ const FANCY_PROBES = new Set([
   '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) {
@@ -384,11 +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),
-    'gpu-info':        () => renderGpuInfoView(output, container),
-    'gpu-health':      () => renderGpuHealthView(output, container),
-    'gpu-processes':   () => renderGpuProcessesView(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; }
@@ -522,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);
@@ -533,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

@@ -860,6 +860,291 @@
     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|WRITABLE|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. Writable snapshots (have a work/ dir) = container layers (running or stopped).
+    //    Image cache layers do NOT have work/ dirs. This lets us classify unmapped snaps.
+    const writableSnaps = new Set((sections.WRITABLE || []).map(l => l.trim()).filter(Boolean));
+
+    // 3. 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);
+      }
+    }
+
+    // 4. 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);
+      }
+    }
+
+    // 5. 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;
+        const isWritable = writableSnaps.has(snapId);
+        return { snapId, kb, hash, info, isWritable };
+      });
+
+    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 stoppedCount = rows.filter(r => !r.info && r.isWritable).length;
+    const imageCount   = rows.filter(r => !r.info && !r.isWritable).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' : '';
+
+      // Determine label for unmapped snapshots using the work/ dir heuristic
+      let podLabel, nameLabel, stateTag, typeTag = '';
+      if (r.info) {
+        podLabel  = r.info.pod || r.info.name;
+        nameLabel = r.info.name !== r.info.pod ? r.info.name : '';
+        stateTag  = r.info.state
+          ? `<span class="st-cont-state ${stateCls}">${h(r.info.state)}</span>` : '';
+      } else if (r.isWritable) {
+        podLabel  = r.hash ? r.hash.substring(0, 20) + '…' : 'unknown container';
+        nameLabel = '';
+        stateTag  = '<span class="st-cont-state hv-warn">Stopped</span>';
+        typeTag   = '<span class="st-cont-type-tag st-tag-stopped">stopped container</span>';
+      } else {
+        podLabel  = 'image cache layer';
+        nameLabel = '';
+        stateTag  = '';
+        typeTag   = '<span class="st-cont-type-tag st-tag-image">image layer</span>';
+      }
+
+      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>
+            ${stateTag}
+            ${typeTag}
+            <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>` : ''}
+          </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">Total snapshot storage</div>
+          <div class="hv-grid-val">${hBytes(totalKb)}</div>
+        </div>
+        <div class="hv-grid-item">
+          <div class="hv-grid-label">Running pods (top ${rows.length})</div>
+          <div class="hv-grid-val" style="color:var(--ok)">${mappedCount}</div>
+        </div>
+        <div class="hv-grid-item">
+          <div class="hv-grid-label">Stopped containers</div>
+          <div class="hv-grid-val" style="color:#d29922">${stoppedCount}</div>
+        </div>
+        <div class="hv-grid-item">
+          <div class="hv-grid-label">Image cache layers</div>
+          <div class="hv-grid-val" style="color:var(--fg-dim)">${imageCount}</div>
+        </div>
+      </div>
+      <div class="st-cont-list">${listHtml}</div>`;
+
+    container.innerHTML = '';
+    container.className = '';
+    container.appendChild(wrap);
+  }
+
   /* ── Exports ─────────────────────────────────────────────────────────── */
   window.renderMemInfoView     = renderMemInfoView;
   window.renderMemPressureView = renderMemPressureView;
@@ -867,8 +1152,11 @@
   window.renderKubeletLogsView = renderKubeletLogsView;
   window.renderDiskView        = renderDiskView;
   window.renderCpuView         = renderCpuView;
-  window.renderGpuInfoView         = renderGpuInfoView;
-  window.renderGpuHealthView       = renderGpuHealthView;
-  window.renderGpuProcessesView    = renderGpuProcessesView;
+  window.renderGpuInfoView              = renderGpuInfoView;
+  window.renderGpuHealthView            = renderGpuHealthView;
+  window.renderGpuProcessesView         = renderGpuProcessesView;
+  window.renderStoragePartitionsView    = renderStoragePartitionsView;
+  window.renderStorageDuTreeView        = renderStorageDuTreeView;
+  window.renderStorageContainersView    = renderStorageContainersView;
 
 })();

package/public/style.css

@@ -914,3 +914,95 @@ kbd {
 .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;
+}
+.st-cont-type-tag {
+  font-size: 10px; font-weight: 700; font-family: var(--mono);
+  padding: 2px 7px; border-radius: 4px; flex-shrink: 0;
+  text-transform: uppercase; letter-spacing: .04em;
+}
+.st-tag-stopped { background: #2b2000; color: #d29922; border: 1px solid #5a4500; }
+.st-tag-image   { background: var(--bg-3); color: var(--fg-dim); border: 1px solid var(--border); }

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; echo '=WRITABLE='; ls -d /var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots/*/work 2>/dev/null | sed 's|.*/snapshots/||;s|/work||'; 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; echo '=WRITABLE='; ls -d /var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots/*/work 2>/dev/null | sed 's|.*/snapshots/||;s|/work||'; echo '=MOUNTS='; mount 2>/dev/null | grep snapshots; echo '=CRICTL='; crictl ps -a 2>/dev/null",
+    ],
+  },
+
   // ── GPU ─────────────────────────────────────────────────────────────
   {
     id: 'gpu-info',