pyre-cli 3.4.0 → 3.5.0

package/dist/index.js

@@ -10,10 +10,12 @@ import chalk9 from "chalk";
 import chalk from "chalk";
 
 // src/monitors/run.ts
-async function run(cmd, fallback = "") {
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function run(cmd, fallback = "", timeout = 5e3) {
   try {
-    const { execSync } = await import("child_process");
-    return execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }).trim();
+    return (await execAsync(cmd, { encoding: "utf8", timeout })).stdout.trim();
   } catch {
     return fallback;
   }
@@ -23,7 +25,7 @@ async function run(cmd, fallback = "") {
 var smcCache = null;
 async function getSmcMetrics() {
   const now = Date.now();
-  if (smcCache && now - smcCache.ts < 1500) return smcCache.data;
+  if (smcCache && now - smcCache.ts < 4e3) return smcCache.data;
   const result = { temps: {}, power: {}, freq: {} };
   try {
     const pm = (await run(
@@ -60,6 +62,46 @@ function parseSuffix(s) {
 }
 
 // src/monitors/collectors.ts
+var SP_TTL_MS = 1e4;
+var NETSTAT_TTL_MS = 1e3;
+var ROUTE_TTL_MS = 5e3;
+var SYSCTL_TTL_MS = 6e4;
+var spGpuCache = null;
+var spBatteryCache = null;
+var netstatIbCache = null;
+var routeCache = null;
+var sysctlCache = /* @__PURE__ */ new Map();
+async function cachedSysctl(key, fallback) {
+  const now = Date.now();
+  const hit = sysctlCache.get(key);
+  if (hit && now - hit.ts < SYSCTL_TTL_MS) return hit.value;
+  const value = await run(`sysctl -n ${key}`, fallback);
+  sysctlCache.set(key, { value, ts: now });
+  return value;
+}
+async function cachedNetstatIb() {
+  const now = Date.now();
+  if (netstatIbCache && now - netstatIbCache.ts < NETSTAT_TTL_MS) return netstatIbCache.raw;
+  const raw = await run("netstat -ib");
+  netstatIbCache = { raw, ts: now };
+  return raw;
+}
+async function cachedRouteIface() {
+  const now = Date.now();
+  if (routeCache && now - routeCache.ts < ROUTE_TTL_MS) return routeCache;
+  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 {
+  }
+  routeCache = { iface, ip, ts: now };
+  return routeCache;
+}
 var BATTERY_WINDOW_MS = 15 * 60 * 1e3;
 var MIN_ESTIMATE_WINDOW_MS = 30 * 1e3;
 var prevBattery = { samples: [] };
@@ -158,46 +200,49 @@ async function collectPower() {
   return null;
 }
 async function collectGpu(detailed) {
-  try {
-    const spRaw = (await run("system_profiler SPDisplaysDataType 2>/dev/null")).trim();
-    if (!spRaw) return null;
-    const modelMatch = spRaw.match(/Chipset Model:\s*(.+)/i);
-    const model = modelMatch ? modelMatch[1].trim() : "Unknown";
-    const memMatch = spRaw.match(/VRAM \(Total\):\s*(.+)/i);
-    let memory = 0;
-    if (memMatch) {
-      const memStr = memMatch[1].trim();
-      const memNum = parseFloat(memStr);
-      if (memStr.includes("GB")) memory = memNum * 1024 * 1024 * 1024;
-      else if (memStr.includes("MB")) memory = memNum * 1024 * 1024;
-    }
-    let utilization = 0;
-    let temperature;
-    let gpuProcesses = 0;
-    if (detailed) {
-      try {
-        const pm = (await run("sudo -n powermetrics --samplers gpu_power -n 1 --format text 2>/dev/null", "")).trim();
-        const gpuPowerMatch = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
-        if (gpuPowerMatch) {
-          utilization = Math.min(100, Math.round(parseFloat(gpuPowerMatch[1]) / 10));
-        }
-      } catch {
-      }
-      try {
-        const { temps } = await getSmcMetrics();
-        if (temps.gpu_die !== void 0) temperature = temps.gpu_die;
-      } catch {
-      }
-      try {
-        const psRaw = (await run('ps aux | grep -i "[g]pu" | wc -l')).trim();
-        gpuProcesses = parseInt(psRaw) || 0;
-      } catch {
+  let spRaw = "";
+  const now = Date.now();
+  if (spGpuCache && now - spGpuCache.ts < SP_TTL_MS) {
+    spRaw = spGpuCache.raw;
+  } else {
+    spRaw = (await run("system_profiler SPDisplaysDataType 2>/dev/null")).trim();
+    spGpuCache = { raw: spRaw, ts: now };
+  }
+  if (!spRaw) return null;
+  const modelMatch = spRaw.match(/Chipset Model:\s*(.+)/i);
+  const model = modelMatch ? modelMatch[1].trim() : "Unknown";
+  const memMatch = spRaw.match(/VRAM \(Total\):\s*(.+)/i);
+  let memory = 0;
+  if (memMatch) {
+    const memStr = memMatch[1].trim();
+    const memNum = parseFloat(memStr);
+    if (memStr.includes("GB")) memory = memNum * 1024 * 1024 * 1024;
+    else if (memStr.includes("MB")) memory = memNum * 1024 * 1024;
+  }
+  let utilization = 0;
+  let temperature;
+  let gpuProcesses = 0;
+  if (detailed) {
+    try {
+      const pm = (await run("sudo -n powermetrics --samplers gpu_power -n 1 --format text 2>/dev/null", "")).trim();
+      const gpuPowerMatch = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+      if (gpuPowerMatch) {
+        utilization = Math.min(100, Math.round(parseFloat(gpuPowerMatch[1]) / 10));
       }
+    } catch {
+    }
+    try {
+      const { temps } = await getSmcMetrics();
+      if (temps.gpu_die !== void 0) temperature = temps.gpu_die;
+    } catch {
+    }
+    try {
+      const psRaw = (await run('ps aux | grep -i "[g]pu" | wc -l')).trim();
+      gpuProcesses = parseInt(psRaw) || 0;
+    } catch {
     }
-    return { model, memory, utilization, temperature, processes: gpuProcesses };
-  } catch {
-    return null;
   }
+  return { model, memory, utilization, temperature, processes: gpuProcesses };
 }
 async function collectSystem() {
   const hostname = (await run("hostname", "Mac")).trim();
@@ -211,10 +256,10 @@ async function collectSystem() {
   };
 }
 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());
+  const brand = (await cachedSysctl("machdep.cpu.brand_string", "Unknown CPU")).trim();
+  const cores = parseInt(await cachedSysctl("hw.ncpu", "1")) || 1;
+  const physicalCores = parseInt(await cachedSysctl("hw.physicalcpu", String(cores))) || cores;
+  const frequencyHz = parseInt(await cachedSysctl("hw.cpufrequency", "0"));
   let frequency = frequencyHz > 0 ? Math.round(frequencyHz / 1e6) : 0;
   if (frequency === 0) {
     try {
@@ -247,8 +292,8 @@ async function collectCpu() {
   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 totalBytes = parseInt(await cachedSysctl("hw.memsize", "0")) || 0;
+  const pageSize = parseInt(await cachedSysctl("hw.pagesize", "4096")) || 4096;
   const vmStat = (await run("vm_stat")).trim();
   const getPageCount = (label) => {
     const m = vmStat.match(new RegExp(`Pages\\s+${label}:\\s+(\\d+)\\.`));
@@ -318,7 +363,14 @@ async function collectBattery() {
     let condition;
     let maxCapacityPercent;
     try {
-      const battInfo = (await run("system_profiler SPPowerDataType 2>/dev/null")).trim();
+      const now = Date.now();
+      let battInfo;
+      if (spBatteryCache && now - spBatteryCache.ts < SP_TTL_MS) {
+        battInfo = spBatteryCache.raw;
+      } else {
+        battInfo = (await run("system_profiler SPPowerDataType 2>/dev/null")).trim();
+        spBatteryCache = { raw: battInfo, ts: now };
+      }
       const cycleMatch = battInfo.match(/Cycle Count:\s+(\d+)/);
       if (cycleMatch) cycles = parseInt(cycleMatch[1]);
       const conditionMatch = battInfo.match(/Condition:\s+(.+)/);
@@ -426,17 +478,8 @@ async function collectThermal(detailed) {
 }
 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();
+    const { iface, ip } = await cachedRouteIface();
+    const netStat = await cachedNetstatIb();
     let rxBytes = 0;
     let txBytes = 0;
     let rxPackets = 0;
@@ -477,7 +520,7 @@ async function collectProcesses(limit) {
 }
 async function collectPackets() {
   try {
-    const netStat = (await run("netstat -ib")).trim();
+    const netStat = await cachedNetstatIb();
     const lines = netStat.split("\n").slice(1);
     let totalRxPackets = 0;
     let totalTxPackets = 0;
@@ -520,15 +563,7 @@ async function collectPackets() {
         }
         return { pid: 0, command: "", rxBytes: 0, txBytes: 0 };
       }).filter((p) => p.pid > 0);
-      const allLsof = (await run("lsof -i -n -P 2>/dev/null | tail -n +2 | awk '{print $1, $2}' | sort | uniq -c | sort -rn", "")).trim();
-      const allLsofLines = allLsof.split("\n");
-      allProcesses = allLsofLines.map((line) => {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length >= 3) {
-          return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
-        }
-        return { pid: 0, command: "", rxBytes: 0, txBytes: 0 };
-      }).filter((p) => p.pid > 0);
+      allProcesses = topProcesses;
     } catch {
       topProcesses = [];
       allProcesses = [];
@@ -677,7 +712,7 @@ function panel(title, lines, width, accent, borderAccent, height) {
   }
   return [top, ...body, bottom];
 }
-function hstack(blocks, gap = 2) {
+function hstack(blocks, gap = 2, targetWidth) {
   if (!blocks.length) return [];
   const height = Math.max(...blocks.map((b) => b.length));
   const widths = blocks.map((b) => visLen(b[0] ?? ""));
@@ -689,7 +724,12 @@ function hstack(blocks, gap = 2) {
   });
   const out = [];
   for (let row = 0; row < height; row++) {
-    out.push(padded.map((a) => a[row]).join(" ".repeat(gap)));
+    let line = padded.map((a) => a[row]).join(" ".repeat(gap));
+    if (targetWidth !== void 0) {
+      const pad = Math.max(0, targetWidth - visLen(line));
+      line += " ".repeat(pad);
+    }
+    out.push(line);
   }
   return out;
 }
@@ -941,6 +981,15 @@ function buildProcessTree(processes) {
   for (const p of processes) {
     if (p.ppid === 0 || !map.has(p.ppid)) roots.push(p);
   }
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const p of processes) {
+    const list = childrenMap.get(p.ppid) || [];
+    list.push(p);
+    childrenMap.set(p.ppid, list);
+  }
+  for (const list of childrenMap.values()) {
+    list.sort((a, b) => b.cpu - a.cpu);
+  }
   const lines = [];
   const visited = /* @__PURE__ */ new Set();
   function renderNode(proc, prefix, isLast) {
@@ -954,12 +1003,19 @@ function buildProcessTree(processes) {
     const thrStr = String(proc.threads).padEnd(6);
     const cmd = truncatePlain(proc.command, Math.max(10, 100 - pidStr.length - cpuStr.length - memStr.length - stateStr.length - thrStr.length - 10));
     lines.push(`${prefix}${connector}${pidStr}${cpuStr}${memStr}${stateStr}${thrStr} ${cmd}`);
-    const children = processes.filter((p) => p.ppid === proc.pid && !visited.has(p.pid));
-    children.sort((a, b) => b.cpu - a.cpu);
-    children.forEach((child, i) => {
-      const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
-      renderNode(child, nextPrefix, i === children.length - 1);
-    });
+    const children = childrenMap.get(proc.pid);
+    if (children) {
+      let idx = 0;
+      let total = 0;
+      for (const c of children) {
+        if (!visited.has(c.pid)) total++;
+      }
+      for (const child of children) {
+        if (visited.has(child.pid)) continue;
+        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+        renderNode(child, nextPrefix, ++idx === total);
+      }
+    }
   }
   roots.sort((a, b) => b.cpu - a.cpu);
   roots.forEach((root, i) => renderNode(root, "", i === roots.length - 1));
@@ -992,8 +1048,10 @@ function detailPanelTitle(panel2) {
   };
   return map[panel2] || panel2;
 }
-function activeDetailLines(data, activePanel, width) {
+function activeDetailLines(data, activePanel, width, opts2 = {}) {
   const contentWidth = width - 4;
+  const themeName = opts2.theme || "default";
+  const theme = THEMES[themeName] || THEMES.default;
   switch (activePanel) {
     case "cpu":
       return cpuCard(data, contentWidth);
@@ -1043,10 +1101,15 @@ function activeDetailLines(data, activePanel, width) {
     case "tasks":
       return data.tasks?.length ? tasksCard(data, contentWidth) : ["No task data available"];
     case "disk":
-      return data.disk.length ? diskTableLines(data.disk, width - 4, THEMES.default.border) : ["No disk data available"];
+      return data.disk.length ? diskTableLines(data.disk, width - 4, theme.border) : ["No disk data available"];
     case "process": {
-      const sorted = sortProcesses([...data.processes], "cpu");
-      return processTableLines(sorted.slice(0, 50), width - 4, THEMES.default.border);
+      const filtered = opts2.filter ? data.processes.filter((p) => p.command.toLowerCase().includes(opts2.filter.toLowerCase())) : data.processes;
+      const sorted = sortProcesses(filtered, opts2.sortBy ?? "cpu");
+      const limited = opts2.processLimit ? sorted.slice(0, opts2.processLimit) : sorted;
+      if (opts2.treeView) {
+        return buildProcessTree(limited);
+      }
+      return processTableLines(limited, width - 4, theme.border);
     }
     default:
       return null;
@@ -1068,7 +1131,7 @@ function formatTable(data, opts2 = {}) {
   out.push(tabBar(activePanel, width, theme));
   out.push("");
   if (activePanel !== "grid") {
-    const lines = activeDetailLines(data, activePanel, width);
+    const lines = activeDetailLines(data, activePanel, width, opts2);
     if (lines) {
       out.push(...panel(detailPanelTitle(activePanel), lines, width, theme[activePanel] ?? theme.cpu, theme.border));
     }
@@ -1111,7 +1174,7 @@ function formatTable(data, opts2 = {}) {
     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(...hstack(blocks, gap, width));
     out.push("");
   }
   if (vis.disk !== false && data.disk.length) {
@@ -1156,8 +1219,14 @@ import chalk4 from "chalk";
 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);
+  let min = opts2.min ?? Infinity;
+  let max = opts2.max ?? -Infinity;
+  if (opts2.min === void 0 || opts2.max === void 0) {
+    for (const v of values) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
   const range = max - min || 1;
   return values.map((v) => {
     const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
@@ -1251,21 +1320,21 @@ function formatGraphs(history, width = 80, themeName = "default", graphMode = "s
   const sampleCount = history.cpuUsage.length;
   const sparkWidth = Math.max(10, contentWidth - 28);
   const lines = [];
-  lines.push(graphRow("CPU %", history.cpuUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth, graphMode));
-  lines.push(graphRow("Mem %", history.memUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth, graphMode));
+  lines.push(graphRow("CPU %", history.cpuUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth, "collecting data...", graphMode));
+  lines.push(graphRow("Mem %", history.memUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth, "collecting data...", graphMode));
   lines.push(
     graphRow("Temp", history.temp, {}, formatTemp, sparkWidth, "no sensor access (needs sudo powermetrics)", graphMode)
   );
-  lines.push(graphRow("Net RX/s", history.netRxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth, graphMode));
-  lines.push(graphRow("Net TX/s", history.netTxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth, graphMode));
+  lines.push(graphRow("Net RX/s", history.netRxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth, "collecting data...", graphMode));
+  lines.push(graphRow("Net TX/s", history.netTxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth, "collecting data...", graphMode));
   if (history.powerWatts.length) {
-    lines.push(graphRow("Power W", history.powerWatts, {}, (v) => `${v.toFixed(1)} W`, sparkWidth, graphMode));
+    lines.push(graphRow("Power W", history.powerWatts, {}, (v) => `${v.toFixed(1)} W`, sparkWidth, "collecting data...", graphMode));
   }
   if (history.rxPacketRate.length) {
-    lines.push(graphRow("RX pkt/s", history.rxPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+    lines.push(graphRow("RX pkt/s", history.rxPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, "collecting data...", graphMode));
   }
   if (history.txPacketRate.length) {
-    lines.push(graphRow("TX pkt/s", history.txPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+    lines.push(graphRow("TX pkt/s", history.txPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, "collecting data...", graphMode));
   }
   const title = `Graphs \xB7 mode:${graphMode} \xB7 last ${sampleCount} sample${sampleCount === 1 ? "" : "s"}`;
   return panel(title, lines, width, theme.graphs, theme.border).join("\n");
@@ -1285,8 +1354,14 @@ function graphRow(label, values, bounds, fmt, sparkWidth = 40, emptyMessage = "c
   return `${chalk4.dim(label.padEnd(10))}${color(spark)}  ${chalk4.bold(fmt(current))}`;
 }
 function barGraph(values, bounds, width) {
-  const min = bounds.min ?? Math.min(...values);
-  const max = bounds.max ?? Math.max(...values);
+  let min = bounds.min ?? Infinity;
+  let max = bounds.max ?? -Infinity;
+  if (bounds.min === void 0 || bounds.max === void 0) {
+    for (const v of values) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
   const range = max - min || 1;
   return values.map((v) => {
     const pct = (v - min) / range;
@@ -1305,6 +1380,8 @@ import readline from "readline";
 var History = class {
   /** Maximum number of samples retained in the rolling window. */
   maxLen;
+  /** Monotonically increasing version, bumped on every push. */
+  version = 0;
   /** Rolling window of CPU usage percentages (0–100). */
   cpuUsage = [];
   /** Rolling window of memory usage percentages (0–100). */
@@ -1376,6 +1453,7 @@ var History = class {
     if (sample.rxPackets !== void 0) this.pushBounded(this.rxPacketRate, rxPktRate);
     if (sample.txPackets !== void 0) this.pushBounded(this.txPacketRate, txPktRate);
     if (sample.connections !== void 0) this.pushBounded(this.connections, sample.connections);
+    this.version++;
   }
   /** Clear all rolling windows and reset cumulative byte counters. */
   reset() {
@@ -1394,6 +1472,7 @@ var History = class {
     this.lastRxPackets = 0;
     this.lastTxPackets = 0;
     this.lastTs = 0;
+    this.version = 0;
   }
   /**
    * Grow or shrink the rolling window (e.g. on terminal resize),
@@ -1416,6 +1495,7 @@ var History = class {
 var SIGNAL_OPTIONS = ["SIGTERM", "SIGKILL", "SIGINT", "SIGHUP", "SIGSTOP", "SIGCONT"];
 var state = {
   intervalHandle: null,
+  uiIntervalHandle: null,
   running: false,
   paused: false,
   detailed: false,
@@ -1451,6 +1531,8 @@ var state = {
   processFilter: "",
   inputMode: null,
   inputBuffer: "",
+  targetPid: "",
+  selectedSignal: "SIGTERM",
   treeView: false,
   SIGNAL_OPTIONS,
   customizerIndex: 0,
@@ -1503,6 +1585,23 @@ function setStatus(msg, ms = 3e3) {
     state.statusMessage = "";
   }, ms);
 }
+function getToggleKey(opt) {
+  const map = {
+    "Toggle CPU": "cpu",
+    "Toggle Memory": "mem",
+    "Toggle GPU": "gpu",
+    "Toggle Power": "power",
+    "Toggle Battery": "battery",
+    "Toggle Thermal": "thermal",
+    "Toggle Network": "network",
+    "Toggle Packets": "packets",
+    "Toggle Tasks": "tasks",
+    "Toggle Disk": "disk",
+    "Toggle Processes": "process",
+    "Toggle Tree View": "tree"
+  };
+  return map[opt] ?? null;
+}
 
 // src/live/export.ts
 import fs from "fs";
@@ -1564,12 +1663,48 @@ function writeLogRow(data) {
 
 // src/live/render.ts
 import chalk5 from "chalk";
+var _cachedTable = "";
+var _cachedTableData = null;
+var _cachedTableParams = "";
+var _tableDataDirty = false;
+function invalidateTableCache() {
+  _tableDataDirty = true;
+}
+var _cachedGraphs = "";
+var _cachedGraphsVersion = -1;
+var _cachedGraphsParams = "";
+function tableCacheParams() {
+  const limit = processRowBudget();
+  return [
+    state.sortMode,
+    state.processFilter || "",
+    limit,
+    state.currentTheme,
+    state.activePanel,
+    state.treeView ? "1" : "0",
+    JSON.stringify(state.visiblePanels)
+  ].join("|");
+}
+function graphsCacheParams() {
+  return [
+    state.termWidth,
+    state.currentTheme,
+    state.graphMode
+  ].join("|");
+}
 function processRowBudget() {
+  let overlayRows = 0;
+  if (state.inputMode === "customizer") overlayRows = state.CUSTOMIZER_OPTIONS.length + 3;
+  else if (state.inputMode === "signal") overlayRows = 6;
+  else if (state.inputMode === "filter" || state.inputMode === "kill" || state.inputMode === "p2p") overlayRows = 3;
+  if (state.activePanel === "process") {
+    return Math.max(10, state.termHeight - 12 - overlayRows);
+  }
   const columns = gridColumns(state.termWidth);
   const visibleCards = Object.values(state.visiblePanels).filter((v) => v !== false).length;
   const cardRows = Math.ceil(visibleCards / columns);
-  const reserved = 2 + cardRows * 8 + 11 + (state.showGraphs ? 9 : 0) + 4;
-  return Math.max(3, Math.min(40, state.termHeight - reserved));
+  const reserved = 4 + cardRows * 8 + 8 + (state.showGraphs ? 11 : 0) + 5 + overlayRows;
+  return Math.max(5, state.termHeight - reserved);
 }
 function p2pPanelLines() {
   const events = state.p2pServer ? state.p2pServer.peerEventHistory : state.p2pEvents;
@@ -1606,94 +1741,144 @@ function renderCustomizerOverlay() {
       lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.currentTheme)} [${themesList.join(", ")}]`);
     } else if (opt === "Graph Mode") {
       lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.graphMode)} [spark, bar]`);
-    } else if (opt === "Toggle Tree View") {
-      const status = state.treeView ? chalk5.green("[VISIBLE]") : chalk5.red("[HIDDEN]");
-      lines.push(`${prefix}${opt}: ${status}`);
     } else {
-      const key = opt.replace("Toggle ", "").toLowerCase();
-      const isVisible = state.visiblePanels[key] !== false;
+      const toggleKey = getToggleKey(opt);
+      const isVisible = toggleKey ? toggleKey === "tree" ? state.treeView : state.visiblePanels[toggleKey] !== false : true;
       const status = isVisible ? chalk5.green("[VISIBLE]") : chalk5.red("[HIDDEN]");
       lines.push(`${prefix}${opt}: ${status}`);
     }
   });
   return lines.map((l) => `  ${l}`).join("\n");
 }
+var _prevFrameLines = [];
+var _frameDirty = true;
+function invalidateFrame() {
+  _frameDirty = true;
+}
+function writeFrame(lines) {
+  if (_frameDirty || _prevFrameLines.length === 0 || lines.length !== _prevFrameLines.length) {
+    process.stdout.write("\x1B[?25l\x1B[H" + lines.map((l) => `\x1B[2K${l}`).join("\r\n") + "\x1B[0J");
+    _prevFrameLines = lines;
+    _frameDirty = false;
+    return;
+  }
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] !== _prevFrameLines[i]) {
+      out += `\x1B[${i + 1};1H\x1B[2K${lines[i]}`;
+    }
+  }
+  if (out) process.stdout.write(out);
+  _prevFrameLines = lines;
+}
 function render() {
   if (!state.lastData) return;
   const lines = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
+  const params = tableCacheParams();
+  const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || params !== _cachedTableParams ? (() => {
+    const out = formatTable(state.lastData, {
+      width: state.termWidth,
+      sortBy: state.sortMode,
+      filter: state.processFilter || void 0,
+      processLimit: processRowBudget(),
+      theme: state.currentTheme,
+      visible: state.visiblePanels,
+      treeView: state.treeView,
+      activePanel: state.activePanel
+    });
+    _cachedTableData = state.lastData;
+    _cachedTableParams = params;
+    _cachedTable = out;
+    _tableDataDirty = false;
+    return out;
+  })() : _cachedTable;
+  const bodyLines = [];
   if (state.activePanel === "p2p") {
     const panelLines = p2pPanelLines();
-    lines.push(...panel(panelLines.title, panelLines.body, state.termWidth, theme.process, theme.border));
+    bodyLines.push(...panel(panelLines.title, panelLines.body, state.termWidth, theme.process, theme.border));
   } else {
-    lines.push(
-      formatTable(state.lastData, {
-        width: state.termWidth,
-        sortBy: state.sortMode,
-        filter: state.processFilter || void 0,
-        processLimit: processRowBudget(),
-        theme: state.currentTheme,
-        visible: state.visiblePanels,
-        treeView: state.treeView,
-        activePanel: state.activePanel
-      })
-    );
-  }
+    bodyLines.push(...tableStr.split("\n"));
+  }
+  const graphsParams = graphsCacheParams();
+  const graphsStr = state.history.version !== _cachedGraphsVersion || graphsParams !== _cachedGraphsParams ? (() => {
+    const out = formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode);
+    _cachedGraphsVersion = state.history.version;
+    _cachedGraphsParams = graphsParams;
+    _cachedGraphs = out;
+    return out;
+  })() : _cachedGraphs;
   if (state.showGraphs && state.activePanel !== "p2p") {
-    lines.push("");
-    lines.push(formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode));
+    bodyLines.push("");
+    bodyLines.push(...graphsStr.split("\n"));
   }
-  lines.push("");
-  lines.push(footerLine());
+  const footerLines = [];
+  footerLines.push("");
+  footerLines.push(...footerLine().split("\n"));
   if (state.inputMode === "customizer") {
-    lines.push(renderCustomizerOverlay());
+    footerLines.push(...renderCustomizerOverlay().split("\n"));
   } else if (state.inputMode === "filter") {
-    lines.push(chalk5.cyan(`  Filter processes: ${state.inputBuffer}_`));
+    footerLines.push(chalk5.cyan(`  Filter processes: ${state.inputBuffer}_`));
   } else if (state.inputMode === "kill") {
-    lines.push(chalk5.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
+    footerLines.push(chalk5.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
   } else if (state.inputMode === "signal") {
     const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer);
     const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk5.yellow(s) : chalk5.dim(s)).join("  ");
-    lines.push(chalk5.cyan(`  Signal: ${state.inputBuffer}_`));
-    lines.push(chalk5.dim(`  ${sigList}`));
-    lines.push(chalk5.dim("  \u2191/\u2193 to select, Enter to confirm, Esc to cancel"));
+    footerLines.push(chalk5.cyan(`  Signal: ${state.inputBuffer}_`));
+    footerLines.push(chalk5.dim(`  ${sigList}`));
+    footerLines.push(chalk5.dim("  \u2191/\u2193 to select, Enter to confirm, Esc to cancel"));
   } else if (state.inputMode === "p2p") {
-    lines.push(chalk5.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
+    footerLines.push(chalk5.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
   } else if (state.statusMessage) {
-    lines.push(`  ${state.statusMessage}`);
+    footerLines.push(`  ${state.statusMessage}`);
+  } else {
+    footerLines.push("");
   }
-  process.stdout.write("\x1B[2J\x1B[H");
-  process.stdout.write(lines.join("\n"));
+  const maxBodyLines = Math.max(1, state.termHeight - footerLines.length);
+  if (bodyLines.length > maxBodyLines) {
+    bodyLines.length = maxBodyLines;
+  }
+  const frameLines = [...bodyLines, ...footerLines];
+  if (frameLines.length > state.termHeight) {
+    frameLines.length = state.termHeight;
+  }
+  writeFrame(frameLines);
 }
 function footerLine() {
-  const keys = [
+  const row1 = [
     ["q", "quit"],
     ["c", "customize UI"],
-    ["r", state.p2pServerRunning ? "stop p2p" : "start p2p"],
-    ["p", state.paused ? "resume" : "pause"],
+    ["\u2190/\u2192", "tab"],
+    ["1-9", "panels"],
     ["g", state.showGraphs ? "hide graphs" : "show graphs"],
     ["b", `graph:${state.graphMode}`],
+    ["t", state.treeView ? "flat" : "tree"],
     ["d", state.detailed ? "basic" : "detailed"],
-    ["\u2190/\u2192", "tab"],
-    ["1-9", "panels"],
+    ["p", state.paused ? "resume" : "pause"]
+  ];
+  const row2 = [
     ["s", `sort:${state.sortMode}`],
     ["/", "filter"],
     ["k", "kill"],
     ["S", "signal"],
-    ["t", state.treeView ? "flat" : "tree"],
     ["e", "export"],
     ["l", state.logging ? "stop log" : "log"],
     ["f", state.exportFormat],
-    ["+/-", `${state.interval}s`]
+    ["+/-", `${state.interval}s`],
+    ["r", state.p2pServerRunning ? "stop p2p" : "start p2p"]
   ];
-  const keyStr = keys.map(([k, label]) => `${chalk5.hex("#50fa7b").bold(k)} ${chalk5.dim(label)}`).join(chalk5.dim("  |  "));
+  const fmt = (list) => list.map(([k, label]) => `${chalk5.hex("#50fa7b").bold(k)} ${chalk5.dim(label)}`).join(chalk5.dim("  |  "));
+  const str1 = fmt(row1);
+  const str2 = fmt(row2);
   const badges = [];
   if (state.paused) badges.push(chalk5.yellow.bold("\u23F8 PAUSED"));
   if (state.logging) badges.push(chalk5.red.bold("\u25CF REC"));
   if (state.activePanel !== "grid") badges.push(chalk5.cyan.bold(`\u25C9 ${state.activePanel.toUpperCase()}`));
   if (state.p2pServerRunning) badges.push(chalk5.green.bold(`P2P ${state.p2pBind || "0.0.0.0"}:${state.p2pPort}`));
   const badgeStr = badges.join("  ");
-  return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;
+  return badgeStr ? `${str1}
+${str2}    ${badgeStr}` : `${str1}
+${str2}`;
 }
 function checkAlerts(data) {
   const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
@@ -2348,8 +2533,20 @@ function deriveHMACKey2(password) {
 }
 
 // src/live/input.ts
+function isUpKey(key, str) {
+  return key.name === "up" || str === "k" || key.sequence === "\x1B[A" || key.sequence === "\x1BOA";
+}
+function isDownKey(key, str) {
+  return key.name === "down" || str === "j" || key.sequence === "\x1B[B" || key.sequence === "\x1BOB";
+}
+function isEnterKey(key, str) {
+  return key.name === "return" || key.name === "enter" || key.sequence === "\r" || key.sequence === "\n" || str === "\r" || str === "\n";
+}
+function isEscKey(key, str) {
+  return key.name === "escape" || key.name === "esc" || key.sequence === "\x1B" || str === "\x1B";
+}
 function handleInputModeKey(str, key) {
-  if (key.name === "escape") {
+  if (isEscKey(key, str)) {
     state.inputMode = null;
     state.inputBuffer = "";
     render();
@@ -2357,38 +2554,55 @@ function handleInputModeKey(str, key) {
   }
   if (state.inputMode === "customizer") {
     const themesList = Object.keys(THEMES);
-    if (key.name === "up" || str === "k") {
+    if (isUpKey(key, str)) {
       state.customizerIndex = (state.customizerIndex - 1 + state.CUSTOMIZER_OPTIONS.length) % state.CUSTOMIZER_OPTIONS.length;
-    } else if (key.name === "down" || str === "j") {
+    } else if (isDownKey(key, str)) {
       state.customizerIndex = (state.customizerIndex + 1) % state.CUSTOMIZER_OPTIONS.length;
-    } else if (key.name === "return" || str === " ") {
+    } else if (isEnterKey(key, str) || str === " ") {
       const selected = state.CUSTOMIZER_OPTIONS[state.customizerIndex];
       if (selected === "Theme") {
         const nextIdx = (themesList.indexOf(state.currentTheme) + 1) % themesList.length;
         state.currentTheme = themesList[nextIdx];
-      } else if (selected === "Toggle Tree View") {
-        state.treeView = !state.treeView;
       } else if (selected === "Graph Mode") {
         state.graphMode = state.graphMode === "spark" ? "bar" : "spark";
       } else {
-        const itemKey = selected.replace("Toggle ", "").toLowerCase();
-        state.visiblePanels[itemKey] = !state.visiblePanels[itemKey];
+        const toggleKey = getToggleKey(selected);
+        if (toggleKey) {
+          if (toggleKey === "tree") {
+            state.treeView = !state.treeView;
+            state.visiblePanels.tree = state.treeView;
+          } else {
+            const isVisible = state.visiblePanels[toggleKey] !== false;
+            state.visiblePanels[toggleKey] = !isVisible;
+          }
+        }
       }
+      invalidateTableCache();
+      invalidateFrame();
     }
     render();
     return;
   }
   if (state.inputMode === "signal") {
-    if (key.name === "up" || str === "k") {
+    if (isUpKey(key, str)) {
       const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer);
       state.inputBuffer = state.SIGNAL_OPTIONS[(idx - 1 + state.SIGNAL_OPTIONS.length) % state.SIGNAL_OPTIONS.length];
-    } else if (key.name === "down" || str === "j") {
+      state.selectedSignal = state.inputBuffer;
+    } else if (isDownKey(key, str)) {
       const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer);
       state.inputBuffer = state.SIGNAL_OPTIONS[(idx + 1) % state.SIGNAL_OPTIONS.length];
-    } else if (key.name === "return" || str === " ") {
-      killProcess(state.inputBuffer.trim(), state.inputBuffer.trim());
-      state.inputMode = null;
-      state.inputBuffer = "";
+      state.selectedSignal = state.inputBuffer;
+    } else if (isEnterKey(key, str) || str === " ") {
+      state.selectedSignal = state.inputBuffer.trim();
+      if (state.targetPid) {
+        killProcess(state.targetPid, state.selectedSignal);
+        state.inputMode = null;
+        state.inputBuffer = "";
+      } else {
+        state.inputMode = "kill";
+        state.inputBuffer = "";
+        setStatus(`Signal ${state.selectedSignal} selected. Enter target PID to kill:`, 5e3);
+      }
       render();
       return;
     }
@@ -2396,13 +2610,13 @@ function handleInputModeKey(str, key) {
     return;
   }
   if (state.inputMode === "p2p") {
-    if (key.name === "escape") {
+    if (isEscKey(key, str)) {
       state.inputMode = null;
       state.inputBuffer = "";
       render();
       return;
     }
-    if (key.name === "return") {
+    if (isEnterKey(key, str)) {
       const password = state.inputBuffer.trim();
       if (password) {
         state.p2pPassword = password;
@@ -2424,12 +2638,14 @@ function handleInputModeKey(str, key) {
     }
     return;
   }
-  if (key.name === "return") {
+  if (isEnterKey(key, str)) {
     if (state.inputMode === "filter") {
       state.processFilter = state.inputBuffer.trim();
       setStatus(state.processFilter ? `Filtering: "${state.processFilter}"` : "Filter cleared");
     } else if (state.inputMode === "kill") {
-      killProcess(state.inputBuffer.trim());
+      const pidStr = state.inputBuffer.trim();
+      state.targetPid = pidStr;
+      killProcess(pidStr, state.selectedSignal);
     }
     state.inputMode = null;
     state.inputBuffer = "";
@@ -2509,6 +2725,8 @@ function onResize() {
   state.termWidth = process.stdout.columns || 80;
   state.termHeight = process.stdout.rows || 24;
   state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+  invalidateFrame();
+  process.stdout.write("\x1B[2J\x1B[H");
   render();
 }
 function restartTicker() {
@@ -2517,8 +2735,9 @@ function restartTicker() {
 }
 async function doWarmup() {
   try {
-    const data = await collectAll({ detailed: state.detailed, processLimit: processRowBudget() });
+    const data = await collectAll({ detailed: state.detailed });
     state.lastData = data;
+    invalidateTableCache();
     const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
     state.history.push({
       cpuUsage: data.cpu.usage,
@@ -2541,8 +2760,9 @@ async function doWarmup() {
 async function tick() {
   if (state.paused) return;
   try {
-    const data = await collectAll({ detailed: state.detailed, processLimit: processRowBudget() });
+    const data = await collectAll({ detailed: state.detailed });
     state.lastData = data;
+    invalidateTableCache();
     const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
     state.history.push({
       cpuUsage: data.cpu.usage,
@@ -2594,6 +2814,10 @@ async function startLive(opts2, splashPromise) {
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
   process.stdin.resume();
   process.stdout.on("resize", onResize);
+  if (state.uiIntervalHandle) clearInterval(state.uiIntervalHandle);
+  state.uiIntervalHandle = setInterval(() => {
+    if (state.running && !state.paused) render();
+  }, 250);
   state.keypressHandler = (str, key) => {
     if (!key) return;
     if (key.ctrl && key.name === "c") {
@@ -2684,28 +2908,12 @@ async function startLive(opts2, splashPromise) {
       case "q":
         stopLive();
         break;
-      case "left": {
-        const currentIdx = state.PANEL_TABS.findIndex((t) => t.id === state.activePanel);
-        if (currentIdx > 0) {
-          state.activePanel = state.PANEL_TABS[currentIdx - 1].id;
-        } else if (currentIdx === -1) {
-          state.activePanel = state.PANEL_TABS[state.PANEL_TABS.length - 1].id;
-        }
-        setStatus(`Panel: ${state.activePanel}`);
-        render();
+      case "left":
+        cycleTab(-1);
         break;
-      }
-      case "right": {
-        const currentIdx = state.PANEL_TABS.findIndex((t) => t.id === state.activePanel);
-        if (currentIdx < state.PANEL_TABS.length - 1) {
-          state.activePanel = state.PANEL_TABS[currentIdx + 1].id;
-        } else if (currentIdx === -1) {
-          state.activePanel = state.PANEL_TABS[0].id;
-        }
-        setStatus(`Panel: ${state.activePanel}`);
-        render();
+      case "right":
+        cycleTab(1);
         break;
-      }
       case "c":
         state.inputMode = "customizer";
         state.customizerIndex = 0;
@@ -2767,12 +2975,6 @@ async function startLive(opts2, splashPromise) {
       case "tab":
         cycleTab(1);
         break;
-      case "left":
-        cycleTab(-1);
-        break;
-      case "right":
-        cycleTab(1);
-        break;
       default:
         if (str && str.length === 1) {
           const tabId = tabKeyToId(str);
@@ -2812,8 +3014,8 @@ function handleSGRMouse(seq) {
   const match = seq.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
   if (!match) return;
   const button = parseInt(match[1]);
-  const cx = parseInt(match[2]);
-  const cy = parseInt(match[3]);
+  const cx = parseInt(match[2]) - 1;
+  const cy = parseInt(match[3]) - 1;
   if (button === 0 || button === 1) {
     handleMouseClick(cy, cx);
   }
@@ -2833,6 +3035,10 @@ function stopLive() {
     clearInterval(state.intervalHandle);
     state.intervalHandle = null;
   }
+  if (state.uiIntervalHandle) {
+    clearInterval(state.uiIntervalHandle);
+    state.uiIntervalHandle = null;
+  }
   if (state.statusTimer) {
     clearTimeout(state.statusTimer);
     state.statusTimer = null;