pyre-cli 5.0.0 → 5.1.0

package/dist/index.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs4 from "fs";
-import os from "os";
+import fs5 from "fs";
+import os3 from "os";
+import path3 from "path";
 import readline2 from "readline";
 import { Command } from "commander";
 import chalk9 from "chalk";
 
 // src/monitors/collectors.ts
 import chalk from "chalk";
+import os from "os";
 
 // src/monitors/run.ts
 import { exec } from "child_process";
@@ -65,6 +67,7 @@ function parseSuffix(s) {
 // src/monitors/collectors.ts
 var SP_TTL_MS = 1e4;
 var NETSTAT_TTL_MS = 1e3;
+var prevCpuTimes = null;
 var ROUTE_TTL_MS = 5e3;
 var SYSCTL_TTL_MS = 6e4;
 var spGpuCache = null;
@@ -290,7 +293,25 @@ async function collectCpu() {
     if (temps.cpu_die !== void 0) temperature = temps.cpu_die;
   } catch {
   }
-  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature };
+  let coreUsage = [];
+  try {
+    const cpus = os.cpus();
+    const current = cpus.map((cpu) => ({
+      total: cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq,
+      idle: cpu.times.idle
+    }));
+    if (prevCpuTimes) {
+      coreUsage = prevCpuTimes.map((prev, i) => {
+        const totalDelta = current[i].total - prev.total;
+        const idleDelta = current[i].idle - prev.idle;
+        if (totalDelta === 0) return 0;
+        return Math.round((totalDelta - idleDelta) / totalDelta * 100);
+      });
+    }
+    prevCpuTimes = current;
+  } catch {
+  }
+  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature, coreUsage };
 }
 async function collectMemory() {
   const totalBytes = parseInt(await cachedSysctl("hw.memsize", "0")) || 0;
@@ -778,6 +799,18 @@ function cpuCard(data, contentWidth) {
     gaugeRow("Usage", data.cpu.usage, contentWidth),
     statRow("Load", data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" "))
   ];
+  if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
+    const slotW = 2;
+    const maxCores = Math.max(1, Math.floor((contentWidth - 10) / (slotW + 1)));
+    const cores = data.cpu.coreUsage.slice(0, maxCores);
+    const bars = cores.map((u) => {
+      const fill = Math.round(Math.min(100, u) / 100 * slotW);
+      const str = "\u2588".repeat(Math.max(0, fill)) + "\u2591".repeat(slotW - fill);
+      const color = u > 90 ? chalk3.red : u > 70 ? chalk3.yellow : chalk3.green;
+      return color(str);
+    });
+    lines.push(statRow("Cores", bars.join(" ")));
+  }
   if (data.cpu.temperature) lines.push(statRow("Temp", formatTemp(data.cpu.temperature)));
   return lines;
 }
@@ -1115,6 +1148,15 @@ function activeDetailLines(data, activePanel, width, opts2 = {}) {
       return null;
   }
 }
