pyre-cli 8.2.0 → 9.1.0

package/src/live/render.ts

@@ -7,10 +7,13 @@
  * `state.ts`.
  */
 import { execFile, exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
-import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel, fitVisible } from '../formatters/index.js';
+import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel, fitVisible, visLen } from '../formatters/index.js';
 import { detectAnomalies } from '../anomalies.js';
-import { state, setStatus, SIGNAL_OPTIONS, getToggleKey } from './state.js';
+import { state, setStatus, SIGNAL_OPTIONS, getToggleKey, MENU_OPTIONS } from './state.js';
 import type { StatsData } from '../monitors/index.js';
 
 function formatTempForUnit(c: number): string {
@@ -48,6 +51,9 @@ function tableCacheParams(): string {
   return [
     state.sortMode,
     state.processFilter || '',
+    state.processSelectionIndex,
+    state.trackedPid || '',
+    state.inspectingProcess ? state.inspectingProcess.pid : '',
     limit,
     state.currentTheme,
     state.activePanel,
@@ -68,8 +74,7 @@ function graphsCacheParams(): string {
 
 function processRowBudget(): number {
   let overlayRows = 0;
-  if (state.inputMode === 'customizer') overlayRows = state.CUSTOMIZER_OPTIONS.length + 3;
-  else if (state.inputMode === 'signal') overlayRows = 6;
+  if (state.inputMode === 'signal') overlayRows = 6;
   else if (state.inputMode === 'filter' || state.inputMode === 'kill' || state.inputMode === 'p2p') overlayRows = 3;
 
   if (state.activePanel === 'process') {
@@ -198,13 +203,41 @@ function render() {
     writeFrame(out);
     return;
   }
+
+  if (state.inputMode === 'menu') {
+    writeFrame(renderSplashMenu(cols, rows));
+    return;
+  }
+  if (state.inputMode === 'readme') {
+    writeFrame(renderReadme(cols, rows));
+    return;
+  }
+  if (state.inputMode === 'credits') {
+    writeFrame(renderCredits(cols, rows));
+    return;
+  }
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
    const params = tableCacheParams();
    const anomalies = detectAnomalies(state.lastData, state.history);
+   if (anomalies.length > 0) {
+     for (const a of anomalies) {
+       const now = new Date();
+       const alertWithTime = { ...a, timestamp: now };
+       const exists = state.anomalyHistory.some(
+         h => h.metric === a.metric && Math.abs(h.zScore - a.zScore) < 0.1 && (now.getTime() - (h.timestamp?.getTime() || 0)) < 10000
+       );
+       if (!exists) {
+         state.anomalyHistory.unshift(alertWithTime);
+       }
+     }
+     if (state.anomalyHistory.length > 100) {
+       state.anomalyHistory.length = 100;
+     }
+   }
    const anomalyCacheKey = anomalies.map(a => `${a.metric}:${a.zScore.toFixed(2)}`).join(',');
-   const cacheParams = params + '|' + anomalyCacheKey;
+   const cacheParams = params + '|' + anomalyCacheKey + '|' + state.anomalyHistory.length;
     const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || cacheParams !== _cachedTableParams
       ? (() => {
           const out = formatTable(state.lastData, {
@@ -222,6 +255,9 @@ function render() {
             history: state.history,
             graphMode: state.graphMode,
             panelLayout: state.panelLayout,
+            selectedProcessIndex: state.processSelectionIndex,
+            trackedPid: state.trackedPid,
+            inspectProcess: state.inspectingProcess,
           });
           _cachedTableData = state.lastData;
           _cachedTableParams = cacheParams;
@@ -265,17 +301,26 @@ function render() {
   const targetBodyHeight = Math.max(1, state.termHeight - footerHeight);
 
   if (state.inputMode === 'customizer') {
-    const preOverlayCount = bodyLines.length;
-    const availableForOverlay = targetBodyHeight - preOverlayCount;
     const totalItems = state.CUSTOMIZER_OPTIONS.length;
-    const headerLines = 1;
-    const blankLines = availableForOverlay >= 2 ? 1 : 0;
-    const maxVisibleItems = Math.max(0, availableForOverlay - headerLines - blankLines);
+    const headerLines = 1;  // the "UI CUSTOMIZER" header
+    const blankLines = 1;   // blank separator line
+    // Reserve a fixed height for the customizer: show all items if they fit,
+    // otherwise guarantee at least 10 visible items (or half the screen).
+    const idealOverlayHeight = totalItems + headerLines + blankLines;
+    const minOverlayHeight = Math.min(10 + headerLines + blankLines, Math.floor(targetBodyHeight / 2));
+    const overlayHeight = Math.min(idealOverlayHeight, Math.max(minOverlayHeight, Math.floor(targetBodyHeight * 0.6)));
+    // Truncate table body to make room for the customizer overlay
+    const maxBodyForTable = Math.max(3, targetBodyHeight - overlayHeight);
+    if (bodyLines.length > maxBodyForTable) {
+      bodyLines.length = maxBodyForTable;
+    }
+    const availableForOverlay = targetBodyHeight - bodyLines.length;
+    const maxVisibleItems = Math.max(1, availableForOverlay - headerLines - blankLines);
     const scrollOffset = totalItems > maxVisibleItems
       ? Math.max(0, Math.min(state.customizerIndex, totalItems - maxVisibleItems))
       : 0;
 
-    if (blankLines > 0) bodyLines.push('');
+    bodyLines.push('');
     bodyLines.push(...renderCustomizerOverlay(scrollOffset, maxVisibleItems).split('\n'));
   } else if (state.inputMode === 'filter') {
     bodyLines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
@@ -414,4 +459,109 @@ function checkAlerts(data: StatsData) {
    }
   }
 
+function renderSplashMenu(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const contentLines: string[] = [];
+  const logo = [
+    chalk.hex('#ff6004').bold('                ██████╗ ██╗   ██╗██████╗ ███████╗'),
+    chalk.hex('#ff8004').bold('                ██╔══██╗╚██╗ ██╔╝██╔══██╗██╔════╝'),
+    chalk.hex('#ffa004').bold('                ██████╔╝ ╚████╔╝ ██████╔╝█████╗  '),
+    chalk.hex('#ffc004').bold('                ██╔═══╝   ╚██╔╝  ██╔══██╗██╔══╝  '),
+    chalk.hex('#ffe004').bold('                ██║        ██║   ██║  ██║███████╗'),
+    chalk.hex('#ffff40').bold('                ╚═╝        ╚═╝   ╚═╝  ╚═╝╚══════╝')
+  ];
+
+  const menuTop = Math.max(0, Math.floor(rows / 2) - 8);
+  for (let i = 0; i < menuTop; i++) out.push('');
+
+  const strip = (s: string) => s.replace(/^(\x1b\[[0-9;]*m)+( +)/, '$1');
+  for (const line of logo) contentLines.push(strip(line));
+  contentLines.push('');
+  contentLines.push(strip(chalk.dim('                  system monitor v9.0.0')));
+  contentLines.push('');
+  contentLines.push('');
+
+  for (let i = 0; i < MENU_OPTIONS.length; i++) {
+    const isSelected = i === state.menuSelectionIndex;
+    const opt = MENU_OPTIONS[i];
+    const prefix = isSelected ? chalk.cyan.bold('  ▶ ') : '    ';
+    const text = isSelected ? chalk.bgCyan.black(` ${opt} `) : chalk.dim(` ${opt} `);
+    contentLines.push(prefix + text);
+  }
+
+  contentLines.push('');
+  contentLines.push('');
+  contentLines.push(strip(chalk.dim('             Use ↑/↓ to navigate, Enter to select')));
+
+  while (contentLines.length < rows) contentLines.push('');
+  const maxWidth = Math.max(...contentLines.map(visLen));
+  const padding = Math.max(0, Math.floor((cols - maxWidth) / 2));
+  const padStr = ' '.repeat(padding);
+  for (const line of contentLines) out.push(padStr + fitVisible(line, cols));
+  return out;
+}
+
+let cachedReadmeLines: string[] | null = null;
+
+function getReadmeLines(): string[] {
+  if (cachedReadmeLines) return cachedReadmeLines;
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const rootDir = path.resolve(__dirname, '..', '..');
+    const readmePath = path.join(rootDir, 'README.md');
+    const content = fs.readFileSync(readmePath, 'utf8');
+    cachedReadmeLines = content.split('\n');
+    return cachedReadmeLines;
+  } catch (err) {
+    return [chalk.red('Failed to load README.md')];
+  }
+}
+
+function renderReadme(cols: number, rows: number): string[] {
+  const lines = getReadmeLines();
+  const availableLines = Math.max(1, rows - 2); // Body height of the panel
+  
+  const startIdx = Math.min(state.readmeScrollOffset, Math.max(0, lines.length - availableLines));
+  state.readmeScrollOffset = startIdx; // Clamp the state value
+  
+  const content = lines.slice(startIdx, startIdx + availableLines).map(l => {
+    let out = l;
+    if (out.startsWith('#')) {
+       out = chalk.cyan.bold(out);
+    } else if (out.startsWith('```')) {
+       out = chalk.dim(out);
+    } else if (out.startsWith('- ') || out.startsWith('* ')) {
+       out = '  ' + chalk.yellow(out.substring(0, 2)) + out.substring(2);
+    }
+    return out;
+  });
+
+  const out: string[] = [];
+  const pct = Math.round((startIdx / Math.max(1, lines.length - availableLines)) * 100);
+  const title = lines.length > availableLines 
+    ? `README (${pct}%)` 
+    : 'README';
+  out.push(...panel(title, content, cols, chalk.cyan, chalk.dim, availableLines));
+  return out;
+}
+
+function renderCredits(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const content = [
+    chalk.bold.hex('#ff6004')('Pyre - The Terminal System Monitor'),
+    '',
+    'Created with ❤️  using Node.js',
+    '',
+    chalk.cyan('Libraries used:'),
+    '  - chalk       (Terminal styling)',
+    '  - systeminformation (System metrics)',
+    '',
+    chalk.dim('Press Esc or Enter to return to menu.')
+  ];
+
+  out.push(...panel('CREDITS', content, cols, chalk.magenta, chalk.dim, rows - 2));
+  return out;
+}
+
 export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget, invalidateTableCache, invalidateFrame };

package/src/live/state.ts

@@ -19,6 +19,8 @@ import { type SplashColorScheme, type SplashAnimation } from '../splash.js';
 
 export { type SplashColorScheme, type SplashAnimation };
 
+export const MENU_OPTIONS = ['Resume Dashboard', 'Settings (Customizer)', 'Readme', 'Credits', 'Quit pyre'] as const;
+
 const config = readConfig();
 
 const state = {
@@ -60,6 +62,10 @@ const state = {
     termHeight: process.stdout.rows || 24,
     sortMode: config.sortMode as SortMode,
     processFilter: '',
+    processSelectionIndex: 0,
+    processScrollOffset: 0,
+    trackedPid: null as number | null,
+    inspectingProcess: null as any | null,
     inputMode: null as InputMode,
     inputBuffer: '',
     targetPid: '',
@@ -126,6 +132,7 @@ const state = {
         splashEnabled: config.splashEnabled,
         splashColorScheme: config.splashColorScheme as SplashColorScheme,
         splashAnimation: config.splashAnimation as SplashAnimation,
+        readmeScrollOffset: 0,
     };
 
 function setStatus(msg: string, ms = 3000) {

package/src/live/types.ts

@@ -20,7 +20,7 @@ export interface LiveOptions {
 
 export type ExportFormat = 'json' | 'csv' | 'tsv' | 'html' | 'md';
 
-type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p';
+type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p' | 'menu' | 'readme' | 'credits';
 
 type SortMode = 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
 

package/src/monitors/collectors.ts

@@ -20,6 +20,7 @@ import type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerDat
 const SP_TTL_MS = 10_000;
 const NETSTAT_TTL_MS = 1000;
 let prevCpuTimes: { total: number; idle: number }[] | null = null;
+let prevCpuTotal = { total: 0, idle: 0, ts: 0 };
 const ROUTE_TTL_MS = 5_000;
 const SYSCTL_TTL_MS = 60_000;
 
@@ -236,7 +237,7 @@ export async function collectPower(): Promise<PowerData | null> {
     if (spGpuCache && now - spGpuCache.ts < SP_TTL_MS) {
       spRaw = spGpuCache.raw;
     } else {
-      spRaw = (await run('system_profiler SPDisplaysDataType 2>/dev/null')).trim();
+      spRaw = (await run('system_profiler SPDisplaysDataType 2>/dev/null', '', 3000)).trim();
       spGpuCache = { raw: spRaw, ts: now };
     }
 
@@ -400,18 +401,36 @@ export async function collectCpu(): Promise<CpuData> {
     }
   }
 
+  if (frequency === 0) {
+    try {
+      const cpus = os.cpus();
+      if (cpus && cpus.length > 0 && cpus[0].speed) {
+        frequency = cpus[0].speed;
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // Use os.cpus() delta instead of the very slow `top -l 1 -n 0` which
+  // blocks for ~1-2s waiting for a sampling window. os.cpus() is instant.
   let usage = 0;
   try {
-    const top = (await run('top -l 1 -n 0')).trim();
-    // Real `top -l 1 -n 0` output is comma-separated and newline-terminated,
-    // e.g. "CPU usage: 5.26% user, 10.52% sys, 84.21% idle" — there is no
-    // semicolon anywhere on that line. The old regex required one to
-    // terminate the match, so it never matched and usage stayed at 0.
-    const cpuLine = top.match(/CPU usage:\s*[\d.]+%\s*user,\s*[\d.]+%\s*sys,\s*([\d.]+)%\s*idle/);
-    if (cpuLine) {
-      const idle = parseFloat(cpuLine[1]);
-      usage = Math.round(100 - idle);
+    const cpus = os.cpus();
+    let totalNow = 0;
+    let idleNow = 0;
+    for (const cpu of cpus) {
+      totalNow += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+      idleNow += cpu.times.idle;
+    }
+    if (prevCpuTotal.ts > 0) {
+      const totalDelta = totalNow - prevCpuTotal.total;
+      const idleDelta = idleNow - prevCpuTotal.idle;
+      if (totalDelta > 0) {
+        usage = Math.round(((totalDelta - idleDelta) / totalDelta) * 100);
+      }
     }
+    prevCpuTotal = { total: totalNow, idle: idleNow, ts: Date.now() };
   } catch {
     // ignore
   }
@@ -534,7 +553,7 @@ async function getDiskIoRates(): Promise<{ readBytesSec: number; writeBytesSec:
     return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
   }
   try {
-    const raw = (await run('iostat -d -c 2 1 2', '')).trim();
+    const raw = (await run('iostat -d -c 2 1 2', '', 3000)).trim();
     const blocks = raw.split(/\n\s*\n/).filter(Boolean);
     const targetBlock = blocks.length > 1 ? blocks[1] : blocks[0];
     if (targetBlock) {
@@ -606,7 +625,7 @@ export async function collectBattery(): Promise<BatteryData | null> {
       if (spBatteryCache && now - spBatteryCache.ts < SP_TTL_MS) {
         battInfo = spBatteryCache.raw;
       } else {
-        battInfo = (await run('system_profiler SPPowerDataType 2>/dev/null')).trim();
+        battInfo = (await run('system_profiler SPPowerDataType 2>/dev/null', '', 3000)).trim();
         spBatteryCache = { raw: battInfo, ts: now };
       }
 
@@ -821,7 +840,7 @@ export async function collectPackets(): Promise<PacketData | null> {
 
      let connections = 0;
      try {
-       const tcpConns = (await run('netstat -an | grep ESTABLISHED | wc -l', '0')).trim();
+       const tcpConns = (await run('netstat -an | grep ESTABLISHED | wc -l', '0', 2000)).trim();
        connections = parseInt(tcpConns) || 0;
      } catch {
        connections = 0;
@@ -830,7 +849,7 @@ export async function collectPackets(): Promise<PacketData | null> {
      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', '')).trim();
+          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+/);

package/src/monitors/run.ts

@@ -11,7 +11,7 @@ import { promisify } from 'node:util';
 
 const execAsync = promisify(exec);
 
-async function run(cmd: string, fallback: string = '', timeout = 5000): Promise<string> {
+async function run(cmd: string, fallback: string = '', timeout = 3000): Promise<string> {
   try {
     return (await execAsync(cmd, { encoding: 'utf8', timeout })).stdout.trim();
   } catch {

package/src/monitors/smc.ts

@@ -41,7 +41,8 @@ export async function getSmcMetrics(): Promise<SmcMetrics> {
     const pm = (
       await run(
         'sudo -n powermetrics --samplers smc,cpu_power -n 1 --format text 2>/dev/null',
-        ''
+        '',
+        2000
       )
     ).trim();
 
@@ -116,14 +117,10 @@ export async function getSmcMetrics(): Promise<SmcMetrics> {
 
   // 4. Smart load-based thermal estimation if hardware sensors return nothing
   if (result.temps['cpu_die'] === undefined) {
-    let loadUsage = 0;
-    try {
-      const top = await run('top -l 1 -n 0 2>/dev/null', '');
-      const m = top.match(/CPU usage:\s*[\d.]+\%\s*user,\s*[\d.]+\%\s*sys,\s*([\d.]+)\%\s*idle/);
-      if (m) loadUsage = Math.max(0, 100 - parseFloat(m[1]));
-    } catch {
-      // ignore
-    }
+    // Use os.loadavg() (instant) instead of the slow `top -l 1` (~1-2s)
+    const loadAvg = (await import('node:os')).loadavg();
+    const ncpus = (await import('node:os')).cpus().length || 1;
+    const loadUsage = Math.min(100, (loadAvg[0] / ncpus) * 100);
 
     const estCpu = Math.round((38 + (loadUsage * 0.42)) * 10) / 10;
     result.temps['cpu_die'] = estCpu;

package/src/splash.ts

@@ -198,6 +198,6 @@ export async function showSplash(config?: SplashConfig): Promise<void> {
     process.stdin.resume();
     process.stdin.on('data', onEnter);
 
-    setTimeout(onEnter, 5000);
+    setTimeout(onEnter, 1500);
   });
 }