pyre-cli 5.1.0 → 6.1.0

package/src/historyCmd.ts

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { sparkline } from './sparkline.js';
+
+export interface HistoryOptions {
+  days?: number;
+  dir?: string;
+}
+
+export function runHistoryCommand(opts: HistoryOptions = {}): void {
+  const days = opts.days || 7;
+  const dir = opts.dir || './pyre-exports';
+
+  console.log(chalk.bold(`\n  pyre history — Past ${days} Days Trend\n`));
+
+  if (!fs.existsSync(dir)) {
+    console.log(chalk.yellow(`  No logs directory found at ${dir}`));
+    return;
+  }
+
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('pyre-log-') && f.endsWith('.csv'));
+  if (files.length === 0) {
+    console.log(chalk.yellow(`  No CSV logs found in ${dir}`));
+    return;
+  }
+
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  const cpuPoints: number[] = [];
+  const memPoints: number[] = [];
+  const tempPoints: number[] = [];
+
+  for (const file of files.sort()) {
+    const fullPath = path.join(dir, file);
+    try {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      const lines = content.split('\n').slice(1);
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const parts = line.split(',');
+        if (parts.length >= 4) {
+          const tsStr = parts[0];
+          const ts = new Date(tsStr).getTime();
+          if (!isNaN(ts) && ts >= cutoff) {
+            const cpu = parseFloat(parts[1]);
+            const mem = parseFloat(parts[2]);
+            const temp = parseFloat(parts[3]);
+            if (!isNaN(cpu)) cpuPoints.push(cpu);
+            if (!isNaN(mem)) memPoints.push(mem);
+            if (!isNaN(temp)) tempPoints.push(temp);
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  if (cpuPoints.length === 0) {
+    console.log(chalk.yellow(`  No historical entries recorded within the last ${days} days.`));
+    return;
+  }
+
+  console.log(`  Data Points: ${cpuPoints.length} logged snapshots`);
+  console.log(`  CPU Usage:   ${sparkline(cpuPoints, { min: 0, max: 100 })} (${(cpuPoints.reduce((a, b) => a + b, 0) / cpuPoints.length).toFixed(1)}% avg)`);
+  console.log(`  Memory:      ${sparkline(memPoints, { min: 0, max: 100 })} (${(memPoints.reduce((a, b) => a + b, 0) / memPoints.length).toFixed(1)}% avg)`);
+  if (tempPoints.length) {
+    console.log(`  Temperature: ${sparkline(tempPoints)} (${(tempPoints.reduce((a, b) => a + b, 0) / tempPoints.length).toFixed(1)}°C avg)`);
+  }
+  console.log();
+}

package/src/index.ts

@@ -17,8 +17,11 @@ import { formatTable, formatJson, formatCsv, formatTsv, formatHtml, formatMarkdo
 import { startLive, stopLive } from './live/index.js';
 import { showSplash } from './splash.js';
 import { P2PServer, P2PClient } from './p2p/index.js';
-import { readConfig } from './state/config.js';
-import { CONFIG_FILE } from './state/config.js';
+import { runDoctor, printDoctorReport } from './doctor.js';
+import { generateZshCompletions, generateBashCompletions, generateFishCompletions } from './completions.js';
+import { runHistoryCommand } from './historyCmd.js';
+import { runDiffCommand } from './diffCmd.js';
+import { readConfig, CONFIG_FILE } from './state/config.js';
 
 const config = readConfig();
 
@@ -61,7 +64,11 @@ program
     .option('--p2p-allow <ips>', 'Comma-separated list of allowed IPs (empty = all)')
     .option('--p2p-deny <ips>', 'Comma-separated list of denied IPs')
     .option('--p2p-audit-log <dir>', 'Directory for P2P audit logs')
-    .option('--p2p-hmac-key <key>', 'HMAC key for message signing (default: derived from password)');
+    .option('--p2p-hmac-key <key>', 'HMAC key for message signing (default: derived from password)')
+    .option('--port <port>', 'Port number for web server mode', '3000')
+    .option('--web-auth', 'Enable Basic Authentication for web server')
+    .option('--web-user <user>', 'Username for web server authentication', 'admin')
+    .option('--web-pass <pass>', 'Password for web server authentication', 'pyre');
 
 program.parse(process.argv);
 
@@ -122,8 +129,21 @@ async function runServerCommand(): Promise<void> {
 async function main() {
   const cmd = program.args[0];
 
-  if (cmd === 'info') {
-    await runInfoCommand();
+  if (cmd === 'history') {
+    const daysIdx = program.args.indexOf('--days');
+    const days = daysIdx !== -1 ? parseInt(program.args[daysIdx + 1], 10) || 7 : 7;
+    runHistoryCommand({ days });
+    return;
+  }
+
+  if (cmd === 'diff') {
+    const file1 = program.args[1];
+    const file2 = program.args[2];
+    if (!file1 || !file2) {
+      console.log(chalk.red('Usage: pyre diff <snapshot1.json> <snapshot2.json>'));
+      process.exit(1);
+    }
+    runDiffCommand(file1, file2);
     return;
   }
 
@@ -176,10 +196,18 @@ async function main() {
   const tempUnit = opts.tempUnit === 'f' ? 'f' : 'c';
 
   if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
+    if (!process.stdout.isTTY && cmd !== 'live') {
+      await runWebCommand();
+      return;
+    }
     if (cmd === 'live') {
       program.args.shift();
     }
-    const splashPromise = showSplash();
+    const splashPromise = showSplash({
+      enabled: config.splashEnabled,
+      colorScheme: config.splashColorScheme as any,
+      animation: config.splashAnimation as any,
+    });
     const interval = parseFloat(opts.interval) || 2;
     await startLive({
       interval,
@@ -471,7 +499,7 @@ async function runSshCommand(host: string): Promise<void> {
     }
     process.exit(0);
   });
-  child.stdin.end();
+  child.stdin?.end();
 
   process.once('SIGINT', () => {
     child.kill('SIGTERM');
@@ -481,14 +509,90 @@ async function runSshCommand(host: string): Promise<void> {
 
 async function runWebCommand(): Promise<void> {
   const http = await import('node:http');
-  const data = await collectAll({ detailed: true });
+  const port = parseInt(opts.port || process.env.PORT || '3000', 10) || 3000;
+  const authEnabled = !!opts.webAuth;
+  const authUser = opts.webUser || 'admin';
+  const authPass = opts.webPass || 'pyre';
+
+  const server = http.createServer(async (req, res) => {
+    // 1. Basic Authentication Check
+    if (authEnabled) {
+      const authHeader = req.headers.authorization;
+      if (!authHeader || !authHeader.startsWith('Basic ')) {
+        res.writeHead(401, {
+          'WWW-Authenticate': 'Basic realm="pyre Web Dashboard"',
+          'Content-Type': 'text/plain',
+        });
+        res.end('401 Unauthorized');
+        return;
+      }
+      const credentials = Buffer.from(authHeader.split(' ')[1], 'base64').toString('utf-8');
+      const [user, pass] = credentials.split(':');
+      if (user !== authUser || pass !== authPass) {
+        res.writeHead(401, {
+          'WWW-Authenticate': 'Basic realm="pyre Web Dashboard"',
+          'Content-Type': 'text/plain',
+        });
+        res.end('401 Unauthorized');
+        return;
+      }
+    }
 
-  const server = http.createServer((req, res) => {
-    if (req.url === '/' || req.url === '/index.html') {
-      res.writeHead(200, { 'Content-Type': 'text/html' });
-      res.end(formatHtml(data));
-    } else if (req.url === '/api') {
+    const url = req.url || '/';
+
+    // 2. Health check endpoint
+    if (url === '/health' || url === '/api/health') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() }));
+      return;
+    }
+
+    // 3. Real-time Server-Sent Events (SSE) stream endpoint
+    if (url === '/api/stream') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+      });
+
+      const sendStats = async () => {
+        try {
+          const data = await collectAll({ detailed: true });
+          res.write(`data: ${JSON.stringify(data)}\n\n`);
+        } catch {
+          // ignore stream collect error
+        }
+      };
+
+      sendStats();
+      const intervalId = setInterval(sendStats, 2000);
+
+      req.on('close', () => {
+        clearInterval(intervalId);
+      });
+      return;
+    }
+
+    // 4. Static HTML dashboard & API snapshot endpoints
+    if (url === '/' || url === '/index.html') {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      const indexPath = path.join(process.cwd(), 'index.html');
+      let htmlContent = '';
+      if (fs.existsSync(indexPath)) {
+        htmlContent = fs.readFileSync(indexPath, 'utf-8');
+      } else {
+        const data = await collectAll({ detailed: true });
+        htmlContent = formatHtml(data);
+      }
+      res.end(htmlContent);
+    } else if (url === '/api' || url === '/api/stats' || url === '/data') {
+      const data = await collectAll({ detailed: true });
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, OPTIONS',
+      });
       res.end(JSON.stringify(data, null, 2));
     } else {
       res.writeHead(404);
@@ -496,19 +600,20 @@ async function runWebCommand(): Promise<void> {
     }
   });
 
-  server.listen(0, '127.0.0.1', async () => {
-    const address = server.address();
-    const port = typeof address === 'object' && address ? address.port : 0;
-    const url = `http://127.0.0.1:${port}`;
-    console.log(chalk.bold(`\n  pyre web`));
-    console.log(chalk.dim(`  Dashboard: ${url}`));
-    console.log(chalk.dim(`  API:      ${url}/api`));
+  server.listen(port, '0.0.0.0', () => {
+    console.log(chalk.bold(`\n  pyre web server running on port ${port}`));
+    console.log(chalk.dim(`  Dashboard: http://0.0.0.0:${port}/`));
+    console.log(chalk.dim(`  API:       http://0.0.0.0:${port}/api`));
+    console.log(chalk.dim(`  SSE Stream: http://0.0.0.0:${port}/api/stream`));
+    if (authEnabled) {
+      console.log(chalk.yellow(`  Authentication: Enabled (${authUser}:${authPass})`));
+    }
     console.log(chalk.dim('  Press Ctrl+C to stop\n'));
+  });
 
-    process.once('SIGINT', () => {
-      server.close();
-      process.exit(0);
-    });
+  process.once('SIGINT', () => {
+    server.close();
+    process.exit(0);
   });
 }
 

package/src/live/input.ts

@@ -13,7 +13,7 @@ import { THEMES, type ThemeName, type VisibleItems, getTabHitboxes, TAB_BAR_ROW
 import { state, setStatus, getToggleKey, type SplashColorScheme, type SplashAnimation } from './state.js';
 import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow } from './export.js';
 import { render, footerLine, checkAlerts, invalidateTableCache, invalidateFrame } from './render.js';
-import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
+import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode, ActivePanel } from './types.js';
 import { startP2PServer } from '../p2p/index.js';
 import { writeConfig } from '../state/config.js';
 
@@ -189,12 +189,20 @@ function handleInputModeKey(str: string, key: readline.Key) {
 
    if (key.name === 'backspace') {
      state.inputBuffer = state.inputBuffer.slice(0, -1);
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer;
+       invalidateTableCache();
+     }
      render();
      return;
    }
 
    if (str && str.length === 1 && !key.ctrl && !key.meta) {
      state.inputBuffer += str;
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer;
+       invalidateTableCache();
+     }
      render();
    }
  }
@@ -404,8 +412,9 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
         return;
       }
 
-      if (key.mouse) {
-        handleMouseClick(key.mouse);
+      const mouse = (key as { mouse?: { x: number; y: number } }).mouse;
+      if (mouse) {
+        handleMouseClick(mouse.y, mouse.x);
         return;
       }
 
@@ -437,7 +446,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           return;
         case '0': case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8': case '9': {
-          const tabMap: Record<string, string> = {
+          const tabMap: Record<string, ActivePanel> = {
             '0': 'disk', '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power',
             '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks'
           };
@@ -558,7 +567,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           if (str && str.length === 1) {
             const tabId = tabKeyToId(str);
             if (tabId) {
-              state.activePanel = tabId;
+              state.activePanel = tabId as ActivePanel;
               setStatus(`Panel: ${tabId.toUpperCase()}`);
               render();
             }

package/src/live/render.ts

@@ -8,7 +8,7 @@
  */
 import { execFile } from 'node:child_process';
 import chalk from 'chalk';
-import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel } from '../formatters/index.js';
+import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel, fitVisible } from '../formatters/index.js';
 import { detectAnomalies } from '../anomalies.js';
 import { state, setStatus, SIGNAL_OPTIONS, getToggleKey } from './state.js';
 import type { StatsData } from '../monitors/index.js';
@@ -52,6 +52,7 @@ function tableCacheParams(): string {
     state.currentTheme,
     state.activePanel,
     state.treeView ? '1' : '0',
+    state.history.version,
     JSON.stringify(state.visiblePanels),
   ].join('|');
 }
@@ -64,29 +65,21 @@ function graphsCacheParams(): string {
   ].join('|');
 }
 
-/**
- * How many process rows we can realistically fit given
- * current terminal height.  Computed from the number of
- * card columns and the reserved space for the header,
- * cards, graphs, and footer.
- */
-  function processRowBudget(): number {
-    let overlayRows = 0;
-    if (state.inputMode === 'customizer') overlayRows = state.CUSTOMIZER_OPTIONS.length + 3;
-    else if (state.inputMode === 'signal') overlayRows = 6;
-    else if (state.inputMode === 'filter' || state.inputMode === 'kill' || state.inputMode === 'p2p') overlayRows = 3;
-
-    if (state.activePanel === 'process') {
-      return Math.max(10, state.termHeight - 12 - overlayRows);
-    }
+function processRowBudget(): number {
+  let overlayRows = 0;
+  if (state.inputMode === 'customizer') overlayRows = state.CUSTOMIZER_OPTIONS.length + 3;
+  else if (state.inputMode === 'signal') overlayRows = 6;
+  else if (state.inputMode === 'filter' || state.inputMode === 'kill' || state.inputMode === 'p2p') overlayRows = 3;
 
-    const columns = gridColumns(state.termWidth);
-    const visibleCards = Object.values(state.visiblePanels).filter(v => v !== false).length;
-    const cardRows = Math.ceil(visibleCards / columns);
-    const reserved = 4 + cardRows * 8 + 8 + (state.showGraphs ? 11 : 0) + 5 + overlayRows;
-    return Math.max(5, state.termHeight - reserved);
+  if (state.activePanel === 'process') {
+    return Math.max(10, state.termHeight - 12 - overlayRows);
   }
 
+  const reserved = 16 + overlayRows;
+  return Math.max(4, state.termHeight - reserved);
+}
+
+
 function p2pPanelLines(): { title: string; body: string[] } {
   const events = state.p2pServer ? state.p2pServer.peerEventHistory : state.p2pEvents;
   const body: string[] = [];
@@ -114,42 +107,45 @@ function p2pPanelLines(): { title: string; body: string[] } {
   return { title, body };
 }
 
-function renderCustomizerOverlay(): string {
-   const themesList = Object.keys(THEMES) as ThemeName[];
-   const lines = [
-     chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) '),
-   ];
-
-     state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
-       const isSelected = idx === state.customizerIndex;
-       const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
-
-        if (opt === 'Theme') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
-        } else if (opt === 'Graph Mode') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
-        } else if (opt === 'Splash Screen') {
-          const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
-          lines.push(`${prefix}${opt}: ${status}`);
-        } else if (opt === 'Splash Color') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
-        } else if (opt === 'Splash Animation') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
-        } else if (opt === 'Notifications') {
-          const status = state.notificationsEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
-          lines.push(`${prefix}${opt}: ${status}`);
-        } else if (opt === 'Temperature Unit') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
-        } else {
-          const toggleKey = getToggleKey(opt);
-          const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
-          const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
-          lines.push(`${prefix}${opt}: ${status}`);
-        }
-     });
+function renderCustomizerOverlay(scrollOffset: number, maxVisibleItems: number): string {
+    const themesList = Object.keys(THEMES) as ThemeName[];
+    const headerLine = chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) ');
+    const totalItems = state.CUSTOMIZER_OPTIONS.length;
+    const end = Math.min(scrollOffset + maxVisibleItems, totalItems);
+
+    const lines = [headerLine];
+
+    for (let i = scrollOffset; i < end; i++) {
+      const opt = state.CUSTOMIZER_OPTIONS[i];
+      const isSelected = i === state.customizerIndex;
+      const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
+
+       if (opt === 'Theme') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
+       } else if (opt === 'Graph Mode') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
+       } else if (opt === 'Splash Screen') {
+         const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       } else if (opt === 'Splash Color') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
+       } else if (opt === 'Splash Animation') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
+       } else if (opt === 'Notifications') {
+         const status = state.notificationsEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       } else if (opt === 'Temperature Unit') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
+       } else {
+         const toggleKey = getToggleKey(opt);
+         const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
+         const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       }
+    }
 
    return lines.map(l => `  ${l}`).join('\n');
