@yuuki824/kanshi 0.1.0 → 0.1.2

package/web/app.js

@@ -167,13 +167,132 @@
 
   function current() { return trail[trail.length - 1]; }
 
+  // Bars are always full width, so height is the only scarce dimension. Grow
+  // the section so even the smallest visible bar clears the label threshold,
+  // capped so one tiny outlier can't blow the section up indefinitely.
+  function treemapHeight(kids) {
+    const MIN_HEIGHT = 300, MAX_HEIGHT = 640, MIN_ROW_HEIGHT = 30;
+    if (!kids || !kids.length) return MIN_HEIGHT;
+    let total = 0, minSize = Infinity;
+    kids.forEach((d) => { total += d.size; if (d.size > 0 && d.size < minSize) minSize = d.size; });
+    if (!total || !isFinite(minSize)) return MIN_HEIGHT;
+    const needed = Math.ceil((MIN_ROW_HEIGHT * total) / minSize);
+    return Math.min(MAX_HEIGHT, Math.max(MIN_HEIGHT, needed));
+  }
+
+  // Pinned custom paths: bookmarks into the already-scanned tree, so adding one
+  // costs no server round trip and can never reach outside what was walked.
+  const PIN_KEY = "kanshi-pins";
+  function loadPins() {
+    try { return JSON.parse(localStorage.getItem(PIN_KEY)) || []; } catch (e) { return []; }
+  }
+  function savePins() { localStorage.setItem(PIN_KEY, JSON.stringify(pins)); }
+  let pins = loadPins();
+
+  // Longest matching root label wins, so "/mnt/data/x" resolves against the
+  // "/mnt/data" root rather than the "/" root that also technically contains it.
+  function bestRootForPath(path) {
+    let best = null;
+    storage.roots.forEach((r, i) => {
+      const label = r.name;
+      const matches = label === "/" ? path.indexOf("/") === 0 : (path === label || path.indexOf(label + "/") === 0);
+      if (!matches) return;
+      if (!best || label.length > best.label.length) {
+        const rest = label === "/" ? path.slice(1) : path.slice(label.length + 1);
+        best = { rootIndex: i, label: label, segs: rest.split("/").filter(Boolean) };
+      }
+    });
+    return best;
+  }
+
+  function resolvePin(pin) {
+    const idx = storage.roots.findIndex((r) => r.name === pin.root);
+    if (idx < 0) return null;
+    let node = storage.roots[idx];
+    const resTrail = [node];
+    for (const seg of pin.segs) {
+      const kids2 = node.children || [];
+      const hit = kids2.find((k) => k.name === seg);
+      if (!hit) break;
+      node = hit;
+      resTrail.push(node);
+    }
+    return { rootIndex: idx, trail: resTrail, complete: resTrail.length === pin.segs.length + 1 };
+  }
+
+  function goToPin(pin) {
+    const res = resolvePin(pin);
+    if (!res) return;
+    rootIndex = res.rootIndex;
+    trail = res.trail;
+    drawStorage();
+    if (!res.complete) {
+      $("#tm-focus").textContent = "Landed as deep as the scan reaches — the rest is below the scan depth or folded away.";
+    }
+  }
+
+  function removePin(pin) {
+    pins = pins.filter((p) => !(p.root === pin.root && p.label === pin.label));
+    savePins();
+    renderRootBar();
+  }
+
+  function flashPinError(msg) { $("#pinform-err").textContent = msg; }
+
+  function submitPin(raw) {
+    const path = raw.trim();
+    if (path.indexOf("/") !== 0) { flashPinError("Use an absolute path, e.g. /mnt/data/media"); return; }
+    const match = bestRootForPath(path);
+    if (!match) { flashPinError("No storage root covers that path"); return; }
+    const pin = { root: storage.roots[match.rootIndex].name, segs: match.segs, label: path };
+    if (!pins.some((p) => p.root === pin.root && p.label === pin.label)) {
+      pins.push(pin);
+      savePins();
+    }
+    renderRootBar();
+    goToPin(pin);
+    hidePinForm();
+  }
+
+  function showPinForm() {
+    $("#pinform-err").textContent = "";
+    $("#pinform").hidden = false;
+    $("#pinform-input").value = "";
+    $("#pinform-input").focus();
+  }
+  function hidePinForm() { $("#pinform").hidden = true; }
+
+  $("#pinform").addEventListener("submit", (ev) => {
+    ev.preventDefault();
+    submitPin($("#pinform-input").value);
+  });
+  $("#pinform-cancel").addEventListener("click", hidePinForm);
+
+  function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+  }
+
   function renderRootBar() {
-    $("#rootbar").innerHTML = storage.roots.map((r, i) =>
+    const rootChips = storage.roots.map((r, i) =>
       '<button role="tab" class="chip' + (i === rootIndex ? " is-on" : "") + '" data-i="' + i + '" type="button" aria-selected="' +
-      (i === rootIndex) + '">' + r.name + " · " + bytes(r.size) + "</button>").join("");
-    $("#rootbar").querySelectorAll("button").forEach((b) => {
+      (i === rootIndex) + '">' + escapeHtml(r.name) + " · " + bytes(r.size) + "</button>").join("");
+    const pinChips = pins.map((p, i) => {
+      const label = escapeHtml(p.label);
+      return '<span class="chip pin" data-i="' + i + '">' +
+        '<button type="button" class="pin-go" title="' + label + '">' + label + "</button>" +
+        '<button type="button" class="pin-x" aria-label="Remove pinned path">×</button></span>';
+    }).join("");
+    $("#rootbar").innerHTML = rootChips + pinChips +
+      '<button class="chip pin-add" id="pin-add" type="button">+ Add path</button>';
+    $("#rootbar").querySelectorAll("button.chip[data-i]").forEach((b) => {
       b.addEventListener("click", () => { rootIndex = +b.dataset.i; trail = [storage.roots[rootIndex]]; drawStorage(); });
     });
+    $("#rootbar").querySelectorAll(".chip.pin").forEach((span) => {
+      const pin = pins[+span.dataset.i];
+      span.querySelector(".pin-go").addEventListener("click", () => goToPin(pin));
+      span.querySelector(".pin-x").addEventListener("click", () => removePin(pin));
+    });
+    $("#pin-add").addEventListener("click", showPinForm);
   }
 
   function renderCrumbs() {
@@ -199,7 +318,30 @@
     $("#stor-meta").textContent = "";
   }
 
+  // There is nothing to compare against on the very first walk ever — no
+  // previous byte totals — so the server omits `progress` rather than
+  // shipping a meaningless 0%. The bar only appears once there is a real
+  // percentage to show.
+  function renderScanProgress() {
+    const bar = $("#scan-progress");
+    const p = storage && storage.progress;
+    if (!storage || !storage.scanning || !p) { bar.hidden = true; return; }
+    bar.hidden = false;
+    $("#scan-progress-fill").style.width = Math.min(100, p.percent) + "%";
+    $("#scan-progress-label").textContent =
+      "Scanning " + p.root + "… " + p.percent.toFixed(0) + "% · " + bytes(p.bytes_done) + " of " + bytes(p.bytes_total);
+  }
+
+  function updateRescanButton() {
+    const btn = $("#rescan");
+    const scanning = !!(storage && storage.scanning);
+    btn.disabled = scanning;
+    btn.textContent = scanning ? "Scanning…" : "Rescan";
+  }
+
   function drawStorage() {
+    renderScanProgress();
+    updateRescanButton();
     if (!storage || !storage.roots || !storage.roots.length) {
       emptyStorage(storage && storage.error
         ? "Scan failed: " + storage.error
@@ -212,7 +354,8 @@
 
     const box = svg.parentElement.getBoundingClientRect();
     const width = Math.max(200, Math.round(box.width));
-    const height = Math.round(parseFloat(getComputedStyle(svg).height)) || 300;
+    const height = treemapHeight(kids);
+    svg.style.height = height + "px";
     svg.setAttribute("height", height);
 
     Treemap.render(svg, kids, {
@@ -254,10 +397,24 @@
       ago(storage.scanned_at) + (storage.scanning ? " · rescanning…" : "") + warn;
   }
 
+  // While a walk is running the server updates its progress counters live, so
+  // poll every second instead of the normal 60s cadence — cheap, since /api/storage
+  // just reads counters rather than repeating any filesystem work. The chain
+  // stops itself the moment a poll comes back with scanning: false.
+  let scanPollTimer = null;
+  function scheduleScanPoll() {
+    clearTimeout(scanPollTimer);
+    scanPollTimer = setTimeout(async () => {
+      await loadStorage();
+      if (storage && storage.scanning) scheduleScanPoll();
+    }, 1000);
+  }
+
   async function loadStorage() {
     try {
       const res = await fetch("/api/storage");
       storage = await res.json();
+      if (storage.scanning) scheduleScanPoll();
       if (!storage.roots || !storage.roots.length) { drawStorage(); return; }
       if (rootIndex >= storage.roots.length) rootIndex = 0;
       // Re-anchor the current view onto the fresh tree so a background rescan
@@ -275,11 +432,13 @@
     } catch (err) { /* keep the previous render */ }
   }
 
+  // The rescan endpoint now starts the walk in the background and returns
+  // immediately (a full walk can run well over a minute), so the button just
+  // kicks it off and lets the 1s poll loop above carry the live percentage —
+  // it does not wait for the walk to finish.
   $("#rescan").addEventListener("click", async () => {
-    const btn = $("#rescan");
-    btn.disabled = true; btn.textContent = "Scanning…";
-    try { await fetch("/api/storage/rescan", { method: "POST" }); await loadStorage(); }
-    finally { btn.disabled = false; btn.textContent = "Rescan"; }
+    try { await fetch("/api/storage/rescan", { method: "POST" }); } catch (err) { /* next poll retries */ }
+    await loadStorage();
   });
 
   let resizeTimer;

package/web/index.html

@@ -50,7 +50,17 @@
       <h2 id="stor-h">Storage map</h2>
       <button id="rescan" class="btn" type="button">Rescan</button>
     </div>
+    <div class="scan-progress" id="scan-progress" hidden aria-live="polite">
+      <div class="meter-track"><div class="meter-fill" id="scan-progress-fill" style="width:0%"></div></div>
+      <p class="muted small" id="scan-progress-label"></p>
+    </div>
     <div class="rootbar" id="rootbar" role="tablist" aria-label="Storage root"></div>
+    <form class="pinform" id="pinform" hidden>
+      <input id="pinform-input" type="text" placeholder="/mnt/data/media/movies" autocomplete="off" spellcheck="false">
+      <button class="btn" type="submit">Go</button>
+      <button class="btn btn-quiet" type="button" id="pinform-cancel">Cancel</button>
+      <span class="pinform-err" id="pinform-err" role="alert"></span>
+    </form>
     <nav class="crumbs" id="crumbs" aria-label="Breadcrumb"></nav>
     <div class="treemap-wrap">
       <svg id="treemap" role="img" aria-labelledby="stor-h" preserveAspectRatio="none"></svg>

package/web/style.css

@@ -193,6 +193,9 @@ main { max-width: 760px; margin: 0 auto; padding: 12px 12px 28px; display: grid;
 .btn[disabled] { opacity: .5; cursor: default; }
 .btn-quiet { border-color: transparent; background: transparent; }
 
+.scan-progress { margin-bottom: 10px; }
+.scan-progress p { margin: 5px 0 0; }
+
 .rootbar, .sortbar { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 10px; }
 .chip {
   font: inherit; font-size: 12px; padding: 5px 11px; min-height: 30px;
@@ -204,6 +207,30 @@ main { max-width: 760px; margin: 0 auto; padding: 12px 12px 28px; display: grid;
    over-wide item, so each chip truncates at the container's width. */
 .rootbar .chip { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 
+/* Pinned custom paths: a chip made of two buttons (jump, remove) rather than
+   one, so the base .chip padding has to move onto the inner buttons. */
+.chip.pin { display: inline-flex; align-items: center; gap: 0; padding: 0; max-width: 100%; }
+.chip.pin .pin-go {
+  font: inherit; font-size: 12px; padding: 5px 4px 5px 11px; border: 0;
+  background: transparent; color: var(--text-muted); cursor: pointer;
+  max-width: 220px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.chip.pin .pin-x {
+  font: inherit; font-size: 13px; line-height: 1; padding: 5px 10px 5px 4px;
+  border: 0; background: transparent; color: var(--text-muted); cursor: pointer;
+}
+.chip.pin .pin-x:hover { color: var(--status-critical); }
+.chip.pin-add { cursor: pointer; }
+
+.pinform { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin: -2px 0 10px; }
+.pinform[hidden] { display: none; }
+.pinform input {
+  font: inherit; font-size: 13px; flex: 1 1 220px; min-width: 0;
+  padding: 6px 10px; border-radius: 8px; border: 1px solid var(--border);
+  background: var(--surface-1); color: var(--text-primary);
+}
+.pinform-err { flex: 1 0 100%; font-size: 12px; color: var(--status-critical); }
+
 /* ── Breadcrumb ──────────────────────────────────────────────────────────── */
 .crumbs { display: flex; flex-wrap: wrap; align-items: center; gap: 2px; margin-bottom: 8px; font-size: 12px; }
 .crumbs button {

package/web/treemap.js

@@ -1,9 +1,12 @@
-/* Squarified treemap, ~120 lines of SVG. No charting library: the whole point
- * of this app is to have no external dependencies.
+/* Full-width stacked bars, ~90 lines of SVG. No charting library: the whole
+ * point of this app is to have no external dependencies.
  *
- * Bruls/Huizing/van Wijk squarified layout — greedily fills rows along the
- * short side, keeping each tile as close to square as it can, so tiles stay
- * tappable on a phone instead of degenerating into slivers. */
+ * Each item is a bar spanning the full width, stacked top to bottom, height
+ * proportional to its byte share. A squarified 2D treemap packs a dominant
+ * item into a near-square block and leaves the rest a sliver whose width is
+ * fixed by that item's share — no matter how tall the section grows, a 2%
+ * item stays too narrow for its name. Giving every bar the full width means
+ * only height is ever scarce, and the section can grow to make room for it. */
 (function (global) {
   "use strict";
 
@@ -12,63 +15,18 @@
   const RADIUS = 3;
   const GLYPH = { dir: "▸", file: "·", rest: "⋯" };
 
-  function worstRatio(row, rowSum, shortSide, scale) {
-    if (!row.length) return Infinity;
-    const s = rowSum * scale;
-    if (s <= 0) return Infinity;
-    const max = row[0].size * scale;
-    const min = row[row.length - 1].size * scale;
-    const sq = shortSide * shortSide;
-    return Math.max((sq * max) / (s * s), (s * s) / (sq * min));
-  }
-
-  function squarify(items, x, y, w, h) {
+  function layoutRows(items, w, h) {
     const out = [];
-    let remaining = items.filter((d) => d.size > 0).slice().sort((a, b) => b.size - a.size);
-
-    while (remaining.length && w > 0.5 && h > 0.5) {
-      let totalRem = 0;
-      for (const item of remaining) totalRem += item.size;
-      if (totalRem <= 0) break;
-
-      const scale = (w * h) / totalRem;
-      const shortSide = Math.min(w, h);
-      const row = [];
-      let rowSum = 0;
-      let prevWorst = Infinity;
-
-      while (remaining.length) {
-        const candidate = remaining[0];
-        const nextSum = rowSum + candidate.size;
-        const ratio = worstRatio(row.concat([candidate]), nextSum, shortSide, scale);
-        // Adding this tile is only worth it while it makes the row *less* oblong.
-        if (row.length === 0 || ratio <= prevWorst) {
-          row.push(remaining.shift());
-          rowSum = nextSum;
-          prevWorst = ratio;
-        } else break;
-      }
-
-      const rowArea = rowSum * scale;
-      if (w >= h) {
-        const rw = rowArea / h;
-        let cy = y;
-        for (const item of row) {
-          const rh = (item.size * scale) / rw;
-          out.push({ item: item, x: x, y: cy, w: rw, h: rh });
-          cy += rh;
-        }
-        x += rw; w -= rw;
-      } else {
-        const rh = rowArea / w;
-        let cx = x;
-        for (const item of row) {
-          const rw = (item.size * scale) / rh;
-          out.push({ item: item, x: cx, y: y, w: rw, h: rh });
-          cx += rw;
-        }
-        y += rh; h -= rh;
-      }
+    const list = items.filter((d) => d.size > 0).slice().sort((a, b) => b.size - a.size);
+    let total = 0;
+    for (const item of list) total += item.size;
+    if (total <= 0) return out;
+
+    let y = 0;
+    for (const item of list) {
+      const rh = (item.size / total) * h;
+      out.push({ item: item, x: 0, y: y, w: w, h: rh });
+      y += rh;
     }
     return out;
   }
@@ -114,7 +72,7 @@
       return;
     }
 
-    const placed = squarify(children, 0, 0, W, H);
+    const placed = layoutRows(children, W, H);
     const pending = [];   // labels to measure once they are in the document
 
     for (const cell of placed) {
@@ -184,5 +142,5 @@
     for (const entry of pending) fitLabel(entry);
   }
 
-  global.Treemap = { render: render, squarify: squarify };
+  global.Treemap = { render: render, layoutRows: layoutRows };
 })(window);

package/app/config.py

@@ -1,72 +0,0 @@
-"""Runtime configuration, all via environment variables.
-
-Defaults are deliberately conservative: this box has 4 cores and ~28 other
-containers, so Kanshi should be invisible in `docker stats`.
-"""
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass, field
-
-
-def _int(name: str, default: int) -> int:
-    try:
-        return int(os.environ.get(name, "") or default)
-    except ValueError:
-        return default
-
-
-def _float(name: str, default: float) -> float:
-    try:
-        return float(os.environ.get(name, "") or default)
-    except ValueError:
-        return default
-
-
-def _list(name: str, default: str) -> list[str]:
-    raw = os.environ.get(name, "") or default
-    return [p.strip() for p in raw.split(",") if p.strip()]
-
-
-@dataclass(frozen=True)
-class Config:
-    # How often the live poller samples vitals + container stats, in seconds.
-    poll_interval: float = field(default_factory=lambda: _float("KANSHI_POLL_INTERVAL", 5.0))
-
-    # Stop polling entirely once no browser has been connected for this long.
-    # Nobody is looking, so there is no reason to keep waking the Docker daemon.
-    idle_timeout: float = field(default_factory=lambda: _float("KANSHI_IDLE_TIMEOUT", 30.0))
-
-    # Max concurrent /stats requests against the Docker socket per tick.
-    docker_concurrency: int = field(default_factory=lambda: _int("KANSHI_DOCKER_CONCURRENCY", 8))
-    docker_socket: str = field(default_factory=lambda: os.environ.get("KANSHI_DOCKER_SOCKET", "/var/run/docker.sock"))
-
-    # Storage walk. Roots are "label=path" or just "path".
-    storage_roots: list[str] = field(default_factory=lambda: _list("KANSHI_STORAGE_ROOTS", "/mnt/data=/mnt/data,/=/hostfs"))
-    storage_interval: float = field(default_factory=lambda: _float("KANSHI_STORAGE_INTERVAL", 1800.0))
-    # Absolute container-side paths to skip entirely. Their bytes vanish from
-    # the totals, so only exclude things you truly don't want counted.
-    storage_exclude: list[str] = field(default_factory=lambda: _list("KANSHI_STORAGE_EXCLUDE", ""))
-    storage_min_rescan: float = field(default_factory=lambda: _float("KANSHI_STORAGE_MIN_RESCAN", 30.0))
-
-    # Tree pruning, to keep the JSON the phone downloads small.
-    tree_depth: int = field(default_factory=lambda: _int("KANSHI_TREE_DEPTH", 4))
-    # Children smaller than this fraction of their parent are folded into an
-    # aggregate node rather than shipped individually.
-    tree_min_fraction: float = field(default_factory=lambda: _float("KANSHI_TREE_MIN_FRACTION", 0.005))
-    tree_max_children: int = field(default_factory=lambda: _int("KANSHI_TREE_MAX_CHILDREN", 24))
-
-    host: str = field(default_factory=lambda: os.environ.get("KANSHI_HOST", "0.0.0.0"))
-    port: int = field(default_factory=lambda: _int("KANSHI_PORT", 8100))
-
-    def roots(self) -> list[tuple[str, str]]:
-        out: list[tuple[str, str]] = []
-        for entry in self.storage_roots:
-            label, _, path = entry.partition("=")
-            if not path:
-                label, path = os.path.basename(label.rstrip("/")) or label, label
-            out.append((label, path))
-        return out
-
-
-config = Config()

package/app/dockerstats.py

@@ -1,207 +0,0 @@
-"""Docker Engine API client over the unix socket.
-
-Uses `GET /containers/{id}/stats?stream=false&one-shot=true`. The one-shot form
-returns immediately; without it the daemon blocks each request for a full
-collection cycle to produce `precpu_stats`, which measured 8.3s per tick across
-31 containers versus 0.07s here.
-
-The tradeoff is that one-shot zeroes `precpu_stats`, so CPU% is computed against
-the previous tick's counters instead — the same thing the daemon would have
-done, just over the poll interval rather than a 1s window. That is also a
-steadier number to read at a glance.
-"""
-from __future__ import annotations
-
-import asyncio
-import time
-
-import httpx
-
-from .config import config
-
-API_VERSION = "v1.43"
-
-_prev_net: dict[str, tuple[float, int, int]] = {}
-_prev_cpu: dict[str, tuple[int, int]] = {}   # cid -> (total_usage, system_usage)
-_client: httpx.AsyncClient | None = None
-
-
-def client() -> httpx.AsyncClient:
-    global _client
-    if _client is None:
-        _client = httpx.AsyncClient(
-            transport=httpx.AsyncHTTPTransport(uds=config.docker_socket, retries=1),
-            base_url=f"http://docker/{API_VERSION}",
-            timeout=httpx.Timeout(20.0, connect=5.0),
-        )
-    return _client
-
-
-async def close() -> None:
-    global _client
-    if _client is not None:
-        await _client.aclose()
-        _client = None
-
-
-def _cpu_percent(cid: str, stats: dict) -> float:
-    """CPU% against the previous tick. 100% = one full core, as `docker stats`."""
-    cpu = stats.get("cpu_stats") or {}
-    usage = (cpu.get("cpu_usage") or {}).get("total_usage")
-    system = cpu.get("system_cpu_usage")
-    if usage is None or system is None:
-        return 0.0
-
-    prev = _prev_cpu.get(cid)
-    _prev_cpu[cid] = (usage, system)
-    if prev is None:
-        return 0.0  # first sighting; the next tick has a real delta
-
-    cpu_delta = usage - prev[0]
-    sys_delta = system - prev[1]
-    # A restarted container resets its counters — report 0 rather than a
-    # nonsensical negative or a huge spike.
-    if sys_delta <= 0 or cpu_delta < 0:
-        return 0.0
-    # online_cpus is absent on older daemons; fall back to the per-cpu array.
-    ncpu = cpu.get("online_cpus") or len((cpu.get("cpu_usage") or {}).get("percpu_usage") or []) or 1
-    return round(min(cpu_delta / sys_delta * ncpu * 100.0, ncpu * 100.0), 2)
-
-
-def _memory(stats: dict) -> tuple[int, int]:
-    mem = stats.get("memory_stats") or {}
-    usage = mem.get("usage")
-    if usage is None:
-        return (0, 0)
-    detail = mem.get("stats") or {}
-    # Match `docker stats`: subtract page cache so the number reflects the
-    # working set. cgroup v2 exposes inactive_file, v1 exposes cache.
-    if "inactive_file" in detail:
-        usage -= min(detail["inactive_file"], usage)
-    elif "cache" in detail:
-        usage -= min(detail["cache"], usage)
-    return (usage, mem.get("limit") or 0)
-
-
-def _network(cid: str, stats: dict, now: float) -> dict | None:
-    networks = stats.get("networks")
-    if not networks:
-        # Containers on `network_mode: service:...` (e.g. behind gluetun) report
-        # no interfaces of their own — their traffic shows up on the provider.
-        _prev_net.pop(cid, None)
-        return None
-    rx = sum(n.get("rx_bytes", 0) for n in networks.values())
-    tx = sum(n.get("tx_bytes", 0) for n in networks.values())
-    prev = _prev_net.get(cid)
-    _prev_net[cid] = (now, rx, tx)
-    rate_rx = rate_tx = 0.0
-    if prev and now > prev[0]:
-        dt = now - prev[0]
-        # A restarted container resets its counters; clamp instead of going negative.
-        rate_rx = max(0, rx - prev[1]) / dt
-        rate_tx = max(0, tx - prev[2]) / dt
-    return {"rx": rx, "tx": tx, "rx_rate": rate_rx, "tx_rate": rate_tx}
-
-
-def _block_io(stats: dict) -> dict | None:
-    entries = (stats.get("blkio_stats") or {}).get("io_service_bytes_recursive")
-    if not entries:
-        return None  # commonly empty under cgroup v2
-    read = sum(e.get("value", 0) for e in entries if e.get("op", "").lower() == "read")
-    write = sum(e.get("value", 0) for e in entries if e.get("op", "").lower() == "write")
-    return {"read": read, "write": write}
-
-
-def _identify(meta: dict) -> tuple[str, str, str]:
-    """(full name, display name, project).
-
-    Runtipi names containers `<project>-<service>-1`, so at phone width three
-    Immich containers all truncate to the same "immich_migra…". The compose
-    labels carry the service name on its own, which is what actually
-    distinguishes them.
-    """
-    full = (meta.get("Names") or ["/?"])[0].lstrip("/")
-    labels = meta.get("Labels") or {}
-    service = labels.get("com.docker.compose.service") or ""
-    project = labels.get("com.docker.compose.project") or ""
-    return full, (service or full), project
-
-
-async def _one(cid: str, meta: dict, sem: asyncio.Semaphore) -> dict | None:
-    async with sem:
-        try:
-            r = await client().get(f"/containers/{cid}/stats", params={"stream": "false", "one-shot": "true"})
-            r.raise_for_status()
-            stats = r.json()
-        except Exception:
-            return None
-    now = time.monotonic()
-    used, limit = _memory(stats)
-    full, name, project = _identify(meta)
-    state = meta.get("State", "")
-    health = ((meta.get("Status") or "").split("(")[-1].rstrip(")") if "(" in (meta.get("Status") or "") else None)
-    return {
-        "id": cid[:12],
-        "name": name,
-        "full_name": full,
-        "project": project,
-        "image": meta.get("Image", ""),
-        "state": state,
-        "status": meta.get("Status", ""),
-        "health": health if health in ("healthy", "unhealthy", "health: starting", "starting") else None,
-        "created": meta.get("Created", 0),
-        "cpu": _cpu_percent(cid, stats),
-        "mem_used": used,
-        "mem_limit": limit,
-        "mem_percent": round(used / limit * 100, 2) if limit else 0.0,
-        "pids": (stats.get("pids_stats") or {}).get("current", 0),
-        "net": _network(cid, stats, now),
-        "blkio": _block_io(stats),
-    }
-
-
-async def sample() -> dict:
-    """One full pass: list containers, then fetch stats for the running ones."""
-    try:
-        r = await client().get("/containers/json", params={"all": "true"})
-        r.raise_for_status()
-        listing = r.json()
-    except Exception as exc:
-        return {"error": f"{type(exc).__name__}: {exc}", "containers": []}
-
-    running = [c for c in listing if c.get("State") == "running"]
-    sem = asyncio.Semaphore(max(1, config.docker_concurrency))
-    results = await asyncio.gather(*(_one(c["Id"], c, sem) for c in running))
-    containers = [c for c in results if c]
-
-    # Keep stopped containers visible but without stats, so a crashed service
-    # is obvious at a glance rather than silently missing from the list.
-    for c in listing:
-        if c.get("State") != "running":
-            full, name, project = _identify(c)
-            containers.append({
-                "id": c["Id"][:12],
-                "name": name,
-                "full_name": full,
-                "project": project,
-                "image": c.get("Image", ""),
-                "state": c.get("State", ""),
-                "status": c.get("Status", ""),
-                "health": None,
-                "created": c.get("Created", 0),
-                "cpu": 0.0, "mem_used": 0, "mem_limit": 0, "mem_percent": 0.0,
-                "pids": 0, "net": None, "blkio": None,
-            })
-
-    live = {c["Id"] for c in running}
-    for stale in [k for k in _prev_net if k not in live]:
-        _prev_net.pop(stale, None)
-    for stale in [k for k in _prev_cpu if k not in live]:
-        _prev_cpu.pop(stale, None)
-
-    containers.sort(key=lambda c: (c["state"] != "running", -c["cpu"], c["name"]))
-    return {
-        "containers": containers,
-        "running": len(running),
-        "total": len(listing),
-    }