pyre-cli 9.5.0 → 9.5.2

package/src/live/state.ts

@@ -23,6 +23,8 @@ export const MENU_OPTIONS = ['Resume Dashboard', 'Settings (Customizer)', 'Readm
 
 const config = readConfig();
 
+const isDockerEnv = fs.existsSync('/.dockerenv') || fs.existsSync('/run/.containerenv');
+
 const state = {
    intervalHandle: null as NodeJS.Timeout | null,
    uiIntervalHandle: null as NodeJS.Timeout | null,
@@ -37,19 +39,21 @@ const state = {
 
     exportDir: config.exportDir,
     currentTheme: config.theme as ThemeName,
-     visiblePanels: {
-       cpu: config.visiblePanels.cpu,
-       mem: config.visiblePanels.mem,
-       gpu: config.visiblePanels.gpu,
-       power: config.visiblePanels.power,
-       battery: config.visiblePanels.battery,
-       thermal: config.visiblePanels.thermal,
-       network: config.visiblePanels.network,
-       packets: config.visiblePanels.packets,
-       tasks: config.visiblePanels.tasks,
-       disk: config.visiblePanels.disk,
-       process: config.visiblePanels.process,
-     } as VisibleItems,
+      visiblePanels: {
+        cpu: config.visiblePanels.cpu,
+        mem: config.visiblePanels.mem,
+        gpu: config.visiblePanels.gpu,
+        power: config.visiblePanels.power,
+        battery: config.visiblePanels.battery,
+        thermal: config.visiblePanels.thermal,
+        network: config.visiblePanels.network,
+        packets: config.visiblePanels.packets,
+        tasks: config.visiblePanels.tasks,
+        disk: config.visiblePanels.disk,
+        process: config.visiblePanels.process,
+        containers: config.visiblePanels.containers,
+        blender: config.visiblePanels.blender,
+      } as VisibleItems,
      panelLayout: config.panelLayout || ['mem', 'disk', 'net'],
     logging: false,
     logStream: null as fs.WriteStream | null,
@@ -66,34 +70,36 @@ const state = {
     processScrollOffset: 0,
     trackedPid: null as number | null,
     inspectingProcess: null as any | null,
-    inputMode: null as InputMode,
+    inputMode: (isDockerEnv && !config.dockerModeConfirmed) ? 'docker-alert' as InputMode : null as InputMode,
     inputBuffer: '',
     targetPid: '',
     selectedSignal: 'SIGTERM' as typeof SIGNAL_OPTIONS[number],
     treeView: config.treeView,
     SIGNAL_OPTIONS,
      customizerIndex: 0,
-     CUSTOMIZER_OPTIONS: [
-       'Theme',
-       'Graph Mode',
-       'Splash Screen',
-       'Splash Color',
-       'Splash Animation',
-       'Notifications',
-       'Temperature Unit',
-       'Toggle CPU',
-       'Toggle Memory',
-       'Toggle GPU',
-       'Toggle Power',
-       'Toggle Battery',
-       'Toggle Thermal',
-       'Toggle Network',
-       'Toggle Packets',
-       'Toggle Tasks',
-       'Toggle Disk',
-       'Toggle Processes',
-       'Toggle Tree View',
-     ],
+      CUSTOMIZER_OPTIONS: [
+        'Theme',
+        'Graph Mode',
+        'Splash Screen',
+        'Splash Color',
+        'Splash Animation',
+        'Notifications',
+        'Temperature Unit',
+        'Toggle CPU',
+        'Toggle Memory',
+        'Toggle GPU',
+        'Toggle Power',
+        'Toggle Battery',
+        'Toggle Thermal',
+        'Toggle Network',
+        'Toggle Conns',
+        'Toggle Tasks',
+        'Toggle Disk',
+        'Toggle Processes',
+        'Toggle Containers',
+        'Toggle Blender',
+        'Toggle Tree View',
+      ],
      CPU_ALERT_PCT: config.cpuAlertPct,
      TEMP_ALERT_C: config.tempAlertC,
      watchdogProcess: config.watchdogProcess || '',
@@ -103,23 +109,25 @@ const state = {
      webhookUrl: config.webhookUrl || '',
      alertCmd: config.alertCmd || '',
       alerted: false,
-      activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies',
+       activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies' | 'containers' | 'blender',
        mouseEnabled: config.mouseEnabled,
-         PANEL_TABS: [
-           { id: 'cpu', label: 'CPU', key: '1' },
-           { id: 'mem', label: 'Memory', key: '2' },
-           { id: 'gpu', label: 'GPU', key: '3' },
-           { 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: 'p2p', label: 'P2P', key: 'R' },
-           { id: 'anomalies', label: 'Anomalies', key: 'A' },
-         ],
+          PANEL_TABS: [
+            { id: 'cpu', label: 'CPU', key: '1' },
+            { id: 'mem', label: 'Memory', key: '2' },
+            { id: 'gpu', label: 'GPU', key: '3' },
+            { 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: 'Conns', key: '8' },
+            { id: 'tasks', label: 'Tasks', key: '9' },
+            { id: 'disk', label: 'Disk', key: '0' },
+            { id: 'process', label: 'Process', key: 'P' },
+            { id: 'containers', label: 'Containers', key: 'C' },
+            { id: 'p2p', label: 'P2P', key: 'R' },
+            { id: 'anomalies', label: 'Anomalies', key: 'A' },
+            { id: 'blender', label: 'Blender', key: 'B' },
+          ],
          p2pServer: null as import('../p2p/server.js').P2PServer | null,
          p2pClient: null as import('../p2p/client.js').P2PClient | null,
          p2pServerRunning: false,
@@ -134,6 +142,9 @@ const state = {
         splashAnimation: config.splashAnimation as SplashAnimation,
         menuSelectionIndex: 0,
         readmeScrollOffset: 0,
+        isDocker: isDockerEnv,
+        dockerModeConfirmed: config.dockerModeConfirmed || false,
+        dockerSelectionIndex: 0,
     };
 
 function setStatus(msg: string, ms = 3000) {
@@ -153,10 +164,12 @@ function getToggleKey(opt: string): keyof VisibleItems | null {
     'Toggle Battery': 'battery',
     'Toggle Thermal': 'thermal',
     'Toggle Network': 'network',
-    'Toggle Packets': 'packets',
+    'Toggle Conns': 'packets',
     'Toggle Tasks': 'tasks',
     'Toggle Disk': 'disk',
     'Toggle Processes': 'process',
+    'Toggle Containers': 'containers',
+    'Toggle Blender': 'blender',
     'Toggle Tree View': 'tree',
   };
   return map[opt] ?? null;

package/src/live/types.ts

@@ -20,13 +20,13 @@ export interface LiveOptions {
 
 export type ExportFormat = 'json' | 'csv' | 'tsv' | 'html' | 'md';
 
-type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p' | 'menu' | 'readme' | 'credits';
+type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p' | 'menu' | 'readme' | 'credits' | 'docker-alert';
 
 type SortMode = 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
 
 type GraphMode = 'spark' | 'bar';
 
-type ActivePanel = 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p';
+type ActivePanel = 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'containers' | 'anomalies' | 'blender';
 
 export type { InputMode, SortMode, GraphMode, ActivePanel, ThemeName };
 

package/src/monitors/blender.ts

@@ -0,0 +1,144 @@
+import { run } from './run.js';
+import type { BlenderRenderData } from './types.js';
+
+const RENDER_LOG_DIR = '/tmp/blender_render_logs';
+
+function blendFileFromArgs(args: string[]): string {
+  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: string[]): string {
+  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: string[]): string {
+  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: string[]): { start: number; end: number } {
+  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: string): Promise<{ framesRendered: number; totalFrames: number; startTime: number; samples?: number } | null> {
+  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() - 60000;
+        const sampleMatch = content.match(/Sample\s*(\d+)/i);
+        if (rendered > 0) {
+          return { framesRendered: rendered, totalFrames: totalFrames || rendered, startTime, samples: sampleMatch ? parseInt(sampleMatch[1], 10) : undefined };
+        }
+      } catch {
+        // try next log file
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+export async function collectBlenderRenders(): Promise<BlenderRenderData[]> {
+  const renders: BlenderRenderData[] = [];
+  try {
+    const psRaw = await run("ps -eo pid,pcpu,pmem,state,command 2>/dev/null | grep -iE '[b]lender'", '', 2000);
+    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() - 60000;
+      const elapsedSec = Math.max(0, Math.round((Date.now() - startTime) / 1000));
+      let currentFrame = logData?.framesRendered ?? 0;
+      if (currentFrame === 0 && cpuPct > 0) currentFrame = 1;
+
+      let status: BlenderRenderData['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 {
+    // ignore
+  }
+  return renders;
+}