@profullstack/hqtui-demo 0.1.8 → 0.1.11

package/src/screens/components.ts

@@ -103,8 +103,14 @@ export function componentsScreen(ui: Container, state: DemoState, theme: Theme):
       });
 
       left.panel({ title: "Log Viewer", size: 11 }, (p) => {
+        const clogs = pane(state, "components.logs", state.sample.logs.length, "log");
         p.log({
           entries: state.sample.logs.map((l) => ({ time: l.time, level: l.level, message: l.message, meta: `{${l.meta}}` })),
+          // Lines scrolled back from the newest; 0 keeps it tailing.
+          fromEnd: clogs.offset,
+          scrollbar: true,
+          onScroll: (delta) => scrollPane(clogs, -delta),
+          onFocus: () => focusPane(state, "components.logs"),
         });
       });
     });
@@ -115,7 +121,15 @@ export function componentsScreen(ui: Container, state: DemoState, theme: Theme):
           r.text("Name", { fg: theme.muted, bold: true });
           r.text("CPU%   MEM%", { fg: theme.muted, bold: true, align: "right" });
         });
-        p.tree({ nodes: TREE, selected: pane(state, "components.tree", 8).selected, followSelection: true });
+        const tree = pane(state, "components.tree", 8);
+        p.tree({
+          nodes: TREE,
+          selected: tree.selected,
+          offset: tree.offset,
+          followSelection: true,
+          onScroll: (delta) => scrollPane(tree, delta),
+          onFocus: () => focusPane(state, "components.tree"),
+        });
       });
 
       right.panel({ title: "Sparklines & Gauges", size: 12 }, (p) => {
@@ -142,6 +156,7 @@ export function componentsScreen(ui: Container, state: DemoState, theme: Theme):
           r.spacer("fill");
         });
         p.spacer(1);
+        const paths = pane(state, "components.list", 4);
         p.list({
           items: [
             { label: "apps/demo", color: theme.primary },
@@ -149,7 +164,12 @@ export function componentsScreen(ui: Container, state: DemoState, theme: Theme):
             { label: "apps/web" },
             { label: "docs" },
           ],
-          selected: pane(state, "components.list", 4).selected,
+          selected: paths.selected,
+          offset: paths.offset,
+          followSelection: true,
+          onScroll: (delta) => scrollPane(paths, delta),
+          onFocus: () => focusPane(state, "components.list"),
+          onSelectRow: (row) => { paths.selected = paths.offset + row; },
           bullet: "▸",
           scrollbar: true,
         });

package/src/screens/dashboard.ts

