pyre-cli 9.5.0 → 9.5.2

package/README.md

@@ -1,6 +1,6 @@
 # pyre
 
-Mac system monitoring CLI: temps, CPU, memory, disk, battery, GPU, power draw, live dashboard, packet monitor, process management, export, alerts, P2P live data streaming, web dashboard, SSH monitoring, and micro-benchmarking.
+Mac system monitoring CLI: temps, CPU, memory, disk, battery, GPU, power draw, live dashboard, packet monitor, process management, export, alerts, P2P live data streaming, web dashboard, SSH monitoring, micro-benchmarking, and Blender render tracking.
 
 ![Version](https://img.shields.io/badge/version-5.0.0-blue)
 ![macOS](https://img.shields.io/badge/macos-14%2B-lightgrey)
@@ -21,6 +21,7 @@ Mac system monitoring CLI: temps, CPU, memory, disk, battery, GPU, power draw, l
 - **Disk I/O throughput & space** — read/write speed per volume and mounted volume space usage
 - **Battery & power health** — level, power source, condition, charge cycles, max capacity, health trends, estimated time to empty, discharge rate, power draw in watts
 - **Packet monitor** — network packet counts, packet rates, active TCP connections, top network processes
+- **Advanced network monitoring** — real-time bandwidth rates (RX/TX bytes/sec), protocol breakdown (TCP/UDP), connection state analysis (ESTABLISHED, LISTENING, TIME_WAIT, CLOSE_WAIT), listening port detection, top remote hosts, per-process network I/O tracking, and GlassWire-style modern TUI panel with sparkline graphs
 - **Task list** — running tasks/applications sorted by CPU with PID, user, memory, state, and runtime
 - **Thermal state** — CPU temperature via `pmset` and `powermetrics` (sudo for detailed readings)
 - **Network** — RX/TX bytes and per-second rates
@@ -28,6 +29,7 @@ Mac system monitoring CLI: temps, CPU, memory, disk, battery, GPU, power draw, l
 - **Interactive live dashboard** — full-screen TUI with keyboard-driven controls, mouse support, configurable panel layout, and tab-based panel navigation
 - **Snapshot export** — JSON, CSV, TSV, HTML, or Markdown output formats
 - **Continuous CSV logging & Anomaly Digest** — automatic per-tick logging and statistical spike analysis (`pyre anomalies`)
+- **Blender render tracking** — automatically detects running Blender background renders, tracks elapsed time, frame progress, completion percentage, render engine, and blend file; fully loggable via CSV/JSON/Markdown exports
 - **Visual themes & custom themes** — six built-in color themes plus user-defined JSON theme support in `~/.config/pyre/themes/`
 - **Persistent configuration & Profiles** — save themes and thresholds in `~/.config/pyre/config.json`, plus atomic profile management (`pyre profile`)
 - **Alert system & webhooks** — configurable threshold alerts with terminal bell, desktop notifications, webhook POST payload execution (`--webhook-url`), and custom shell command execution (`--alert-cmd`)
@@ -132,6 +134,7 @@ These options apply to both static snapshots and `pyre live`, except where noted
 | `pyre doctor` | Run system diagnostics (permissions, Gatekeeper, SIP, XProtect, P2P network) |
 | `pyre extensions` | System Extensions inspector (`systemextensionsctl list`) |
 | `pyre brew` | Homebrew health panel (installed formulae, outdated count, Cellar disk size, doctor summary) |
+| `pyre blender` | Track active Blender background renders: PID, blend file, engine, frame progress, elapsed time, and completion status |
 | `pyre update` | Check npm registry for latest `pyre-cli` release |
 | `pyre profile <save\|load\|list> [name]` | Atomic configuration profile management (`~/.config/pyre/profiles/`) |
 | `pyre config <show\|reset>` | View or reset persistent configuration file (`~/.config/pyre/config.json`) |
@@ -314,6 +317,8 @@ Run with `pyre live`.
 | `←` / `→` / `Tab` | Cycle to previous / next panel tab |
 | `1`–`9`, `0` | Jump to panel by number (cpu, mem, gpu, power, battery, thermal, network, packets, tasks, disk) |
 | `P` | Toggle process panel |
+| `C` | Toggle containers panel |
+| `B` | Toggle Blender render tracker panel |
 | `Esc` | Close customizer or clear filter/kill input |
 
 ### UI Customizer
@@ -321,7 +326,7 @@ Run with `pyre live`.
 Press `c` to open the customizer overlay. From there:
 
 - Cycle through six built-in themes (Default, Dracula, Cyberpunk, Monochrome, Nord, Gruvbox) — `↑`/`↓` or `j`/`k` to navigate, `Enter`/`Space` to select
-- Toggle individual panels (CPU, Memory, GPU, Power, Battery, Thermal, Network, Packets, Tasks, Disk, Processes) on or off
+- Toggle individual panels (CPU, Memory, GPU, Power, Battery, Thermal, Network, Packets, Tasks, Disk, Processes, Containers, Blender) on or off
 - Switch graph mode between sparkline and bar charts
 - Toggle process tree view
 - Toggle temperature unit between Celsius and Fahrenheit
@@ -440,6 +445,14 @@ timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,net_rx_pa
 - **Node.js 18+**
 - **Optional:** `sudo` for `powermetrics` detailed temperatures in `--detailed` mode
 
+  To enable password‑less access for `powermetrics` (required for accurate sensor readings), run:
+
+  ```bash
+  echo "$(whoami) ALL=(root) NOPASSWD: /usr/bin/powermetrics" | sudo tee /etc/sudoers.d/pyre-powermetrics
+  ```
+
+  This adds a single sudoers entry granting `pyre` the ability to execute `powermetrics` without a password prompt. Remove it later with `sudo rm /etc/sudoers.d/pyre-powermetrics`.
+
 ## Project Structure
 
 ```

package/dist/blender-7UT5J7IP.js

@@ -0,0 +1,7 @@
+import {
+  collectBlenderRenders
+} from "./chunk-25I533OF.js";
+import "./chunk-FH5WDJBF.js";
+export {
+  collectBlenderRenders
+};

package/dist/{checkCmd-ULNENOPZ.js → checkCmd-T7O4KXXA.js}

@@ -1,10 +1,11 @@
 import {
   formatBytes
-} from "./chunk-MOAEGMFP.js";
-import "./chunk-SG26Y3WF.js";
+} from "./chunk-3TE7MJLS.js";
+import "./chunk-IM3IQMMT.js";
 import {
   collectAll
-} from "./chunk-PV4MXTAJ.js";
+} from "./chunk-N4WJVF5M.js";
+import "./chunk-25I533OF.js";
 import "./chunk-FH5WDJBF.js";
 
 // src/checkCmd.ts

package/dist/chunk-25I533OF.js

@@ -0,0 +1,133 @@
+import {
+  run
+} from "./chunk-FH5WDJBF.js";
+
+// src/monitors/blender.ts
+var RENDER_LOG_DIR = "/tmp/blender_render_logs";
+function blendFileFromArgs(args) {
+  const nonFlag = args.filter((a) => !a.startsWith("-"));
+  for (const a of nonFlag) {
+    if (a.endsWith(".blend") || a.includes(".blend")) {
+      return a.split("/").pop() || a;
+    }
+  }
+  return "unknown.blend";
+}
+function engineFromArgs(args) {
+  const idx = args.indexOf("-E");
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  const flag = args.find((a) => a.startsWith("-E="));
+  if (flag) return flag.slice(3);
+  return "unknown";
+}
+function outputPathFromArgs(args) {
+  const oIdx = args.indexOf("-o");
+  if (oIdx !== -1 && args[oIdx + 1]) {
+    let p = args[oIdx + 1];
+    if (p.endsWith("/")) p = p.slice(0, -1);
+    return p.split("/").slice(0, -1).join("/") || "/tmp";
+  }
+  const fFlag = args.find((a) => a.startsWith("-o="));
+  if (fFlag) {
+    const p = fFlag.slice(3);
+    return p.endsWith("/") ? p.slice(0, -1).split("/").slice(0, -1).join("/") || "/tmp" : p.split("/").slice(0, -1).join("/") || "/tmp";
+  }
+  return "/tmp";
+}
+function frameRangeFromArgs(args) {
+  const fIdx = args.indexOf("-f");
+  if (fIdx !== -1 && args[fIdx + 1]) {
+    const raw = args[fIdx + 1];
+    if (raw.includes("..")) {
+      const [s, e] = raw.split("..").map(Number);
+      if (!isNaN(s) && !isNaN(e)) return { start: s, end: e };
+    }
+    const n = parseInt(raw, 10);
+    if (!isNaN(n)) return { start: n, end: n };
+  }
+  const sFlag = args.find((a) => a.startsWith("-s="));
+  const eFlag = args.find((a) => a.startsWith("-e="));
+  const start = sFlag ? parseInt(sFlag.slice(3), 10) : 1;
+  const end = eFlag ? parseInt(eFlag.slice(3), 10) : 250;
+  return { start: isNaN(start) ? 1 : start, end: isNaN(end) ? 250 : end };
+}
+async function parseRenderLog(blendName) {
+  const baseName = blendName.replace(/\.blend$/i, "");
+  try {
+    const entries = (await run(`ls -t "${RENDER_LOG_DIR}" 2>/dev/null | grep "^${baseName}_" | head -5`, "")).trim().split("\n").filter(Boolean);
+    for (const entry of entries) {
+      const logPath = `${RENDER_LOG_DIR}/${entry}`;
+      try {
+        const content = await run(`cat "${logPath}" 2>/dev/null`, "", 500);
+        if (!content) continue;
+        const lines = content.split("\n");
+        const rendered = lines.filter((l) => /Fra:(\d+)/i.test(l)).length;
+        const totalMatch = content.match(/Fra:\s*\d+\s*\/\s*(\d+)/);
+        const totalFrames = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+        const startMatch = content.match(/^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/m);
+        const startTime = startMatch ? new Date(startMatch[1]).getTime() : Date.now() - 6e4;
+        const sampleMatch = content.match(/Sample\s*(\d+)/i);
+        if (rendered > 0) {
+          return { framesRendered: rendered, totalFrames: totalFrames || rendered, startTime, samples: sampleMatch ? parseInt(sampleMatch[1], 10) : void 0 };
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectBlenderRenders() {
+  const renders = [];
+  try {
+    const psRaw = await run("ps -eo pid,pcpu,pmem,state,command 2>/dev/null | grep -iE '[b]lender'", "", 2e3);
+    if (!psRaw) return renders;
+    const lines = psRaw.split("\n");
+    for (const line of lines) {
+      const parts = line.trim().match(/\s*(\d+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(.+)/);
+      if (!parts) continue;
+      const pid = parseInt(parts[1], 10);
+      const cpuPct = parseFloat(parts[2]);
+      const command = parts[5];
+      const args = command.split(/\s+/);
+      const isRender = /-b|--background|-f\s/.test(command) || /render/i.test(command);
+      if (!isRender && !command.includes("blender")) continue;
+      const blendFile = blendFileFromArgs(args);
+      const engine = engineFromArgs(args);
+      const outputPath = outputPathFromArgs(args);
+      const { start: frameStart, end: frameEnd } = frameRangeFromArgs(args);
+      const totalFrames = Math.max(1, frameEnd - frameStart + 1);
+      const logData = await parseRenderLog(blendFile);
+      const startTime = logData?.startTime ?? Date.now() - 6e4;
+      const elapsedSec = Math.max(0, Math.round((Date.now() - startTime) / 1e3));
+      let currentFrame = logData?.framesRendered ?? 0;
+      if (currentFrame === 0 && cpuPct > 0) currentFrame = 1;
+      let status = "unknown";
+      if (cpuPct > 0 && currentFrame > 0 && currentFrame < totalFrames) status = "rendering";
+      else if (cpuPct > 0 && currentFrame >= totalFrames) status = "finalizing";
+      else if (currentFrame === 0 && cpuPct > 0) status = "loading";
+      else if (cpuPct === 0) status = "idle";
+      const completionPercent = totalFrames > 0 ? Math.min(100, Math.round(currentFrame / totalFrames * 100)) : 0;
+      renders.push({
+        pid,
+        blendFile,
+        renderEngine: engine,
+        frameStart,
+        frameEnd,
+        currentFrame,
+        totalFrames,
+        elapsedSec,
+        completionPercent,
+        status,
+        outputPath,
+        sampleCount: logData?.samples
+      });
+    }
+  } catch {
+  }
+  return renders;
+}
+
+export {
+  collectBlenderRenders
+};

package/dist/{chunk-MOAEGMFP.js → chunk-3TE7MJLS.js}

@@ -106,7 +106,8 @@ var BUILTIN_THEMES = {
     network: chalk.hex("#60a5fa"),
     disk: chalk.hex("#f472b6"),
     graphs: chalk.hex("#22d3ee"),
-    process: chalk.hex("#e5e7eb")
+    process: chalk.hex("#e5e7eb"),
+    blender: chalk.hex("#f97316")
   },
   dracula: {
     border: chalk.hex("#6272a4"),
@@ -119,7 +120,8 @@ var BUILTIN_THEMES = {
     network: chalk.hex("#ff79c6"),
     disk: chalk.hex("#ff5555"),
     graphs: chalk.hex("#8be9fd"),
-    process: chalk.hex("#f8f8f2")
+    process: chalk.hex("#f8f8f2"),
+    blender: chalk.hex("#ffb86c")
   },
   cyberpunk: {
     border: chalk.hex("#ff0055"),
@@ -132,7 +134,8 @@ var BUILTIN_THEMES = {
     network: chalk.hex("#00ffff"),
     disk: chalk.hex("#ff007f"),
     graphs: chalk.hex("#00ffcc"),
-    process: chalk.hex("#ffffff")
+    process: chalk.hex("#ffffff"),
+    blender: chalk.hex("#ff6600")
   },
   monochrome: {
     border: chalk.gray,
@@ -145,7 +148,8 @@ var BUILTIN_THEMES = {
     network: chalk.white.bold,
     disk: chalk.white.bold,
     graphs: chalk.white.bold,
-    process: chalk.white.bold
+    process: chalk.white.bold,
+    blender: chalk.white.bold
   },
   nord: {
     border: chalk.hex("#4c566a"),
@@ -158,7 +162,8 @@ var BUILTIN_THEMES = {
     network: chalk.hex("#81a1c1"),
     disk: chalk.hex("#b48ead"),
     graphs: chalk.hex("#88c0d0"),
-    process: chalk.hex("#eceff4")
+    process: chalk.hex("#eceff4"),
+    blender: chalk.hex("#d08770")
   },
   gruvbox: {
     border: chalk.hex("#928374"),
@@ -171,7 +176,8 @@ var BUILTIN_THEMES = {
     network: chalk.hex("#83a598"),
     disk: chalk.hex("#d3869b"),
     graphs: chalk.hex("#fb4934"),
-    process: chalk.hex("#ebdbb2")
+    process: chalk.hex("#ebdbb2"),
+    blender: chalk.hex("#fe8019")
   }
 };
 function loadCustomThemes() {
@@ -198,7 +204,8 @@ function loadCustomThemes() {
               network: buildColor(data.network),
               disk: buildColor(data.disk),
               graphs: buildColor(data.graphs),
-              process: buildColor(data.process)
+              process: buildColor(data.process),
+              blender: buildColor(data.blender)
             };
           } catch {
           }
@@ -458,11 +465,83 @@ function thermalCard(data, contentWidth) {
 }
 function networkCard(data, contentWidth) {
   const valW = Math.max(6, contentWidth - 8);
-  return [
-    statRow("Iface", truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)),
-    statRow("RX", `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`),
-    statRow("TX", `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)
-  ];
+  const lines = [];
+  lines.push(statRow("Iface", truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)));
+  const rxTotal = formatBytes(data.network.rxBytes);
+  const txTotal = formatBytes(data.network.txBytes);
+  const rxRateStr = formatBytes(data.network.rxRate);
+  const txRateStr = formatBytes(data.network.txRate);
+  lines.push(statRow("RX", `${rxTotal} \xB7 ${rxRateStr}/s`));
+  lines.push(statRow("TX", `${txTotal} \xB7 ${txRateStr}/s`));
+  const totalBytes = data.network.rxBytes + data.network.txBytes;
+  if (totalBytes > 0) {
+    const rxPct = Math.round(data.network.rxBytes / totalBytes * 100);
+    const barW = Math.max(4, contentWidth - 20);
+    const rxBar = gaugeBar(rxPct, barW);
+    lines.push(statRow("RX/TX", `${rxBar} ${rxPct}%`));
+  }
+  if (data.network.protocols) {
+    const p = data.network.protocols;
+    const totalConns = (p.tcp.connections || 0) + (p.udp.connections || 0);
+    if (totalConns > 0) {
+      const tcpPct = Math.round(p.tcp.connections / totalConns * 100);
+      lines.push(statRow("TCP", `${p.tcp.connections} conns \xB7 ${gaugeBar(tcpPct, Math.max(4, contentWidth - 20))} ${tcpPct}%`));
+      lines.push(statRow("UDP", `${p.udp.connections} conns`));
+    }
+  }
+  if (data.network.connectionStates) {
+    const cs = data.network.connectionStates;
+    const total = cs.established + cs.listening + cs.timeWait + cs.closeWait + cs.other;
+    if (total > 0) {
+      const estPct = Math.round(cs.established / total * 100);
+      lines.push(statRow("Active", `${cs.established} ESTABLISHED \xB7 ${estPct}%`));
+      lines.push(statRow("Listen", `${cs.listening} LISTEN`));
+      if (cs.timeWait > 0) lines.push(statRow("TimeWait", `${cs.timeWait}`));
+      if (cs.closeWait > 0) lines.push(statRow("CloseWait", `${cs.closeWait}`));
+    }
+  }
+  if (data.network.listeningPorts && data.network.listeningPorts.length > 0) {
+    const ports = data.network.listeningPorts.slice(0, 8).join(", ");
+    lines.push(statRow("Ports", truncatePlain(ports, valW)));
+  }
+  if (data.network.topRemoteHosts && data.network.topRemoteHosts.length > 0) {
+    for (const host of data.network.topRemoteHosts.slice(0, 3)) {
+      lines.push(statRow("Host", truncatePlain(`${host.host} (${host.connectionCount})`, valW)));
+    }
+  }
+  return lines;
+}
+function networkDetailCard(data, width, theme) {
+  const contentWidth = width - 4;
+  const lines = networkCard(data, contentWidth);
+  if (data.packets && data.packets.allProcesses && data.packets.allProcesses.length > 0) {
+    lines.push("");
+    lines.push(chalk2.bold("PROCESSES & BANDWIDTH USAGE:"));
+    lines.push(chalk2.dim("\u2500".repeat(contentWidth)));
+    const pWidth = 8;
+    const rxWidth = 12;
+    const txWidth = 12;
+    const totalWidth = 12;
+    const cmdWidth = Math.max(15, contentWidth - (pWidth + rxWidth + txWidth + totalWidth + 4 * 2));
+    lines.push(
+      chalk2.bold("PID".padEnd(pWidth)) + "  " + chalk2.bold("COMMAND".padEnd(cmdWidth)) + "  " + chalk2.bold("RX".padStart(rxWidth)) + "  " + chalk2.bold("TX".padStart(txWidth)) + "  " + chalk2.bold("TOTAL".padStart(totalWidth))
+    );
+    const sorted = [...data.packets.allProcesses].sort((a, b) => b.rxBytes + b.txBytes - (a.rxBytes + a.txBytes));
+    for (const proc of sorted) {
+      if (proc.rxBytes + proc.txBytes === 0) continue;
+      const rxStr = formatBytes(proc.rxBytes).padStart(rxWidth);
+      const txStr = formatBytes(proc.txBytes).padStart(txWidth);
+      const totalStr = formatBytes(proc.rxBytes + proc.txBytes).padStart(totalWidth);
+      const cmdStr = truncatePlain(proc.command, cmdWidth).padEnd(cmdWidth);
+      lines.push(
+        chalk2.cyan(proc.pid.toString().padEnd(pWidth)) + "  " + cmdStr + "  " + chalk2.yellow(rxStr) + "  " + chalk2.yellow(txStr) + "  " + chalk2.bold(totalStr)
+      );
+    }
+  } else {
+    lines.push("");
+    lines.push(chalk2.dim("No active network process data available."));
+  }
+  return lines;
 }
 function tasksCard(data, contentWidth) {
   if (!data.tasks || !data.tasks.length) return null;
@@ -488,13 +567,14 @@ var TAB_DEFS = [
   { id: "power", label: "Power", key: "4" },
   { id: "battery", label: "Battery", key: "5" },
   { id: "thermal", label: "Thermal", key: "6" },
-  { id: "network", label: "Network", key: "7" },
-  { id: "packets", label: "Packets", key: "8" },
-  { id: "tasks", label: "Tasks", key: "9" },
-  { id: "disk", label: "Disk", key: "0" },
-  { id: "process", label: "Process", key: "P" },
+  { id: "packets", label: "Conns", key: "7" },
+  { id: "tasks", label: "Tasks", key: "8" },
+  { id: "disk", label: "Disk", key: "9" },
+  { id: "process", label: "Process", key: "0" },
   { id: "p2p", label: "P2P", key: "R" },
-  { id: "anomalies", label: "Anomalies", key: "A" }
+  { id: "anomalies", label: "Anomalies", key: "A" },
+  { id: "containers", label: "Containers", key: "C" },
+  { id: "blender", label: "Blender", key: "B" }
 ];
 var TAB_BAR_INDENT = 2;
 var TAB_SEPARATOR_WIDTH = 3;
@@ -645,6 +725,31 @@ function diskTableLines(disks, contentWidth, borderAccent = THEMES.default.borde
   });
   return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
 }