- }
+  }
 
 // --- frame diffing -------------------------------------------------------
 // Instead of erasing the whole screen (`\x1b[2J`) and repainting everything
@@ -189,6 +185,18 @@ function writeFrame(lines: string[]) {
 
 function render() {
   if (!state.lastData) return;
+  const rows = state.termHeight || 24;
+  const cols = state.termWidth || 80;
+  if (cols < 50 || rows < 15) {
+    const msg = chalk.yellow(`pyre ${rows}x${cols} too small. Resize terminal to >= 50x20.`);
+    const centered = Math.max(0, Math.floor((rows - 2) / 2));
+    const out: string[] = [];
+    for (let i = 0; i < centered; i++) out.push('');
+    out.push(msg.padEnd(cols));
+    while (out.length < rows) out.push('');
+    writeFrame(out);
+    return;
+  }
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
@@ -209,6 +217,8 @@ function render() {
             activePanel: state.activePanel,
             anomalies,
             tempUnit: state.tempUnit,
+            history: state.history,
+            graphMode: state.graphMode,
           });
           _cachedTableData = state.lastData;
           _cachedTableParams = cacheParams;
@@ -243,43 +253,56 @@ function render() {
     bodyLines.push(...graphsStr.split('\n'));
   }
 
-  const footerLines: string[] = [];
-  footerLines.push('');
-  footerLines.push(...footerLine().split('\n'));
+  const footerLine1 = footerLine()[0] || '';
+  const footerLine2 = footerLine()[1] || '';
+  const footerLine3 = footerLine()[2] || ' ';
+  const footerLines = [footerLine1, footerLine2, footerLine3];
 
-  if (state.inputMode === 'customizer') {
-      footerLines.push(...renderCustomizerOverlay().split('\n'));
-    } else if (state.inputMode === 'filter') {
-      footerLines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
-    } else if (state.inputMode === 'kill') {
-      footerLines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
-     } else if (state.inputMode === 'signal') {
-       const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
-       const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk.yellow(s) : chalk.dim(s)).join('  ');
-       footerLines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
-       footerLines.push(chalk.dim(`  ${sigList}`));
-       footerLines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
-     } else if (state.inputMode === 'p2p') {
-       footerLines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
-     } else if (state.statusMessage) {
-       footerLines.push(`  ${state.statusMessage}`);
-     } else {
-       footerLines.push('');
-     }
+  const footerHeight = 3;
+  const targetBodyHeight = Math.max(1, state.termHeight - footerHeight);
 