@@ -119,8 +119,10 @@ function systemPanel(ui: Container, state: DemoState, theme: Theme): void {
           q.keyValues([
             { label: "Uptime", value: duration(s.system.uptime), color: theme.accent },
             { label: "Procs", value: String(s.system.processCount || s.processes.length), color: theme.accent },
-            { label: "Threads", value: String(s.system.threadCount), color: theme.accent },
-            { label: "Ctx/s", value: `${(s.system.contextSwitches / 1000).toFixed(1)}K`, color: theme.accent },
+            { label: "Threads", value: s.system.threadCount ? String(s.system.threadCount) : "—", color: theme.accent },
+            // contextSwitches is cumulative since boot; the per-second rate is
+            // what the label claims, and what the Services screen already uses.
+            { label: "Ctx/s", value: `${(s.telemetry.kernel.contextSwitchRate / 1000).toFixed(1)}K`, color: theme.accent },
           ]);
         });
         r.panel({ title: "Memory" }, (q) => {
@@ -268,7 +270,20 @@ function sensorsPanel(ui: Container, state: DemoState, theme: Theme): void {
 
 function logsPanel(ui: Container, state: DemoState): void {
   ui.panel({ title: "Logs" }, (p) => {
-    p.log({ entries: state.sample.logs.map((l) => ({ time: l.time, level: l.level, message: l.message, meta: `{${l.meta}}` })) });
+    const logs = pane(state, "dashboard.logs", state.sample.logs.length, "log");
+    p.log({
+      entries: state.sample.logs.map((l) => ({
+        time: l.time,
+        level: l.level,
+        message: l.message,
+        meta: `{${l.meta}}`,
+      })),
+      // Lines scrolled back from the newest; 0 keeps it tailing.
+      fromEnd: logs.offset,
+      scrollbar: true,
+      onScroll: (delta) => scrollPane(logs, -delta),
+      onFocus: () => focusPane(state, "dashboard.logs"),
+    });
   });
 }
 

package/src/screens/services.ts

@@ -70,8 +70,16 @@ export function servicesScreen(ui: Container, state: DemoState, theme: Theme): v
           p.label("(docker not installed or not reachable)", { size: 1 });
           return;
         }
+        const containers = pane(state, "services.containers", t.containers.length);
         p.table({
           rows: t.containers,
+          selected: containers.selected,
+          offset: containers.offset,
+          followSelection: true,
+          scrollbar: true,
+          onScroll: (delta) => scrollPane(containers, delta),
+          onFocus: () => focusPane(state, "services.containers"),
+          onSelectRow: (row) => { containers.selected = containers.offset + row; },
           zebra: true,
           columns: [
             { key: "name", title: "Name", min: 12, color: theme.primary },
@@ -110,8 +118,16 @@ export function servicesScreen(ui: Container, state: DemoState, theme: Theme): v
       p.label("No filesystems reported.");
       return;
     }
+    const filesystems = pane(state, "services.filesystems", t.filesystems.length);
     p.table({
       rows: t.filesystems,
+      selected: filesystems.selected,
+      offset: filesystems.offset,
+      followSelection: true,
+      scrollbar: true,
+      onScroll: (delta) => scrollPane(filesystems, delta),
+      onFocus: () => focusPane(state, "services.filesystems"),
+      onSelectRow: (row) => { filesystems.selected = filesystems.offset + row; },
       zebra: true,
       columns: [
         { key: "mount", title: "Mount", min: 14, color: theme.primary },

package/src/screens/sessions.ts

@@ -12,8 +12,16 @@ export function sessionsScreen(ui: Container, state: DemoState, theme: Theme): v
         p.label("(`who` reports nothing on this host)", { size: 1 });
         return;
       }
+      const active = pane(state, "sessions.active", t.sessions.length);
       p.table({
         rows: t.sessions,
+        selected: active.selected,
+        offset: active.offset,
+        followSelection: true,
+        scrollbar: true,
+        onScroll: (delta) => scrollPane(active, delta),
+        onFocus: () => focusPane(state, "sessions.active"),
+        onSelectRow: (row) => { active.selected = active.offset + row; },
         columns: [
           { key: "user", title: "User", width: 12, color: theme.primary },
           { key: "tty", title: "TTY", width: 10 },
@@ -73,8 +81,16 @@ export function sessionsScreen(ui: Container, state: DemoState, theme: Theme): v
           p.label("(btmp is usually root-only)", { size: 1 });
           return;
         }
+        const failed = pane(state, "sessions.failed", t.failedLogins.length);
         p.table({
           rows: t.failedLogins,
+          selected: failed.selected,
+          offset: failed.offset,
+          followSelection: true,
+          scrollbar: true,
+          onScroll: (delta) => scrollPane(failed, delta),
+          onFocus: () => focusPane(state, "sessions.failed"),
+          onSelectRow: (row) => { failed.selected = failed.offset + row; },
           columns: [
             { key: "user", title: "User", width: 12, color: theme.danger },
             { key: "from", title: "From", min: 12 },

package/src/screens/traffic.ts

@@ -116,8 +116,16 @@ export function trafficScreen(ui: Container, state: DemoState, theme: Theme): vo
           { labelWidth: 5, valueWidth: 7 },
         );
         p.divider({ label: "top paths" });
+        const paths = pane(state, "traffic.paths", http.topPaths.length);
         p.table({
           rows: http.topPaths,
+          selected: paths.selected,
+          offset: paths.offset,
+          followSelection: true,
+          scrollbar: true,
+          onScroll: (delta) => scrollPane(paths, delta),
+          onFocus: () => focusPane(state, "traffic.paths"),
+          onSelectRow: (row) => { paths.selected = paths.offset + row; },
           header: false,
           columns: [
             { key: "path", title: "Path", min: 20, color: theme.primary },
@@ -167,8 +175,16 @@ export function trafficScreen(ui: Container, state: DemoState, theme: Theme): vo
           p.label("No remote peers.");
           return;
         }
+        const remotes = pane(state, "traffic.remotes", t.remotes.length);
         p.table({
           rows: t.remotes,
+          selected: remotes.selected,
+          offset: remotes.offset,
+          followSelection: true,
+          scrollbar: true,
+          onScroll: (delta) => scrollPane(remotes, delta),
+          onFocus: () => focusPane(state, "traffic.remotes"),
+          onSelectRow: (row) => { remotes.selected = remotes.offset + row; },
           zebra: true,
           columns: [
             { key: "host", title: "Host", min: 16, color: theme.accent },

package/src/state.ts

@@ -56,19 +56,24 @@ export interface Pane {
   offset: number;
   /** Row count, refreshed by the screen each frame so keys can clamp. */
   total: number;
+  /**
+   * A log has no selected row: the arrows move its window instead, and it
+   * counts backwards from the newest line rather than forwards from the first.
+   */
+  kind: "list" | "log";
 }
 
 /**
  * The cursor for one scrollable, created on first use. Screens call this while
  * drawing, which is also what registers the pane as existing.
  */
-export function pane(state: DemoState, id: string, total: number): Pane {
+export function pane(state: DemoState, id: string, total: number, kind: Pane["kind"] = "list"): Pane {
   const existing = state.panes[id];
   if (existing) {
     existing.total = total;
     return existing;
   }
-  const created: Pane = { selected: 0, offset: 0, total };
+  const created: Pane = { selected: 0, offset: 0, total, kind };
   state.panes[id] = created;
   // The first pane a screen draws is the one the arrows drive by default.
   if (!state.focused[state.screen]) state.focused[state.screen] = id;
@@ -89,7 +94,24 @@ export function focusPane(state: DemoState, id: string): void {
 export function scrollPane(p: Pane, delta: number, rows = 3): void {
   const max = Math.max(0, p.total - 1);
   p.offset = Math.max(0, Math.min(p.offset + delta * rows, max));
-  p.selected = Math.max(p.offset, Math.min(p.selected, max));
+  if (p.kind !== "log") p.selected = Math.max(p.offset, Math.min(p.selected, max));
+}
+
+/**
+ * What the arrow keys do to the focused pane. Lists move the selection and let
+ * the widget scroll to follow it; logs have nothing to select, so they move
+ * their own window.
+ */
+export function moveSelection(state: DemoState, delta: number): void {
+  const p = focusedPane(state);
+  if (!p || p.total === 0) return;
+  if (p.kind === "log") {
+    // Down means newer, which is a smaller distance from the end.
+    p.offset = Math.max(0, Math.min(p.total - 1, p.offset - delta));
+    return;
+  }
+  p.selected = Math.max(0, Math.min(p.total - 1, p.selected + delta));
+  p.offset = Math.max(0, Math.min(p.offset, Math.max(0, p.total - 1)));
 }
 
 export function createState(

package/src/system/common.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { open, stat } from "node:fs/promises";
 import { promisify } from "node:util";
 import os from "node:os";
 import type { SystemSample } from "../simulation.ts";
@@ -6,16 +7,112 @@ import { emptyTelemetry } from "./telemetry.ts";
 
 const run = promisify(execFile);
 
-/** Run a command, returning "" instead of throwing when it is unavailable. */
+/**
+ * Run a command, returning "" instead of throwing when it is unavailable.
+ *
+ * Whatever it managed to write is kept even when it exits non-zero. `df` exits
+ * 1 if any single mount is unreadable while still reporting every other one, so
+ * discarding stdout on failure zeroed the capacity of every disk on the machine
+ * whenever one stale automount or a departed removable drive was listed.
+ */
 export async function sh(command: string, args: string[], timeout = 4000): Promise<string> {
   try {
     const { stdout } = await run(command, args, { timeout, maxBuffer: 8 * 1024 * 1024 });
     return stdout;
+  } catch (error) {
+    const partial = (error as { stdout?: string }).stdout;
+    return typeof partial === "string" ? partial : "";
+  }
+}
+
+/**
+ * The last `bytes` of a file, as text.
+ *
+ * Log files are read for their tail, and reading one whole to keep 40 lines is
+ * a habit that only shows up in production: a brute-forced auth.log reaching a
+ * few hundred MB blocks the event loop for the better part of a second on every
+ * refresh, and above the maximum string length it throws and the panel silently
+ * empties.
+ */
+export async function tailFile(path: string, bytes = 256 * 1024): Promise<string> {
+  try {
+    const info = await stat(path);
+    if (info.size === 0) return "";
+    const handle = await open(path, "r");
+    try {
+      const length = Math.min(bytes, info.size);
+      const buffer = Buffer.alloc(length);
+      // `bytesRead` matters: the file can be rotated or truncated between the
+      // stat and the read, and the untouched tail of the buffer is NUL bytes.
+      const { bytesRead } = await handle.read(buffer, 0, length, Math.max(0, info.size - length));
+      return buffer.subarray(0, bytesRead).toString("utf8");
+    } finally {
+      await handle.close();
+    }
   } catch {
     return "";
   }
 }
 
+/**
+ * A process name from its command line, used when `comm` is unavailable.
+ *
+ * `args` is argv joined by spaces, so an executable whose own path contains a
+ * space is ambiguous: "/tmp/Google Chrome 60" could be argv0 "/tmp/Google"
+ * with an argument, or "/tmp/Google Chrome" with one. Nothing in the string
+ * resolves it, which is why `comm` is read separately and preferred.
+ */
+export function processName(args: string): string {
+  const argv0 = args.trim().split(/\s+/)[0] ?? "";
+  // Kernel threads are already bracketed names, not paths.
+  if (argv0.startsWith("[")) return argv0;
+  return argv0.split("/").pop() || argv0 || "-";
+}
+
+/**
+ * Reconcile the two names a process has, neither of which is reliable alone.
+ *
+ * The accounting name (`comm` on Linux, `ucomm` on macOS) keeps spaces but is
+ * truncated — to 15 bytes on Linux, 16 on macOS. The name derived from argv[0]
+ * is untruncated but splits at the first space, because `args` is argv joined
+ * by spaces and nothing in it says where argv[0] ended.
+ *
+ * So: trust argv[0], and take the accounting name only when it *extends* it —
+ * which is exactly the case where argv[0] was cut at a space. Anything else the
+ * accounting name says is not corroborated, and it is not always a name at all:
+ * on macOS `ucomm` for one live process here reads "2.1.243".
+ *
+ *   argv0 "Web"                      comm  "Web Content"      -> "Web Content"
+ *   argv0 "StorageManagementService" ucomm "StorageManagemen" -> argv0's
+ *   argv0 "claude"                   ucomm "2.1.243"          -> argv0's
+ */
+export function bestName(accounting: string | undefined, fromArgs: string): string {
+  if (!fromArgs || fromArgs === "-") return accounting || fromArgs;
+  if (!accounting) return fromArgs;
+  return accounting.length > fromArgs.length && accounting.startsWith(fromArgs)
+    ? accounting
+    : fromArgs;
+}
+
+/**
+ * pid -> accounting name, read with that name as the only free-form column so
+ * its spaces cannot shift anything. Parsing it out of a combined `ps` row is
+ * what corrupted every column after it.
+ */
+export async function processNames(psArgs: string[]): Promise<Map<number, string>> {
+  const names = new Map<number, string>();
+  const text = await sh("ps", psArgs);
+  for (const line of text.trim().split("\n").slice(1)) {
+    const trimmed = line.trim();
+    const gap = trimmed.indexOf(" ");
+    if (gap < 0) continue;
+    const pid = Number(trimmed.slice(0, gap));
+    const comm = trimmed.slice(gap + 1).trim();
+    if (Number.isFinite(pid) && comm) names.set(pid, comm);
+  }
+  return names;
+}
+
 export function push(history: number[], value: number, limit = 240): void {
   history.push(value);
   if (history.length > limit) history.shift();

package/src/system/darwin.ts

@@ -1,6 +1,8 @@
 import os from "node:os";
 import type { Collector, SystemSample } from "./types.ts";
-import { baseSample, loadAverage, primaryInterface, push, ratePerSecond, sh } from "./common.ts";
+import {
+  baseSample, loadAverage, primaryInterface, bestName, processName, processNames, push, ratePerSecond, sh,
+} from "./common.ts";
 
 /**
  * macOS has no /proc, so everything comes from small command-line tools that
@@ -8,7 +10,7 @@ import { baseSample, loadAverage, primaryInterface, push, ratePerSecond, sh } fr
  */
 export class DarwinCollector implements Collector {
   source = "macOS sysctl";
-  unavailable = ["temperatures", "fan speed"];
+  unavailable = ["temperatures", "fan speed", "per-core CPU", "thread count"];
   private sample = baseSample();
   private prevCpu: { idle: number; total: number } | null = null;
   private prevNet: [number, number] | null = null;
@@ -28,12 +30,12 @@ export class DarwinCollector implements Collector {
     }
     const load = loadAverage();
     s.cpu.load = load;
+    // `top` reports one aggregate figure. Per-core detail would need
+    // host_processor_info, so every core shows the measured total rather than
+    // a synthesised spread around it — the README promises that anything a
+    // platform cannot provide is reported as unavailable, not fabricated.
     const cores = Math.max(1, os.cpus().length);
-    s.cpu.cores = Array.from({ length: cores }, (_, i) => {
-      // Spread total load across cores with a stable per-core offset.
-      const jitter = ((i * 37) % 17) / 100;
-      return Math.max(0, Math.min(1, s.cpu.total + jitter - 0.08));
-    });
+    s.cpu.cores = new Array(cores).fill(s.cpu.total);
     push(s.cpu.history, s.cpu.total * 100);
 
     // Memory via vm_stat page counts.
@@ -133,25 +135,36 @@ export class DarwinCollector implements Collector {
   }
 
   private async updateProcesses(): Promise<void> {
-    const text = await sh("ps", ["-Ao", "pid,comm,pcpu,pmem,rss,user,state,args", "-r"]);
-    if (!text) return;
-    const lines = text.trim().split("\n").slice(1, 60);
-    this.sample.processes = lines.map((line) => {
+    // `comm` is omitted: macOS truncates it to 16 characters, so taking the
+    // last path segment yields a fragment — "/System/Applicat" became
+    // "Applicat", and a 16-character path ending in "/" became "".
+    const text = await sh("ps", ["-Ao", "pid,pcpu,pmem,rss,user,state,args", "-r"]);
+    if (!text) {
+      if (!this.unavailable.includes("processes")) this.unavailable.push("processes");
+      return;
+    }
+    // `comm` in its own read, where its spaces cannot shift a column.
+    // macOS `comm` is the full path truncated to 16 characters; `ucomm` is the
+    // accounting name, which is what a process table wants.
+    const names = await processNames(["-Ao", "pid,ucomm"]);
+    const rows = text.trim().split("\n").slice(1);
+    this.sample.processes = rows.slice(0, 59).map((line) => {
       const parts = line.trim().split(/\s+/);
-      const name = (parts[1] ?? "-").split("/").pop() ?? "-";
+      const command = parts.slice(6).join(" ");
       return {
         pid: Number(parts[0]),
-        name,
-        cpu: Number(parts[2]) || 0,
-        mem: Number(parts[3]) || 0,
-        rss: (Number(parts[4]) || 0) * 1024,
+        name: bestName(names.get(Number(parts[0])), processName(command)),
+        cpu: Number(parts[1]) || 0,
+        mem: Number(parts[2]) || 0,
+        rss: (Number(parts[3]) || 0) * 1024,
         threads: 1,
-        user: parts[5] ?? "-",
-        state: parts[6] ?? "-",
-        command: parts.slice(7).join(" "),
+        user: parts[4] ?? "-",
+        state: parts[5] ?? "-",
+        command,
       };
     });
-    this.sample.system.processCount = this.sample.processes.length;
+    // Every row, not the truncated table.
+    this.sample.system.processCount = rows.length;
   }
 
   current(): SystemSample {

package/src/system/linux-telemetry.ts

@@ -1,6 +1,6 @@
 import { readFile, readdir } from "node:fs/promises";
 import os from "node:os";
-import { sh, push } from "./common.ts";
+import { sh, push, tailFile } from "./common.ts";
 import type {
   Connection, Container, Filesystem, Interface, JournalEntry, KernelStats,
   Listener, LoginEvent, ProcessStates, PowerStats, ServiceUnit, Session, Telemetry, GpuStats,
@@ -155,6 +155,7 @@ export async function interfaces(dt: number, history: Map<string, Interface>): P
   if (!netdev) return [];
   const addresses = os.networkInterfaces();
   const out: Interface[] = [];
+  const seen = new Set<string>();
 
   for (const line of netdev.split("\n").slice(2)) {
     const match = /^\s*([\w.@-]+):\s*(.*)$/.exec(line);
@@ -172,6 +173,7 @@ export async function interfaces(dt: number, history: Map<string, Interface>): P
     const txRate = previous && txBytes >= previous[1] ? (txBytes - previous[1]) / dt : 0;
     previousInterfaces[name] = [rxBytes, txBytes];
 
+    seen.add(name);
     const address = (addresses[name] ?? []).find((a) => a.family === "IPv4");
     const existing = history.get(name);
     const entry: Interface = {
@@ -194,6 +196,16 @@ export async function interfaces(dt: number, history: Map<string, Interface>): P
     history.set(name, entry);
     out.push(entry);
   }
+  // Both maps are keyed by interface name and neither was ever pruned. On a
+  // container host the veth* names churn constantly, and each retained entry
+  // holds two 240-element history arrays — unbounded growth over an uptime.
+  for (const name of Object.keys(previousInterfaces)) {
+    if (!seen.has(name)) delete previousInterfaces[name];
+  }
+  for (const name of history.keys()) {
+    if (!seen.has(name)) history.delete(name);
+  }
+
   return out;
 }
 
@@ -542,7 +554,8 @@ export async function journal(limit = 60): Promise<JournalEntry[]> {
   }
 
   for (const path of ["/var/log/syslog", "/var/log/messages"]) {
-    const raw = await read(path);
+    // Tailed, not read whole; only the last `limit` lines are used anyway.
+    const raw = await tailFile(path);
     if (!raw) continue;
     return raw.trim().split("\n").slice(-limit).map((line) => {
       const match = /^(\w+\s+\d+\s+[\d:]+)\s+\S+\s+([^:[]+)/.exec(line);

package/src/system/linux-traffic.ts

@@ -1,6 +1,5 @@
 import { readFile, stat } from "node:fs/promises";
-import { open } from "node:fs/promises";
-import { sh } from "./common.ts";
+import { sh, tailFile } from "./common.ts";
 
 /**
  * Protocol-level visibility without root: socket classification, kernel
@@ -224,7 +223,8 @@ export async function sshEvents(limit = 40): Promise<SshEvent[]> {
   const text = await sh("journalctl", [
     "-u", "ssh", "-u", "sshd", "-n", String(limit * 2), "--no-pager", "--output=short-iso",
   ], 5000);
-  const source = text || (await read("/var/log/auth.log"));
+  // Tailed, not read whole: this file grows without bound under a brute force.
+  const source = text || (await tailFile("/var/log/auth.log"));
   if (!source) return [];
 
   const events: SshEvent[] = [];
@@ -302,17 +302,11 @@ export async function http(tailBytes = 256 * 1024): Promise<HttpStats | null> {
   }
   if (!path) return null;
 
-  let text = "";
-  try {
-    const handle = await open(path, "r");
-    const start = Math.max(0, size - tailBytes);
-    const buffer = Buffer.alloc(Math.min(tailBytes, size));
-    await handle.read(buffer, 0, buffer.length, start);
-    await handle.close();
-    text = buffer.toString("utf8");
-  } catch {
-    return null;
-  }
+  // Shares `tailFile`'s handling of a rotation between the stat and the read,
+  // which otherwise leaves the tail of the buffer as NUL bytes — and those flow
+  // into `split("\n")` and into the request-rate denominator below.
+  const text = await tailFile(path, tailBytes);
+  if (!text) return null;
 
   const lines = text.split("\n").slice(1).filter(Boolean);
   const statusClasses = new Map<string, number>();

package/src/system/linux.ts

@@ -1,7 +1,10 @@
 import { readFile, readdir } from "node:fs/promises";
 import os from "node:os";
 import type { Collector, SystemSample } from "./types.ts";
-import { baseSample, loadAverage, primaryInterface, push, ratePerSecond, sh } from "./common.ts";
+import { bitRate } from "../format.ts";
+import {
+  baseSample, loadAverage, primaryInterface, bestName, processName, processNames, push, ratePerSecond, sh,
+} from "./common.ts";
 import type { Interface } from "./telemetry.ts";
 import * as telemetry from "./linux-telemetry.ts";
 import * as traffic from "./linux-traffic.ts";
@@ -92,7 +95,7 @@ export class LinuxCollector implements Collector {
     const ctxt = /^ctxt (\d+)/m.exec(stat);
     if (ctxt) s.system.contextSwitches = Number(ctxt[1]);
     const procs = /^procs_running (\d+)/m.exec(stat);
-    if (procs) s.system.threadCount = Number(procs[1]);
+    // `procs_running` is runnable processes; the thread total comes from ps.
 
     // Memory.
     const mem = parseMeminfo(meminfo);
@@ -172,7 +175,10 @@ export class LinuxCollector implements Collector {
     s.network.downPeak = Math.max(s.network.downPeak, s.network.downRate);
     s.network.upPeak = Math.max(s.network.upPeak, s.network.upRate);
     const speed = await read(`/sys/class/net/${iface.name}/speed`);
-    s.network.speed = speed.trim() && Number(speed) > 0 ? `${Number(speed) / 1000} Gb/s` : "-";
+    // /sys reports Mb/s. Dividing unconditionally rendered a 100 Mb/s NIC as
+    // "0.1 Gb/s"; bitRate picks the unit the number belongs in.
+    const mbps = Number(speed);
+    s.network.speed = speed.trim() && mbps > 0 ? bitRate((mbps * 1e6) / 8) : "-";
 
     await Promise.all([this.updateProcesses(), this.updateTemperatures()]);
     await this.updateTelemetry(dt);
@@ -294,27 +300,39 @@ export class LinuxCollector implements Collector {
   }
 
   private async updateProcesses(): Promise<void> {
-    const text = await sh("ps", ["-eo", "pid,comm,pcpu,pmem,rss,nlwp,user,state,args", "--sort=-pcpu"]);
+    // `comm` is deliberately absent: it can contain spaces, which shifts every
+    // column parsed after it. Every field here is space-free, so `args` — which
+    // may contain anything — is the only free-form one and it comes last.
+    const text = await sh("ps", ["-eo", "pid,pcpu,pmem,rss,nlwp,user,state,args", "--sort=-pcpu"]);
     if (!text) {
       if (!this.unavailable.includes("processes")) this.unavailable.push("processes");
       return;
     }
-    const lines = text.trim().split("\n").slice(1, 60);
-    this.sample.processes = lines.map((line) => {
+    // `comm` in its own read, where its spaces cannot shift a column.
+    const names = await processNames(["-eo", "pid,comm"]);
+    const rows = text.trim().split("\n").slice(1);
+    this.sample.processes = rows.slice(0, 59).map((line) => {
       const parts = line.trim().split(/\s+/);
+      const command = parts.slice(7).join(" ");
       return {
         pid: Number(parts[0]),
-        name: parts[1] ?? "-",
-        cpu: Number(parts[2]) || 0,
-        mem: Number(parts[3]) || 0,
-        rss: (Number(parts[4]) || 0) * 1024,
-        threads: Number(parts[5]) || 1,
-        user: parts[6] ?? "-",
-        state: parts[7] ?? "-",
-        command: parts.slice(8).join(" "),
+        name: bestName(names.get(Number(parts[0])), processName(command)),
+        cpu: Number(parts[1]) || 0,
+        mem: Number(parts[2]) || 0,
+        rss: (Number(parts[3]) || 0) * 1024,
+        threads: Number(parts[4]) || 1,
+        user: parts[5] ?? "-",
+        state: parts[6] ?? "-",
+        command,
       };
     });
-    this.sample.system.processCount = this.sample.processes.length;
+    // Count every row, not the truncated table: this used to overwrite the real
+    // total from /proc with at most 59, so the figure alternated every tick.
+    this.sample.system.processCount = rows.length;
+    this.sample.system.threadCount = rows.reduce(
+      (total, line) => total + (Number(line.trim().split(/\s+/)[4]) || 0),
+      0,
+    );
   }
 
   private async updateTemperatures(): Promise<void> {