pyre-cli 9.5.0 → 9.5.2

package/src/formatters/render.ts

@@ -13,6 +13,7 @@ import chalk from 'chalk';
 import { sparkline, multiRowSparkline, brailleGraph, multiRowBrailleGraph } from '../sparkline.js';
 import type { History } from '../history.js';
 import type { StatsData, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
+import type { BlenderRenderData } from '../monitors/types.js';
 import { THEMES, type ThemeName, type ThemeColors } from './themes.js';
 
 
@@ -333,11 +334,102 @@ function thermalCard(data: StatsData, contentWidth: number): string[] {
 
 function networkCard(data: StatsData, contentWidth: number): string[] {
   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: string[] = [];
+  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} · ${rxRateStr}/s`));
+  lines.push(statRow('TX', `${txTotal} · ${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 · ${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 · ${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: StatsData, width: number, theme: ThemeColors): string[] {
+  const contentWidth = width - 4;
+  const lines = networkCard(data, contentWidth);
+  
+  if (data.packets && data.packets.allProcesses && data.packets.allProcesses.length > 0) {
+    lines.push('');
+    lines.push(chalk.bold('PROCESSES & BANDWIDTH USAGE:'));
+    lines.push(chalk.dim('─'.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(
+      chalk.bold('PID'.padEnd(pWidth)) + '  ' +
+      chalk.bold('COMMAND'.padEnd(cmdWidth)) + '  ' +
+      chalk.bold('RX'.padStart(rxWidth)) + '  ' +
+      chalk.bold('TX'.padStart(txWidth)) + '  ' +
+      chalk.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(
+        chalk.cyan(proc.pid.toString().padEnd(pWidth)) + '  ' +
+        cmdStr + '  ' +
+        chalk.yellow(rxStr) + '  ' +
+        chalk.yellow(txStr) + '  ' +
+        chalk.bold(totalStr)
+      );
+    }
+  } else {
+    lines.push('');
+    lines.push(chalk.dim('No active network process data available.'));
+  }
+  
+  return lines;
 }
 
 function packetCard(data: StatsData, contentWidth: number): string[] | null {
@@ -347,8 +439,19 @@ function packetCard(data: StatsData, contentWidth: number): string[] | null {
   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.protocolStats) {
+    const ps = data.packets.protocolStats;
+    lines.push(statRow('TCP', `${ps.tcp.connections} conns`));
+    lines.push(statRow('UDP', `${ps.udp.connections} conns`));
+  }
+  if (data.packets.connectionStates) {
+    const cs = data.packets.connectionStates;
+    lines.push(statRow('ESTAB', `${cs.established}`));
+    lines.push(statRow('LISTEN', `${cs.listening}`));
+  }
   if (data.packets.topProcesses && data.packets.topProcesses.length) {
-    lines.push(statRow('Top Proc', truncatePlain(data.packets.topProcesses[0].command, contentWidth - 10)));
+    const topProc = data.packets.topProcesses[0];
+    lines.push(statRow('Top Proc', `${truncatePlain(topProc.command, contentWidth - 25)} (${formatBytes(topProc.rxBytes + topProc.txBytes)})`));
   }
   if (data.packets.allProcesses && data.packets.allProcesses.length > 1) {
     lines.push(statRow('Net Procs', `${data.packets.allProcesses.length} processes`));
@@ -392,13 +495,14 @@ export const TAB_DEFS: { id: string; label: string; key: string }[] = [
   { 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: 'containers', label: 'Containers', key: 'C' },
+  { id: 'blender', label: 'Blender', key: 'B' },
 ];
 
 /** The number of leading columns of indent before the tab bar's first character (see `tabBar`). */
@@ -620,6 +724,58 @@ function diskTableLines(
   return [head, borderAccent('─'.repeat(contentWidth)), ...rows];
 }
 
+function containersTableLines(
+  containers: { id: string; name: string; cpuPercent: number; memUsage: string; memPercent: number; netIO: string; blockIO: string; pids: number }[],
+  contentWidth: number,
+  borderAccent = THEMES.default.border
+): string[] {
+   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 =
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' CONTAINER ID ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' CPU%   ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' MEM%   ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' MEM USAGE          ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' NET I/O            ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' BLOCK I/O          ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' PIDS ') +
+     chalk.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('─'.repeat(contentWidth)), ...rows];
+ }
+
+function blenderCard(renders: BlenderRenderData[], contentWidth: number, theme: ThemeColors): string[] {
+  if (!renders.length) return ['No active Blender renders detected'];
+  const lines: string[] = [];
+  for (const r of renders.slice(0, 8)) {
+    const statusColor = r.status === 'rendering' ? chalk.green : r.status === 'finalizing' ? chalk.yellow : r.status === 'loading' ? chalk.cyan : chalk.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 · ${statusColor(r.status)}${r.sampleCount !== undefined ? ` · ${r.sampleCount} spp` : ''}`);
+  }
+  return lines;
+}
+
 // --- main dashboard ------------------------------------------------------------
 
 function detailPanelTitle(panel: string, trackedPid?: number | null): string {
@@ -635,6 +791,8 @@ function detailPanelTitle(panel: string, trackedPid?: number | null): string {
     tasks: 'Tasks',
     disk: 'Disk',
     process: trackedPid !== undefined && trackedPid !== null ? `Processes (Following PID ${trackedPid})` : 'Processes',
+    containers: 'Containers',
+    blender: 'Blender Renders',
   };
   return map[panel] || panel;
 }
@@ -667,26 +825,73 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
     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: string[] = [];
-      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: string[] = [];
+      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 header = 
+        chalk.bold('PID'.padEnd(pWidth)) + '  ' +
+        chalk.bold('COMMAND'.padEnd(cmdWidth)) + '  ' +
+        chalk.bold('PROTO'.padEnd(protoWidth)) + '  ' +
+        chalk.bold('LOCAL'.padEnd(localWidth)) + '  ' +
+        chalk.bold('REMOTE'.padEnd(remoteWidth)) + '  ' +
+        chalk.bold('STATE'.padEnd(stateWidth)) + '  ' +
+        chalk.bold('RX'.padStart(rxWidth)) + '  ' +
+        chalk.bold('TX'.padStart(txWidth));
+        
+      lines.push(header);
+      lines.push(chalk.dim('─'.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(
+          chalk.cyan(proc.pid.toString().padEnd(pWidth)) + '  ' +
+          chalk.cyan(summaryCmd.padEnd(width - pWidth - rxWidth - txWidth - 6)) + '  ' +
+          chalk.yellow(summaryRx) + '  ' +
+          chalk.yellow(summaryTx)
+        );
+        
+        for (const conn of proc.connections) {
+          const cProto = chalk.dim(truncatePlain(conn.protocol, protoWidth).padEnd(protoWidth));
+          const cLocal = chalk.dim(truncatePlain(conn.local, localWidth).padEnd(localWidth));
+          const cRemote = truncatePlain(conn.remote, remoteWidth).padEnd(remoteWidth);
+          
+          const cStateStr = conn.state === 'Established' ? chalk.green('ESTABLISHED'.padEnd(stateWidth)) : chalk.dim(truncatePlain(conn.state, stateWidth).padEnd(stateWidth));
+          const cRx = chalk.dim(formatBytes(conn.rxBytes).padStart(rxWidth));
+          const cTx = chalk.dim(formatBytes(conn.txBytes).padStart(txWidth));
+          
+          lines.push(
+            ' '.repeat(pWidth) + '  ' +
+            ' '.repeat(cmdWidth) + '  ' +
+            cProto + '  ' +
+            cLocal + '  ' +
+            cRemote + '  ' +
+            cStateStr + '  ' +
+            cRx + '  ' +
+            cTx
+          );
         }
       }
+    
       return lines;
     }
     case 'tasks':
@@ -758,6 +963,13 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
       }
       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;
   }
@@ -1034,7 +1246,7 @@ export function formatTable(data: StatsData, opts: TableOptions = {}): string {
       lines.push(gaugeRow('GPU', data.gpu.utilization, contentWidth));
     }
     const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
-    if (tempC !== undefined) {
+    if (tempC != null) {
       const tempStr = formatTempUnit(tempC, opts.tempUnit);
       lines.push(statRow('Temp', thermalColor(data.thermal.pressureLevel)(tempStr)));
     }

package/src/formatters/themes.ts

@@ -26,6 +26,7 @@ export interface ThemeColors {
    disk: (s: string) => string;
    graphs: (s: string) => string;
    process: (s: string) => string;
+   blender: (s: string) => string;
 }
 
 export const BUILTIN_THEMES: Record<string, ThemeColors> = {
@@ -41,6 +42,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
      disk: chalk.hex('#f472b6'),
      graphs: chalk.hex('#22d3ee'),
      process: chalk.hex('#e5e7eb'),
+     blender: chalk.hex('#f97316'),
    },
    dracula: {
      border: chalk.hex('#6272a4'),
@@ -54,6 +56,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
      disk: chalk.hex('#ff5555'),
      graphs: chalk.hex('#8be9fd'),
      process: chalk.hex('#f8f8f2'),
+     blender: chalk.hex('#ffb86c'),
    },
    cyberpunk: {
      border: chalk.hex('#ff0055'),
@@ -67,6 +70,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
      disk: chalk.hex('#ff007f'),
      graphs: chalk.hex('#00ffcc'),
      process: chalk.hex('#ffffff'),
+     blender: chalk.hex('#ff6600'),
    },
     monochrome: {
       border: chalk.gray,
@@ -80,6 +84,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
       disk: chalk.white.bold,
       graphs: chalk.white.bold,
       process: chalk.white.bold,
+      blender: chalk.white.bold,
     },
     nord: {
       border: chalk.hex('#4c566a'),
@@ -93,6 +98,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
       disk: chalk.hex('#b48ead'),
       graphs: chalk.hex('#88c0d0'),
       process: chalk.hex('#eceff4'),
+      blender: chalk.hex('#d08770'),
     },
     gruvbox: {
       border: chalk.hex('#928374'),
@@ -106,6 +112,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
       disk: chalk.hex('#d3869b'),
       graphs: chalk.hex('#fb4934'),
       process: chalk.hex('#ebdbb2'),
+      blender: chalk.hex('#fe8019'),
     },
   };
 
@@ -134,6 +141,7 @@ export function loadCustomThemes(): Record<string, ThemeColors> {
               disk: buildColor(data.disk),
               graphs: buildColor(data.graphs),
               process: buildColor(data.process),
+              blender: buildColor(data.blender),
             };
           } catch {
             // ignore bad theme file

package/src/formatters/types.ts

@@ -24,6 +24,7 @@ export interface ThemeColors {
    disk: (s: string) => string;
    graphs: (s: string) => string;
    process: (s: string) => string;
+   blender: (s: string) => string;
 }
 
 export type { StatsData };
@@ -40,6 +41,8 @@ export interface VisibleItems {
    tasks?: boolean;
    disk?: boolean;
    process?: boolean;
+   containers?: boolean;
+   blender?: boolean;
    tree?: boolean;
 }
 
@@ -67,7 +70,7 @@ export interface TableOptions {
     /** Show process tree view instead of flat list. */
     treeView?: boolean;
     /** Active panel for detail/focus view. 'grid' means show all panels. */
-    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies';
+    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies' | 'containers' | 'blender';
     /** Active anomaly alerts from the statistical detector. */
     anomalies?: AnomalyAlert[];
     /** Historical anomaly alerts for the anomalies tab. */

package/src/index.ts

@@ -82,32 +82,33 @@ program
     .option('--port <port>', 'Port number for web server mode', '3000');
 
 program.addHelpText('after', `
-Commands:
-  live                           Interactive live dashboard
-  check                          One-line plain-English health summary
-  pipe                           Continuous newline-delimited JSON stream for scripting
-  stress                         Synthetic CPU/GPU load generator
-  ui                             Launch the native macOS UI dashboard
-  web                            Serve an auto-refreshing live web portal
-  ssh <host>                     Stream live stats from a remote Mac over SSH
-  fleet <host1> [host2]...       Multi-host live dashboard monitoring multiple Macs
-  bench <cmd>                    Log CPU, memory, network, power draw, and estimate kWh cost
-  benchmark                      Run a 1-minute CPU benchmark calculating digits of PI
-  anomalies                      Compute z-score anomalies and print plain-language digest
-  doctor                         Run system diagnostics
-  extensions                     System Extensions inspector
-  brew                           Homebrew health panel
-  update                         Check for pyre-cli updates
-  profile <save|load|list>       Atomic configuration profile management
-  config <show|reset>            View or reset persistent configuration file
-  history                        Graph historical resource trends from CSV logs
-  diff <file1> <file2>           Compare two saved snapshot files side-by-side
-  info                           Concise hardware summary
-  completions <shell>            Generate shell auto-completion scripts
-  xbar                           Generate an xbar / SwiftBar menu bar plugin script
-  p2p <server|connect>           Start a P2P server or connect to one
-  server                         Print commands for starting P2P server/client
-`);
+ Commands:
+   live                           Interactive live dashboard
+   check                          One-line plain-English health summary
+   pipe                           Continuous newline-delimited JSON stream for scripting
+   stress                         Synthetic CPU/GPU load generator
+   ui                             Launch the native macOS UI dashboard
+   web                            Serve an auto-refreshing live web portal
+   ssh <host>                     Stream live stats from a remote Mac over SSH
+   fleet <host1> [host2]...       Multi-host live dashboard monitoring multiple Macs
+   bench <cmd>                    Log CPU, memory, network, power draw, and estimate kWh cost
+   benchmark                      Run a 1-minute CPU benchmark calculating digits of PI
+   anomalies                      Compute z-score anomalies and print plain-language digest
+   doctor                         Run system diagnostics
+   extensions                     System Extensions inspector
+   brew                           Homebrew health panel
+   update                         Check for pyre-cli updates
+   profile <save|load|list>       Atomic configuration profile management
+   config <show|reset>            View or reset persistent configuration file
+   history                        Graph historical resource trends from CSV logs
+   diff <file1> <file2>           Compare two saved snapshot files side-by-side
+   info                           Concise hardware summary
+   completions <shell>            Generate shell auto-completion scripts
+   xbar                           Generate an xbar / SwiftBar menu bar plugin script
+   p2p <server|connect>           Start a P2P server or connect to one
+   server                         Print commands for starting P2P server/client
+   blender                        Track active Blender render jobs and their progress
+ `);
 
 program.parse(process.argv);
 
@@ -233,6 +234,32 @@ async function main() {
     return;
   }
 
+  if (cmd === 'blender') {
+    const { collectBlenderRenders } = await import('./monitors/blender.js');
+    const renders = await collectBlenderRenders();
+    if (!renders.length) {
+      console.log(chalk.dim('No active Blender renders detected.'));
+      return;
+    }
+    const lines: string[] = [];
+    lines.push(chalk.bold('  Blender Render Tracker'));
+    lines.push('');
+    for (const r of renders) {
+      const statusColor = r.status === 'rendering' ? chalk.green : r.status === 'finalizing' ? chalk.yellow : r.status === 'loading' ? chalk.cyan : chalk.dim;
+      lines.push(`  PID:         ${r.pid}`);
+      lines.push(`  Blend File:  ${r.blendFile}`);
+      lines.push(`  Engine:      ${r.renderEngine}`);
+      lines.push(`  Frames:      ${r.currentFrame} / ${r.totalFrames}  (${r.completionPercent}%)`);
+      lines.push(`  Elapsed:     ${r.elapsedSec}s`);
+      lines.push(`  Status:      ${statusColor(r.status)}`);
+      lines.push(`  Output:      ${r.outputPath}`);
+      if (r.sampleCount !== undefined) lines.push(`  Samples:     ${r.sampleCount}`);
+      lines.push('');
+    }
+    console.log(lines.join('\n'));
+    return;
+  }
+
   if (cmd === 'brew') {
     const { printBrewHealthReport } = await import('./brewHealth.js');
     await printBrewHealthReport();

package/src/live/input.ts

@@ -38,6 +38,7 @@ import { writeConfig } from '../state/config.js';
        splashAnimation: state.splashAnimation,
        visiblePanels: { ...state.visiblePanels },
        notificationsEnabled: state.notificationsEnabled,
+       dockerModeConfirmed: state.dockerModeConfirmed,
     });
   }
 
@@ -179,6 +180,51 @@ function handleInputModeKey(str: string, key: readline.Key) {
       return;
     }
 
+    if (state.inputMode === 'docker-alert') {
+      if (isEscKey(key, str)) {
+        state.inputMode = null;
+        state.dockerModeConfirmed = true;
+        render();
+        return;
+      }
+      if (isUpKey(key, str)) {
+        state.dockerSelectionIndex = Math.max(0, state.dockerSelectionIndex - 1);
+        render();
+        return;
+      }
+      if (isDownKey(key, str)) {
+        state.dockerSelectionIndex = Math.min(1, state.dockerSelectionIndex + 1);
+        render();
+        return;
+      }
+      if (isEnterKey(key, str) || str === ' ') {
+        state.dockerModeConfirmed = true;
+        state.inputMode = null;
+        
+        if (state.dockerSelectionIndex === 0) {
+          // Docker Mode
+          state.visiblePanels.battery = false;
+          state.visiblePanels.thermal = false;
+          state.visiblePanels.power = false;
+          state.visiblePanels.gpu = false;
+          state.detailed = false;
+        } else {
+          // Regular TUI
+          state.visiblePanels.battery = true;
+          state.visiblePanels.thermal = true;
+          state.visiblePanels.power = true;
+          state.visiblePanels.gpu = true;
+        }
+        
+        invalidateTableCache();
+        invalidateFrame();
+        persistConfig();
+        render();
+        return;
+      }
+      return;
+    }
+
     if (state.inputMode === 'signal') {
       if (isUpKey(key, str)) {
        const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
@@ -540,6 +586,18 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           render();
           return;
         }
+         case 'C': {
+           state.activePanel = state.activePanel === 'containers' ? 'grid' : 'containers';
+           setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Containers panel');
+           render();
+           return;
+         }
+         case 'B': {
+           state.activePanel = state.activePanel === 'blender' ? 'grid' : 'blender';
+           setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Blender panel');
+           render();
+           return;
+         }
       }
 
       switch (key.name) {
@@ -716,16 +774,16 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     process.once('SIGINT', () => stopLive());
   }
 
-  function tabKeyToId(str: string): string | null {
-    const map: Record<string, string> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process', 'r': 'p2p', 'A': 'anomalies' };
+  function tabKeyToId(str: string): ActivePanel | null {
+    const map: Record<string, ActivePanel> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process', 'C': 'containers', 'r': 'p2p', 'A': 'anomalies', 'B': 'blender' };
     return map[str] ?? null;
   }
 
   function cycleTab(direction: number) {
-    const tabs = state.PANEL_TABS.map(t => t.id);
+    const tabs = state.PANEL_TABS.map(t => t.id) as string[];
     const current = state.activePanel === 'grid' ? -1 : tabs.indexOf(state.activePanel);
     const next = (current + direction + tabs.length) % tabs.length;
-    state.activePanel = tabs[next];
+    state.activePanel = tabs[next] as typeof state.activePanel;
     setStatus(`Panel: ${state.activePanel.toUpperCase()}`);
     render();
   }

package/src/live/render.ts

@@ -216,6 +216,10 @@ function render() {
     writeFrame(renderCredits(cols, rows));
     return;
   }
+  if (state.inputMode === 'docker-alert') {
+    writeFrame(renderDockerAlert(cols, rows));
+    return;
+  }
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
@@ -564,4 +568,31 @@ function renderCredits(cols: number, rows: number): string[] {
   return out;
 }
 
+function renderDockerAlert(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const content = [
+    chalk.bold.red('Docker Container Detected'),
+    '',
+    'Pyre is running inside a container. Some hardware sensors',
+    '(battery, thermal, power) may not be available or relevant.',
+    '',
+    chalk.cyan('Do you wish to continue in Docker mode?'),
+    ''
+  ];
+  
+  const options = ['Yes, use Docker mode (hide hardware sensors)', 'No, launch regular TUI with all features'];
+  for (let i = 0; i < options.length; i++) {
+    const isSelected = i === state.dockerSelectionIndex;
+    const prefix = isSelected ? chalk.cyan.bold('  ▶ ') : '    ';
+    const text = isSelected ? chalk.bgCyan.black(` ${options[i]} `) : chalk.dim(` ${options[i]} `);
+    content.push(prefix + text);
+  }
+  
+  content.push('');
+  content.push(chalk.dim('Press ↑/↓ to select, Enter to confirm, Esc to skip.'));
+
+  out.push(...panel('DOCKER DETECTED', content, cols, chalk.red, chalk.dim, rows - 2));
+  return out;
+}
+
 export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget, invalidateTableCache, invalidateFrame };