pyre-cli 5.0.0 → 6.0.0

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')
@@ -51,14 +61,15 @@ 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');
 
 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,23 +123,82 @@ 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 (!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,
-      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 +226,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 +435,145 @@ 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 port = parseInt(opts.port || process.env.PORT || '3000', 10) || 3000;
+
+  const server = http.createServer(async (req, res) => {
+    const url = req.url || '/';
+    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);
+      res.end('Not found');
+    }
+  });
+
+  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('  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

@@ -13,10 +13,35 @@ 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';
+
+  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();
 
@@ -369,8 +404,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;
       }
 
@@ -402,7 +438,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'
           };
@@ -467,6 +503,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 +540,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;
@@ -515,7 +559,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();
             }
@@ -574,6 +618,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   }
 
   export function stopLive() {
+    persistConfig();
     if (state.intervalHandle) {
       clearInterval(state.intervalHandle);
       state.intervalHandle = null;