+function anomalyPanel(anomalies, width, theme) {
+  const lines = [];
+  for (const a of anomalies) {
+    const color = a.severity === "critical" ? chalk3.red.bold : chalk3.yellow;
+    const direction = a.zScore > 0 ? "\u2191 spike" : "\u2193 drop";
+    lines.push(color(` \u26A0 ${a.metric}: ${a.value.toFixed(1)} (${direction}, \u03C3=${a.zScore.toFixed(1)})`));
+  }
+  return lines;
+}
 function formatTable(data, opts2 = {}) {
   const width = clampWidth(opts2.width);
   const activePanel = opts2.activePanel || "grid";
@@ -1128,6 +1170,11 @@ function formatTable(data, opts2 = {}) {
   const out = [];
   out.push(...header(data, width, [], theme.border));
   out.push("");
+  const anomalies = opts2.anomalies ?? [];
+  if (anomalies.length && activePanel === "grid") {
+    out.push(...anomalyPanel(anomalies, width, theme));
+    out.push("");
+  }
   out.push(tabBar(activePanel, width, theme));
   out.push("");
   if (activePanel !== "grid") {
@@ -1239,6 +1286,314 @@ function sparkline(values, opts2 = {}) {
 function formatJson(data) {
   return JSON.stringify(data, null, 2);
 }
+function formatHtml(data) {
+  const rows = (items) => items.map((i) => `<tr><td class="label">${escapeHtml(i.label)}</td><td class="value">${escapeHtml(i.value)}</td></tr>`).join("\n");
+  const sections = [];
+  sections.push(`<h2>System</h2>
+<table>
+  ${rows([
+    { label: "Hostname", value: data.header.hostname },
+    { label: "OS", value: data.header.os },
+    { label: "Uptime", value: data.header.uptime },
+    { label: "Timestamp", value: data.timestamp }
+  ]).trim()}
+</table>`);
+  sections.push(`<h2>CPU</h2>
+<table>
+  ${rows([
+    { label: "Brand", value: data.cpu.brand },
+    { label: "Cores", value: `${data.cpu.physicalCores}/${data.cpu.cores}` },
+    { label: "Frequency", value: `${data.cpu.frequency} MHz` },
+    { label: "Usage", value: `${data.cpu.usage}%` },
+    { label: "Load Avg", value: data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" ") },
+    ...data.cpu.temperature ? [{ label: "Temperature", value: `${data.cpu.temperature.toFixed(1)}\xB0C` }] : []
+  ]).trim()}
+</table>`);
+  sections.push(`<h2>Memory</h2>
+<table>
+  ${rows([
+    { label: "Total", value: formatBytes(data.memory.total) },
+    { label: "Used", value: formatBytes(data.memory.used) },
+    { label: "Free", value: formatBytes(data.memory.free) },
+    { label: "Usage", value: `${data.memory.usagePercent}%` },
+    { label: "Swap", value: `${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}` }
+  ]).trim()}
+</table>`);
+  if (data.gpu) {
+    sections.push(`<h2>GPU</h2>
+<table>
+  ${rows([
+      { label: "Model", value: data.gpu.model },
+      { label: "Memory", value: formatBytes(data.gpu.memory) },
+      { label: "Utilization", value: `${data.gpu.utilization}%` },
+      ...data.gpu.temperature ? [{ label: "Temperature", value: `${data.gpu.temperature.toFixed(1)}\xB0C` }] : [],
+      { label: "Processes", value: String(data.gpu.processes) }
+    ]).trim()}
+</table>`);
+  }
+  if (data.power) {
+    const powerRows = [];
+    if (data.power.cpuWatts !== void 0) powerRows.push({ label: "CPU", value: `${data.power.cpuWatts.toFixed(2)} W` });
+    if (data.power.gpuWatts !== void 0) powerRows.push({ label: "GPU", value: `${data.power.gpuWatts.toFixed(2)} W` });
+    if (data.power.combinedWatts !== void 0) powerRows.push({ label: "Combined", value: `${data.power.combinedWatts.toFixed(2)} W` });
+    if (powerRows.length) {
+      sections.push(`<h2>Power</h2>
+<table>
+  ${rows(powerRows).trim()}
+</table>`);
+    }
+  }
+  if (data.battery) {
+    const battRows = [
+      { label: "Level", value: `${data.battery.level}%` },
+      { label: "State", value: data.battery.state },
+      { label: "Time Remaining", value: data.battery.timeRemaining },
+      { label: "Health", value: data.battery.health },
+      { label: "Power Source", value: data.battery.powerSource }
+    ];
+    if (data.battery.condition) battRows.push({ label: "Condition", value: data.battery.condition });
+    if (data.battery.maxCapacityPercent !== void 0) battRows.push({ label: "Max Capacity", value: `${data.battery.maxCapacityPercent}%` });
+    if (data.battery.cycles !== void 0) battRows.push({ label: "Cycles", value: String(data.battery.cycles) });
+    if (data.battery.estimatedTimeToEmpty) battRows.push({ label: "Est. Empty", value: data.battery.estimatedTimeToEmpty });
+    if (data.battery.dischargeRatePerHour !== void 0) battRows.push({ label: "Discharge Rate", value: `${data.battery.dischargeRatePerHour}%/h` });
+    sections.push(`<h2>Battery</h2>
+<table>
+  ${rows(battRows).trim()}
+</table>`);
+  }
+  sections.push(`<h2>Thermal</h2>
+<table>
+  ${rows([
+    { label: "State", value: data.thermal.state },
+    { label: "Pressure", value: ["Nominal", "Fair", "Serious", "Critical"][data.thermal.pressureLevel] || "Unknown" },
+    ...data.thermal.temperatures ? Object.entries(data.thermal.temperatures).flatMap(
+      ([k, v]) => v !== null && v !== void 0 ? [{ label: k.replace(/_/g, " "), value: `${v.toFixed(1)}\xB0C` }] : []
+    ) : []
+  ]).trim()}
+</table>`);
+  sections.push(`<h2>Network</h2>
+<table>
+  ${rows([
+    { label: "Interface", value: `${data.network.interface} (${data.network.ip})` },
+    { label: "RX", value: `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt` },
+    { label: "TX", value: `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt` }
+  ]).trim()}
+</table>`);
+  if (data.packets) {
+    sections.push(`<h2>Packets</h2>
+<table>
+  ${rows([
+      { label: "Total", value: `${data.packets.totalPackets} pkt` },
+      { label: "RX", value: `${data.packets.rxPackets} pkt` },
+      { label: "TX", value: `${data.packets.txPackets} pkt` },
+      { label: "Connections", value: `${data.packets.connections} TCP` }
+    ]).trim()}
+</table>`);
+  }
+  if (data.tasks.length) {
+    const taskRows = data.tasks.slice(0, 20).map((t) => ({
+      label: `${t.pid}`,
+      value: `${t.user.padEnd(10)} ${t.cpu.toFixed(1).padStart(6)}% ${t.mem.toFixed(1).padStart(6)}% ${t.state} ${t.command}`
+    }));
+    sections.push(`<h2>Tasks</h2>
+<table>
+  ${rows(taskRows).trim()}
+</table>`);
+  }
+  if (data.disk.length) {
+    const diskRows = data.disk.map((d) => ({
+      label: d.mountpoint,
+      value: `${d.used} / ${d.size} (${d.capacity})`
+    }));
+    sections.push(`<h2>Disk</h2>
+<table>
+  ${rows(diskRows).trim()}
+</table>`);
+  }
+  if (data.processes.length) {
+    const procRows = data.processes.slice(0, 50).map((p) => ({
+      label: String(p.pid),
+      value: `${p.user.padEnd(10)} ${p.cpu.toFixed(1).padStart(6)}% ${p.mem.toFixed(1).padStart(6)}% ${p.state} ${p.command}`
+    }));
+    sections.push(`<h2>Processes</h2>
+<table>
+  ${rows(procRows).trim()}
+</table>`);
+  }
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>pyre \u2014 ${data.header.hostname}</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #1e1e2e; color: #cdd6f4; margin: 0; padding: 24px; }
+  h1 { color: #ff6a39; margin-bottom: 4px; }
+  .meta { color: #a6adc8; margin-bottom: 24px; }
+  h2 { color: #89b4fa; margin-top: 28px; border-bottom: 1px solid #313244; padding-bottom: 6px; }
+  table { width: 100%; border-collapse: collapse; margin-bottom: 16px; }
+  td { padding: 6px 10px; border-bottom: 1px solid #313244; vertical-align: top; }
+  td.label { color: #a6adc8; width: 22%; font-weight: 500; }
+  td.value { color: #cdd6f4; }
+  tr:last-child td { border-bottom: none; }
+</style>
+</head>
+<body>
+  <h1>PYRE</h1>
+  <div class="meta">${escapeHtml(data.header.hostname)} \xB7 ${escapeHtml(data.header.os)} \xB7 up ${escapeHtml(data.header.uptime)} \xB7 ${escapeHtml(data.timestamp)}</div>
+  ${sections.join("\n  ")}
+</body>
+</html>`;
+}
+function formatMarkdown(data) {
+  const lines = [];
+  lines.push(`# pyre \u2014 ${data.header.hostname}`);
+  lines.push("");
+  lines.push(`**${data.header.os}** \xB7 up ${data.header.uptime} \xB7 ${data.timestamp}`);
+  lines.push("");
+  lines.push("## System");
+  lines.push("");
+  lines.push("| Property | Value |");
+  lines.push("|---|---|");
+  lines.push(`| Hostname | ${mdCell(data.header.hostname)} |`);
+  lines.push(`| OS | ${mdCell(data.header.os)} |`);
+  lines.push(`| Uptime | ${mdCell(data.header.uptime)} |`);
+  lines.push("");
+  lines.push("## CPU");
+  lines.push("");
+  lines.push("| Property | Value |");
+  lines.push("|---|---|");
+  lines.push(`| Brand | ${mdCell(data.cpu.brand)} |`);
+  lines.push(`| Cores | ${mdCell(`${data.cpu.physicalCores}/${data.cpu.cores}`)} |`);
+  lines.push(`| Frequency | ${mdCell(`${data.cpu.frequency} MHz`)} |`);
+  lines.push(`| Usage | ${mdCell(`${data.cpu.usage}%`)} |`);
+  lines.push(`| Load Avg | ${mdCell(data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" "))} |`);
+  if (data.cpu.temperature) lines.push(`| Temperature | ${mdCell(`${data.cpu.temperature.toFixed(1)}\xB0C`)} |`);
+  lines.push("");
+  lines.push("## Memory");
+  lines.push("");
+  lines.push("| Property | Value |");
+  lines.push("|---|---|");
+  lines.push(`| Total | ${mdCell(formatBytes(data.memory.total))} |`);
+  lines.push(`| Used | ${mdCell(formatBytes(data.memory.used))} |`);
+  lines.push(`| Free | ${mdCell(formatBytes(data.memory.free))} |`);
+  lines.push(`| Usage | ${mdCell(`${data.memory.usagePercent}%`)} |`);
+  lines.push(`| Swap | ${mdCell(`${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}`)} |`);
+  lines.push("");
+  if (data.gpu) {
+    lines.push("## GPU");
+    lines.push("");
+    lines.push("| Property | Value |");
+    lines.push("|---|---|");
+    lines.push(`| Model | ${mdCell(data.gpu.model)} |`);
+    lines.push(`| Memory | ${mdCell(formatBytes(data.gpu.memory))} |`);
+    lines.push(`| Utilization | ${mdCell(`${data.gpu.utilization}%`)} |`);
+    if (data.gpu.temperature) lines.push(`| Temperature | ${mdCell(`${data.gpu.temperature.toFixed(1)}\xB0C`)} |`);
+    lines.push(`| Processes | ${mdCell(String(data.gpu.processes))} |`);
+    lines.push("");
+  }
+  if (data.power) {
+    const pw = [];
+    if (data.power.cpuWatts !== void 0) pw.push(`CPU ${data.power.cpuWatts.toFixed(2)} W`);
+    if (data.power.gpuWatts !== void 0) pw.push(`GPU ${data.power.gpuWatts.toFixed(2)} W`);
+    if (data.power.combinedWatts !== void 0) pw.push(`Combined ${data.power.combinedWatts.toFixed(2)} W`);
+    if (pw.length) {
+      lines.push("## Power");
+      lines.push("");
+      lines.push("| Metric | Value |");
+      lines.push("|---|---|");
+      if (data.power.cpuWatts !== void 0) lines.push(`| CPU | ${mdCell(`${data.power.cpuWatts.toFixed(2)} W`)} |`);
+      if (data.power.gpuWatts !== void 0) lines.push(`| GPU | ${mdCell(`${data.power.gpuWatts.toFixed(2)} W`)} |`);
+      if (data.power.combinedWatts !== void 0) lines.push(`| Combined | ${mdCell(`${data.power.combinedWatts.toFixed(2)} W`)} |`);
+      lines.push("");
+    }
+  }
+  if (data.battery) {
+    lines.push("## Battery");
+    lines.push("");
+    lines.push("| Property | Value |");
+    lines.push("|---|---|");
+    lines.push(`| Level | ${mdCell(`${data.battery.level}%`)} |`);
+    lines.push(`| State | ${mdCell(data.battery.state)} |`);
+    lines.push(`| Time Remaining | ${mdCell(data.battery.timeRemaining)} |`);
+    lines.push(`| Health | ${mdCell(data.battery.health)} |`);
+    lines.push(`| Power Source | ${mdCell(data.battery.powerSource)} |`);
+    if (data.battery.condition) lines.push(`| Condition | ${mdCell(data.battery.condition)} |`);
+    if (data.battery.maxCapacityPercent !== void 0) lines.push(`| Max Capacity | ${mdCell(`${data.battery.maxCapacityPercent}%`)} |`);
+    if (data.battery.cycles !== void 0) lines.push(`| Cycles | ${mdCell(String(data.battery.cycles))} |`);
+    if (data.battery.estimatedTimeToEmpty) lines.push(`| Est. Empty | ${mdCell(data.battery.estimatedTimeToEmpty)} |`);
+    if (data.battery.dischargeRatePerHour !== void 0) lines.push(`| Discharge Rate | ${mdCell(`${data.battery.dischargeRatePerHour}%/h`)} |`);
+    lines.push("");
+  }
+  lines.push("## Thermal");
+  lines.push("");
+  lines.push("| Property | Value |");
+  lines.push("|---|---|");
+  lines.push(`| State | ${mdCell(data.thermal.state)} |`);
+  lines.push(`| Pressure | ${mdCell(["Nominal", "Fair", "Serious", "Critical"][data.thermal.pressureLevel] || "Unknown")} |`);
+  if (data.thermal.temperatures) {
+    for (const [k, v] of Object.entries(data.thermal.temperatures)) {
+      if (v !== null && v !== void 0) lines.push(`| ${mdCell(k.replace(/_/g, " "))} | ${mdCell(`${v.toFixed(1)}\xB0C`)} |`);
+    }
+  }
+  lines.push("");
+  lines.push("## Network");
+  lines.push("");
+  lines.push("| Property | Value |");
+  lines.push("|---|---|");
+  lines.push(`| Interface | ${mdCell(`${data.network.interface} (${data.network.ip})`)} |`);
+  lines.push(`| RX | ${mdCell(`${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`)} |`);
+  lines.push(`| TX | ${mdCell(`${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)} |`);
+  lines.push("");
+  if (data.packets) {
+    lines.push("## Packets");
+    lines.push("");
+    lines.push("| Property | Value |");
+    lines.push("|---|---|");
+    lines.push(`| Total | ${mdCell(`${data.packets.totalPackets} pkt`)} |`);
+    lines.push(`| RX | ${mdCell(`${data.packets.rxPackets} pkt`)} |`);
+    lines.push(`| TX | ${mdCell(`${data.packets.txPackets} pkt`)} |`);
+    lines.push(`| Connections | ${mdCell(`${data.packets.connections} TCP`)} |`);
+    lines.push("");
+  }
+  if (data.tasks.length) {
+    lines.push("## Tasks");
+    lines.push("");
+    lines.push("| PID | User | CPU% | MEM% | State | Command |");
+    lines.push("|---|---|---|---|---|---|");
+    for (const t of data.tasks.slice(0, 20)) {
+      lines.push(`| ${t.pid} | ${mdCell(t.user)} | ${t.cpu.toFixed(1)} | ${t.mem.toFixed(1)} | ${t.state} | ${mdCell(t.command)} |`);
+    }
+    lines.push("");
+  }
+  if (data.disk.length) {
+    lines.push("## Disk");
+    lines.push("");
+    lines.push("| Mountpoint | Used / Size | Capacity |");
+    lines.push("|---|---|---|");
+    for (const d of data.disk) {
+      lines.push(`| ${mdCell(d.mountpoint)} | ${mdCell(`${d.used} / ${d.size}`)} | ${mdCell(d.capacity)} |`);
+    }
+    lines.push("");
+  }
+  if (data.processes.length) {
+    lines.push("## Processes");
+    lines.push("");
+    lines.push("| PID | User | CPU% | MEM% | State | Command |");
+    lines.push("|---|---|---|---|---|---|");
+    for (const p of data.processes.slice(0, 50)) {
+      lines.push(`| ${p.pid} | ${mdCell(p.user)} | ${p.cpu.toFixed(1)} | ${p.mem.toFixed(1)} | ${p.state} | ${mdCell(p.command)} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function mdCell(s) {
+  return String(s).replace(/\|/g, "\\|");
+}
 function formatCsv(data) {
   const rows = [
     ["property", "key", "value"],
@@ -1247,6 +1602,9 @@ function formatCsv(data) {
     ["cpu", "loadAvg_1m", String(data.cpu.loadAvg[0])],
     ["cpu", "loadAvg_5m", String(data.cpu.loadAvg[1])],
     ["cpu", "loadAvg_15m", String(data.cpu.loadAvg[2])],
+    ["cpu", "cores", String(data.cpu.cores)],
+    ["cpu", "physicalCores", String(data.cpu.physicalCores)],
+    ["cpu", "frequency", String(data.cpu.frequency)],
     ["memory", "total", String(data.memory.total)],
     ["memory", "used", String(data.memory.used)],
     ["memory", "usagePercent", String(data.memory.usagePercent)],
@@ -1254,11 +1612,7 @@ function formatCsv(data) {
     ["memory", "swapTotal", String(data.memory.swapTotal)],
     ["thermal", "state", data.thermal.state],
     ["thermal", "cpuTempC", data.thermal.temperatures?.cpu_die ? String(data.thermal.temperatures.cpu_die) : ""],
-    [
-      "thermal",
-      "cpuTempF",
-      data.thermal.temperatures?.cpu_die != null ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : ""
-    ],
+    ["thermal", "cpuTempF", data.thermal.temperatures?.cpu_die != null ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : ""],
     ["network", "rxBytes", String(data.network.rxBytes)],
     ["network", "txBytes", String(data.network.txBytes)],
     ["network", "rxPackets", String(data.network.rxPackets)],
@@ -1279,6 +1633,9 @@ function formatCsv(data) {
     ["system", "uptime", data.header.uptime],
     ["system", "timestamp", data.timestamp]
   ];
+  if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
+    data.cpu.coreUsage.forEach((u, i) => rows.push(["cpu", `coreUsage_${i}`, String(u)]));
+  }
   if (data.packets) {
     rows.push(["packets", "totalPackets", String(data.packets.totalPackets)]);
     rows.push(["packets", "rxPackets", String(data.packets.rxPackets)]);
@@ -1377,7 +1734,7 @@ function barGraph(values, bounds, width) {
 import readline from "readline";
 
 // src/history.ts
-var History = class {
+var History = class _History {
   /** Maximum number of samples retained in the rolling window. */
   maxLen;
   /** Monotonically increasing version, bumped on every push. */
@@ -1414,6 +1771,46 @@ var History = class {
   constructor(maxLen = 40) {
     this.maxLen = maxLen;
   }
+  /**
+   * Compute the arithmetic mean of a numeric array.
+   * Returns 0 if the array is empty.
+   */
+  static mean(arr) {
+    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) {
+    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, arr) {
+    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, arr, threshold = 2.5) {
+    if (arr.length < 5) return false;
+    return Math.abs(_History.zScore(value, arr)) > threshold;
+  }
   /**
    * Push a new sample into the rolling window.
    *
@@ -1491,20 +1888,31 @@ var History = class {
   }
 };
 
-// src/live/state.ts
-var SIGNAL_OPTIONS = ["SIGTERM", "SIGKILL", "SIGINT", "SIGHUP", "SIGSTOP", "SIGCONT"];
-var state = {
-  intervalHandle: null,
-  uiIntervalHandle: null,
-  running: false,
-  paused: false,
-  detailed: false,
+// src/state/config.ts
+import fs from "fs";
+import os2 from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os2.homedir(), ".config", "pyre");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  theme: "default",
   interval: 2,
-  showGraphs: true,
-  graphMode: "spark",
-  exportFormat: "json",
   exportDir: "./pyre-exports",
-  currentTheme: "default",
+  detailed: false,
+  sortMode: "cpu",
+  treeView: false,
+  graphMode: "spark",
+  showGraphs: true,
+  autoLog: false,
+  mouseEnabled: true,
+  cpuAlertPct: 90,
+  tempAlertC: 95,
+  notificationsEnabled: true,
+  p2pPort: 9876,
+  p2pPassword: "pyre",
+  splashEnabled: true,
+  splashColorScheme: "fire",
+  splashAnimation: "classic",
   visiblePanels: {
     cpu: true,
     mem: true,
@@ -1516,7 +1924,72 @@ var state = {
     packets: true,
     tasks: true,
     disk: true,
-    process: true
+    process: true,
+    tree: false
+  }
+};
+function readConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(DEFAULT_CONFIG, parsed);
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(config3) {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const merged = deepMerge(readConfig(), config3);
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n");
+  } catch {
+  }
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] !== void 0 && source[key] !== null) {
+      if (typeof source[key] === "object" && !Array.isArray(source[key]) && typeof target[key] === "object" && !Array.isArray(target[key])) {
+        result[key] = deepMerge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+
+// src/live/state.ts
+var SIGNAL_OPTIONS = ["SIGTERM", "SIGKILL", "SIGINT", "SIGHUP", "SIGSTOP", "SIGCONT"];
+var config = readConfig();
+var state = {
+  intervalHandle: null,
+  uiIntervalHandle: null,
+  running: false,
+  paused: false,
+  detailed: config.detailed,
+  interval: config.interval,
+  showGraphs: config.showGraphs,
+  graphMode: config.graphMode,
+  exportFormat: "json",
+  tempUnit: "c",
+  exportDir: config.exportDir,
+  currentTheme: config.theme,
+  visiblePanels: {
+    cpu: config.visiblePanels.cpu,
+    mem: config.visiblePanels.mem,
+    gpu: config.visiblePanels.gpu,
+    power: config.visiblePanels.power,
+    battery: config.visiblePanels.battery,
+    thermal: config.visiblePanels.thermal,
+    network: config.visiblePanels.network,
+    packets: config.visiblePanels.packets,
+    tasks: config.visiblePanels.tasks,
+    disk: config.visiblePanels.disk,
+    process: config.visiblePanels.process
   },
   logging: false,
   logStream: null,
@@ -1527,18 +2000,23 @@ var state = {
   keypressHandler: null,
   termWidth: process.stdout.columns || 80,
   termHeight: process.stdout.rows || 24,
-  sortMode: "cpu",
+  sortMode: config.sortMode,
   processFilter: "",
   inputMode: null,
   inputBuffer: "",
   targetPid: "",
   selectedSignal: "SIGTERM",
-  treeView: false,
+  treeView: config.treeView,
   SIGNAL_OPTIONS,
   customizerIndex: 0,
   CUSTOMIZER_OPTIONS: [
     "Theme",
     "Graph Mode",
+    "Splash Screen",
+    "Splash Color",
+    "Splash Animation",
+    "Notifications",
+    "Temperature Unit",
     "Toggle CPU",
     "Toggle Memory",
     "Toggle GPU",
@@ -1550,16 +2028,14 @@ var state = {
     "Toggle Tasks",
     "Toggle Disk",
     "Toggle Processes",
-    "Toggle Tree View",
-    "Splash Screen",
-    "Splash Color",
-    "Splash Animation"
+    "Toggle Tree View"
   ],
-  CPU_ALERT_PCT: 90,
-  TEMP_ALERT_C: 95,
+  CPU_ALERT_PCT: config.cpuAlertPct,
+  TEMP_ALERT_C: config.tempAlertC,
+  notificationsEnabled: config.notificationsEnabled,
   alerted: false,
   activePanel: "grid",
-  mouseEnabled: true,
+  mouseEnabled: config.mouseEnabled,
   PANEL_TABS: [
     { id: "cpu", label: "CPU", key: "1" },
     { id: "mem", label: "Memory", key: "2" },
@@ -1578,11 +2054,11 @@ var state = {
   p2pBind: "",
   p2pServer: null,
   p2pServerRunning: false,
-  p2pPort: 9876,
-  p2pPassword: "pyre",
-  splashEnabled: true,
-  splashColorScheme: "fire",
-  splashAnimation: "classic"
+  p2pPort: config.p2pPort,
+  p2pPassword: config.p2pPassword,
+  splashEnabled: config.splashEnabled,
+  splashColorScheme: config.splashColorScheme,
+  splashAnimation: config.splashAnimation
 };
 function setStatus(msg, ms = 3e3) {
   state.statusMessage = msg;
@@ -1610,10 +2086,10 @@ function getToggleKey(opt) {
 }
 
 // src/live/export.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 function ensureDir(dir) {
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
 }
 function timestampForFile() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -1625,9 +2101,27 @@ 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);
-    fs.writeFileSync(file, content);
+    const ext = state.exportFormat === "json" ? "json" : state.exportFormat === "csv" ? "csv" : state.exportFormat === "tsv" ? "tsv" : state.exportFormat === "html" ? "html" : "md";
+    const file = path2.join(state.exportDir, `pyre-${timestampForFile()}.${ext}`);
+    let content;
+    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;
+    }
+    fs2.writeFileSync(file, content);
     setStatus(`Exported snapshot -> ${file}`);
   } catch (err) {
     setStatus(`Export failed: ${err.message}`);
@@ -1636,8 +2130,9 @@ function exportSnapshot() {
 function startLogging() {
   try {
     ensureDir(state.exportDir);
-    const file = path.join(state.exportDir, `pyre-log-${timestampForFile()}.csv`);
-    state.logStream = fs.createWriteStream(file, { flags: "a" });
+    rotateLogs();
+    const file = path2.join(state.exportDir, `pyre-log-${timestampForFile()}.csv`);
+    state.logStream = fs2.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");
     state.logging = true;
     setStatus(`Logging every tick -> ${file}`);
@@ -1645,6 +2140,52 @@ function startLogging() {
     setStatus(`Logging failed to start: ${err.message}`);
   }
 }
+var MAX_LOG_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var MAX_LOG_COUNT = 20;
+var MAX_LOG_BYTES = 50 * 1024 * 1024;
+function rotateLogs() {
+  try {
+    const dir = state.exportDir;
+    if (!fs2.existsSync(dir)) return;
+    const files = fs2.readdirSync(dir).filter((f) => f.startsWith("pyre-log-") && f.endsWith(".csv")).map((f) => ({ name: f, path: path2.join(dir, f), mtime: fs2.statSync(path2.join(dir, f)).mtimeMs, size: fs2.statSync(path2.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 {
+          fs2.unlinkSync(f.path);
+        } catch {
+        }
+      }
+    }
+    const remaining = fs2.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 {
+          fs2.unlinkSync(path2.join(dir, f));
+        } catch {
+        }
+      }
+    }
+    let totalSize = 0;
+    for (const f of remaining) {
+      totalSize += fs2.statSync(path2.join(dir, f)).size;
+    }
+    if (totalSize > MAX_LOG_BYTES) {
+      const sorted = remaining.sort();
+      for (const f of sorted) {
+        const sz = fs2.statSync(path2.join(dir, f)).size;
+        try {
+          fs2.unlinkSync(path2.join(dir, f));
+        } catch {
+        }
+        totalSize -= sz;
+        if (totalSize <= MAX_LOG_BYTES * 0.8) break;
+      }
+    }
+  } catch {
+  }
+}
 function stopLogging() {
   state.logging = false;
   state.logStream?.end();
@@ -1657,7 +2198,10 @@ function toggleLogging() {
 }
 function writeLogRow(data) {
   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;
@@ -1668,7 +2212,101 @@ function writeLogRow(data) {
 }
 
 // src/live/render.ts
+import { execFile } from "child_process";
 import chalk5 from "chalk";
+
+// src/anomalies.ts
+var ZSCORE_THRESHOLD = 2.5;
+var CRITICAL_ZSCORE = 3.5;
+var MIN_SAMPLES = 5;
+function detectAnomalies(data, history) {
+  const alerts = [];
+  const cpuZ = History.zScore(data.cpu.usage, history.cpuUsage);
+  if (Math.abs(cpuZ) > ZSCORE_THRESHOLD && history.cpuUsage.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: "CPU",
+      value: data.cpu.usage,
+      zScore: cpuZ,
+      severity: Math.abs(cpuZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+    });
+  }
+  const memZ = History.zScore(data.memory.usagePercent, history.memUsage);
+  if (Math.abs(memZ) > ZSCORE_THRESHOLD && history.memUsage.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: "Memory",
+      value: data.memory.usagePercent,
+      zScore: memZ,
+      severity: Math.abs(memZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+    });
+  }
+  if (data.cpu.temperature !== void 0) {
+    const tempZ = History.zScore(data.cpu.temperature, history.temp);
+    if (Math.abs(tempZ) > ZSCORE_THRESHOLD && history.temp.length >= MIN_SAMPLES) {
+      alerts.push({
+        metric: "Temp",
+        value: data.cpu.temperature,
+        zScore: tempZ,
+        severity: Math.abs(tempZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+      });
+    }
+  }
+  const netRxZ = History.zScore(data.network.rxBytes, history.netRxRate);
+  if (Math.abs(netRxZ) > ZSCORE_THRESHOLD && history.netRxRate.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: "Net RX",
+      value: data.network.rxBytes,
+      zScore: netRxZ,
+      severity: Math.abs(netRxZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+    });
+  }
+  const netTxZ = History.zScore(data.network.txBytes, history.netTxRate);
+  if (Math.abs(netTxZ) > ZSCORE_THRESHOLD && history.netTxRate.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: "Net TX",
+      value: data.network.txBytes,
+      zScore: netTxZ,
+      severity: Math.abs(netTxZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+    });
+  }
+  if (data.power?.combinedWatts !== void 0) {
+    const powerZ = History.zScore(data.power.combinedWatts, history.powerWatts);
+    if (Math.abs(powerZ) > ZSCORE_THRESHOLD && history.powerWatts.length >= MIN_SAMPLES) {
+      alerts.push({
+        metric: "Power",
+        value: data.power.combinedWatts,
+        zScore: powerZ,
+        severity: Math.abs(powerZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+      });
+    }
+  }
+  if (data.gpu) {
+    const gpuZ = History.zScore(data.gpu.utilization, history.gpuUtil);
+    if (Math.abs(gpuZ) > ZSCORE_THRESHOLD && history.gpuUtil.length >= MIN_SAMPLES) {
+      alerts.push({
+        metric: "GPU",
+        value: data.gpu.utilization,
+        zScore: gpuZ,
+        severity: Math.abs(gpuZ) > CRITICAL_ZSCORE ? "critical" : "warning"
+      });
+    }
+  }
+  return alerts;
+}
+
+// src/live/render.ts
+function formatTempForUnit(c) {
+  if (state.tempUnit === "f") {
+    const f = c * (9 / 5) + 32;
+    return `${f.toFixed(1)}\xB0F`;
+  }
+  return `${c.toFixed(1)}\xB0C`;
+}
+function applyTempUnit(text) {
+  if (state.tempUnit === "f") {
+    return text.replace(/([\d.]+)°C \/ ([\d.]+)°F/g, "$2\xB0F");
+  }
+  return text.replace(/([\d.]+)°C \/ ([\d.]+)°F/g, "$1\xB0C");
+}
 var _cachedTable = "";
 var _cachedTableData = null;
 var _cachedTableParams = "";
@@ -1754,6 +2392,11 @@ function renderCustomizerOverlay() {
       lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
     } else if (opt === "Splash Animation") {
       lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
+    } else if (opt === "Notifications") {
+      const status = state.notificationsEnabled ? chalk5.green("[ON]") : chalk5.red("[OFF]");
+      lines.push(`${prefix}${opt}: ${status}`);
+    } else if (opt === "Temperature Unit") {
+      lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
     } else {
       const toggleKey = getToggleKey(opt);
       const isVisible = toggleKey ? toggleKey === "tree" ? state.treeView : state.visiblePanels[toggleKey] !== false : true;
@@ -1789,7 +2432,10 @@ function render() {
   const lines = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
   const params = tableCacheParams();
-  const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || params !== _cachedTableParams ? (() => {
+  const anomalies = detectAnomalies(state.lastData, state.history);
+  const anomalyCacheKey = anomalies.map((a) => `${a.metric}:${a.zScore.toFixed(2)}`).join(",");
+  const cacheParams = params + "|" + anomalyCacheKey;
+  const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || cacheParams !== _cachedTableParams ? (() => {
     const out = formatTable(state.lastData, {
       width: state.termWidth,
       sortBy: state.sortMode,
@@ -1798,13 +2444,15 @@ function render() {
       theme: state.currentTheme,
       visible: state.visiblePanels,
       treeView: state.treeView,
-      activePanel: state.activePanel
+      activePanel: state.activePanel,
+      anomalies,
+      tempUnit: state.tempUnit
     });
     _cachedTableData = state.lastData;
-    _cachedTableParams = params;
-    _cachedTable = out;
+    _cachedTableParams = cacheParams;
+    _cachedTable = applyTempUnit(out);
     _tableDataDirty = false;
-    return out;
+    return _cachedTable;
   })() : _cachedTable;
   const bodyLines = [];
   if (state.activePanel === "p2p") {
@@ -1818,8 +2466,8 @@ function render() {
     const out = formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode);
     _cachedGraphsVersion = state.history.version;
     _cachedGraphsParams = graphsParams;
-    _cachedGraphs = out;
-    return out;
+    _cachedGraphs = applyTempUnit(out);
+    return _cachedGraphs;
   })() : _cachedGraphs;
   if (state.showGraphs && state.activePanel !== "p2p") {
     bodyLines.push("");
@@ -1867,6 +2515,7 @@ function footerLine() {
     ["b", `graph:${state.graphMode}`],
     ["t", state.treeView ? "flat" : "tree"],
     ["d", state.detailed ? "basic" : "detailed"],
+    ["T", `temp:${state.tempUnit}`],
     ["p", state.paused ? "resume" : "pause"]
   ];
   const row2 = [
@@ -1893,15 +2542,32 @@ function footerLine() {
 ${str2}    ${badgeStr}` : `${str1}
 ${str2}`;
 }
+function sendNotification(title, message) {
+  if (!state.notificationsEnabled) return;
+  execFile("osascript", ["-e", `display notification "${message}" with title "${title}"`], (err) => {
+    if (err) {
+    }
+  });
+}
 function checkAlerts(data) {
   const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
   const hot = data.cpu.usage >= state.CPU_ALERT_PCT || temp !== null && temp >= state.TEMP_ALERT_C;
-  if (hot && !state.alerted) {
+  const anomalies = detectAnomalies(data, state.history);
+  const hasCriticalAnomaly = anomalies.some((a) => a.severity === "critical");
+  const hasWarningAnomaly = anomalies.some((a) => a.severity === "warning");
+  const anomalyTriggered = hasCriticalAnomaly || hasWarningAnomaly;
+  if ((hot || anomalyTriggered) && !state.alerted) {
     state.alerted = true;
     process.stdout.write("\x07");
-    const reason = data.cpu.usage >= state.CPU_ALERT_PCT ? `CPU at ${data.cpu.usage}%` : `Temp at ${temp}\xB0C`;
-    setStatus(chalk5.red(`\u26A0 Alert: ${reason}`), 5e3);
-  } else if (!hot) {
+    const reasons = [];
+    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)}`);
+    for (const a of anomalies) {
+      reasons.push(`${a.metric} anomaly (\u03C3=${a.zScore.toFixed(1)})`);
+    }
+    setStatus(chalk5.red(`\u26A0 Alert: ${reasons.join("; ")}`), 5e3);
+    sendNotification("pyre Alert", reasons.join("; "));
+  } else if (!hot && !anomalyTriggered) {
     state.alerted = false;
   }
 }
@@ -1909,7 +2575,7 @@ function checkAlerts(data) {
 // src/p2p/server.ts
 import net from "net";
 import tls from "tls";
-import fs2 from "fs";
+import fs3 from "fs";
 import crypto2 from "crypto";
 import chalk6 from "chalk";
 
@@ -2054,9 +2720,9 @@ var P2PServer = class {
   async start() {
     if (this.options.auditLog) {
       try {
-        fs2.mkdirSync(this.options.auditLog, { recursive: true });
+        fs3.mkdirSync(this.options.auditLog, { recursive: true });
         const logFile = `${this.options.auditLog}/p2p-audit.log`;
-        this.auditStream = fs2.createWriteStream(logFile, { flags: "a" });
+        this.auditStream = fs3.createWriteStream(logFile, { flags: "a" });
       } catch {
         this.log(chalk6.yellow("Warning: could not open audit log"));
       }
@@ -2065,11 +2731,11 @@ var P2PServer = class {
       const useTLS = !!(this.options.tlsCert && this.options.tlsKey);
       if (useTLS) {
         const tlsOptions = {
-          key: fs2.readFileSync(this.options.tlsKey),
-          cert: fs2.readFileSync(this.options.tlsCert)
+          key: fs3.readFileSync(this.options.tlsKey),
+          cert: fs3.readFileSync(this.options.tlsCert)
         };
         if (this.options.tlsCA) {
-          tlsOptions.ca = fs2.readFileSync(this.options.tlsCA);
+          tlsOptions.ca = fs3.readFileSync(this.options.tlsCA);
         }
         this.server = tls.createServer(tlsOptions, (socket) => this.onConnection(socket));
       } else {
@@ -2337,7 +3003,7 @@ async function startP2PServer(options) {
 // src/p2p/client.ts
 import net2 from "net";
 import tls2 from "tls";
-import fs3 from "fs";
+import fs4 from "fs";
 import crypto3 from "crypto";
 import chalk7 from "chalk";
 var P2PClient = class {
@@ -2365,9 +3031,9 @@ var P2PClient = class {
   async connect() {
     if (this.options.auditLog) {
       try {
-        fs3.mkdirSync(this.options.auditLog, { recursive: true });
+        fs4.mkdirSync(this.options.auditLog, { recursive: true });
         const logFile = `${this.options.auditLog}/p2p-client-audit.log`;
-        this.auditStream = fs3.createWriteStream(logFile, { flags: "a" });
+        this.auditStream = fs4.createWriteStream(logFile, { flags: "a" });
       } catch {
         console.log(chalk7.yellow("Warning: could not open audit log"));
       }
@@ -2382,7 +3048,7 @@ var P2PClient = class {
           rejectUnauthorized: !this.options.tlsInsecure
         };
         if (this.options.tlsCA) {
-          tlsOptions.ca = fs3.readFileSync(this.options.tlsCA);
+          tlsOptions.ca = fs4.readFileSync(this.options.tlsCA);
         }
         this.socket = tls2.connect(tlsOptions, () => {
           this.running = true;
@@ -2572,6 +3238,29 @@ function deriveHMACKey2(password) {
 }
 
 // src/live/input.ts
+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, str) {
   return key.name === "up" || str === "k" || key.sequence === "\x1B[A" || key.sequence === "\x1BOA";
 }
@@ -2617,6 +3306,12 @@ function handleInputModeKey(str, key) {
         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) {
@@ -2631,6 +3326,7 @@ function handleInputModeKey(str, key) {
       }
       invalidateTableCache();
       invalidateFrame();
+      persistConfig();
     }
     render();
     return;
@@ -2843,6 +3539,9 @@ async function startLive(opts2, splashPromise) {
   if (opts2.theme) state.currentTheme = opts2.theme;
   state.interval = opts2.interval;
   if (opts2.exportDir) state.exportDir = opts2.exportDir;
+  if (opts2.alertCpu !== void 0) state.CPU_ALERT_PCT = opts2.alertCpu;
+  if (opts2.alertTemp !== void 0) state.TEMP_ALERT_C = opts2.alertTemp;
+  if (opts2.tempUnit) state.tempUnit = opts2.tempUnit;
   state.termWidth = process.stdout.columns || 80;
   state.termHeight = process.stdout.rows || 24;
   state.history.reset();
@@ -2989,6 +3688,12 @@ async function startLive(opts2, splashPromise) {
         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 = ["cpu", "mem", "pid", "user", "command", "state", "threads", "runtime"];
         const curIdx = sortCycle.indexOf(state.sortMode);
@@ -3020,7 +3725,9 @@ async function startLive(opts2, splashPromise) {
         render();
         break;
       case "f":
-        state.exportFormat = state.exportFormat === "json" ? "csv" : state.exportFormat === "csv" ? "tsv" : "json";
+        const fmtCycle = ["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;
@@ -3089,6 +3796,7 @@ function handleMouseClick(y, x) {
   }
 }
 function stopLive() {
+  persistConfig();
   if (state.intervalHandle) {
     clearInterval(state.intervalHandle);
     state.intervalHandle = null;
@@ -3401,11 +4109,11 @@ function spreadFireSparks(fire, cols, rows) {
     }
   }
 }
-async function showSplash(config) {
-  const enabled = config?.enabled ?? true;
+async function showSplash(config3) {
+  const enabled = config3?.enabled ?? true;
   if (!enabled) return;
-  const colorScheme = config?.colorScheme ?? "fire";
-  const animation = config?.animation ?? "classic";
+  const colorScheme = config3?.colorScheme ?? "fire";
+  const animation = config3?.animation ?? "classic";
   const rgbPalette = getPalette(colorScheme);
   const cols = 60;
   const rows = 15;
@@ -3455,13 +4163,14 @@ async function showSplash(config) {
 }
 
 // src/index.ts
-var pkg = JSON.parse(fs4.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+var config2 = readConfig();
+var pkg = JSON.parse(fs5.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 var program = new Command();
-program.name("pyre").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("-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("--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("--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("--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("--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").option("--p2p-tls", "Enable TLS encryption for P2P connections").option("--p2p-cert <file>", "TLS certificate file (PEM) for P2P server").option("--p2p-key <file>", "TLS private key file (PEM) for P2P server").option("--p2p-ca <file>", "TLS CA certificate file (PEM) for P2P client").option("--p2p-insecure", "Skip TLS certificate verification (client only)").option("--p2p-rate-limit <n>", "Max auth attempts per IP per minute (default: 5)", "5").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)");
+program.name("pyre").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)", config2.theme).option("--interval <seconds>", "Refresh interval for live mode", String(config2.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", config2.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", config2.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(config2.cpuAlertPct)).option("--alert-temp <c>", "CPU temperature alert threshold in Celsius (default: 95)", String(config2.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").option("--p2p-tls", "Enable TLS encryption for P2P connections").option("--p2p-cert <file>", "TLS certificate file (PEM) for P2P server").option("--p2p-key <file>", "TLS private key file (PEM) for P2P server").option("--p2p-ca <file>", "TLS CA certificate file (PEM) for P2P client").option("--p2p-insecure", "Skip TLS certificate verification (client only)").option("--p2p-rate-limit <n>", "Max auth attempts per IP per minute (default: 5)", "5").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)");
 program.parse(process.argv);
 var 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) {
   return s.replace(/\x1b\[[0-9;]*m/g, "");
@@ -3470,7 +4179,7 @@ function sanitizeHost2(host) {
   return host.trim().replace(/%$/, "");
 }
 function detectLocalIP() {
-  const ifaces = os.networkInterfaces();
+  const ifaces = os3.networkInterfaces();
   for (const [, addrs] of Object.entries(ifaces)) {
     if (!addrs) continue;
     for (const addr of addrs) {
@@ -3504,10 +4213,52 @@ async function runServerCommand() {
 }
 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(chalk9.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(chalk9.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") {
+      fs5.rmSync(CONFIG_FILE, { force: true });
+      console.log(chalk9.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) : void 0;
+  const alertTemp = opts.alertTemp ? parseInt(opts.alertTemp, 10) : void 0;
+  const tempUnit = opts.tempUnit === "f" ? "f" : "c";
   if (cmd === "live" || !isExportMode() && !opts.once && cmd !== "p2p") {
     if (cmd === "live") {
       program.args.shift();
@@ -3516,10 +4267,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 ?? config2.detailed,
+      theme: opts.theme || config2.theme,
+      exportDir: opts.exportDir || config2.exportDir,
+      autoLog: opts.log || config2.autoLog,
+      alertCpu,
+      alertTemp,
+      tempUnit
     }, splashPromise);
     return;
   }
@@ -3541,12 +4295,14 @@ async function main() {
   const data = await collectAll({ detailed: opts.detailed, processLimit });
   let output;
   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 : void 0 } });
+  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree ?? config2.treeView, visible: { packets: opts.packets ? true : void 0 } });
   console.log(output);
   if (opts.out) {
-    fs4.writeFileSync(opts.out, stripAnsi(output));
+    fs5.writeFileSync(opts.out, stripAnsi(output));
     console.log(chalk9.dim(`
 Saved to ${opts.out}`));
   }
@@ -3728,3 +4484,124 @@ async function runP2PConnect() {
     process.exit(0);
   });
 }
+async function runInfoCommand() {
+  const data = await collectAll({ detailed: true });
+  const lines = [];
+  lines.push(chalk9.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) {
+  const password = opts.p2pPassword || "mysecret";
+  const cmd = `ssh -o LogLevel=QUIET ${host} "pyre --json --once"`;
+  console.log(chalk9.bold(`
+  pyre ssh \u2014 ${host}`));
+  console.log(chalk9.dim(`  Running: ${cmd}
+`));
+  const { execFile: execFile2 } = await import("child_process");
+  const child = execFile2("ssh", ["-o", "LogLevel=QUIET", host, "pyre", "--json", "--once"], (err, stdout, stderr) => {
+    if (err) {
+      console.log(chalk9.red(`  SSH failed: ${err.message}`));
+      console.log(chalk9.dim("  Ensure SSH keys are set up or the host is reachable."));
+      process.exit(1);
+    }
+    if (stderr) console.log(chalk9.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() {
+  const http = await import("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(chalk9.bold(`
+  pyre web`));
+    console.log(chalk9.dim(`  Dashboard: ${url}`));
+    console.log(chalk9.dim(`  API:      ${url}/api`));
+    console.log(chalk9.dim("  Press Ctrl+C to stop\n"));
+    process.once("SIGINT", () => {
+      server.close();
+      process.exit(0);
+    });
+  });
+}
+async function runBenchCommand(benchCmd) {
+  const { spawn } = await import("child_process");
+  const logDir = opts.exportDir || "./pyre-exports";
+  const file = path3.join(logDir, `pyre-bench-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.csv`);
+  if (!fs5.existsSync(logDir)) fs5.mkdirSync(logDir, { recursive: true });
+  const stream = fs5.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(chalk9.bold(`
+  pyre bench`));
+  console.log(chalk9.dim(`  Command: ${benchCmd}`));
+  console.log(chalk9.dim(`  Log: ${file}
+`));
+  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}
+`);
+    } catch {
+    }
+  }, interval * 1e3);
+  child.on("close", () => {
+    clearInterval(handle);
+    stream.end();
+    console.log(chalk9.green(`
+  Bench complete. Log saved to ${file}`));
+    process.exit(0);
+  });
+  process.once("SIGINT", () => {
+    clearInterval(handle);
+    child.kill("SIGTERM");
+    stream.end();
+    process.exit(0);
+  });
+}