pyre-cli 4.17.0 → 5.1.0

package/src/history.ts

@@ -47,21 +47,65 @@ export class History {
    txPacketRate: number[] = [];
 
    /** Rolling window of active TCP connections. */
-   connections: number[] = [];
+    connections: number[] = [];
 
-   private lastRxBytes = 0;
-   private lastTxBytes = 0;
-   private lastRxPackets = 0;
-   private lastTxPackets = 0;
-   private lastTs = 0;
+    private lastRxBytes = 0;
+    private lastTxBytes = 0;
+    private lastRxPackets = 0;
+    private lastTxPackets = 0;
+    private lastTs = 0;
 
-  /**
-   * Create a new History instance.
-   * @param maxLen - Maximum number of samples to retain. Defaults to 40.
-   */
-  constructor(maxLen = 40) {
-    this.maxLen = maxLen;
-  }
+   /**
+    * Create a new History instance.
+    * @param maxLen - Maximum number of samples to retain. Defaults to 40.
+    */
+   constructor(maxLen = 40) {
+     this.maxLen = maxLen;
+   }
+
+   /**
+    * Compute the arithmetic mean of a numeric array.
+    * Returns 0 if the array is empty.
+    */
+   static mean(arr: number[]): number {
+     if (!arr.length) return 0;
+     return arr.reduce((s, v) => s + v, 0) / arr.length;
+   }
+
+   /**
+    * Compute the population standard deviation of a numeric array.
+    * Returns 0 if the array has fewer than 2 elements.
+    */
+   static stdDev(arr: number[]): number {
+     if (arr.length < 2) return 0;
+     const m = History.mean(arr);
+     const variance = arr.reduce((s, v) => s + (v - m) ** 2, 0) / arr.length;
+     return Math.sqrt(variance);
+   }
+
+   /**
+    * Compute the z-score of a value against a reference array.
+    * Returns 0 when the array is empty or has zero std dev.
+    */
+   static zScore(value: number, arr: number[]): number {
+     const m = History.mean(arr);
+     const sd = History.stdDev(arr);
+     if (sd === 0) return 0;
+     return (value - m) / sd;
+   }
+
+   /**
+    * Check whether a value is a statistical outlier against a
+    * reference array.
+    * @param value - The current reading
+    * @param arr - The rolling history window
+    * @param threshold - Z-score threshold (default 2.5)
+    * @returns true if the value deviates from the baseline by more than `threshold` standard deviations
+    */
+   static isAnomaly(value: number, arr: number[], threshold = 2.5): boolean {
+     if (arr.length < 5) return false;
+     return Math.abs(History.zScore(value, arr)) > threshold;
+   }
 
   /**
    * Push a new sample into the rolling window.

package/src/index.ts

@@ -8,14 +8,19 @@
  */
 import fs from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
 import readline from 'node:readline';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { collectAll } from './monitors/index.js';
-import { formatTable, formatJson, formatCsv, formatTsv } from './formatters/index.js';
+import { formatTable, formatJson, formatCsv, formatTsv, formatHtml, formatMarkdown, formatBytes } from './formatters/index.js';
 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';
+
+const config = readConfig();
 
 const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 
@@ -26,19 +31,24 @@ program
     .version(pkg.version)
     .description('Mac system monitoring CLI: interactive live dashboard, stats, graphs, export, packet monitor, battery predictor')
     .option('-j, --json', 'Output as JSON')
+    .option('--html', 'Output as HTML')
+    .option('--md', 'Output as Markdown')
     .option('-c, --csv', 'Output as CSV')
     .option('-t, --tsv', 'Output as TSV')
     .option('--detailed', 'Include detailed system info and sensor readings')
-    .option('--theme <name>', 'Default theme for live mode (default, dracula, cyberpunk, monochrome, nord, gruvbox)', 'default')
-    .option('--interval <seconds>', 'Refresh interval for live mode', '2')
+    .option('--theme <name>', 'Default theme for live mode (default, dracula, cyberpunk, monochrome, nord, gruvbox)', config.theme)
+    .option('--interval <seconds>', 'Refresh interval for live mode', String(config.interval))
     .option('--once', 'Show a single static snapshot instead of live feed')
     .option('--out <file>', 'Also write the snapshot output to a file (--once/--json/--csv/--tsv modes)')
-    .option('--export-dir <dir>', 'Directory used for live-mode snapshot exports and logs', './pyre-exports')
+    .option('--export-dir <dir>', 'Directory used for live-mode snapshot exports and logs', config.exportDir)
     .option('--log', 'Start continuous CSV logging immediately when live mode starts')
     .option('--tree', 'Show process tree view instead of flat list')
-    .option('--sort <key>', 'Sort processes by: cpu, mem, pid, user, command, state, threads, runtime', 'cpu')
+    .option('--sort <key>', 'Sort processes by: cpu, mem, pid, user, command, state, threads, runtime', config.sortMode)
     .option('--packets', 'Include packet monitor panel in output')
     .option('--limit <n>', 'Max number of processes to include in --once/--json/--csv/--tsv snapshots (0 = all)', '10')
+    .option('--alert-cpu <pct>', 'CPU usage alert threshold (default: 90)', String(config.cpuAlertPct))
+    .option('--alert-temp <c>', 'CPU temperature alert threshold in Celsius (default: 95)', String(config.tempAlertC))
+    .option('--temp-unit <unit>', 'Temperature display unit: c or f (default: c)', 'c')
     .option('--p2p-host <host>', 'P2P host address (server: bind address, client: server address)')
     .option('--p2p-port <port>', 'P2P port number', '9876')
     .option('--p2p-password <password>', 'Password for P2P authentication')
@@ -58,7 +68,7 @@ program.parse(process.argv);
 const opts = program.opts();
 
 function isExportMode() {
-  return opts.json || opts.csv || opts.tsv;
+  return opts.json || opts.csv || opts.tsv || opts.html || opts.md;
 }
 
 function stripAnsi(s: string): string {
@@ -112,11 +122,59 @@ async function runServerCommand(): Promise<void> {
 async function main() {
   const cmd = program.args[0];
 
+  if (cmd === 'info') {
+    await runInfoCommand();
+    return;
+  }
+
+  if (cmd === 'ssh') {
+    const host = program.args[1];
+    if (!host) {
+      console.log(chalk.red('Usage: pyre ssh <host>'));
+      process.exit(1);
+    }
+    await runSshCommand(host);
+    return;
+  }
+
+  if (cmd === 'web') {
+    await runWebCommand();
+    return;
+  }
+
+  if (cmd === 'bench') {
+    const benchCmd = program.args.slice(1).join(' ');
+    if (!benchCmd) {
+      console.log(chalk.red('Usage: pyre bench <command>'));
+      process.exit(1);
+    }
+    await runBenchCommand(benchCmd);
+    return;
+  }
+
+  if (cmd === 'config') {
+    const sub = program.args[1];
+    if (sub === 'show') {
+      const cfg = readConfig();
+      console.log(JSON.stringify(cfg, null, 2));
+    } else if (sub === 'reset') {
+      fs.rmSync(CONFIG_FILE, { force: true });
+      console.log(chalk.green('Config reset to defaults'));
+    } else {
+      console.log('Usage: pyre config <show|reset>');
+    }
+    return;
+  }
+
   if (cmd === 'server') {
     await runServerCommand();
     return;
   }
 
+  const alertCpu = opts.alertCpu ? parseInt(opts.alertCpu, 10) : undefined;
+  const alertTemp = opts.alertTemp ? parseInt(opts.alertTemp, 10) : undefined;
+  const tempUnit = opts.tempUnit === 'f' ? 'f' : 'c';
+
   if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
     if (cmd === 'live') {
       program.args.shift();
@@ -125,10 +183,13 @@ async function main() {
     const interval = parseFloat(opts.interval) || 2;
     await startLive({
       interval,
-      detailed: opts.detailed,
-      theme: opts.theme,
-      exportDir: opts.exportDir,
-      autoLog: opts.log,
+      detailed: opts.detailed ?? config.detailed,
+      theme: opts.theme || config.theme,
+      exportDir: opts.exportDir || config.exportDir,
+      autoLog: opts.log || config.autoLog,
+      alertCpu,
+      alertTemp,
+      tempUnit,
     }, splashPromise);
     return;
   }
@@ -156,9 +217,11 @@ async function main() {
 
   let output: string;
   if (opts.json) output = formatJson(data);
+  else if (opts.html) output = formatHtml(data);
+  else if (opts.md) output = formatMarkdown(data);
   else if (opts.csv) output = formatCsv(data);
   else if (opts.tsv) output = formatTsv(data);
-  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree, visible: { packets: opts.packets ? true : undefined } });
+  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree ?? config.treeView, visible: { packets: opts.packets ? true : undefined } });
 
   console.log(output);
 
@@ -363,4 +426,134 @@ async function runP2PConnect(): Promise<void> {
     process.stdout.write('\x1b[?25h\x1b[2J\x1b[H');
     process.exit(0);
   });
+}
+
+async function runInfoCommand(): Promise<void> {
+  const data = await collectAll({ detailed: true });
+  const lines: string[] = [];
+  lines.push(chalk.bold('  pyre info'));
+  lines.push('');
+  lines.push(`  Hostname:  ${data.header.hostname}`);
+  lines.push(`  OS:        ${data.header.os}`);
+  lines.push(`  Uptime:    ${data.header.uptime}`);
+  lines.push(`  CPU:       ${data.cpu.brand}`);
+  lines.push(`  Cores:     ${data.cpu.physicalCores}/${data.cpu.cores} (phys/log)`);
+  lines.push(`  Frequency: ${data.cpu.frequency} MHz`);
+  lines.push(`  Memory:    ${formatBytes(data.memory.total)}`);
+  if (data.gpu) lines.push(`  GPU:       ${data.gpu.model} (${formatBytes(data.gpu.memory)})`);
+  if (data.battery) {
+    lines.push(`  Battery:   ${data.battery.level}% (${data.battery.state})`);
+    lines.push(`  Health:    ${data.battery.health}`);
+  }
+  lines.push(`  Thermal:   ${data.thermal.state}`);
+  console.log(lines.join('\n'));
+}
+
+async function runSshCommand(host: string): Promise<void> {
+  const password = opts.p2pPassword || 'mysecret';
+  const cmd = `ssh -o LogLevel=QUIET ${host} "pyre --json --once"`;
+  console.log(chalk.bold(`\n  pyre ssh — ${host}`));
+  console.log(chalk.dim(`  Running: ${cmd}\n`));
+
+  const { execFile } = await import('node:child_process');
+  const child = execFile('ssh', ['-o', 'LogLevel=QUIET', host, 'pyre', '--json', '--once'], (err, stdout, stderr) => {
+    if (err) {
+      console.log(chalk.red(`  SSH failed: ${err.message}`));
+      console.log(chalk.dim('  Ensure SSH keys are set up or the host is reachable.'));
+      process.exit(1);
+    }
+    if (stderr) console.log(chalk.dim(stderr));
+    try {
+      const remote = JSON.parse(stdout);
+      console.log(formatTable(remote, { width: process.stdout.columns || 80, sortBy: 'cpu', treeView: false, visible: { packets: true } }));
+    } catch {
+      console.log(stdout);
+    }
+    process.exit(0);
+  });
+  child.stdin.end();
+
+  process.once('SIGINT', () => {
+    child.kill('SIGTERM');
+    process.exit(0);
+  });
+}
+
+async function runWebCommand(): Promise<void> {
+  const http = await import('node:http');
+  const data = await collectAll({ detailed: true });
+
+  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') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data, null, 2));
+    } else {
+      res.writeHead(404);
+      res.end('Not found');
+    }
+  });
+
+  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`));
+    console.log(chalk.dim('  Press Ctrl+C to stop\n'));
+
+    process.once('SIGINT', () => {
+      server.close();
+      process.exit(0);
+    });
+  });
+}
+
+async function runBenchCommand(benchCmd: string): Promise<void> {
+  const { spawn } = await import('node:child_process');
+  const logDir = opts.exportDir || './pyre-exports';
+  const file = path.join(logDir, `pyre-bench-${new Date().toISOString().replace(/[:.]/g, '-')}.csv`);
+
+  if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+  const stream = fs.createWriteStream(file, { flags: 'a' });
+  stream.write('timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,net_rx_packets,net_tx_packets,connections,thermal_state\n');
+
+  console.log(chalk.bold(`\n  pyre bench`));
+  console.log(chalk.dim(`  Command: ${benchCmd}`));
+  console.log(chalk.dim(`  Log: ${file}\n`));
+
+  const child = spawn('sh', ['-c', benchCmd]);
+  child.stdout.on('data', d => process.stdout.write(d));
+  child.stderr.on('data', d => process.stdout.write(d));
+
+  const interval = parseFloat(opts.interval) || 2;
+  const handle = setInterval(async () => {
+    try {
+      const data = await collectAll({ detailed: opts.detailed });
+      const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? '';
+      const rxPackets = data.network.rxPackets ?? 0;
+      const txPackets = data.network.txPackets ?? 0;
+      const connections = data.network.connections ?? 0;
+      stream.write(`${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${rxPackets},${txPackets},${connections},${data.thermal.state}\n`);
+    } catch {
+      // skip bad tick
+    }
+  }, interval * 1000);
+
+  child.on('close', () => {
+    clearInterval(handle);
+    stream.end();
+    console.log(chalk.green(`\n  Bench complete. Log saved to ${file}`));
+    process.exit(0);
+  });
+
+  process.once('SIGINT', () => {
+    clearInterval(handle);
+    child.kill('SIGTERM');
+    stream.end();
+    process.exit(0);
+  });
 }

package/src/live/export.ts

@@ -1,13 +1,13 @@
 /**
  * Live dashboard export and logging helpers.
  *
- * Handles snapshot export (JSON/CSV/TSV), continuous
- * CSV logging, and the supporting file-system utilities.
+ * Handles snapshot export (JSON/CSV/TSV/HTML/Markdown), continuous
+ * CSV logging with rotation, and the supporting file-system utilities.
  * All state variables are imported from `state.ts`.
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { formatJson, formatCsv, formatTsv } from '../formatters/index.js';
+import { formatJson, formatCsv, formatTsv, formatHtml, formatMarkdown } from '../formatters/index.js';
 import { state, setStatus } from './state.js';
 
 /** Ensure a directory exists, creating it recursively if needed. */
@@ -27,9 +27,16 @@ function exportSnapshot() {
   }
   try {
     ensureDir(state.exportDir);
-    const file = path.join(state.exportDir, `pyre-${timestampForFile()}.${state.exportFormat}`);
-    const content =
-      state.exportFormat === 'json' ? formatJson(state.lastData) : state.exportFormat === 'csv' ? formatCsv(state.lastData) : formatTsv(state.lastData);
+    const ext = state.exportFormat === 'json' ? 'json' : state.exportFormat === 'csv' ? 'csv' : state.exportFormat === 'tsv' ? 'tsv' : state.exportFormat === 'html' ? 'html' : 'md';
+    const file = path.join(state.exportDir, `pyre-${timestampForFile()}.${ext}`);
+    let content: string;
+    switch (state.exportFormat) {
+      case 'json': content = formatJson(state.lastData); break;
+      case 'csv': content = formatCsv(state.lastData); break;
+      case 'tsv': content = formatTsv(state.lastData); break;
+      case 'html': content = formatHtml(state.lastData); break;
+      case 'md': content = formatMarkdown(state.lastData); break;
+    }
     fs.writeFileSync(file, content);
     setStatus(`Exported snapshot -> ${file}`);
   } catch (err: any) {
@@ -40,6 +47,7 @@ function exportSnapshot() {
 function startLogging() {
   try {
     ensureDir(state.exportDir);
+    rotateLogs();
     const file = path.join(state.exportDir, `pyre-log-${timestampForFile()}.csv`);
     state.logStream = fs.createWriteStream(file, { flags: 'a' });
     state.logStream.write('timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,net_rx_packets,net_tx_packets,connections,thermal_state\n');
@@ -50,6 +58,52 @@ function startLogging() {
   }
 }
 
+const MAX_LOG_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_LOG_COUNT = 20;
+const MAX_LOG_BYTES = 50 * 1024 * 1024;
+
+function rotateLogs() {
+  try {
+    const dir = state.exportDir;
+    if (!fs.existsSync(dir)) return;
+    const files = fs.readdirSync(dir)
+      .filter(f => f.startsWith('pyre-log-') && f.endsWith('.csv'))
+      .map(f => ({ name: f, path: path.join(dir, f), mtime: fs.statSync(path.join(dir, f)).mtimeMs, size: fs.statSync(path.join(dir, f)).size }))
+      .sort((a, b) => a.mtime - b.mtime);
+
+    const now = Date.now();
+    for (const f of files) {
+      if (now - f.mtime > MAX_LOG_AGE_MS) {
+        try { fs.unlinkSync(f.path); } catch { /* ignore */ }
+      }
+    }
+
+    const remaining = fs.readdirSync(dir).filter(f => f.startsWith('pyre-log-') && f.endsWith('.csv'));
+    if (remaining.length > MAX_LOG_COUNT) {
+      const toDelete = remaining.sort().slice(0, remaining.length - MAX_LOG_COUNT);
+      for (const f of toDelete) {
+        try { fs.unlinkSync(path.join(dir, f)); } catch { /* ignore */ }
+      }
+    }
+
+    let totalSize = 0;
+    for (const f of remaining) {
+      totalSize += fs.statSync(path.join(dir, f)).size;
+    }
+    if (totalSize > MAX_LOG_BYTES) {
+      const sorted = remaining.sort();
+      for (const f of sorted) {
+        const sz = fs.statSync(path.join(dir, f)).size;
+        try { fs.unlinkSync(path.join(dir, f)); } catch { /* ignore */ }
+        totalSize -= sz;
+        if (totalSize <= MAX_LOG_BYTES * 0.8) break;
+      }
+    }
+  } catch {
+    // ignore rotation errors
+  }
+}
+
 function stopLogging() {
   state.logging = false;
   state.logStream?.end();
@@ -64,7 +118,10 @@ function toggleLogging() {
 
 function writeLogRow(data: any) {
   if (!state.logging || !state.logStream) return;
-  const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? '';
+  let temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? '';
+  if (temp !== '' && state.tempUnit === 'f') {
+    temp = ((temp * 9 / 5) + 32).toFixed(1);
+  }
   const rxPackets = data.network.rxPackets ?? 0;
   const txPackets = data.network.txPackets ?? 0;
   const connections = data.network.connections ?? 0;

package/src/live/input.ts

@@ -15,8 +15,33 @@ import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow }
 import { render, footerLine, checkAlerts, invalidateTableCache, invalidateFrame } from './render.js';
 import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
 import { startP2PServer } from '../p2p/index.js';
+import { writeConfig } from '../state/config.js';
+
+  function persistConfig() {
+    writeConfig({
+      theme: state.currentTheme,
+      interval: state.interval,
+      exportDir: state.exportDir,
+      detailed: state.detailed,
+      sortMode: state.sortMode,
+      treeView: state.treeView,
+      graphMode: state.graphMode,
+      showGraphs: state.showGraphs,
+      autoLog: state.logging,
+      mouseEnabled: state.mouseEnabled,
+      cpuAlertPct: state.CPU_ALERT_PCT,
+      tempAlertC: state.TEMP_ALERT_C,
+      p2pPort: state.p2pPort,
+      p2pPassword: state.p2pPassword,
+      splashEnabled: state.splashEnabled,
+      splashColorScheme: state.splashColorScheme,
+       splashAnimation: state.splashAnimation,
+       visiblePanels: { ...state.visiblePanels },
+       notificationsEnabled: state.notificationsEnabled,
+    });
+  }
 
-function isUpKey(key: readline.Key, str?: string): boolean {
+  function isUpKey(key: readline.Key, str?: string): boolean {
   return key.name === 'up' || str === 'k' || key.sequence === '\x1b[A' || key.sequence === '\x1bOA';
 }
 function isDownKey(key: readline.Key, str?: string): boolean {
@@ -59,28 +84,35 @@ function handleInputModeKey(str: string, key: readline.Key) {
           const curIdx = schemes.indexOf(state.splashColorScheme);
           state.splashColorScheme = schemes[(curIdx + 1) % schemes.length];
           setStatus(`Splash color: ${state.splashColorScheme}`);
-        } else if (selected === 'Splash Animation') {
-          const animations: SplashAnimation[] = ['classic', 'wave', 'sparks'];
-          const curIdx = animations.indexOf(state.splashAnimation);
-          state.splashAnimation = animations[(curIdx + 1) % animations.length];
-          setStatus(`Splash animation: ${state.splashAnimation}`);
-        } else {
-          const toggleKey = getToggleKey(selected);
-          if (toggleKey) {
-            if (toggleKey === 'tree') {
-              state.treeView = !state.treeView;
-              state.visiblePanels.tree = state.treeView;
-            } else {
-              const isVisible = state.visiblePanels[toggleKey] !== false;
-              state.visiblePanels[toggleKey] = !isVisible;
+         } else if (selected === 'Splash Animation') {
+           const animations: SplashAnimation[] = ['classic', 'wave', 'sparks'];
+           const curIdx = animations.indexOf(state.splashAnimation);
+           state.splashAnimation = animations[(curIdx + 1) % animations.length];
+           setStatus(`Splash animation: ${state.splashAnimation}`);
+          } else if (selected === 'Notifications') {
+            state.notificationsEnabled = !state.notificationsEnabled;
+            setStatus(`Notifications: ${state.notificationsEnabled ? 'on' : 'off'}`);
+           } else if (selected === 'Temperature Unit') {
+             state.tempUnit = state.tempUnit === 'c' ? 'f' : 'c';
+             setStatus(`Temperature unit: ${state.tempUnit.toUpperCase()}`);
+           } else {
+            const toggleKey = getToggleKey(selected);
+            if (toggleKey) {
+              if (toggleKey === 'tree') {
+                state.treeView = !state.treeView;
+                state.visiblePanels.tree = state.treeView;
+              } else {
+                const isVisible = state.visiblePanels[toggleKey] !== false;
+                state.visiblePanels[toggleKey] = !isVisible;
+              }
             }
           }
-        }
-       invalidateTableCache();
-       invalidateFrame();
-     }
-     render();
-     return;
+        invalidateTableCache();
+        invalidateFrame();
+        persistConfig();
+      }
+      render();
+      return;
    }
 
     if (state.inputMode === 'signal') {
@@ -310,18 +342,21 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   * rendering interval.  Idempotent — calling while already
   * running is a no-op.
   */
-  export async function startLive(opts: LiveOptions, splashPromise?: Promise<void>) {
-    if (state.running) return;
-    state.running = true;
-    state.paused = false;
-    state.detailed = !!opts.detailed;
-    if (opts.theme) state.currentTheme = opts.theme;
-    state.interval = opts.interval;
-    if (opts.exportDir) state.exportDir = opts.exportDir;
-    state.termWidth = process.stdout.columns || 80;
-    state.termHeight = process.stdout.rows || 24;
-    state.history.reset();
-    state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+   export async function startLive(opts: LiveOptions, splashPromise?: Promise<void>) {
+     if (state.running) return;
+     state.running = true;
+     state.paused = false;
+     state.detailed = !!opts.detailed;
+     if (opts.theme) state.currentTheme = opts.theme;
+     state.interval = opts.interval;
+     if (opts.exportDir) state.exportDir = opts.exportDir;
+     if (opts.alertCpu !== undefined) state.CPU_ALERT_PCT = opts.alertCpu;
+     if (opts.alertTemp !== undefined) state.TEMP_ALERT_C = opts.alertTemp;
+     if (opts.tempUnit) state.tempUnit = opts.tempUnit;
+     state.termWidth = process.stdout.columns || 80;
+     state.termHeight = process.stdout.rows || 24;
+     state.history.reset();
+     state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
 
     const warmupPromise = doWarmup();
 
@@ -467,6 +502,12 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
            state.detailed = !state.detailed;
            setStatus(`Detailed sensor mode: ${state.detailed ? 'on' : 'off'}`);
            break;
+        case 'T':
+          state.tempUnit = state.tempUnit === 'c' ? 'f' : 'c';
+          setStatus(`Temperature unit: ${state.tempUnit.toUpperCase()}`);
+          invalidateTableCache();
+          render();
+          break;
         case 's':
           const sortCycle: SortMode[] = ['cpu', 'mem', 'pid', 'user', 'command', 'state', 'threads', 'runtime'];
           const curIdx = sortCycle.indexOf(state.sortMode);
@@ -498,7 +539,9 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           render();
           break;
         case 'f':
-          state.exportFormat = state.exportFormat === 'json' ? 'csv' : state.exportFormat === 'csv' ? 'tsv' : 'json';
+          const fmtCycle: ExportFormat[] = ['json', 'csv', 'tsv', 'html', 'md'];
+          const curFmt = fmtCycle.indexOf(state.exportFormat);
+          state.exportFormat = fmtCycle[(curFmt + 1) % fmtCycle.length];
           setStatus(`Export format: ${state.exportFormat}`);
           render();
           break;
@@ -574,6 +617,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   }
 
   export function stopLive() {
+    persistConfig();
     if (state.intervalHandle) {
       clearInterval(state.intervalHandle);
       state.intervalHandle = null;