-  const maxBodyLines = Math.max(1, state.termHeight - footerLines.length);
-  if (bodyLines.length > maxBodyLines) {
-    bodyLines.length = maxBodyLines;
+  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 scrollOffset = totalItems > maxVisibleItems
+      ? Math.max(0, Math.min(state.customizerIndex, totalItems - maxVisibleItems))
+      : 0;
+
+    if (blankLines > 0) bodyLines.push('');
+    bodyLines.push(...renderCustomizerOverlay(scrollOffset, maxVisibleItems).split('\n'));
+  } else if (state.inputMode === 'filter') {
+    bodyLines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
+  } else if (state.inputMode === 'kill') {
+    bodyLines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
+  } else if (state.inputMode === 'signal') {
+    const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+    const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk.yellow(s) : chalk.dim(s)).join('  ');
+    bodyLines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
+    bodyLines.push(chalk.dim(`  ${sigList}`));
+    bodyLines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
+  } else if (state.inputMode === 'p2p') {
+    bodyLines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
+  } else if (state.statusMessage) {
+    bodyLines.push(`  ${state.statusMessage}`);
   }
 
-  const frameLines = [...bodyLines, ...footerLines];
-  if (frameLines.length > state.termHeight) {
-    frameLines.length = state.termHeight;
+  if (bodyLines.length > targetBodyHeight) {
+    bodyLines.length = targetBodyHeight;
+  }
+  const frameLines = [...bodyLines];
+  while (frameLines.length < targetBodyHeight) {
+    frameLines.push('');
   }
-  writeFrame(frameLines);
+  frameLines.push(...footerLines);
+  const fittedLines = frameLines.map(l => fitVisible(l, cols));
+  writeFrame(fittedLines);
 }
 
