pyre-cli 9.5.0 → 9.5.2

package/src/monitors/collectors.ts

@@ -15,7 +15,9 @@ import chalk from 'chalk';
 import os from 'node:os';
 import { run } from './run.js';
 import { getSmcMetrics, parseSuffix } from './smc.js';
-import type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess, TaskData } from './types.js';
+import { resolveIp } from './dns_cache.js';
+import type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess, TaskData, ContainerData, NetworkConnection, BlenderRenderData, ProtocolStats, ConnectionStateStats, RemoteHostInfo } from './types.js';
+import { collectBlenderRenders } from './blender.js';
 
 const SP_TTL_MS = 10_000;
 const NETSTAT_TTL_MS = 1000;
@@ -30,6 +32,8 @@ let netstatIbCache: { raw: string; ts: number } | null = null;
 let routeCache: { iface: string; ip: string; ts: number } | null = null;
 const sysctlCache = new Map<string, { value: string; ts: number }>();
 
+let prevNetSample: { rxBytes: number; txBytes: number; rxPackets: number; txPackets: number; ts: number } | null = null;
+
 async function cachedSysctl(key: string, fallback: string): Promise<string> {
   const now = Date.now();
   const hit = sysctlCache.get(key);
@@ -127,7 +131,7 @@ function estimateBatteryLife(level: number, state: string): { estimatedTimeToEmp
  * complete {@link StatsData} snapshot.
  */
 export async function collectAll(opts: { detailed?: boolean; processLimit?: number } = {}): Promise<StatsData> {
-   const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks] = await Promise.all([
+   const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks, containers, blenderRenders] = await Promise.all([
      collectCpu(),
      collectGpu(opts.detailed),
      collectMemory(),
@@ -140,6 +144,8 @@ export async function collectAll(opts: { detailed?: boolean; processLimit?: numb
      collectPower(),
      collectPackets(),
      collectTasks(),
+     collectContainers(),
+     collectBlenderRenders(),
    ]);
 
    return {
@@ -161,9 +167,34 @@ export async function collectAll(opts: { detailed?: boolean; processLimit?: numb
      timestamp: new Date().toISOString(),
      packets,
      tasks,
+     containers,
+     blenderRenders,
    };
  }
 
+export async function collectContainers(): Promise<ContainerData[]> {
+  try {
+    const raw = (await run('docker stats --no-stream --format "{{.ID}}|{{.Name}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}|{{.NetIO}}|{{.BlockIO}}|{{.PIDs}}" 2>/dev/null', '')).trim();
+    if (!raw) return [];
+    
+    return raw.split('\n').map(line => {
+      const parts = line.split('|');
+      return {
+        id: parts[0],
+        name: parts[1],
+        cpuPercent: parseFloat(parts[2].replace('%', '')) || 0,
+        memUsage: parts[3],
+        memPercent: parseFloat(parts[4].replace('%', '')) || 0,
+        netIO: parts[5],
+        blockIO: parts[6],
+        pids: parseInt(parts[7], 10) || 0
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Read power-draw metrics (CPU watts, GPU watts, combined)
  * from the SMC via powermetrics.  Returns `null` when no
@@ -829,9 +860,166 @@ export async function collectNetwork(): Promise<NetworkData> {
       }
     }
 
-    return { interface: iface, ip, rxBytes, txBytes, rxPackets, txPackets };
+    const now = Date.now();
+    let rxRate = 0;
+    let txRate = 0;
+    if (prevNetSample && prevNetSample.ts > 0) {
+      const dt = Math.max((now - prevNetSample.ts) / 1000, 0.001);
+      rxRate = Math.max(0, (rxBytes - prevNetSample.rxBytes) / dt);
+      txRate = Math.max(0, (txBytes - prevNetSample.txBytes) / dt);
+    }
+    prevNetSample = { rxBytes, txBytes, rxPackets, txPackets, ts: now };
+
+    const protocolStats = await getProtocolStats();
+    const connectionStates = await getConnectionStates();
+    const listeningPorts = await getListeningPorts();
+    const establishedConnections = connectionStates.established;
+    const topRemoteHosts = await getTopRemoteHosts();
+
+    return {
+      interface: iface,
+      ip,
+      rxBytes,
+      txBytes,
+      rxPackets,
+      txPackets,
+      rxRate,
+      txRate,
+      connections: establishedConnections,
+      protocols: protocolStats,
+      connectionStates,
+      listeningPorts,
+      establishedConnections,
+      topRemoteHosts,
+    };
+  } catch {
+    return {
+      interface: 'unknown',
+      ip: '0.0.0.0',
+      rxBytes: 0,
+      txBytes: 0,
+      rxPackets: 0,
+      txPackets: 0,
+      rxRate: 0,
+      txRate: 0,
+      connections: 0,
+      protocols: { tcp: { connections: 0, rxBytes: 0, txBytes: 0 }, udp: { connections: 0, rxBytes: 0, txBytes: 0 } },
+      connectionStates: { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 },
+      listeningPorts: [],
+      establishedConnections: 0,
+      topRemoteHosts: [],
+    };
+  }
+}
+
+async function getProtocolStats(): Promise<ProtocolStats> {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | awk '{print $1}' | sort | uniq -c", '');
+    const tcpConnections = (await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | wc -l", '0')).trim();
+    const udpConnections = (await run("netstat -n -p udp 2>/dev/null | tail -n +3 | wc -l", '0')).trim();
+    
+    let tcpRxBytes = 0;
+    let tcpTxBytes = 0;
+    let udpRxBytes = 0;
+    let udpTxBytes = 0;
+    
+    try {
+      const netstat = await cachedNetstatIb();
+      for (const line of netstat.split('\n')) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 9 && parts[0] && !parts[0].startsWith('Name')) {
+          const iface = parts[0];
+          if (iface.includes('lo')) continue;
+          const rx = parseInt(parts[5]) || 0;
+          const tx = parseInt(parts[7]) || 0;
+          tcpRxBytes += rx;
+          tcpTxBytes += tx;
+        }
+      }
+    } catch {
+      // ignore
+    }
+    
+    return {
+      tcp: {
+        connections: parseInt(tcpConnections) || 0,
+        rxBytes: tcpRxBytes,
+        txBytes: tcpTxBytes,
+      },
+      udp: {
+        connections: parseInt(udpConnections) || 0,
+        rxBytes: udpRxBytes,
+        txBytes: udpTxBytes,
+      },
+    };
+  } catch {
+    return { tcp: { connections: 0, rxBytes: 0, txBytes: 0 }, udp: { connections: 0, rxBytes: 0, txBytes: 0 } };
+  }
+}
+
+async function getConnectionStates(): Promise<ConnectionStateStats> {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | awk '{print $6}' | sort | uniq -c", '');
+    const lines = raw.split('\n').filter(Boolean);
+    const stats: ConnectionStateStats = { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+    
+    for (const line of lines) {
+      const match = line.match(/(\d+)\s+(\S+)/);
+      if (!match) continue;
+      const count = parseInt(match[1]);
+      const state = match[2].toUpperCase();
+      
+      if (state.includes('ESTABLISHED')) stats.established += count;
+      else if (state.includes('LISTEN')) stats.listening += count;
+      else if (state.includes('TIME_WAIT')) stats.timeWait += count;
+      else if (state.includes('CLOSE_WAIT')) stats.closeWait += count;
+      else stats.other += count;
+    }
+    
+    return stats;
+  } catch {
+    return { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+  }
+}
+
+async function getListeningPorts(): Promise<number[]> {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | grep LISTEN | awk '{print $4}' | rev | cut -d. -f1 | rev", '');
+    const ports = raw.split('\n')
+      .map(p => parseInt(p, 10))
+      .filter(p => !isNaN(p) && p > 0);
+    return [...new Set(ports)].sort((a, b) => a - b);
+  } catch {
+    return [];
+  }
+}
+
+async function getTopRemoteHosts(): Promise<RemoteHostInfo[]> {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | grep ESTABLISHED | awk '{print $5}' | rev | cut -d. -f1 | rev", '');
+    const ports = raw.split('\n').filter(Boolean);
+    const hostMap = new Map<string, { count: number; bytes: number }>();
+    
+    for (const port of ports) {
+      const host = port.split(':')[0];
+      if (!host || host === '127.0.0.1' || host === '::1') continue;
+      const existing = hostMap.get(host) || { count: 0, bytes: 0 };
+      hostMap.set(host, { count: existing.count + 1, bytes: existing.bytes });
+    }
+    
+    const result: RemoteHostInfo[] = [];
+    for (const [host, info] of hostMap.entries()) {
+      result.push({
+        host,
+        ip: host,
+        bytesTransferred: info.bytes,
+        connectionCount: info.count,
+      });
+    }
+    
+    return result.sort((a, b) => b.connectionCount - a.connectionCount).slice(0, 10);
   } catch {
-    return { interface: 'unknown', ip: '0.0.0.0', rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0 };
+    return [];
   }
 }
 
@@ -886,47 +1074,106 @@ export async function collectPackets(): Promise<PacketData | null> {
      }
 
      let connections = 0;
+     let allProcesses: NetworkProcess[] = [];
+     
      try {
-       const tcpConns = (await run('netstat -an | grep ESTABLISHED | wc -l', '0', 2000)).trim();
-       connections = parseInt(tcpConns) || 0;
-     } catch {
-       connections = 0;
-     }
-
-     let topProcesses: { pid: number; command: string; rxBytes: number; txBytes: number }[] = [];
-     let allProcesses: { pid: number; command: string; rxBytes: number; txBytes: number; rxPackets?: number; txPackets?: number }[] = [];
-       try {
-          const lsof = (await run('lsof -i -n -P 2>/dev/null | tail -n +2 | awk \'{print $1, $2}\' | sort | uniq -c | sort -rn', '', 2000)).trim();
-         const lsofLines = lsof.split('\n');
-         topProcesses = lsofLines.map(line => {
-           const parts = line.trim().split(/\s+/);
-           if (parts.length >= 3) {
-             return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
+       const nettop = (await run('nettop -L 1 -J bytes_in,bytes_out,state 2>/dev/null', '', 2000)).trim();
+       const rows = nettop.split('\n');
+       
+       let currentProc: NetworkProcess | null = null;
+       
+       for (const row of rows) {
+         if (!row || row.startsWith(',state,')) continue;
+         
+         const cols = row.split(',');
+         const nameCol = cols[0];
+         
+         // If it doesn't contain <->, it's a process row
+         if (!nameCol.includes('<->')) {
+           if (currentProc) {
+             if (currentProc.connections && currentProc.connections.length > 0) {
+               allProcesses.push(currentProc);
+             }
            }
-           return { pid: 0, command: '', rxBytes: 0, txBytes: 0 };
-         }).filter(p => p.pid > 0);
-
-         allProcesses = topProcesses;
+           
+           // Extract PID and Name (e.g., "syslogd.369")
+           const lastDot = nameCol.lastIndexOf('.');
+           let pid = 0;
+           let command = nameCol;
+           if (lastDot > 0) {
+             const possiblePid = parseInt(nameCol.substring(lastDot + 1));
+             if (!isNaN(possiblePid)) {
+               pid = possiblePid;
+               command = nameCol.substring(0, lastDot);
+             }
+           }
+           
+           const rx = parseInt(cols[2]) || 0;
+           const tx = parseInt(cols[3]) || 0;
+           
+           currentProc = { pid, command, rxBytes: rx, txBytes: tx, connections: [] };
+         } else {
+           // Connection row
+           if (currentProc) {
+             const state = cols[1];
+             const rx = parseInt(cols[2]) || 0;
+             const tx = parseInt(cols[3]) || 0;
+             if (state === 'Established') connections++;
+             
+             // Parse endpoints (e.g. "tcp4 172.16.0.2:49844<->17.242.13.5:5223")
+             const spaceIdx = nameCol.indexOf(' ');
+             const protocol = spaceIdx > 0 ? nameCol.substring(0, spaceIdx) : '';
+             const endpoints = spaceIdx > 0 ? nameCol.substring(spaceIdx + 1) : nameCol;
+             const arrowIdx = endpoints.indexOf('<->');
+             let local = '';
+             let remote = '';
+             if (arrowIdx > 0) {
+               local = endpoints.substring(0, arrowIdx);
+               remote = endpoints.substring(arrowIdx + 3);
+               
+               // Attempt DNS resolution on remote IP
+               remote = resolveIp(remote);
+             } else {
+               local = endpoints;
+             }
+             
+             // Ignore purely local communication if you want, but for now include all
+             currentProc.connections!.push({ protocol, local, remote, state, rxBytes: rx, txBytes: tx });
+           }
+         }
+       }
+       if (currentProc && currentProc.connections && currentProc.connections.length > 0) {
+         allProcesses.push(currentProc);
+       }
      } catch {
-       topProcesses = [];
        allProcesses = [];
      }
-
-      return {
-        totalPackets: totalRxPackets + totalTxPackets,
-        rxPackets: totalRxPackets,
-        txPackets: totalTxPackets,
-        rxRate: 0,
-        txRate: 0,
-        connections,
-        topProcesses,
-        interfaces: ifaceStats,
-        allProcesses,
-      };
-   } catch {
-     return null;
-   }
- }
+     
+      // Sort processes by total bandwidth (tx + rx) to get top processes
+      const topProcesses = [...allProcesses].sort((a, b) => (b.rxBytes + b.txBytes) - (a.rxBytes + a.txBytes));
+      
+      const protocolStats = await getProtocolStats();
+      const connectionStates = await getConnectionStates();
+      const listeningPorts = await getListeningPorts();
+
+       return {
+         totalPackets: totalRxPackets + totalTxPackets,
+         rxPackets: totalRxPackets,
+         txPackets: totalTxPackets,
+         rxRate: 0,
+         txRate: 0,
+         connections,
+         topProcesses,
+         interfaces: ifaceStats,
+         allProcesses,
+         protocolStats,
+         connectionStates,
+         listeningPorts,
+       };
+    } catch {
+      return null;
+    }
+  }
 
 export async function collectTasks(limit = 12): Promise<TaskData[]> {
    try {

package/src/monitors/dns_cache.ts

@@ -0,0 +1,48 @@
+import dns from 'node:dns';
+
+const cache = new Map<string, string>();
+const pending = new Set<string>();
+
+export function resolveIp(ip: string): string {
+  // Extract IP if it has port (e.g., 17.242.13.5:5223 or [2606:4700...]:443)
+  let cleanIp = ip;
+  if (cleanIp.includes(']:')) {
+    cleanIp = cleanIp.substring(1, cleanIp.indexOf(']'));
+  } else if (cleanIp.includes(':') && cleanIp.split(':').length === 2) {
+    cleanIp = cleanIp.split(':')[0];
+  } else if (cleanIp.includes(':') && !cleanIp.includes(']')) {
+      // ipv6 without port or brackets? 
+      // If there's more than one colon, it's ipv6.
+      const lastColon = cleanIp.lastIndexOf(':');
+      const isPort = !cleanIp.includes(':', cleanIp.indexOf(':') + 1); // Only 1 colon means it's a port. Wait, ipv6 has many colons.
+      // E.g., 2606:4700:103::2.443 -> nettop uses `.` for port in ipv6!
+  }
+
+  // Handle nettop's IPv6 port format: 2606:4700:103::2.443 (the last dot separates the port)
+  if (cleanIp.includes(':') && cleanIp.includes('.')) {
+      const lastDot = cleanIp.lastIndexOf('.');
+      if (lastDot > cleanIp.lastIndexOf(':')) {
+          cleanIp = cleanIp.substring(0, lastDot);
+      }
+  }
+
+  if (cache.has(cleanIp)) return cache.get(cleanIp)!;
+  if (pending.has(cleanIp)) return ip;
+  
+  // Don't resolve local/multicast/broadcast
+  if (cleanIp.startsWith('127.') || cleanIp.startsWith('192.168.') || cleanIp.startsWith('10.') || cleanIp.startsWith('172.16.') || cleanIp.startsWith('ff02:') || cleanIp === '*:*' || cleanIp === '*' || cleanIp.startsWith('fe80:')) {
+    return ip;
+  }
+
+  pending.add(cleanIp);
+  dns.reverse(cleanIp, (err, hostnames) => {
+    if (!err && hostnames && hostnames.length > 0) {
+      cache.set(cleanIp, hostnames[0]);
+    } else {
+      cache.set(cleanIp, cleanIp); // don't try again
+    }
+    pending.delete(cleanIp);
+  });
+  
+  return ip;
+}

package/src/monitors/index.ts

@@ -10,5 +10,6 @@
  * - `collectors.ts` — individual metric collectors and the orchestrator
  * - `run.ts`   — shared shell-execution helper
  */
-export { collectAll, collectPower, collectPackets, collectTasks } from './collectors.js';
-export type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess, TaskData } from './types.js';
+export { collectAll, collectPower, collectPackets, collectTasks, collectContainers } from './collectors.js';
+export { collectBlenderRenders } from './blender.js';
+export type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess, TaskData, ContainerData, BlenderRenderData } from './types.js';

package/src/monitors/smc.ts

@@ -99,6 +99,33 @@ export async function getSmcMetrics(): Promise<SmcMetrics> {
     }
   }
 
+  // 2b. AppleSmartBattery fallback — works without sudo on all MacBooks
+  // VirtualTemperature reflects the SoC/die temperature; Temperature is
+  // the battery cell temperature.  Both are reported in centi-Celsius
+  // (e.g. 3539 → 35.39 °C).
+  if (result.temps['cpu_die'] === undefined) {
+    try {
+      const battRaw = await run('ioreg -r -n AppleSmartBattery 2>/dev/null', '');
+      if (battRaw) {
+        // Prefer VirtualTemperature (closer to die temp) over Temperature (battery cell)
+        const virtMatch = battRaw.match(/"VirtualTemperature"\s*=\s*(\d+)/);
+        const cellMatch = battRaw.match(/"Temperature"\s*=\s*(\d+)/);
+        const rawVirt = virtMatch ? parseFloat(virtMatch[1]) : undefined;
+        const rawCell = cellMatch ? parseFloat(cellMatch[1]) : undefined;
+        // Convert centi-Celsius to Celsius (e.g. 3085 → 30.85 → 30.9)
+        const virtC = rawVirt !== undefined ? Math.round(rawVirt / 10) / 10 : undefined;
+        const cellC = rawCell !== undefined ? Math.round(rawCell / 10) / 10 : undefined;
+        if (virtC !== undefined && virtC >= 15 && virtC <= 115) {
+          result.temps['cpu_die'] = virtC;
+        } else if (cellC !== undefined && cellC >= 15 && cellC <= 115) {
+          result.temps['cpu_die'] = cellC;
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
   // 3. Linux /sys/class/thermal or /sys/class/hwmon fallback
   if (result.temps['cpu_die'] === undefined) {
     try {

package/src/monitors/types.ts

@@ -21,6 +21,19 @@ export interface StatsData {
    timestamp: string;
    packets: PacketData | null;
    tasks: TaskData[];
+   containers?: ContainerData[];
+   blenderRenders?: BlenderRenderData[];
+}
+
+export interface ContainerData {
+  id: string;
+  name: string;
+  cpuPercent: number;
+  memUsage: string;
+  memPercent: number;
+  netIO: string;
+  blockIO: string;
+  pids: number;
 }
 
 export interface GpuData {
@@ -38,18 +51,20 @@ export interface GpuData {
    combinedWatts?: number;
  }
 
- export interface PacketData {
-   totalPackets: number;
-   rxPackets: number;
-   txPackets: number;
-   rxRate: number;
-   txRate: number;
-   connections: number;
-   topProcesses: { pid: number; command: string; rxBytes: number; txBytes: number }[];
-   /** Every process with an open network connection (unlike topProcesses, not truncated). */
-   allProcesses: { pid: number; command: string; rxBytes: number; txBytes: number; rxPackets?: number; txPackets?: number }[];
-   interfaces: { iface: string; rxPackets: number; txPackets: number; rxBytes: number; txBytes: number }[];
- }
+export interface PacketData {
+  totalPackets: number;
+  rxPackets: number;
+  txPackets: number;
+  rxRate: number;
+  txRate: number;
+  connections: number;
+  topProcesses: NetworkProcess[];
+  allProcesses: NetworkProcess[];
+  interfaces: { iface: string; rxPackets: number; txPackets: number; rxBytes: number; txBytes: number }[];
+  protocolStats?: ProtocolStats;
+  connectionStates?: ConnectionStateStats;
+  listeningPorts?: number[];
+}
 
  export interface TaskData {
    pid: number;
@@ -138,10 +153,60 @@ export interface NetworkData {
   txBytes: number;
   rxPackets: number;
   txPackets: number;
+  rxRate: number;
+  txRate: number;
   rxPacketsPerSec?: number;
   txPacketsPerSec?: number;
   connections?: number;
   topProcesses?: NetworkProcess[];
+  protocols?: ProtocolStats;
+  connectionStates?: ConnectionStateStats;
+  listeningPorts?: number[];
+  establishedConnections?: number;
+  topRemoteHosts?: RemoteHostInfo[];
+}
+
+export interface ProtocolStats {
+  tcp: { connections: number; rxBytes: number; txBytes: number };
+  udp: { connections: number; rxBytes: number; txBytes: number };
+}
+
+export interface ConnectionStateStats {
+  established: number;
+  listening: number;
+  timeWait: number;
+  closeWait: number;
+  other: number;
+}
+
+export interface RemoteHostInfo {
+  host: string;
+  ip: string;
+  country?: string;
+  city?: string;
+  asn?: string;
+  bytesTransferred: number;
+  connectionCount: number;
+}
+
+export interface DnsQuery {
+  timestamp: number;
+  domain: string;
+  type: string;
+  process: string;
+}
+
+export interface NetworkConnection {
+  protocol: string;
+  local: string;
+  remote: string;
+  state: string;
+  rxBytes: number;
+  txBytes: number;
+  remoteHost?: string;
+  country?: string;
+  city?: string;
+  asn?: string;
 }
 
 export interface NetworkProcess {
@@ -149,8 +214,11 @@ export interface NetworkProcess {
   command: string;
   rxBytes: number;
   txBytes: number;
-  rxPackets: number;
-  txPackets: number;
+  rxRate?: number;
+  txRate?: number;
+  rxPackets?: number;
+  txPackets?: number;
+  connections?: NetworkConnection[];
 }
 
 export interface ProcessData {
@@ -164,4 +232,19 @@ export interface ProcessData {
    threads: number;
    runtime: number;
    isGpuOrMlAttributed?: boolean;
+}
+
+export interface BlenderRenderData {
+  pid: number;
+  blendFile: string;
+  renderEngine: string;
+  frameStart: number;
+  frameEnd: number;
+  currentFrame: number;
+  totalFrames: number;
+  elapsedSec: number;
+  completionPercent: number;
+  status: 'rendering' | 'finalizing' | 'loading' | 'idle' | 'unknown';
+  outputPath: string;
+  sampleCount?: number;
 }

package/src/state/config.ts

@@ -41,6 +41,7 @@ export interface PyreConfig {
   watchdogMem?: number;
   webhookUrl?: string;
   alertCmd?: string;
+  dockerModeConfirmed?: boolean;
   visiblePanels?: {
     cpu?: boolean;
     mem?: boolean;
@@ -53,6 +54,8 @@ export interface PyreConfig {
     tasks?: boolean;
     disk?: boolean;
     process?: boolean;
+    containers?: boolean;
+    blender?: boolean;
     tree?: boolean;
   };
   panelLayout?: string[];
@@ -83,6 +86,7 @@ export const DEFAULT_CONFIG: Required<PyreConfig> = {
   splashAnimation: 'classic',
   webhookUrl: '',
   alertCmd: '',
+  dockerModeConfirmed: false,
   visiblePanels: {
     cpu: true,
     mem: true,
@@ -95,6 +99,8 @@ export const DEFAULT_CONFIG: Required<PyreConfig> = {
     tasks: true,
     disk: true,
     process: true,
+    containers: true,
+    blender: true,
     tree: false,
   },
   panelLayout: ['mem', 'disk', 'net'],