pyre-cli 1.2.0

package/dist/index.js

@@ -0,0 +1,1267 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs2 from "fs";
+import { Command } from "commander";
+import chalk4 from "chalk";
+
+// src/monitors.ts
+import chalk from "chalk";
+async function run(cmd, fallback = "") {
+  try {
+    const { execSync } = await import("child_process");
+    return execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }).trim();
+  } catch {
+    return fallback;
+  }
+}
+var smcCache = null;
+async function getSmcMetrics() {
+  const now = Date.now();
+  if (smcCache && now - smcCache.ts < 1500) return smcCache.data;
+  const result = { temps: {}, power: {}, freq: {} };
+  try {
+    const pm = (await run(
+      "sudo -n powermetrics --samplers smc,cpu_power -n 1 --format text 2>/dev/null",
+      ""
+    )).trim();
+    if (pm) {
+      const cpuTemp = pm.match(/CPU die temperature:\s*([\d.]+)/i);
+      if (cpuTemp) result.temps["cpu_die"] = parseFloat(cpuTemp[1]);
+      const gpuTemp = pm.match(/GPU die temperature:\s*([\d.]+)/i);
+      if (gpuTemp) result.temps["gpu_die"] = parseFloat(gpuTemp[1]);
+      const smcTemp = pm.match(/SMC die temperature:\s*([\d.]+)/i);
+      if (smcTemp) result.temps["smc_die"] = parseFloat(smcTemp[1]);
+      const cpuPower = pm.match(/CPU Power:\s*([\d.]+)\s*mW/i);
+      if (cpuPower) result.power.cpu = parseFloat(cpuPower[1]) / 1e3;
+      const gpuPower = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+      if (gpuPower) result.power.gpu = parseFloat(gpuPower[1]) / 1e3;
+      const combinedPower = pm.match(/Combined Power \(CPU \+ GPU.*?\):\s*([\d.]+)\s*mW/i);
+      if (combinedPower) result.power.combined = parseFloat(combinedPower[1]) / 1e3;
+      const eFreq = pm.match(/E-Cluster HW active frequency:\s*([\d.]+)/i);
+      if (eFreq) result.freq["e_cluster"] = parseFloat(eFreq[1]);
+      const pFreq = pm.match(/P-Cluster HW active frequency:\s*([\d.]+)/i);
+      if (pFreq) result.freq["p_cluster"] = parseFloat(pFreq[1]);
+      const cpuFreq = pm.match(/CPU HW active frequency:\s*([\d.]+)/i);
+      if (cpuFreq) result.freq["cpu"] = parseFloat(cpuFreq[1]);
+    }
+  } catch {
+  }
+  smcCache = { data: result, ts: now };
+  return result;
+}
+function parseSuffix(s) {
+  return s.toUpperCase() === "K" ? 1024 : s.toUpperCase() === "M" ? 1024 * 1024 : s.toUpperCase() === "G" ? 1024 * 1024 * 1024 : 1;
+}
+async function collectAll(opts2 = {}) {
+  const [cpu, memory, disk, battery, thermal, network, processes, system, power] = await Promise.all([
+    collectCpu(),
+    collectMemory(),
+    collectDisk(),
+    collectBattery(),
+    collectThermal(opts2.detailed),
+    collectNetwork(),
+    collectProcesses(opts2.processLimit ?? 10),
+    collectSystem(),
+    collectPower()
+  ]);
+  return {
+    header: {
+      title: chalk.hex("#ff5500").bold("PYRE"),
+      hostname: system.hostname,
+      os: system.os,
+      uptime: system.uptime
+    },
+    cpu,
+    memory,
+    disk,
+    battery,
+    thermal,
+    network,
+    processes,
+    power,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function collectPower() {
+  try {
+    const { power } = await getSmcMetrics();
+    if (power.cpu === void 0 && power.gpu === void 0 && power.combined === void 0) return null;
+    return { cpuWatts: power.cpu, gpuWatts: power.gpu, combinedWatts: power.combined };
+  } catch {
+    return null;
+  }
+}
+async function collectSystem() {
+  const hostname = (await run("hostname", "Mac")).trim();
+  const osRaw = (await run("sw_vers -productVersion", "Unknown")).trim();
+  const uptimeRaw = (await run("uptime")).trim();
+  const uptimeMatch = uptimeRaw.match(/up\s+(.*?),\s+\d+\s+users/);
+  return {
+    hostname,
+    os: `macOS ${osRaw}`,
+    uptime: uptimeMatch ? uptimeMatch[1] : uptimeRaw
+  };
+}
+async function collectCpu() {
+  const brand = (await run("sysctl -n machdep.cpu.brand_string", "Unknown CPU")).trim();
+  const cores = parseInt((await run("sysctl -n hw.ncpu")).trim()) || 1;
+  const physicalCores = parseInt((await run("sysctl -n hw.physicalcpu")).trim()) || cores;
+  const frequencyHz = parseInt((await run("sysctl -n hw.cpufrequency")).trim());
+  let frequency = frequencyHz > 0 ? Math.round(frequencyHz / 1e6) : 0;
+  if (frequency === 0) {
+    try {
+      const { freq } = await getSmcMetrics();
+      const values = Object.values(freq);
+      if (values.length) frequency = Math.round(Math.max(...values));
+    } catch {
+    }
+  }
+  let usage = 0;
+  try {
+    const top = (await run("top -l 1 -n 0")).trim();
+    const cpuLine = top.match(/CPU usage:\s*[\d.]+%\s*user,\s*[\d.]+%\s*sys,\s*([\d.]+)%\s*idle/);
+    if (cpuLine) {
+      const idle = parseFloat(cpuLine[1]);
+      usage = Math.round(100 - idle);
+    }
+  } catch {
+  }
+  const loadAvgStr = (await run("sysctl -n vm.loadavg", "0.00 0.00 0.00")).trim();
+  const loadAvg = loadAvgStr.match(/\{ (.+?) \}/)?.[1].split(" ").map(Number) || [0, 0, 0];
+  let temperature;
+  try {
+    const { temps } = await getSmcMetrics();
+    if (temps.cpu_die !== void 0) temperature = temps.cpu_die;
+  } catch {
+  }
+  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature };
+}
+async function collectMemory() {
+  const totalBytes = parseInt((await run("sysctl -n hw.memsize")).trim()) || 0;
+  const pageSize = parseInt((await run("sysctl -n hw.pagesize", "4096")).trim()) || 4096;
+  const vmStat = (await run("vm_stat")).trim();
+  const getPageCount = (label) => {
+    const m = vmStat.match(new RegExp(`Pages\\s+${label}:\\s+(\\d+)\\.`));
+    return m ? parseInt(m[1]) : 0;
+  };
+  const freePages = getPageCount("free");
+  const activePages = getPageCount("active");
+  const inactivePages = getPageCount("inactive");
+  const wiredPages = getPageCount("wired down");
+  const compressedPages = getPageCount("occupied by compressor");
+  const free = freePages * pageSize;
+  const used = (activePages + inactivePages + wiredPages + compressedPages) * pageSize;
+  const usagePercent = totalBytes > 0 ? Math.round(used / totalBytes * 100) : 0;
+  let swapTotal = 0;
+  let swapUsed = 0;
+  let swapFree = 0;
+  try {
+    const swapRaw = (await run("sysctl -n vm.swapusage")).trim();
+    const swapMatch = swapRaw.match(
+      /total\s*=\s*([\d.]+)([KMGkmg])\s+used\s*=\s*([\d.]+)([KMGkmg])\s+free\s*=\s*([\d.]+)([KMGkmg])/
+    );
+    if (swapMatch) {
+      swapTotal = parseFloat(swapMatch[1]) * parseSuffix(swapMatch[2]);
+      swapUsed = parseFloat(swapMatch[3]) * parseSuffix(swapMatch[4]);
+      swapFree = parseFloat(swapMatch[5]) * parseSuffix(swapMatch[6]);
+    }
+  } catch {
+  }
+  return {
+    total: totalBytes,
+    used,
+    free,
+    swapTotal,
+    swapUsed,
+    swapFree,
+    pageSize,
+    usagePercent
+  };
+}
+async function collectDisk() {
+  const raw = (await run("df -h")).trim();
+  const lines = raw.split("\n").slice(1);
+  return lines.map((line) => {
+    const parts = line.split(/\s+/);
+    return {
+      filesystem: parts[0],
+      size: parts[1],
+      used: parts[2],
+      available: parts[3],
+      capacity: parts[4],
+      mountpoint: parts[5] || parts[6] || "/"
+    };
+  }).filter((d) => d.filesystem.includes("/") || d.size.includes("G") || d.size.includes("T"));
+}
+async function collectBattery() {
+  try {
+    const raw = (await run("pmset -g batt")).trim();
+    if (!raw.includes("Battery Power") && !raw.includes("AC Power")) return null;
+    const levelMatch = raw.match(/(\d+)%/);
+    const stateMatch = raw.match(/;\s*(charging|discharging|charged|finishing charge|attached to charger)/i);
+    const timeMatch = raw.match(/:\s*([\d:]+)\s+remaining/i);
+    const powerPlugged = raw.includes("AC Power") || raw.includes("attached to charger");
+    const level = levelMatch ? parseInt(levelMatch[1]) : 0;
+    const state = powerPlugged ? "charged" : stateMatch ? stateMatch[1].toLowerCase() : "discharging";
+    const timeRemaining = timeMatch ? timeMatch[1] : powerPlugged ? "\u221E" : "calculating";
+    let cycles;
+    let condition;
+    let maxCapacityPercent;
+    try {
+      const battInfo = (await run("system_profiler SPPowerDataType 2>/dev/null")).trim();
+      const cycleMatch = battInfo.match(/Cycle Count:\s+(\d+)/);
+      if (cycleMatch) cycles = parseInt(cycleMatch[1]);
+      const conditionMatch = battInfo.match(/Condition:\s+(.+)/);
+      if (conditionMatch) condition = conditionMatch[1].trim();
+      const maxCapMatch = battInfo.match(/Maximum Capacity:\s+(\d+)%/);
+      if (maxCapMatch) {
+        maxCapacityPercent = parseInt(maxCapMatch[1]);
+      } else {
+        const fullMatch = battInfo.match(/Full Charge Capacity[^\d]*(\d+)/i);
+        const designMatch = battInfo.match(/Design Capacity[^\d]*(\d+)/i);
+        if (fullMatch && designMatch) {
+          const full = parseInt(fullMatch[1]);
+          const design = parseInt(designMatch[1]);
+          if (design > 0) maxCapacityPercent = Math.round(full / design * 100);
+        }
+      }
+    } catch {
+    }
+    const healthParts = [];
+    if (condition) healthParts.push(condition);
+    if (maxCapacityPercent !== void 0) healthParts.push(`${maxCapacityPercent}% capacity`);
+    if (cycles !== void 0) healthParts.push(`${cycles} cycles`);
+    const health = healthParts.length ? healthParts.join(", ") : "unknown";
+    return {
+      level,
+      state,
+      timeRemaining,
+      health,
+      powerSource: powerPlugged ? "AC" : "Battery",
+      cycles,
+      condition,
+      maxCapacityPercent
+    };
+  } catch {
+    return null;
+  }
+}
+function pressureFromState(state) {
+  const s = state.toLowerCase();
+  if (s.includes("critical")) return 3;
+  if (s.includes("serious") || s.includes("heavy")) return 2;
+  if (s.includes("fair") || s.includes("moderate")) return 1;
+  return 0;
+}
+async function collectThermal(detailed2) {
+  try {
+    const therm = (await run("pmset -g therm", "")).trim();
+    let state = "Unknown";
+    let detail = therm || "No pmset thermal data";
+    const stateMatch = therm.match(/Thermal state:\s*(.+)/i);
+    if (stateMatch) {
+      const raw = stateMatch[1].trim();
+      state = /0|no warning|normal/i.test(raw) ? "Nominal" : raw;
+      detail = state;
+    } else {
+      const limitMatch = therm.match(
+        /CPU_(?:Speed|Scheduler)_Limit\s*(?:=|:)\s*([\d.]+)/i
+      );
+      if (limitMatch) {
+        const limit = parseFloat(limitMatch[1]);
+        if (limit >= 100) state = "Nominal";
+        else if (limit >= 85) state = "Fair";
+        else if (limit >= 50) state = "Serious";
+        else state = "Critical";
+        detail = `${state} (CPU limit ${limit}%)`;
+      } else if (/no thermal warning level has been recorded/i.test(therm)) {
+        state = "Nominal";
+        detail = "Nominal (no thermal warning recorded)";
+      }
+    }
+    const temperatures = {};
+    let cpuDieTemp;
+    try {
+      const { temps } = await getSmcMetrics();
+      cpuDieTemp = temps.cpu_die;
+      if (detailed2) {
+        if (temps.cpu_die !== void 0) temperatures["cpu_die"] = temps.cpu_die;
+        if (temps.gpu_die !== void 0) temperatures["gpu_die"] = temps.gpu_die;
+        if (temps.smc_die !== void 0) temperatures["smc_die"] = temps.smc_die;
+        if (!Object.keys(temps).length) {
+          detail += " (sensor data needs powermetrics privileges)";
+        }
+      }
+    } catch {
+      if (detailed2) detail += " (powermetrics unavailable)";
+    }
+    if (state === "Unknown" && cpuDieTemp !== void 0) {
+      if (cpuDieTemp >= 100) state = "Critical";
+      else if (cpuDieTemp >= 90) state = "Serious";
+      else if (cpuDieTemp >= 80) state = "Fair";
+      else state = "Nominal";
+      detail = `${state} (estimated from ${cpuDieTemp}\xB0C)`;
+    }
+    return {
+      state,
+      detail,
+      pressureLevel: pressureFromState(state),
+      temperatures: Object.keys(temperatures).length ? temperatures : void 0
+    };
+  } catch {
+    return { state: "Unknown", pressureLevel: 0, error: "Thermal info unavailable on this system" };
+  }
+}
+async function collectNetwork() {
+  try {
+    const primary = (await run("route -n get default")).trim();
+    const ifaceMatch = primary.match(/interface:\s+(\S+)/);
+    const iface = ifaceMatch?.[1] || "en0";
+    let ip = "0.0.0.0";
+    try {
+      const ifconfig = (await run(`ifconfig ${iface}`)).trim();
+      const ipMatch = ifconfig.match(/inet\s+([\d.]+)\s+netmask/);
+      if (ipMatch) ip = ipMatch[1];
+    } catch {
+    }
+    const netStat = (await run("netstat -ib")).trim();
+    let rxBytes = 0;
+    let txBytes = 0;
+    let rxPackets = 0;
+    let txPackets = 0;
+    for (const line of netStat.split("\n")) {
+      if (line.startsWith(iface) || line.startsWith(iface + ":")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 9) {
+          rxPackets += parseInt(parts[4]) || 0;
+          rxBytes += parseInt(parts[5]) || 0;
+          txPackets += parseInt(parts[6]) || 0;
+          txBytes += parseInt(parts[7]) || 0;
+        }
+      }
+    }
+    return { interface: iface, ip, rxBytes, txBytes, rxPackets, txPackets };
+  } catch {
+    return { interface: "unknown", ip: "0.0.0.0", rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0 };
+  }
+}
+async function collectProcesses(limit = 10) {
+  try {
+    const raw = (await run(`ps -Ao pid,user,pcpu,pmem,comm -r | head -n ${limit + 1}`)).trim();
+    const lines = raw.split("\n").slice(1);
+    return lines.map((line) => {
+      const parts = line.match(/\s*(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(.+)/);
+      if (!parts) return null;
+      return { pid: parseInt(parts[1]), user: parts[2], cpu: parseFloat(parts[3]), mem: parseFloat(parts[4]), command: parts[5] };
+    }).filter((p) => p !== null && p.pid > 0);
+  } catch {
+    return [];
+  }
+}
+
+// src/formatters.ts
+import chalk2 from "chalk";
+
+// src/sparkline.ts
+var BLOCKS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function sparkline(values, opts2 = {}) {
+  if (!values.length) return "";
+  const min = opts2.min ?? Math.min(...values);
+  const max = opts2.max ?? Math.max(...values);
+  const range = max - min || 1;
+  return values.map((v) => {
+    const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
+    const clamped = Math.min(BLOCKS.length - 1, Math.max(0, idx));
+    return BLOCKS[clamped];
+  }).join("");
+}
+
+// src/formatters.ts
+var THEMES = {
+  default: {
+    border: chalk2.hex("#4b5563"),
+    cpu: chalk2.hex("#22d3ee"),
+    mem: chalk2.hex("#a78bfa"),
+    power: chalk2.hex("#fbbf24"),
+    battery: chalk2.hex("#34d399"),
+    thermal: chalk2.hex("#fb923c"),
+    network: chalk2.hex("#60a5fa"),
+    disk: chalk2.hex("#f472b6"),
+    graphs: chalk2.hex("#22d3ee"),
+    process: chalk2.hex("#e5e7eb")
+  },
+  dracula: {
+    border: chalk2.hex("#6272a4"),
+    cpu: chalk2.hex("#8be9fd"),
+    mem: chalk2.hex("#bd93f9"),
+    power: chalk2.hex("#f1fa8c"),
+    battery: chalk2.hex("#50fa7b"),
+    thermal: chalk2.hex("#ffb86c"),
+    network: chalk2.hex("#ff79c6"),
+    disk: chalk2.hex("#ff5555"),
+    graphs: chalk2.hex("#8be9fd"),
+    process: chalk2.hex("#f8f8f2")
+  },
+  cyberpunk: {
+    border: chalk2.hex("#ff0055"),
+    cpu: chalk2.hex("#00ffcc"),
+    mem: chalk2.hex("#ff00ff"),
+    power: chalk2.hex("#ffff00"),
+    battery: chalk2.hex("#00ff00"),
+    thermal: chalk2.hex("#ff6600"),
+    network: chalk2.hex("#00ffff"),
+    disk: chalk2.hex("#ff007f"),
+    graphs: chalk2.hex("#00ffcc"),
+    process: chalk2.hex("#ffffff")
+  },
+  monochrome: {
+    border: chalk2.gray,
+    cpu: chalk2.white.bold,
+    mem: chalk2.white.bold,
+    power: chalk2.white.bold,
+    battery: chalk2.white.bold,
+    thermal: chalk2.white.bold,
+    network: chalk2.white.bold,
+    disk: chalk2.white.bold,
+    graphs: chalk2.white.bold,
+    process: chalk2.white.bold
+  }
+};
+function clampWidth(width) {
+  if (!width || Number.isNaN(width)) return 80;
+  return Math.max(60, Math.min(width, 240));
+}
+function gridColumns(width) {
+  if (width >= 150) return 3;
+  if (width >= 96) return 2;
+  return 1;
+}
+function visLen(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function padVisible(s, width) {
+  const len = visLen(s);
+  if (len >= width) return s;
+  return s + " ".repeat(width - len);
+}
+function truncatePlain(s, width) {
+  if (s.length <= width) return s;
+  return width <= 1 ? s.slice(0, width) : s.slice(0, width - 1) + "\u2026";
+}
+function panel(title, lines, width, accent, borderAccent, height) {
+  const h = height ?? lines.length;
+  const contentWidth = Math.max(1, width - 4);
+  const label = ` ${title} `;
+  const dashLen = Math.max(0, width - 3 - label.length);
+  const top = borderAccent("\u256D\u2500" + label + "\u2500".repeat(dashLen) + "\u256E");
+  const bottom = borderAccent("\u2570" + "\u2500".repeat(width - 2) + "\u256F");
+  const body = [];
+  for (let i = 0; i < h; i++) {
+    const line = lines[i] ?? "";
+    body.push(`${borderAccent("\u2502")} ${padVisible(line, contentWidth)} ${borderAccent("\u2502")}`);
+  }
+  return [top, ...body, bottom];
+}
+function hstack(blocks, gap = 2) {
+  if (!blocks.length) return [];
+  const height = Math.max(...blocks.map((b) => b.length));
+  const widths = blocks.map((b) => visLen(b[0] ?? ""));
+  const padded = blocks.map((b, i) => {
+    const filler = " ".repeat(widths[i]);
+    const arr = [...b];
+    while (arr.length < height) arr.push(filler);
+    return arr;
+  });
+  const out = [];
+  for (let row = 0; row < height; row++) {
+    out.push(padded.map((a) => a[row]).join(" ".repeat(gap)));
+  }
+  return out;
+}
+function statRow(label, value, width = 9) {
+  const w = Math.max(width, label.length + 1);
+  return `${chalk2.dim(label.padEnd(w))}${value}`;
+}
+function bar(percent, width = 20) {
+  const filled = Math.round(Math.min(100, Math.max(0, percent)) / 100 * width);
+  const empty = width - filled;
+  const barStr = "\u2588".repeat(Math.max(0, filled)) + "\u2591".repeat(Math.max(0, empty));
+  const color = percent > 90 ? chalk2.red : percent > 70 ? chalk2.yellow : chalk2.green;
+  return color(barStr);
+}
+function gaugeRow(label, percent, contentWidth) {
+  const labelW = 9;
+  const pctText = `${Math.round(percent)}%`;
+  const barW = Math.max(6, contentWidth - labelW - pctText.length - 1);
+  return `${chalk2.dim(label.padEnd(labelW))}${bar(percent, barW)} ${pctText}`;
+}
+function thermalColor(pressureLevel) {
+  if (pressureLevel >= 3) return chalk2.red;
+  if (pressureLevel === 2) return chalk2.yellow;
+  if (pressureLevel === 1) return chalk2.yellowBright;
+  return chalk2.green;
+}
+function capacityColor(percent) {
+  if (percent < 80) return chalk2.red;
+  if (percent < 90) return chalk2.yellow;
+  return chalk2.green;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function celsiusToFahrenheit(c) {
+  return c * (9 / 5) + 32;
+}
+function formatTemp(c) {
+  return `${c.toFixed(1)}\xB0C / ${celsiusToFahrenheit(c).toFixed(1)}\xB0F`;
+}
+function cpuCard(data, contentWidth) {
+  const lines = [
+    statRow("Brand", truncatePlain(data.cpu.brand, Math.max(4, contentWidth - 8))),
+    statRow("Cores", `${data.cpu.physicalCores}/${data.cpu.cores} phys/log`),
+    statRow("Freq", `${data.cpu.frequency} MHz`),
+    gaugeRow("Usage", data.cpu.usage, contentWidth),
+    statRow("Load", data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" \xB7 "))
+  ];
+  if (data.cpu.temperature) lines.push(statRow("Temp", formatTemp(data.cpu.temperature)));
+  return lines;
+}
+function memCard(data, contentWidth) {
+  return [
+    statRow("Total", formatBytes(data.memory.total)),
+    statRow("Used", formatBytes(data.memory.used)),
+    statRow("Free", formatBytes(data.memory.free)),
+    gaugeRow("Usage", data.memory.usagePercent, contentWidth),
+    statRow("Swap", `${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}`)
+  ];
+}
+function powerCard(data) {
+  if (!data.power) return null;
+  const lines = [];
+  if (data.power.cpuWatts !== void 0) lines.push(statRow("CPU", `${data.power.cpuWatts.toFixed(2)} W`));
+  if (data.power.gpuWatts !== void 0) lines.push(statRow("GPU", `${data.power.gpuWatts.toFixed(2)} W`));
+  if (data.power.combinedWatts !== void 0) lines.push(statRow("Total", `${data.power.combinedWatts.toFixed(2)} W`));
+  return lines.length ? lines : null;
+}
+function batteryCard(data, contentWidth) {
+  if (!data.battery) return null;
+  const valW = Math.max(6, contentWidth - 10);
+  const lines = [
+    statRow("Level", `${data.battery.level}%  (${data.battery.state})`),
+    statRow("Time", data.battery.timeRemaining),
+    statRow("Health", truncatePlain(data.battery.health, valW))
+  ];
+  if (data.battery.maxCapacityPercent !== void 0) {
+    lines.push(statRow("Capacity", capacityColor(data.battery.maxCapacityPercent)(`${data.battery.maxCapacityPercent}%`)));
+  }
+  lines.push(statRow("Source", data.battery.powerSource));
+  return lines;
+}
+function thermalCard(data, contentWidth) {
+  const valW = Math.max(6, contentWidth - 10);
+  const lines = [statRow("State", thermalColor(data.thermal.pressureLevel)(truncatePlain(data.thermal.state, valW)))];
+  if (data.thermal.temperatures) {
+    for (const [k, v] of Object.entries(data.thermal.temperatures)) {
+      lines.push(statRow(k.replace("_", " "), v !== null && v !== void 0 ? formatTemp(v) : "N/A"));
+    }
+  }
+  if (data.thermal.error) lines.push(statRow("Error", truncatePlain(data.thermal.error, valW)));
+  return lines;
+}
+function networkCard(data, contentWidth) {
+  const valW = Math.max(6, contentWidth - 8);
+  return [
+    statRow("Iface", truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)),
+    statRow("RX", `${formatBytes(data.network.rxBytes)} \xB7 ${data.network.rxPackets} pkts`),
+    statRow("TX", `${formatBytes(data.network.txBytes)} \xB7 ${data.network.txPackets} pkts`)
+  ];
+}
+function header(data, width, badges = [], borderAccent = THEMES.default.border) {
+  const left = `${chalk2.hex("#ff5500").bold(" PYRE ")} ${chalk2.bold(data.header.hostname)}  ${chalk2.dim(data.header.os)}  ${chalk2.dim("up " + data.header.uptime)}`;
+  const right = badges.join("   ");
+  const gap = Math.max(1, width - visLen(left) - visLen(right));
+  const line = left + " ".repeat(gap) + right;
+  return [line, borderAccent("\u2500".repeat(width))];
+}
+function sortProcesses(processes, sortBy) {
+  const copy = [...processes];
+  if (sortBy === "pid") return copy.sort((a, b) => a.pid - b.pid);
+  if (sortBy === "mem") return copy.sort((a, b) => b.mem - a.mem);
+  return copy.sort((a, b) => b.cpu - a.cpu);
+}
+function pctColor(v) {
+  return v > 80 ? chalk2.red : v > 50 ? chalk2.yellow : chalk2.dim;
+}
+function processTableLines(processes, contentWidth, borderAccent = THEMES.default.border) {
+  const pidW = 7, userW = 10, cpuW = 7, memW = 7;
+  const cmdW = Math.max(10, contentWidth - pidW - userW - cpuW - memW - 4);
+  const head = chalk2.bold.dim("PID".padEnd(pidW)) + chalk2.bold.dim("USER".padEnd(userW)) + chalk2.bold.dim("CPU%".padEnd(cpuW)) + chalk2.bold.dim("MEM%".padEnd(memW)) + chalk2.bold.dim("COMMAND");
+  const rows = processes.map((p) => {
+    const cpuStr = pctColor(p.cpu)(`${p.cpu.toFixed(1)}`.padEnd(cpuW));
+    const memStr = pctColor(p.mem)(`${p.mem.toFixed(1)}`.padEnd(memW));
+    return String(p.pid).padEnd(pidW) + truncatePlain(p.user, userW - 1).padEnd(userW) + cpuStr + memStr + truncatePlain(p.command, cmdW);
+  });
+  return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
+}
+function diskTableLines(disks, contentWidth, borderAccent = THEMES.default.border) {
+  const fsW = 16, sizeW = 8, usedW = 8, availW = 8, capW = 7;
+  const mountW = Math.max(8, contentWidth - fsW - sizeW - usedW - availW - capW - 5);
+  const head = chalk2.bold.dim("FILESYSTEM".padEnd(fsW)) + chalk2.bold.dim("SIZE".padEnd(sizeW)) + chalk2.bold.dim("USED".padEnd(usedW)) + chalk2.bold.dim("AVAIL".padEnd(availW)) + chalk2.bold.dim("CAP".padEnd(capW)) + chalk2.bold.dim("MOUNT");
+  const rows = disks.slice(0, 8).map((d) => {
+    const capNum = parseInt(d.capacity, 10) || 0;
+    const capStr = pctColor(capNum)(d.capacity.padEnd(capW));
+    return truncatePlain(d.filesystem, fsW - 1).padEnd(fsW) + d.size.padEnd(sizeW) + d.used.padEnd(usedW) + d.available.padEnd(availW) + capStr + truncatePlain(d.mountpoint, mountW);
+  });
+  return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
+}
+function formatTable(data, opts2 = {}) {
+  const width = clampWidth(opts2.width);
+  const columns = gridColumns(width);
+  const gap = 2;
+  const cardWidth = Math.floor((width - gap * (columns - 1)) / columns);
+  const contentWidth = cardWidth - 4;
+  const themeName = opts2.theme || "default";
+  const theme = THEMES[themeName] || THEMES.default;
+  const vis = opts2.visible ?? {};
+  const out = [];
+  out.push(...header(data, width, [], theme.border));
+  out.push("");
+  const cards = [];
+  if (vis.cpu !== false) {
+    cards.push({ title: "CPU", accent: theme.cpu, lines: cpuCard(data, contentWidth) });
+  }
+  if (vis.mem !== false) {
+    cards.push({ title: "Memory", accent: theme.mem, lines: memCard(data, contentWidth) });
+  }
+  if (vis.power !== false) {
+    const power = powerCard(data);
+    if (power) cards.push({ title: "Power", accent: theme.power, lines: power });
+  }
+  if (vis.battery !== false) {
+    const battery = batteryCard(data, contentWidth);
+    if (battery) cards.push({ title: "Battery", accent: theme.battery, lines: battery });
+  }
+  if (vis.thermal !== false) {
+    cards.push({ title: "Thermal", accent: theme.thermal, lines: thermalCard(data, contentWidth) });
+  }
+  if (vis.network !== false) {
+    cards.push({ title: "Network", accent: theme.network, lines: networkCard(data, contentWidth) });
+  }
+  for (let i = 0; i < cards.length; i += columns) {
+    const row = cards.slice(i, i + columns);
+    const rowHeight = Math.max(...row.map((c) => c.lines.length));
+    const blocks = row.map((c) => panel(c.title, c.lines, cardWidth, c.accent, theme.border, rowHeight));
+    out.push(...hstack(blocks, gap));
+    out.push("");
+  }
+  if (vis.disk !== false && data.disk.length) {
+    const dw = width - 4;
+    out.push(...panel("Disk", diskTableLines(data.disk, dw, theme.border), width, theme.disk, theme.border));
+    out.push("");
+  }
+  if (vis.process !== false) {
+    const filteredProcesses = opts2.filter ? data.processes.filter((p) => p.command.toLowerCase().includes(opts2.filter.toLowerCase())) : data.processes;
+    const sortedProcesses = sortProcesses(filteredProcesses, opts2.sortBy ?? "cpu");
+    const limited = opts2.processLimit ? sortedProcesses.slice(0, opts2.processLimit) : sortedProcesses;
+    const procTitle = opts2.filter ? `Processes \xB7 filter "${opts2.filter}" \xB7 sort ${opts2.sortBy ?? "cpu"}` : `Processes \xB7 sort ${opts2.sortBy ?? "cpu"}`;
+    if (limited.length) {
+      out.push(...panel(procTitle, processTableLines(limited, width - 4, theme.border), width, theme.process, theme.border));
+    } else if (opts2.filter) {
+      out.push(...panel(procTitle, [chalk2.dim(`No processes match "${opts2.filter}"`)], width, theme.process, theme.border));
+    }
+  }
+  return out.join("\n");
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatCsv(data) {
+  const rows = [
+    ["property", "key", "value"],
+    ["cpu", "brand", data.cpu.brand],
+    ["cpu", "usage", String(data.cpu.usage)],
+    ["cpu", "loadAvg_1m", String(data.cpu.loadAvg[0])],
+    ["cpu", "loadAvg_5m", String(data.cpu.loadAvg[1])],
+    ["cpu", "loadAvg_15m", String(data.cpu.loadAvg[2])],
+    ["memory", "total", String(data.memory.total)],
+    ["memory", "used", String(data.memory.used)],
+    ["memory", "usagePercent", String(data.memory.usagePercent)],
+    ["memory", "swapUsed", String(data.memory.swapUsed)],
+    ["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 !== void 0 ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : ""
+    ],
+    ["network", "rxBytes", String(data.network.rxBytes)],
+    ["network", "txBytes", String(data.network.txBytes)],
+    ["battery", "level", data.battery ? String(data.battery.level) : ""],
+    ["battery", "powerSource", data.battery ? data.battery.powerSource : ""],
+    ["battery", "condition", data.battery?.condition ?? ""],
+    ["battery", "maxCapacityPercent", data.battery?.maxCapacityPercent !== void 0 ? String(data.battery.maxCapacityPercent) : ""],
+    ["battery", "cycles", data.battery?.cycles !== void 0 ? String(data.battery.cycles) : ""],
+    ["power", "cpuWatts", data.power?.cpuWatts !== void 0 ? String(data.power.cpuWatts) : ""],
+    ["power", "gpuWatts", data.power?.gpuWatts !== void 0 ? String(data.power.gpuWatts) : ""],
+    ["power", "combinedWatts", data.power?.combinedWatts !== void 0 ? String(data.power.combinedWatts) : ""],
+    ["system", "hostname", data.header.hostname],
+    ["system", "uptime", data.header.uptime],
+    ["system", "timestamp", data.timestamp]
+  ];
+  return rows.map((r) => r.map((item) => `"${String(item).replace(/"/g, '""')}"`).join(",")).join("\n");
+}
+function formatTsv(data) {
+  return formatCsv(data).split("\n").map((r) => r.split(",").join("	")).join("\n");
+}
+function formatGraphs(history2, width = 80, themeName = "default") {
+  const theme = THEMES[themeName] || THEMES.default;
+  const contentWidth = width - 4;
+  const sampleCount = history2.cpuUsage.length;
+  const sparkWidth = Math.max(10, contentWidth - 28);
+  const lines = [];
+  lines.push(graphRow("CPU %", history2.cpuUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth));
+  lines.push(graphRow("Mem %", history2.memUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth));
+  lines.push(
+    graphRow("Temp", history2.temp, {}, formatTemp, sparkWidth, "no sensor access (needs sudo powermetrics)")
+  );
+  lines.push(graphRow("Net RX/s", history2.netRxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth));
+  lines.push(graphRow("Net TX/s", history2.netTxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth));
+  const title = `Graphs \xB7 last ${sampleCount} sample${sampleCount === 1 ? "" : "s"}`;
+  return panel(title, lines, width, theme.graphs, theme.border).join("\n");
+}
+function graphRow(label, values, bounds, fmt, sparkWidth = 40, emptyMessage = "collecting data...") {
+  if (!values.length) {
+    return `${chalk2.dim(label.padEnd(10))} ${chalk2.dim(emptyMessage)}`;
+  }
+  const visible = values.slice(-sparkWidth);
+  const spark = sparkline(visible, bounds);
+  const current = values[values.length - 1];
+  let color = chalk2.cyan;
+  if (bounds.min !== void 0 && bounds.max !== void 0) {
+    const pct = (current - bounds.min) / (bounds.max - bounds.min || 1) * 100;
+    color = pct > 90 ? chalk2.red : pct > 70 ? chalk2.yellow : chalk2.green;
+  }
+  return `${chalk2.dim(label.padEnd(10))}${color(spark)}  ${chalk2.bold(fmt(current))}`;
+}
+
+// src/live.ts
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import chalk3 from "chalk";
+
+// src/history.ts
+var History = class {
+  maxLen;
+  cpuUsage = [];
+  memUsage = [];
+  temp = [];
+  netRxRate = [];
+  netTxRate = [];
+  lastRxBytes = 0;
+  lastTxBytes = 0;
+  lastTs = 0;
+  constructor(maxLen = 40) {
+    this.maxLen = maxLen;
+  }
+  push(sample) {
+    const now = Date.now();
+    let rxRate = 0;
+    let txRate = 0;
+    if (this.lastTs > 0) {
+      const dtSeconds = Math.max((now - this.lastTs) / 1e3, 1e-3);
+      rxRate = Math.max(0, (sample.rxBytes - this.lastRxBytes) / dtSeconds);
+      txRate = Math.max(0, (sample.txBytes - this.lastTxBytes) / dtSeconds);
+    }
+    this.lastRxBytes = sample.rxBytes;
+    this.lastTxBytes = sample.txBytes;
+    this.lastTs = now;
+    this.pushBounded(this.cpuUsage, sample.cpuUsage);
+    this.pushBounded(this.memUsage, sample.memUsage);
+    if (sample.temp !== null) this.pushBounded(this.temp, sample.temp);
+    this.pushBounded(this.netRxRate, rxRate);
+    this.pushBounded(this.netTxRate, txRate);
+  }
+  reset() {
+    this.cpuUsage = [];
+    this.memUsage = [];
+    this.temp = [];
+    this.netRxRate = [];
+    this.netTxRate = [];
+    this.lastRxBytes = 0;
+    this.lastTxBytes = 0;
+    this.lastTs = 0;
+  }
+  /** Grow or shrink the rolling window (e.g. on terminal resize), trimming from the oldest samples. */
+  setMaxLen(n) {
+    this.maxLen = Math.max(1, n);
+    for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate]) {
+      while (arr.length > this.maxLen) arr.shift();
+    }
+  }
+  pushBounded(arr, v) {
+    arr.push(v);
+    if (arr.length > this.maxLen) arr.shift();
+  }
+};
+
+// src/live.ts
+var intervalHandle = null;
+var running = false;
+var paused = false;
+var detailed = false;
+var interval = 2;
+var showGraphs = true;
+var exportFormat = "json";
+var exportDir = "./pyre-exports";
+var currentTheme = "default";
+var visiblePanels = {
+  cpu: true,
+  mem: true,
+  power: true,
+  battery: true,
+  thermal: true,
+  network: true,
+  disk: true,
+  process: true
+};
+var logging = false;
+var logStream = null;
+var statusMessage = "";
+var statusTimer = null;
+var lastData = null;
+var history = new History(40);
+var keypressHandler = null;
+var termWidth = process.stdout.columns || 80;
+var termHeight = process.stdout.rows || 24;
+var sortMode = "cpu";
+var processFilter = "";
+var inputMode = null;
+var inputBuffer = "";
+var customizerIndex = 0;
+var CUSTOMIZER_OPTIONS = [
+  "Theme",
+  "Toggle CPU",
+  "Toggle Memory",
+  "Toggle Power",
+  "Toggle Battery",
+  "Toggle Thermal",
+  "Toggle Network",
+  "Toggle Disk",
+  "Toggle Processes"
+];
+var CPU_ALERT_PCT = 90;
+var TEMP_ALERT_C = 95;
+var alerted = false;
+function setStatus(msg, ms = 3e3) {
+  statusMessage = msg;
+  if (statusTimer) clearTimeout(statusTimer);
+  statusTimer = setTimeout(() => {
+    statusMessage = "";
+    render();
+  }, ms);
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function timestampForFile() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function exportSnapshot() {
+  if (!lastData) {
+    setStatus("No data yet \u2014 try again in a moment");
+    return;
+  }
+  try {
+    ensureDir(exportDir);
+    const file = path.join(exportDir, `pyre-${timestampForFile()}.${exportFormat}`);
+    const content = exportFormat === "json" ? formatJson(lastData) : exportFormat === "csv" ? formatCsv(lastData) : formatTsv(lastData);
+    fs.writeFileSync(file, content);
+    setStatus(`Exported snapshot -> ${file}`);
+  } catch (err) {
+    setStatus(`Export failed: ${err.message}`);
+  }
+}
+function startLogging() {
+  try {
+    ensureDir(exportDir);
+    const file = path.join(exportDir, `pyre-log-${timestampForFile()}.csv`);
+    logStream = fs.createWriteStream(file, { flags: "a" });
+    logStream.write("timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,thermal_state\n");
+    logging = true;
+    setStatus(`Logging every tick -> ${file}`);
+  } catch (err) {
+    setStatus(`Logging failed to start: ${err.message}`);
+  }
+}
+function stopLogging() {
+  logging = false;
+  logStream?.end();
+  logStream = null;
+  setStatus("Logging stopped");
+}
+function toggleLogging() {
+  if (logging) stopLogging();
+  else startLogging();
+}
+function writeLogRow(data) {
+  if (!logging || !logStream) return;
+  const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? "";
+  logStream.write(
+    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${data.thermal.state}
+`
+  );
+}
+function processRowBudget() {
+  const columns = gridColumns(termWidth);
+  const cardRows = Math.ceil(6 / columns);
+  const reserved = 2 + cardRows * 8 + 11 + (showGraphs ? 9 : 0) + 4;
+  return Math.max(3, Math.min(40, termHeight - reserved));
+}
+function renderCustomizerOverlay() {
+  const themesList = Object.keys(THEMES);
+  const lines = [
+    chalk3.bgCyan.black.bold(" UI CUSTOMIZER (Use \u2191/\u2193 or J/K to navigate, Enter/Space to toggle, Esc to exit) ")
+  ];
+  CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
+    const isSelected = idx === customizerIndex;
+    const prefix = isSelected ? chalk3.yellow("\u25B6 ") : "  ";
+    if (opt === "Theme") {
+      lines.push(`${prefix}${opt}: ${chalk3.bold.green(currentTheme)} [${themesList.join(", ")}]`);
+    } else {
+      const key = opt.replace("Toggle ", "").toLowerCase();
+      const isVisible = visiblePanels[key] !== false;
+      const status = isVisible ? chalk3.green("[VISIBLE]") : chalk3.red("[HIDDEN]");
+      lines.push(`${prefix}${opt}: ${status}`);
+    }
+  });
+  return lines.map((l) => `  ${l}`).join("\n");
+}
+function render() {
+  if (!lastData) return;
+  const lines = [];
+  lines.push(
+    formatTable(lastData, {
+      width: termWidth,
+      sortBy: sortMode,
+      filter: processFilter || void 0,
+      processLimit: processRowBudget(),
+      theme: currentTheme,
+      visible: visiblePanels
+    })
+  );
+  if (showGraphs) {
+    lines.push("");
+    lines.push(formatGraphs(history, termWidth, currentTheme));
+  }
+  lines.push("");
+  lines.push(footerLine());
+  if (inputMode === "customizer") {
+    lines.push(renderCustomizerOverlay());
+  } else if (inputMode === "filter") {
+    lines.push(chalk3.cyan(`  Filter processes: ${inputBuffer}_`));
+  } else if (inputMode === "kill") {
+    lines.push(chalk3.cyan(`  Kill PID: ${inputBuffer}_  (enter to confirm, esc to cancel)`));
+  } else if (statusMessage) {
+    lines.push(`  ${statusMessage}`);
+  }
+  process.stdout.write("\x1B[2J\x1B[H");
+  process.stdout.write(lines.join("\n"));
+}
+function footerLine() {
+  const keys = [
+    ["q", "quit"],
+    ["c", "customize UI"],
+    ["p", paused ? "resume" : "pause"],
+    ["g", showGraphs ? "hide graphs" : "show graphs"],
+    ["d", detailed ? "basic" : "detailed"],
+    ["s", `sort:${sortMode}`],
+    ["/", "filter"],
+    ["k", "kill"],
+    ["e", "export"],
+    ["l", logging ? "stop log" : "log"],
+    ["f", exportFormat],
+    ["+/-", `${interval}s`]
+  ];
+  const keyStr = keys.map(([k, label]) => `${chalk3.cyan.bold(k)} ${chalk3.dim(label)}`).join(chalk3.dim("  \xB7  "));
+  const badges = [];
+  if (paused) badges.push(chalk3.yellow.bold("\u23F8 PAUSED"));
+  if (logging) badges.push(chalk3.red.bold("\u25CF REC"));
+  const badgeStr = badges.join("  ");
+  return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;
+}
+function checkAlerts(data) {
+  const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+  const hot = data.cpu.usage >= CPU_ALERT_PCT || temp !== null && temp >= TEMP_ALERT_C;
+  if (hot && !alerted) {
+    alerted = true;
+    process.stdout.write("\x07");
+    const reason = data.cpu.usage >= CPU_ALERT_PCT ? `CPU at ${data.cpu.usage}%` : `Temp at ${temp}\xB0C`;
+    setStatus(chalk3.red(`\u26A0 Alert: ${reason}`), 5e3);
+  } else if (!hot) {
+    alerted = false;
+  }
+}
+async function tick() {
+  if (paused) return;
+  try {
+    const data = await collectAll({ detailed, processLimit: processRowBudget() });
+    lastData = data;
+    const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+    history.push({
+      cpuUsage: data.cpu.usage,
+      memUsage: data.memory.usagePercent,
+      temp,
+      rxBytes: data.network.rxBytes,
+      txBytes: data.network.txBytes
+    });
+    writeLogRow(data);
+    checkAlerts(data);
+    render();
+  } catch {
+  }
+}
+function killProcess(pidStr) {
+  const pid = parseInt(pidStr, 10);
+  if (!pid || pid <= 0) {
+    setStatus(`Invalid PID: ${pidStr}`);
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    setStatus(`Sent SIGTERM to PID ${pid}`);
+  } catch (err) {
+    setStatus(`Failed to kill ${pid}: ${err.message}`);
+  }
+}
+function handleInputModeKey(str, key) {
+  if (key.name === "escape") {
+    inputMode = null;
+    inputBuffer = "";
+    render();
+    return;
+  }
+  if (inputMode === "customizer") {
+    const themesList = Object.keys(THEMES);
+    if (key.name === "up" || str === "k") {
+      customizerIndex = (customizerIndex - 1 + CUSTOMIZER_OPTIONS.length) % CUSTOMIZER_OPTIONS.length;
+    } else if (key.name === "down" || str === "j") {
+      customizerIndex = (customizerIndex + 1) % CUSTOMIZER_OPTIONS.length;
+    } else if (key.name === "return" || str === " ") {
+      const selected = CUSTOMIZER_OPTIONS[customizerIndex];
+      if (selected === "Theme") {
+        const nextIdx = (themesList.indexOf(currentTheme) + 1) % themesList.length;
+        currentTheme = themesList[nextIdx];
+      } else {
+        const itemKey = selected.replace("Toggle ", "").toLowerCase();
+        visiblePanels[itemKey] = !visiblePanels[itemKey];
+      }
+    }
+    render();
+    return;
+  }
+  if (key.name === "return") {
+    if (inputMode === "filter") {
+      processFilter = inputBuffer.trim();
+      setStatus(processFilter ? `Filtering: "${processFilter}"` : "Filter cleared");
+    } else if (inputMode === "kill") {
+      killProcess(inputBuffer.trim());
+    }
+    inputMode = null;
+    inputBuffer = "";
+    render();
+    return;
+  }
+  if (key.name === "backspace") {
+    inputBuffer = inputBuffer.slice(0, -1);
+    render();
+    return;
+  }
+  if (str && str.length === 1 && !key.ctrl && !key.meta) {
+    inputBuffer += str;
+    render();
+  }
+}
+function onResize() {
+  termWidth = process.stdout.columns || 80;
+  termHeight = process.stdout.rows || 24;
+  history.setMaxLen(Math.max(20, Math.min(200, termWidth - 30)));
+  render();
+}
+function restartTicker() {
+  if (intervalHandle) clearInterval(intervalHandle);
+  intervalHandle = setInterval(tick, interval * 1e3);
+}
+async function startLive(opts2) {
+  if (running) return;
+  running = true;
+  paused = false;
+  detailed = !!opts2.detailed;
+  interval = opts2.interval;
+  if (opts2.exportDir) exportDir = opts2.exportDir;
+  termWidth = process.stdout.columns || 80;
+  termHeight = process.stdout.rows || 24;
+  history.reset();
+  history.setMaxLen(Math.max(20, Math.min(200, termWidth - 30)));
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[?25l");
+  process.stdout.write("\x1B[2J\x1B[H");
+  process.title = "pyre";
+  await tick();
+  restartTicker();
+  if (opts2.autoLog) startLogging();
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.on("resize", onResize);
+  keypressHandler = (str, key) => {
+    if (!key) return;
+    if (key.ctrl && key.name === "c") {
+      stopLive();
+      return;
+    }
+    if (inputMode) {
+      handleInputModeKey(str, key);
+      return;
+    }
+    switch (key.sequence) {
+      case "+":
+        interval += 1;
+        restartTicker();
+        setStatus(`Interval set to ${interval}s`);
+        return;
+      case "-":
+        interval = Math.max(1, interval - 1);
+        restartTicker();
+        setStatus(`Interval set to ${interval}s`);
+        return;
+      case "/":
+        inputMode = "filter";
+        inputBuffer = processFilter;
+        render();
+        return;
+    }
+    switch (key.name) {
+      case "q":
+        stopLive();
+        break;
+      case "c":
+        inputMode = "customizer";
+        customizerIndex = 0;
+        render();
+        break;
+      case "p":
+        paused = !paused;
+        setStatus(paused ? "Paused" : "Resumed");
+        render();
+        break;
+      case "g":
+        showGraphs = !showGraphs;
+        render();
+        break;
+      case "d":
+        detailed = !detailed;
+        setStatus(`Detailed sensor mode: ${detailed ? "on" : "off"}`);
+        break;
+      case "s":
+        sortMode = sortMode === "cpu" ? "mem" : sortMode === "mem" ? "pid" : "cpu";
+        setStatus(`Sorting by ${sortMode}`);
+        render();
+        break;
+      case "k":
+        inputMode = "kill";
+        inputBuffer = "";
+        render();
+        break;
+      case "e":
+        exportSnapshot();
+        render();
+        break;
+      case "l":
+        toggleLogging();
+        render();
+        break;
+      case "f":
+        exportFormat = exportFormat === "json" ? "csv" : exportFormat === "csv" ? "tsv" : "json";
+        setStatus(`Export format: ${exportFormat}`);
+        render();
+        break;
+    }
+  };
+  process.stdin.on("keypress", keypressHandler);
+  process.once("SIGINT", () => stopLive());
+}
+function stopLive() {
+  if (intervalHandle) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+  if (statusTimer) {
+    clearTimeout(statusTimer);
+    statusTimer = null;
+  }
+  if (logStream) {
+    logStream.end();
+    logStream = null;
+  }
+  if (keypressHandler) {
+    process.stdin.removeListener("keypress", keypressHandler);
+    keypressHandler = null;
+  }
+  process.stdout.removeListener("resize", onResize);
+  running = false;
+  logging = false;
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  process.stdin.pause();
+  process.stdout.write("\x1B[?25h");
+  process.stdout.write("\x1B[?1049l");
+  process.stdout.write("\x1B[2J\x1B[H");
+  process.exit(0);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("pyre").version("1.1.0").description("Mac system monitoring CLI: interactive live dashboard, stats, graphs, export").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("--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");
+program.parse(process.argv);
+var opts = program.opts();
+function isExportMode() {
+  return opts.json || opts.csv || opts.tsv;
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+async function main() {
+  const requestedLive = program.args[0] === "live" || !isExportMode() && !opts.once;
+  if (requestedLive) {
+    const interval2 = parseFloat(opts.interval) || 2;
+    await startLive({
+      interval: interval2,
+      detailed: opts.detailed,
+      exportDir: opts.exportDir,
+      autoLog: opts.log
+    });
+    return;
+  }
+  const data = await collectAll({ detailed: opts.detailed });
+  let output;
+  if (opts.json) output = formatJson(data);
+  else if (opts.csv) output = formatCsv(data);
+  else if (opts.tsv) output = formatTsv(data);
+  else output = formatTable(data, { width: process.stdout.columns || 80 });
+  console.log(output);
+  if (opts.out) {
+    fs2.writeFileSync(opts.out, stripAnsi(output));
+    console.log(chalk4.dim(`
+Saved to ${opts.out}`));
+  }
+}
+main().catch((err) => {
+  console.error(chalk4.red(`Error: ${err.message}`));
+  stopLive();
+  process.exit(1);
+});