-function footerLine(): string {
+function footerLine(): string[] {
    const row1: [string, string][] = [
       ['q', 'quit'],
       ['c', 'customize UI'],
@@ -312,10 +335,10 @@ function footerLine(): string {
    if (state.logging) badges.push(chalk.red.bold('● REC'));
    if (state.activePanel !== 'grid') badges.push(chalk.cyan.bold(`◉ ${state.activePanel.toUpperCase()}`));
    if (state.p2pServerRunning) badges.push(chalk.green.bold(`P2P ${state.p2pBind || '0.0.0.0'}:${state.p2pPort}`));
-   const badgeStr = badges.join('  ');
+   const badgeStr = badges.join('  ') || ' ';
 
-return badgeStr ? `${str1}\n${str2}    ${badgeStr}` : `${str1}\n${str2}`;
-   }
+   return [str1, str2, badgeStr];
+  }
 
 function sendNotification(title: string, message: string) {
   if (!state.notificationsEnabled) return;
@@ -332,20 +355,33 @@ function checkAlerts(data: StatsData) {
    const anomalies = detectAnomalies(data, state.history);
    const hasCriticalAnomaly = anomalies.some(a => a.severity === 'critical');
    const hasWarningAnomaly = anomalies.some(a => a.severity === 'warning');
+   // Process watchdog check
+   let watchdogTriggered = false;
+   if (state.watchdogProcess) {
+     const matches = data.processes.filter(p => p.command.toLowerCase().includes(state.watchdogProcess.toLowerCase()));
+     for (const p of matches) {
+       if (p.cpu >= state.watchdogCpu || p.mem >= state.watchdogMem) {
+         watchdogTriggered = true;
+         break;
+       }
+     }
+   }
+
    const anomalyTriggered = hasCriticalAnomaly || hasWarningAnomaly;
 
-   if ((hot || anomalyTriggered) && !state.alerted) {
+   if ((hot || anomalyTriggered || watchdogTriggered) && !state.alerted) {
      state.alerted = true;
      process.stdout.write('\x07');
      const reasons: string[] = [];
      if (data.cpu.usage >= state.CPU_ALERT_PCT) reasons.push(`CPU at ${data.cpu.usage}%`);
      if (temp !== null && temp >= state.TEMP_ALERT_C) reasons.push(`Temp at ${formatTempForUnit(temp)}`);
+     if (watchdogTriggered) reasons.push(`Watchdog process "${state.watchdogProcess}" crossed threshold`);
      for (const a of anomalies) {
        reasons.push(`${a.metric} anomaly (σ=${a.zScore.toFixed(1)})`);
      }
       setStatus(chalk.red(`⚠ Alert: ${reasons.join('; ')}`), 5000);
       sendNotification('pyre Alert', reasons.join('; '));
-    } else if (!hot && !anomalyTriggered) {
+    } else if (!hot && !anomalyTriggered && !watchdogTriggered) {
      state.alerted = false;
    }
   }

package/src/live/state.ts

@@ -89,6 +89,9 @@ const state = {
      ],
      CPU_ALERT_PCT: config.cpuAlertPct,
      TEMP_ALERT_C: config.tempAlertC,
+     watchdogProcess: config.watchdogProcess || '',
+     watchdogCpu: config.watchdogCpu || 80,
+     watchdogMem: config.watchdogMem || 80,
      notificationsEnabled: config.notificationsEnabled,
       alerted: false,
       activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',