+function containersTableLines(containers, contentWidth, borderAccent = THEMES.default.border) {
+  const idW = 14, cpuW = 8, memW = 8, memUsgW = 20, netW = 20, blockW = 20, pidsW = 6;
+  const nameW = Math.max(10, contentWidth - idW - cpuW - memW - memUsgW - netW - blockW - pidsW - 7);
+  const head = chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" CONTAINER ID ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" CPU%   ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" MEM%   ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" MEM USAGE          ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" NET I/O            ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" BLOCK I/O          ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" PIDS ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" NAME".padEnd(nameW + 1));
+  const rows = containers.map((c) => {
+    const cpuStr = pctColor(c.cpuPercent)(`${c.cpuPercent.toFixed(1)}`.padEnd(cpuW));
+    const memStr = pctColor(c.memPercent)(`${c.memPercent.toFixed(1)}`.padEnd(memW));
+    return truncatePlain(c.id, idW - 1).padEnd(idW) + cpuStr + memStr + c.memUsage.padEnd(memUsgW) + c.netIO.padEnd(netW) + c.blockIO.padEnd(blockW) + String(c.pids).padEnd(pidsW) + truncatePlain(c.name, nameW);
+  });
+  return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
+}
+function blenderCard(renders, contentWidth, theme) {
+  if (!renders.length) return ["No active Blender renders detected"];
+  const lines = [];
+  for (const r of renders.slice(0, 8)) {
+    const statusColor = r.status === "rendering" ? chalk2.green : r.status === "finalizing" ? chalk2.yellow : r.status === "loading" ? chalk2.cyan : chalk2.dim;
+    const pctStr = `${r.completionPercent}%`;
+    const barW = Math.max(4, contentWidth - 28);
+    const bar = gaugeBar(r.completionPercent, barW);
+    lines.push(`${theme.blender(`PID ${r.pid}`)} ${truncatePlain(r.blendFile, 18)} ${r.renderEngine}`);
+    lines.push(`  Fra ${String(r.currentFrame).padStart(4)}/${r.totalFrames}  ${bar}  ${pctStr}`);
+    lines.push(`  ${r.elapsedSec}s elapsed \xB7 ${statusColor(r.status)}${r.sampleCount !== void 0 ? ` \xB7 ${r.sampleCount} spp` : ""}`);
+  }
+  return lines;
+}
 function detailPanelTitle(panel2, trackedPid) {
   const map = {
     cpu: "CPU",
@@ -657,7 +762,9 @@ function detailPanelTitle(panel2, trackedPid) {
     packets: "Packets",
     tasks: "Tasks",
     disk: "Disk",
-    process: trackedPid !== void 0 && trackedPid !== null ? `Processes (Following PID ${trackedPid})` : "Processes"
+    process: trackedPid !== void 0 && trackedPid !== null ? `Processes (Following PID ${trackedPid})` : "Processes",
+    containers: "Containers",
+    blender: "Blender Renders"
   };
   return map[panel2] || panel2;
 }
@@ -689,24 +796,42 @@ function activeDetailLines(data, activePanel, width, opts = {}) {
     case "thermal":
       return thermalCard(data, contentWidth);
     case "network":
-      return networkCard(data, contentWidth);
+      return networkDetailCard(data, width, theme);
     case "packets": {
-      if (!data.packets) return ["No packet data available"];
-      const lines = [];
-      lines.push(statRow("Total", `${data.packets.totalPackets} pkt`));
-      lines.push(statRow("RX", `${data.packets.rxPackets} pkt`));
-      lines.push(statRow("TX", `${data.packets.txPackets} pkt`));
-      lines.push(statRow("Conns", `${data.packets.connections} TCP`));
-      if (data.packets.interfaces && data.packets.interfaces.length) {
-        lines.push(statRow("Ifaces", `${data.packets.interfaces.length} active`));
-        for (const iface of data.packets.interfaces.slice(0, 8)) {
-          lines.push(statRow(`  ${iface.iface}`, `RX ${formatBytes(iface.rxBytes)} / TX ${formatBytes(iface.txBytes)}`));
-        }
+      if (!data.packets || !data.packets.allProcesses || !data.packets.allProcesses.length) {
+        return ["No advanced network tracking data available."];
       }
-      if (data.packets.allProcesses && data.packets.allProcesses.length) {
-        lines.push(statRow("Net Procs", `${data.packets.allProcesses.length} total`));
-        for (const proc of data.packets.allProcesses.slice(0, 10)) {
-          lines.push(statRow(`  ${proc.pid}`, `${truncatePlain(proc.command, 20)}  TX ${formatBytes(proc.txBytes)}`));
+      const lines = [];
+      const pWidth = 8;
+      const cmdWidth = 15;
+      const protoWidth = 5;
+      const stateWidth = 11;
+      const rxWidth = 10;
+      const txWidth = 10;
+      const remaining = Math.max(20, width - (pWidth + cmdWidth + protoWidth + stateWidth + rxWidth + txWidth + 7 * 2));
+      const localWidth = Math.floor(remaining * 0.4);
+      const remoteWidth = remaining - localWidth;
+      const header2 = chalk2.bold("PID".padEnd(pWidth)) + "  " + chalk2.bold("COMMAND".padEnd(cmdWidth)) + "  " + chalk2.bold("PROTO".padEnd(protoWidth)) + "  " + chalk2.bold("LOCAL".padEnd(localWidth)) + "  " + chalk2.bold("REMOTE".padEnd(remoteWidth)) + "  " + chalk2.bold("STATE".padEnd(stateWidth)) + "  " + chalk2.bold("RX".padStart(rxWidth)) + "  " + chalk2.bold("TX".padStart(txWidth));
+      lines.push(header2);
+      lines.push(chalk2.dim("\u2500".repeat(width)));
+      for (const proc of data.packets.allProcesses) {
+        if (!proc.connections || proc.connections.length === 0) continue;
+        const summaryCmd = truncatePlain(proc.command, cmdWidth + protoWidth + localWidth + remoteWidth + stateWidth + 8);
+        const summaryRx = formatBytes(proc.rxBytes).padStart(rxWidth);
+        const summaryTx = formatBytes(proc.txBytes).padStart(txWidth);
+        lines.push(
+          chalk2.cyan(proc.pid.toString().padEnd(pWidth)) + "  " + chalk2.cyan(summaryCmd.padEnd(width - pWidth - rxWidth - txWidth - 6)) + "  " + chalk2.yellow(summaryRx) + "  " + chalk2.yellow(summaryTx)
+        );
+        for (const conn of proc.connections) {
+          const cProto = chalk2.dim(truncatePlain(conn.protocol, protoWidth).padEnd(protoWidth));
+          const cLocal = chalk2.dim(truncatePlain(conn.local, localWidth).padEnd(localWidth));
+          const cRemote = truncatePlain(conn.remote, remoteWidth).padEnd(remoteWidth);
+          const cStateStr = conn.state === "Established" ? chalk2.green("ESTABLISHED".padEnd(stateWidth)) : chalk2.dim(truncatePlain(conn.state, stateWidth).padEnd(stateWidth));
+          const cRx = chalk2.dim(formatBytes(conn.rxBytes).padStart(rxWidth));
+          const cTx = chalk2.dim(formatBytes(conn.txBytes).padStart(txWidth));
+          lines.push(
+            " ".repeat(pWidth) + "  " + " ".repeat(cmdWidth) + "  " + cProto + "  " + cLocal + "  " + cRemote + "  " + cStateStr + "  " + cRx + "  " + cTx
+          );
         }
       }
       return lines;
@@ -769,6 +894,13 @@ function activeDetailLines(data, activePanel, width, opts = {}) {
       }
       return lines;
     }
+    case "containers": {
+      return data.containers && data.containers.length ? containersTableLines(data.containers, width - 4, theme.border) : ["No container data available"];
+    }
+    case "blender": {
+      const renders = data.blenderRenders && data.blenderRenders.length ? data.blenderRenders : [];
+      return blenderCard(renders, contentWidth, theme);
+    }
     default:
       return null;
   }
@@ -992,7 +1124,7 @@ function formatTable(data, opts = {}) {
       lines.push(gaugeRow("GPU", data.gpu.utilization, contentWidth));
     }
     const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
-    if (tempC !== void 0) {
+    if (tempC != null) {
       const tempStr = formatTempUnit(tempC, opts.tempUnit);
       lines.push(statRow("Temp", thermalColor(data.thermal.pressureLevel)(tempStr)));
     }

package/dist/{chunk-RVGKEJXT.js → chunk-CXL4GYGQ.js}

@@ -29,6 +29,7 @@ var DEFAULT_CONFIG = {
   splashAnimation: "classic",
   webhookUrl: "",
   alertCmd: "",
+  dockerModeConfirmed: false,
   visiblePanels: {
     cpu: true,
     mem: true,
@@ -41,6 +42,8 @@ var DEFAULT_CONFIG = {
     tasks: true,
     disk: true,
     process: true,
+    containers: true,
+    blender: true,
     tree: false
   },
   panelLayout: ["mem", "disk", "net"]