pyre-cli 1.4.0 → 3.0.0

package/dist/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs2 from "fs";
+import fs4 from "fs";
+import readline2 from "readline";
 import { Command } from "commander";
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 
 // src/monitors/collectors.ts
 import chalk from "chalk";
@@ -59,8 +60,39 @@ function parseSuffix(s) {
 }
 
 // src/monitors/collectors.ts
+var BATTERY_WINDOW_MS = 15 * 60 * 1e3;
+var MIN_ESTIMATE_WINDOW_MS = 30 * 1e3;
+var prevBattery = { samples: [] };
+function estimateBatteryLife(level, state2) {
+  const now = Date.now();
+  if (state2 === "charged" || state2 === "charging") {
+    prevBattery.samples = [];
+    return {};
+  }
+  prevBattery.samples.push({ level, ts: now });
+  prevBattery.samples = prevBattery.samples.filter((s) => now - s.ts <= BATTERY_WINDOW_MS);
+  const first = prevBattery.samples[0];
+  const elapsedMs = now - first.ts;
+  if (elapsedMs < MIN_ESTIMATE_WINDOW_MS) {
+    return {};
+  }
+  const dtHours = Math.max(elapsedMs / 1e3 / 3600, 1e-4);
+  const discharged = first.level - level;
+  if (discharged <= 0) {
+    return { estimatedTimeToEmpty: "calculating" };
+  }
+  const dischargeRate = discharged / dtHours;
+  const remainingLevel = Math.max(level, 0);
+  const hoursToEmpty = remainingLevel / dischargeRate;
+  const h = Math.floor(hoursToEmpty);
+  const m = Math.round((hoursToEmpty - h) * 60);
+  const estimatedTimeToEmpty = hoursToEmpty > 0 ? `${h}h ${m}m` : "calculating";
+  const ASSUMED_CAPACITY_WH = 55;
+  const powerWatts = Math.round(dischargeRate * (ASSUMED_CAPACITY_WH / 100) * 100) / 100;
+  return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10, powerWatts };
+}
 async function collectAll(opts2 = {}) {
-  const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power] = await Promise.all([
+  const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks] = await Promise.all([
     collectCpu(),
     collectGpu(opts2.detailed),
     collectMemory(),
@@ -68,9 +100,11 @@ async function collectAll(opts2 = {}) {
     collectBattery(),
     collectThermal(opts2.detailed),
     collectNetwork(),
-    collectProcesses(opts2.processLimit ?? 10),
+    collectProcesses(opts2.processLimit),
     collectSystem(),
-    collectPower()
+    collectPower(),
+    collectPackets(),
+    collectTasks()
   ]);
   return {
     header: {
@@ -88,17 +122,40 @@ async function collectAll(opts2 = {}) {
     network,
     processes,
     power,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    packets,
+    tasks
   };
 }
 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 };
+    if (power.cpu !== void 0 || power.gpu !== void 0 || power.combined !== void 0) {
+      return { cpuWatts: power.cpu, gpuWatts: power.gpu, combinedWatts: power.combined };
+    }
   } catch {
-    return null;
   }
+  try {
+    const ioreg = (await run("ioreg -rn AppleSmartBattery 2>/dev/null")).trim();
+    const ampMatch = ioreg.match(/"InstantAmperage"\s*=\s*(-?\d+)/);
+    const voltMatch = ioreg.match(/"Voltage"\s*=\s*(\d+)/);
+    if (ampMatch && voltMatch) {
+      let ampsBig = BigInt(ampMatch[1]);
+      if (!ampMatch[1].startsWith("-")) {
+        const UINT64_MAX_PLUS_1 = 1n << 64n;
+        const INT64_MAX = (1n << 63n) - 1n;
+        if (ampsBig > INT64_MAX) ampsBig -= UINT64_MAX_PLUS_1;
+      }
+      const amps = Number(ampsBig);
+      const volts = parseInt(voltMatch[1], 10) / 1e3;
+      const watts = Math.abs(amps / 1e3 * volts);
+      if (Number.isFinite(watts) && watts < 500) {
+        return { combinedWatts: Math.round(watts * 100) / 100 };
+      }
+    }
+  } catch {
+  }
+  return null;
 }
 async function collectGpu(detailed) {
   try {
@@ -252,7 +309,7 @@ async function collectBattery() {
     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 timeMatch = raw.match(/:\s*([\d:]+)\s+remaining/i) || raw.match(/(\d+:\d+)\s+remaining/i);
     const powerPlugged = raw.includes("AC Power") || raw.includes("attached to charger");
     const level = levelMatch ? parseInt(levelMatch[1]) : 0;
     const state2 = powerPlugged ? "charged" : stateMatch ? stateMatch[1].toLowerCase() : "discharging";
@@ -285,6 +342,7 @@ async function collectBattery() {
     if (maxCapacityPercent !== void 0) healthParts.push(`${maxCapacityPercent}% capacity`);
     if (cycles !== void 0) healthParts.push(`${cycles} cycles`);
     const health = healthParts.length ? healthParts.join(", ") : "unknown";
+    const estimate = estimateBatteryLife(level, state2);
     return {
       level,
       state: state2,
@@ -293,7 +351,8 @@ async function collectBattery() {
       powerSource: powerPlugged ? "AC" : "Battery",
       cycles,
       condition,
-      maxCapacityPercent
+      maxCapacityPercent,
+      ...estimate
     };
   } catch {
     return null;
@@ -398,9 +457,13 @@ async function collectNetwork() {
     return { interface: "unknown", ip: "0.0.0.0", rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0 };
   }
 }
-async function collectProcesses(limit = 10) {
+async function collectProcesses(limit) {
   try {
-    const raw = (await run(`ps -Ao pid,ppid,user,pcpu,pmem,state,threads,time,comm -r | head -n ${limit + 1}`)).trim();
+    const isMac = process.platform === "darwin";
+    const sortArg = isMac ? "-r" : "--sort=-pcpu";
+    const threadsArg = isMac ? "threads" : "nlwp";
+    const headClause = limit && limit > 0 ? ` | head -n ${limit + 1}` : "";
+    const raw = (await run(`ps -eo pid,ppid,user,pcpu,pmem,state,${threadsArg},time,comm ${sortArg}${headClause}`)).trim();
     const lines = raw.split("\n").slice(1);
     return lines.map((line) => {
       const parts = line.match(/\s*(\d+)\s+(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(\d+)\s+([\d:]+)\s+(.+)/);
@@ -412,6 +475,95 @@ async function collectProcesses(limit = 10) {
     return [];
   }
 }
+async function collectPackets() {
+  try {
+    const netStat = (await run("netstat -ib")).trim();
+    const lines = netStat.split("\n").slice(1);
+    let totalRxPackets = 0;
+    let totalTxPackets = 0;
+    let totalRxBytes = 0;
+    let totalTxBytes = 0;
+    const ifaceStats = [];
+    for (const line of lines) {
+      const parts = line.split(/\s+/);
+      if (parts.length >= 11 && parts[0] && !parts[0].startsWith("Name")) {
+        const iface = parts[0];
+        const rxPackets = parseInt(parts[4]) || 0;
+        const rxBytes = parseInt(parts[5]) || 0;
+        const txPackets = parseInt(parts[6]) || 0;
+        const txBytes = parseInt(parts[7]) || 0;
+        totalRxPackets += rxPackets;
+        totalTxPackets += txPackets;
+        totalRxBytes += rxBytes;
+        totalTxBytes += txBytes;
+        if (iface && !iface.includes("lo")) {
+          ifaceStats.push({ iface, rxPackets, txPackets, rxBytes, txBytes });
+        }
+      }
+    }
+    let connections = 0;
+    try {
+      const tcpConns = (await run("netstat -an | grep ESTABLISHED | wc -l", "0")).trim();
+      connections = parseInt(tcpConns) || 0;
+    } catch {
+      connections = 0;
+    }
+    let topProcesses = [];
+    let allProcesses = [];
+    try {
+      const lsof = (await run("lsof -i -n -P 2>/dev/null | tail -n +2 | awk '{print $1, $2}' | sort | uniq -c | sort -rn", "")).trim();
+      const lsofLines = lsof.split("\n");
+      topProcesses = lsofLines.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);
+      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);
+    } catch {
+      topProcesses = [];
+      allProcesses = [];
+    }
+    return {
+      totalPackets: totalRxPackets + totalTxPackets,
+      rxPackets: totalRxPackets,
+      txPackets: totalTxPackets,
+      rxRate: 0,
+      txRate: 0,
+      connections,
+      topProcesses,
+      interfaces: ifaceStats,
+      allProcesses
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectTasks(limit = 12) {
+  try {
+    const isMac = process.platform === "darwin";
+    const sortArg = isMac ? "-r" : "--sort=-pcpu";
+    const raw = (await run(`ps -eo pid,user,pcpu,pmem,state,time,comm ${sortArg} | 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+(\S+)\s+([\d:]+)\s+(.+)/);
+      if (!parts) return null;
+      const runtimeSec = parts[6].split(":").reduce((acc, val, idx) => acc + parseInt(val) * Math.pow(60, 2 - idx), 0);
+      return { pid: parseInt(parts[1]), user: parts[2], cpu: parseFloat(parts[3]), mem: parseFloat(parts[4]), state: parts[5], runtime: runtimeSec, command: parts[7] };
+    }).filter((t) => t !== null && t.pid > 0);
+  } catch {
+    return [];
+  }
+}
 
 // src/formatters/render.ts
 import chalk3 from "chalk";
@@ -610,11 +762,15 @@ function gpuCard(data, contentWidth) {
   return lines;
 }
 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`));
+  if (data.power) {
+    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`));
+  }
+  if (data.battery?.powerWatts !== void 0 && data.battery.powerWatts > 0) {
+    lines.push(statRow("Battery", `${data.battery.powerWatts.toFixed(2)} W`));
+  }
   return lines.length ? lines : null;
 }
 function batteryCard(data, contentWidth) {
@@ -630,6 +786,12 @@ function batteryCard(data, contentWidth) {
     lines.push(statRow("Capacity", capacityColor(data.battery.maxCapacityPercent)(`${data.battery.maxCapacityPercent}%`)));
   }
   lines.push(statRow("Source", data.battery.powerSource));
+  if (data.battery.estimatedTimeToEmpty && data.battery.state !== "charged") {
+    lines.push(statRow("Est. Empty", data.battery.estimatedTimeToEmpty));
+  }
+  if (data.battery.dischargeRatePerHour !== void 0 && data.battery.state !== "charged") {
+    lines.push(statRow("Disch. Rate", `${data.battery.dischargeRatePerHour}%/h`));
+  }
   return lines;
 }
 function thermalCard(data, contentWidth) {
@@ -651,6 +813,33 @@ function networkCard(data, contentWidth) {
     statRow("TX", `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)
   ];
 }
+function packetCard(data, contentWidth) {
+  if (!data.packets) return null;
+  const lines = [];
+  lines.push(statRow("Total", `${data.packets.totalPackets} pkt`));
+  lines.push(statRow("RX", `${data.packets.rxPackets} pkt`));
+  lines.push(statRow("TX", `${data.packets.txPackets} pkt`));
+  lines.push(statRow("Conns", `${data.packets.connections} TCP`));
+  if (data.packets.topProcesses && data.packets.topProcesses.length) {
+    lines.push(statRow("Top Proc", truncatePlain(data.packets.topProcesses[0].command, contentWidth - 10)));
+  }
+  if (data.packets.allProcesses && data.packets.allProcesses.length > 1) {
+    lines.push(statRow("Net Procs", `${data.packets.allProcesses.length} processes`));
+  }
+  if (data.packets.interfaces && data.packets.interfaces.length) {
+    lines.push(statRow("Ifaces", `${data.packets.interfaces.length} active`));
+  }
+  return lines;
+}
+function tasksCard(data, contentWidth) {
+  if (!data.tasks || !data.tasks.length) return null;
+  const lines = [];
+  for (const task of data.tasks.slice(0, 6)) {
+    const cmd = truncatePlain(task.command, Math.max(4, contentWidth - 28));
+    lines.push(statRow(`${task.pid}`, `${task.user.padEnd(8)} ${task.cpu.toFixed(1).padStart(5)}% ${task.mem.toFixed(1).padStart(5)}% ${task.state} ${cmd}`));
+  }
+  return lines;
+}
 function header(data, width, badges = [], borderAccent = THEMES.default.border) {
   const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
   const left = `${chalk3.hex("#ff5500").bold(" PYRE ")} ${chalk3.bold(data.header.hostname)}  ${chalk3.dim(data.header.os)}  ${chalk3.dim("up " + data.header.uptime)}`;
@@ -659,6 +848,46 @@ function header(data, width, badges = [], borderAccent = THEMES.default.border)
   const line = left + " ".repeat(gap) + right;
   return [line, borderAccent("\u2500".repeat(width))];
 }
+var TAB_DEFS = [
+  { id: "cpu", label: "CPU", key: "1" },
+  { id: "mem", label: "Memory", key: "2" },
+  { id: "gpu", label: "GPU", key: "3" },
+  { id: "power", label: "Power", key: "4" },
+  { id: "battery", label: "Battery", key: "5" },
+  { id: "thermal", label: "Thermal", key: "6" },
+  { id: "network", label: "Network", key: "7" },
+  { id: "packets", label: "Packets", key: "8" },
+  { id: "tasks", label: "Tasks", key: "9" },
+  { id: "disk", label: "Disk", key: "0" },
+  { id: "process", label: "Process", key: "p" }
+];
+var TAB_BAR_INDENT = 2;
+var TAB_SEPARATOR_WIDTH = 3;
+function getTabHitboxes() {
+  const boxes = [];
+  let col = TAB_BAR_INDENT;
+  TAB_DEFS.forEach((t, i) => {
+    const text = `[${t.key}]${t.label}`;
+    const start = col;
+    const end = col + text.length;
+    boxes.push({ id: t.id, start, end });
+    col = end;
+    if (i < TAB_DEFS.length - 1) col += TAB_SEPARATOR_WIDTH;
+  });
+  return boxes;
+}
+var TAB_BAR_ROW = 4;
+function tabBar(activePanel, width, theme) {
+  const rendered = TAB_DEFS.map((t) => {
+    const isActive = activePanel === t.id;
+    const label = isActive ? chalk3.bold(t.label) : chalk3.dim(t.label);
+    const keyHint = chalk3.dim(`[${t.key}]`);
+    return `${keyHint}${label}`;
+  });
+  const joined = rendered.join(chalk3.dim(" \u2502 "));
+  const padded = visLen(joined) < width ? joined + " ".repeat(width - visLen(joined)) : joined;
+  return chalk3.dim("  ") + padded;
+}
 function sortProcesses(processes, sortBy) {
   const copy = [...processes];
   switch (sortBy) {
@@ -746,8 +975,85 @@ function diskTableLines(disks, contentWidth, borderAccent = THEMES.default.borde
   });
   return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
 }
+function detailPanelTitle(panel2) {
+  const map = {
+    cpu: "CPU",
+    mem: "Memory",
+    gpu: "GPU",
+    power: "Power",
+    battery: "Battery",
+    thermal: "Thermal",
+    network: "Network",
+    packets: "Packets",
+    tasks: "Tasks",
+    disk: "Disk",
+    process: "Processes"
+  };
+  return map[panel2] || panel2;
+}
+function activeDetailLines(data, activePanel, width) {
+  const contentWidth = width - 4;
+  switch (activePanel) {
+    case "cpu":
+      return cpuCard(data, contentWidth);
+    case "mem":
+      return memCard(data, contentWidth);
+    case "gpu": {
+      const gpu = gpuCard(data, contentWidth);
+      return gpu ?? ["No GPU data available"];
+    }
+    case "power": {
+      const power = powerCard(data);
+      if (!power && !data.battery) return ["No power data available"];
+      const lines = [];
+      if (power) lines.push(...power);
+      if (data.battery?.powerWatts !== void 0 && data.battery.powerWatts > 0) {
+        lines.push(statRow("Battery", `${data.battery.powerWatts.toFixed(2)} W`));
+      }
+      return lines.length ? lines : ["No power data available"];
+    }
+    case "battery":
+      return data.battery ? batteryCard(data, contentWidth) : ["No battery data available"];
+    case "thermal":
+      return thermalCard(data, contentWidth);
+    case "network":
+      return networkCard(data, contentWidth);
+    case "packets": {
+      if (!data.packets) return ["No packet data available"];
+      const lines = [];
+      lines.push(statRow("Total", `${data.packets.totalPackets} pkt`));
+      lines.push(statRow("RX", `${data.packets.rxPackets} pkt`));
+      lines.push(statRow("TX", `${data.packets.txPackets} pkt`));
+      lines.push(statRow("Conns", `${data.packets.connections} TCP`));
+      if (data.packets.interfaces && data.packets.interfaces.length) {
+        lines.push(statRow("Ifaces", `${data.packets.interfaces.length} active`));
+        for (const iface of data.packets.interfaces.slice(0, 8)) {
+          lines.push(statRow(`  ${iface.iface}`, `RX ${formatBytes(iface.rxBytes)} / TX ${formatBytes(iface.txBytes)}`));
+        }
+      }
+      if (data.packets.allProcesses && data.packets.allProcesses.length) {
+        lines.push(statRow("Net Procs", `${data.packets.allProcesses.length} total`));
+        for (const proc of data.packets.allProcesses.slice(0, 10)) {
+          lines.push(statRow(`  ${proc.pid}`, `${truncatePlain(proc.command, 20)}  TX ${formatBytes(proc.txBytes)}`));
+        }
+      }
+      return lines;
+    }
+    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"];
+    case "process": {
+      const sorted = sortProcesses([...data.processes], "cpu");
+      return processTableLines(sorted.slice(0, 50), width - 4, THEMES.default.border);
+    }
+    default:
+      return null;
+  }
+}
 function formatTable(data, opts2 = {}) {
   const width = clampWidth(opts2.width);
+  const activePanel = opts2.activePanel || "grid";
   const columns = gridColumns(width);
   const gap = 2;
   const cardWidth = Math.floor((width - gap * (columns - 1)) / columns);
@@ -758,6 +1064,15 @@ function formatTable(data, opts2 = {}) {
   const out = [];
   out.push(...header(data, width, [], theme.border));
   out.push("");
+  out.push(tabBar(activePanel, width, theme));
+  out.push("");
+  if (activePanel !== "grid") {
+    const lines = activeDetailLines(data, activePanel, width);
+    if (lines) {
+      out.push(...panel(detailPanelTitle(activePanel), lines, width, theme[activePanel] ?? theme.cpu, theme.border));
+    }
+    return out.join("\n");
+  }
   const cards = [];
   if (vis.cpu !== false) {
     cards.push({ title: "CPU", accent: theme.cpu, lines: cpuCard(data, contentWidth) });
@@ -783,6 +1098,14 @@ function formatTable(data, opts2 = {}) {
   if (vis.network !== false) {
     cards.push({ title: "Network", accent: theme.network, lines: networkCard(data, contentWidth) });
   }
+  if (vis.packets !== false) {
+    const packets = packetCard(data, contentWidth);
+    if (packets) cards.push({ title: "Packets", accent: theme.network, lines: packets });
+  }
+  if (vis.tasks !== false) {
+    const tasks = tasksCard(data, contentWidth);
+    if (tasks) cards.push({ title: "Tasks", accent: theme.process, lines: tasks });
+  }
   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));
@@ -868,11 +1191,17 @@ function formatCsv(data) {
     ],
     ["network", "rxBytes", String(data.network.rxBytes)],
     ["network", "txBytes", String(data.network.txBytes)],
+    ["network", "rxPackets", String(data.network.rxPackets)],
+    ["network", "txPackets", String(data.network.txPackets)],
+    ["network", "connections", data.network.connections ? String(data.network.connections) : ""],
     ["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) : ""],
+    ["battery", "estimatedTimeToEmpty", data.battery?.estimatedTimeToEmpty ?? ""],
+    ["battery", "dischargeRatePerHour", data.battery?.dischargeRatePerHour !== void 0 ? String(data.battery.dischargeRatePerHour) : ""],
+    ["battery", "powerWatts", data.battery?.powerWatts !== void 0 ? String(data.battery.powerWatts) : ""],
     ["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) : ""],
@@ -880,6 +1209,18 @@ function formatCsv(data) {
     ["system", "uptime", data.header.uptime],
     ["system", "timestamp", data.timestamp]
   ];
+  if (data.packets) {
+    rows.push(["packets", "totalPackets", String(data.packets.totalPackets)]);
+    rows.push(["packets", "rxPackets", String(data.packets.rxPackets)]);
+    rows.push(["packets", "txPackets", String(data.packets.txPackets)]);
+    rows.push(["packets", "connections", String(data.packets.connections)]);
+    for (const iface of data.packets.interfaces || []) {
+      rows.push(["packets_iface", iface.iface, `${iface.rxPackets},${iface.txPackets},${iface.rxBytes},${iface.txBytes}`]);
+    }
+    for (const proc of data.packets.allProcesses || []) {
+      rows.push(["packets_proc", `pid=${proc.pid}`, `${proc.command},${proc.rxBytes},${proc.txBytes}`]);
+    }
+  }
   if (data.gpu) {
     rows.push(["gpu", "model", data.gpu.model]);
     rows.push(["gpu", "memory", String(data.gpu.memory)]);
@@ -916,6 +1257,15 @@ function formatGraphs(history, width = 80, themeName = "default", graphMode = "s
   );
   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));
+  if (history.powerWatts.length) {
+    lines.push(graphRow("Power W", history.powerWatts, {}, (v) => `${v.toFixed(1)} W`, sparkWidth, graphMode));
+  }
+  if (history.rxPacketRate.length) {
+    lines.push(graphRow("RX pkt/s", history.rxPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+  }
+  if (history.txPacketRate.length) {
+    lines.push(graphRow("TX pkt/s", history.txPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, 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");
 }
@@ -966,8 +1316,18 @@ var History = class {
   netTxRate = [];
   /** Rolling window of GPU utilization percentages (0–100). */
   gpuUtil = [];
+  /** Rolling window of combined power draw in watts. */
+  powerWatts = [];
+  /** Rolling window of network receive packet rates in packets/sec. */
+  rxPacketRate = [];
+  /** Rolling window of network transmit packet rates in packets/sec. */
+  txPacketRate = [];
+  /** Rolling window of active TCP connections. */
+  connections = [];
   lastRxBytes = 0;
   lastTxBytes = 0;
+  lastRxPackets = 0;
+  lastTxPackets = 0;
   lastTs = 0;
   /**
    * Create a new History instance.
@@ -987,13 +1347,23 @@ var History = class {
     const now = Date.now();
     let rxRate = 0;
     let txRate = 0;
+    let rxPktRate = 0;
+    let txPktRate = 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);
+      if (sample.rxPackets !== void 0) {
+        rxPktRate = Math.max(0, (sample.rxPackets - this.lastRxPackets) / dtSeconds);
+      }
+      if (sample.txPackets !== void 0) {
+        txPktRate = Math.max(0, (sample.txPackets - this.lastTxPackets) / dtSeconds);
+      }
     }
     this.lastRxBytes = sample.rxBytes;
     this.lastTxBytes = sample.txBytes;
+    if (sample.rxPackets !== void 0) this.lastRxPackets = sample.rxPackets;
+    if (sample.txPackets !== void 0) this.lastTxPackets = sample.txPackets;
     this.lastTs = now;
     this.pushBounded(this.cpuUsage, sample.cpuUsage);
     this.pushBounded(this.memUsage, sample.memUsage);
@@ -1001,6 +1371,10 @@ var History = class {
     this.pushBounded(this.netRxRate, rxRate);
     this.pushBounded(this.netTxRate, txRate);
     if (sample.gpuUtil !== void 0) this.pushBounded(this.gpuUtil, sample.gpuUtil);
+    if (sample.powerWatts !== void 0) this.pushBounded(this.powerWatts, sample.powerWatts);
+    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);
   }
   /** Clear all rolling windows and reset cumulative byte counters. */
   reset() {
@@ -1010,8 +1384,14 @@ var History = class {
     this.netRxRate = [];
     this.netTxRate = [];
     this.gpuUtil = [];
+    this.powerWatts = [];
+    this.rxPacketRate = [];
+    this.txPacketRate = [];
+    this.connections = [];
     this.lastRxBytes = 0;
     this.lastTxBytes = 0;
+    this.lastRxPackets = 0;
+    this.lastTxPackets = 0;
     this.lastTs = 0;
   }
   /**
@@ -1021,7 +1401,7 @@ var History = class {
    */
   setMaxLen(n) {
     this.maxLen = Math.max(1, n);
-    for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate, this.gpuUtil]) {
+    for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate, this.gpuUtil, this.powerWatts, this.rxPacketRate, this.txPacketRate, this.connections]) {
       while (arr.length > this.maxLen) arr.shift();
     }
   }
@@ -1047,10 +1427,13 @@ var state = {
   visiblePanels: {
     cpu: true,
     mem: true,
+    gpu: true,
     power: true,
     battery: true,
     thermal: true,
     network: true,
+    packets: true,
+    tasks: true,
     disk: true,
     process: true
   },
@@ -1075,17 +1458,35 @@ var state = {
     "Graph Mode",
     "Toggle CPU",
     "Toggle Memory",
+    "Toggle GPU",
     "Toggle Power",
     "Toggle Battery",
     "Toggle Thermal",
     "Toggle Network",
+    "Toggle Packets",
+    "Toggle Tasks",
     "Toggle Disk",
     "Toggle Processes",
     "Toggle Tree View"
   ],
   CPU_ALERT_PCT: 90,
   TEMP_ALERT_C: 95,
-  alerted: false
+  alerted: false,
+  activePanel: "grid",
+  mouseEnabled: true,
+  PANEL_TABS: [
+    { id: "cpu", label: "CPU", key: "1" },
+    { id: "mem", label: "Memory", key: "2" },
+    { id: "gpu", label: "GPU", key: "3" },
+    { id: "power", label: "Power", key: "4" },
+    { id: "battery", label: "Battery", key: "5" },
+    { id: "thermal", label: "Thermal", key: "6" },
+    { id: "network", label: "Network", key: "7" },
+    { id: "packets", label: "Packets", key: "8" },
+    { id: "tasks", label: "Tasks", key: "9" },
+    { id: "disk", label: "Disk", key: "0" },
+    { id: "process", label: "Process", key: "P" }
+  ]
 };
 function setStatus(msg, ms = 3e3) {
   state.statusMessage = msg;
@@ -1124,7 +1525,7 @@ function startLogging() {
     ensureDir(state.exportDir);
     const file = path.join(state.exportDir, `pyre-log-${timestampForFile()}.csv`);
     state.logStream = fs.createWriteStream(file, { flags: "a" });
-    state.logStream.write("timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,thermal_state\n");
+    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}`);
   } catch (err) {
@@ -1144,8 +1545,11 @@ function toggleLogging() {
 function writeLogRow(data) {
   if (!state.logging || !state.logStream) return;
   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;
   state.logStream.write(
-    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${data.thermal.state}
+    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${rxPackets},${txPackets},${connections},${data.thermal.state}
 `
   );
 }
@@ -1154,7 +1558,8 @@ function writeLogRow(data) {
 import chalk5 from "chalk";
 function processRowBudget() {
   const columns = gridColumns(state.termWidth);
-  const cardRows = Math.ceil(6 / columns);
+  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));
 }
@@ -1193,7 +1598,8 @@ function render() {
       processLimit: processRowBudget(),
       theme: state.currentTheme,
       visible: state.visiblePanels,
-      treeView: state.treeView
+      treeView: state.treeView,
+      activePanel: state.activePanel
     })
   );
   if (state.showGraphs) {
@@ -1228,6 +1634,8 @@ function footerLine() {
     ["g", state.showGraphs ? "hide graphs" : "show graphs"],
     ["b", `graph:${state.graphMode}`],
     ["d", state.detailed ? "basic" : "detailed"],
+    ["\u2190/\u2192", "tab"],
+    ["1-9", "panels"],
     ["s", `sort:${state.sortMode}`],
     ["/", "filter"],
     ["k", "kill"],
@@ -1242,6 +1650,7 @@ function footerLine() {
   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()}`));
   const badgeStr = badges.join("  ");
   return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;
 }
@@ -1363,7 +1772,11 @@ async function tick() {
       temp,
       rxBytes: data.network.rxBytes,
       txBytes: data.network.txBytes,
-      gpuUtil: data.gpu?.utilization
+      gpuUtil: data.gpu?.utilization,
+      powerWatts: data.power?.combinedWatts ?? data.power?.cpuWatts ?? 0,
+      rxPackets: data.network.rxPackets,
+      txPackets: data.network.txPackets,
+      connections: data.network.connections ?? 0
     });
     writeLogRow(data);
     checkAlerts(data);
@@ -1386,6 +1799,9 @@ async function startLive(opts2) {
   process.stdout.write("\x1B[?25l");
   process.stdout.write("\x1B[2J\x1B[H");
   process.title = "pyre";
+  if (state.mouseEnabled) {
+    process.stdout.write("\x1B[?1000h");
+  }
   await tick();
   restartTicker();
   if (opts2.autoLog) startLogging();
@@ -1403,6 +1819,18 @@ async function startLive(opts2) {
       handleInputModeKey(str, key);
       return;
     }
+    if (key.mouse) {
+      handleMouseClick(key.mouse);
+      return;
+    }
+    if (key.sequence && key.sequence.startsWith("\x1B[M")) {
+      handleNormalMouse(key.sequence);
+      return;
+    }
+    if (key.sequence && key.sequence.startsWith("\x1B[<")) {
+      handleSGRMouse(key.sequence);
+      return;
+    }
     switch (key.sequence) {
       case "+":
         state.interval += 1;
@@ -1419,11 +1847,69 @@ async function startLive(opts2) {
         state.inputBuffer = state.processFilter;
         render();
         return;
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9": {
+        const tabMap = {
+          "0": "disk",
+          "1": "cpu",
+          "2": "mem",
+          "3": "gpu",
+          "4": "power",
+          "5": "battery",
+          "6": "thermal",
+          "7": "network",
+          "8": "packets",
+          "9": "tasks"
+        };
+        const panelId = tabMap[key.sequence];
+        if (panelId) {
+          state.activePanel = state.activePanel === panelId ? "grid" : panelId;
+          setStatus(state.activePanel === "grid" ? "Grid view" : `${panelId} panel`);
+          render();
+        }
+        return;
+      }
+      case "P": {
+        state.activePanel = state.activePanel === "process" ? "grid" : "process";
+        setStatus(state.activePanel === "grid" ? "Grid view" : "Process panel");
+        render();
+        return;
+      }
     }
     switch (key.name) {
       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();
+        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();
+        break;
+      }
       case "c":
         state.inputMode = "customizer";
         state.customizerIndex = 0;
@@ -1482,11 +1968,70 @@ async function startLive(opts2) {
         setStatus(`Export format: ${state.exportFormat}`);
         render();
         break;
+      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);
+          if (tabId) {
+            state.activePanel = tabId;
+            setStatus(`Panel: ${tabId.toUpperCase()}`);
+            render();
+          }
+        }
     }
   };
   process.stdin.on("keypress", state.keypressHandler);
   process.once("SIGINT", () => stopLive());
 }
+function tabKeyToId(str) {
+  const map = { "1": "cpu", "2": "mem", "3": "gpu", "4": "power", "5": "battery", "6": "thermal", "7": "network", "8": "packets", "9": "tasks", "0": "disk", "p": "process" };
+  return map[str] ?? null;
+}
+function cycleTab(direction) {
+  const tabs = state.PANEL_TABS.map((t) => t.id);
+  const current = state.activePanel === "grid" ? -1 : tabs.indexOf(state.activePanel);
+  const next = (current + direction + tabs.length) % tabs.length;
+  state.activePanel = tabs[next];
+  setStatus(`Panel: ${state.activePanel.toUpperCase()}`);
+  render();
+}
+function handleNormalMouse(seq) {
+  if (seq.length < 6) return;
+  const cb = seq.charCodeAt(3) - 32;
+  const cx = seq.charCodeAt(4) - 32;
+  const cy = seq.charCodeAt(5) - 32;
+  if (cb === 0 || cb === 1) {
+    handleMouseClick(cy, cx);
+  }
+}
+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]);
+  if (button === 0 || button === 1) {
+    handleMouseClick(cy, cx);
+  }
+}
+function handleMouseClick(y, x) {
+  if (y !== TAB_BAR_ROW) return;
+  const hitboxes = getTabHitboxes();
+  const hit = hitboxes.find((h) => x >= h.start && x < h.end);
+  if (hit) {
+    state.activePanel = state.activePanel === hit.id ? "grid" : hit.id;
+    setStatus(state.activePanel === "grid" ? "Grid view" : `Panel: ${hit.id.toUpperCase()}`);
+    render();
+  }
+}
 function stopLive() {
   if (state.intervalHandle) {
     clearInterval(state.intervalHandle);
@@ -1509,6 +2054,9 @@ function stopLive() {
   state.logging = false;
   if (process.stdin.isTTY) process.stdin.setRawMode(false);
   process.stdin.pause();
+  if (state.mouseEnabled) {
+    process.stdout.write("\x1B[?1000l");
+  }
   process.stdout.write("\x1B[?25h");
   process.stdout.write("\x1B[?1049l");
   process.stdout.write("\x1B[2J\x1B[H");
@@ -1626,9 +2174,609 @@ async function showSplash() {
   });
 }
 
+// src/p2p/server.ts
+import net from "net";
+import tls from "tls";
+import fs2 from "fs";
+import crypto2 from "crypto";
+import chalk7 from "chalk";
+
+// src/p2p/protocol.ts
+import crypto from "crypto";
+var HEADER_SIZE = 4;
+var MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+var HMAC_ALGO = "sha256";
+function buildMessage(kind, payload, hmac) {
+  const envelope = { kind, payload };
+  if (hmac) envelope.hmac = hmac;
+  const body = Buffer.from(JSON.stringify(envelope), "utf-8");
+  const header2 = Buffer.alloc(HEADER_SIZE);
+  header2.writeUInt32BE(body.length, 0);
+  return Buffer.concat([header2, body]);
+}
+function generateNonce() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function hashPassword(password, nonce) {
+  return crypto.createHash("sha256").update(`${password}:${nonce}`).digest("hex");
+}
+function computeHMAC(body, key) {
+  if (!key) return void 0;
+  return crypto.createHmac(HMAC_ALGO, key).update(body).digest("hex");
+}
+function verifyHMAC(body, expectedHmac, key) {
+  if (!key) return expectedHmac === void 0;
+  if (!expectedHmac) return false;
+  try {
+    const parsed = JSON.parse(body);
+    const payloadWithoutHmac = { ...parsed, hmac: void 0 };
+    const canonical = JSON.stringify(payloadWithoutHmac);
+    const computed = crypto.createHmac(HMAC_ALGO, key).update(canonical).digest("hex");
+    return crypto.timingSafeEqual(Buffer.from(computed), Buffer.from(expectedHmac));
+  } catch {
+    return false;
+  }
+}
+function encodeDisconnect(reason) {
+  return buildMessage("disconnect", { reason });
+}
+function decodeMessage(buf) {
+  const str = buf.toString("utf-8");
+  const msg = JSON.parse(str);
+  return msg;
+}
+function signMessage(kind, payload, key) {
+  const envelope = { kind, payload };
+  const bodyJson = JSON.stringify(envelope);
+  const hmac = computeHMAC(bodyJson, key);
+  return buildMessage(kind, payload, hmac);
+}
+
+// src/p2p/server.ts
+var HEADER_SIZE2 = 4;
+var DEFAULT_RATE_LIMIT_MAX = 5;
+var DEFAULT_RATE_LIMIT_WINDOW = 6e4;
+var HMAC_KEY_LENGTH = 32;
+function readMessageFromPeer(peer) {
+  while (peer.readBuffer.length > 0) {
+    if (peer.readExpectingHeader) {
+      if (peer.readBuffer.length >= HEADER_SIZE2) {
+        peer.readMessageLength = peer.readBuffer.readUInt32BE(0);
+        peer.readBuffer = peer.readBuffer.subarray(HEADER_SIZE2);
+        peer.readExpectingHeader = false;
+      } else {
+        break;
+      }
+    }
+    if (!peer.readExpectingHeader) {
+      if (peer.readBuffer.length >= peer.readMessageLength) {
+        const body = peer.readBuffer.subarray(0, peer.readMessageLength);
+        peer.readBuffer = peer.readBuffer.subarray(peer.readMessageLength);
+        peer.readExpectingHeader = true;
+        return body;
+      } else {
+        break;
+      }
+    }
+  }
+  return null;
+}
+function isIPAllowed(ip, allowedIPs, deniedIPs) {
+  for (const denied of deniedIPs) {
+    if (ip === denied || ip.startsWith(denied)) {
+      return false;
+    }
+  }
+  if (allowedIPs.length === 0) {
+    return true;
+  }
+  for (const allowed of allowedIPs) {
+    if (ip === allowed || ip.startsWith(allowed)) {
+      return true;
+    }
+  }
+  return false;
+}
+function deriveHMACKey(password) {
+  return crypto2.createHash("sha256").update(password).digest("hex").slice(0, HMAC_KEY_LENGTH);
+}
+var P2PServer = class {
+  server = null;
+  peers = /* @__PURE__ */ new Map();
+  options;
+  running = false;
+  rateLimitMap = /* @__PURE__ */ new Map();
+  auditStream = null;
+  hmacKey;
+  constructor(options) {
+    this.options = options;
+    this.hmacKey = deriveHMACKey(options.password);
+  }
+  get info() {
+    return {
+      host: this.options.host,
+      port: this.options.port,
+      peersConnected: this.peers.size
+    };
+  }
+  async start() {
+    if (this.options.auditLog) {
+      try {
+        fs2.mkdirSync(this.options.auditLog, { recursive: true });
+        const logFile = `${this.options.auditLog}/p2p-audit.log`;
+        this.auditStream = fs2.createWriteStream(logFile, { flags: "a" });
+      } catch {
+        console.log(chalk7.yellow("Warning: could not open audit log"));
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const useTLS = !!(this.options.tlsCert && this.options.tlsKey);
+      if (useTLS) {
+        const tlsOptions = {
+          key: fs2.readFileSync(this.options.tlsKey),
+          cert: fs2.readFileSync(this.options.tlsCert)
+        };
+        if (this.options.tlsCA) {
+          tlsOptions.ca = fs2.readFileSync(this.options.tlsCA);
+        }
+        this.server = tls.createServer(tlsOptions, (socket) => this.onConnection(socket));
+      } else {
+        this.server = net.createServer((socket) => this.onConnection(socket));
+      }
+      this.server.on("error", (err) => reject(err));
+      this.server.listen(this.options.port, this.options.host, () => {
+        this.running = true;
+        const addr = this.server?.address();
+        const bound = addr ? typeof addr === "object" ? `${addr.address}:${addr.port}` : String(addr) : "unknown";
+        const protocol = useTLS ? "TLS" : "TCP";
+        console.log(chalk7.green(`P2P server listening on ${bound} (${protocol})`));
+        console.log(chalk7.dim(`  Password: ${this.options.password}`));
+        console.log(chalk7.dim(`  Interval: ${this.options.intervalMs}ms`));
+        const allowedIPs = this.options.allowedIPs ?? [];
+        const deniedIPs = this.options.deniedIPs ?? [];
+        if (allowedIPs.length > 0) console.log(chalk7.dim(`  Allowed IPs: ${allowedIPs.join(", ")}`));
+        if (deniedIPs.length > 0) console.log(chalk7.dim(`  Denied IPs: ${deniedIPs.join(", ")}`));
+        resolve();
+      });
+    });
+  }
+  stop() {
+    this.running = false;
+    for (const peer of this.peers.values()) {
+      this.disconnectPeer(peer, "Server shutting down");
+    }
+    this.peers.clear();
+    this.rateLimitMap.clear();
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    if (this.auditStream) {
+      this.auditStream.end();
+      this.auditStream = null;
+    }
+  }
+  audit(ip, event, detail) {
+    if (!this.auditStream) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    this.auditStream.write(`${ts} ${ip} ${event} ${detail}
+`);
+  }
+  getPeerIP(socket) {
+    const addr = socket.remoteAddress;
+    if (!addr) return "unknown";
+    if (addr.startsWith("::ffff:")) {
+      return addr.slice(7);
+    }
+    return addr;
+  }
+  checkRateLimit(ip) {
+    const maxAttempts = this.options.rateLimitMaxAttempts ?? DEFAULT_RATE_LIMIT_MAX;
+    const windowMs = this.options.rateLimitWindowMs ?? DEFAULT_RATE_LIMIT_WINDOW;
+    const now = Date.now();
+    const entry = this.rateLimitMap.get(ip);
+    if (!entry) {
+      this.rateLimitMap.set(ip, { attempts: 1, firstAttempt: now });
+      return true;
+    }
+    if (now - entry.firstAttempt > windowMs) {
+      this.rateLimitMap.set(ip, { attempts: 1, firstAttempt: now });
+      return true;
+    }
+    entry.attempts++;
+    if (entry.attempts > maxAttempts) {
+      return false;
+    }
+    return true;
+  }
+  cleanupRateLimit(ip) {
+    this.rateLimitMap.delete(ip);
+  }
+  onConnection(socket) {
+    const ip = this.getPeerIP(socket);
+    const allowedIPs = this.options.allowedIPs ?? [];
+    const deniedIPs = this.options.deniedIPs ?? [];
+    if (!isIPAllowed(ip, allowedIPs, deniedIPs)) {
+      this.audit(ip, "BLOCKED", "IP not allowed");
+      console.log(chalk7.yellow(`Blocked IP: ${ip}`));
+      socket.destroy();
+      return;
+    }
+    if (!this.checkRateLimit(ip)) {
+      this.audit(ip, "RATE_LIMITED", "Too many auth attempts");
+      console.log(chalk7.yellow(`Rate limit exceeded for IP: ${ip}`));
+      socket.destroy();
+      return;
+    }
+    const peer = {
+      socket,
+      authenticated: false,
+      intervalHandle: null,
+      pingHandle: null,
+      readBuffer: Buffer.alloc(0),
+      readExpectingHeader: true,
+      readMessageLength: 0,
+      ip,
+      pendingNonce: null
+    };
+    this.peers.set(socket, peer);
+    const remoteAddr = socket.remoteAddress ? `${socket.remoteAddress}:${socket.remotePort}` : "unknown";
+    console.log(chalk7.cyan(`Peer connected: ${remoteAddr}`));
+    this.audit(ip, "CONNECT", remoteAddr);
+    socket.on("data", (data) => this.onData(peer, data));
+    socket.on("close", () => this.onPeerClose(peer));
+    socket.on("error", (err) => this.onPeerError(peer, err));
+    socket.setTimeout(3e4);
+    socket.on("timeout", () => {
+      if (!peer.authenticated) {
+        this.disconnectPeer(peer, "Authentication timeout");
+      }
+    });
+    const nonce = generateNonce();
+    this.sendSigned(peer, signMessage("challenge", { nonce }, this.hmacKey));
+    peer.pendingNonce = nonce;
+  }
+  onData(peer, data) {
+    peer.readBuffer = Buffer.concat([peer.readBuffer, data]);
+    if (!peer.authenticated) {
+      const body = readMessageFromPeer(peer);
+      if (body) {
+        this.handleAuthMessage(peer, body);
+      }
+      return;
+    }
+  }
+  handleAuthMessage(peer, body) {
+    try {
+      const raw = body.toString("utf-8");
+      const msg = decodeMessage(body);
+      if (msg.kind !== "auth") {
+        peer.socket.write(signMessage("auth-fail", { ok: false, reason: "Expected auth message first" }, this.hmacKey));
+        this.disconnectPeer(peer, "Expected auth message");
+        return;
+      }
+      const authPayload = msg.payload;
+      if (!authPayload.passwordHash || !authPayload.nonce) {
+        peer.socket.write(signMessage("auth-fail", { ok: false, reason: "Invalid auth payload" }, this.hmacKey));
+        this.disconnectPeer(peer, "Invalid auth payload");
+        return;
+      }
+      if (peer.pendingNonce && authPayload.nonce !== peer.pendingNonce) {
+        this.audit(peer.ip, "AUTH_FAIL", "Nonce mismatch");
+        peer.socket.write(signMessage("auth-fail", { ok: false, reason: "Invalid nonce" }, this.hmacKey));
+        this.disconnectPeer(peer, "Invalid nonce");
+        return;
+      }
+      const expectedHash = hashPassword(this.options.password, authPayload.nonce);
+      if (authPayload.passwordHash !== expectedHash) {
+        this.audit(peer.ip, "AUTH_FAIL", "Invalid password hash");
+        peer.socket.write(signMessage("auth-fail", { ok: false, reason: "Invalid password" }, this.hmacKey));
+        this.disconnectPeer(peer, "Authentication failed");
+        return;
+      }
+      peer.authenticated = true;
+      this.cleanupRateLimit(peer.ip);
+      peer.pendingNonce = null;
+      peer.socket.write(signMessage("auth-ok", { ok: true }, this.hmacKey));
+      console.log(chalk7.green(`Peer authenticated: ${peer.socket.remoteAddress}`));
+      this.audit(peer.ip, "AUTH_OK", "Challenge-response successful");
+      this.startDataStream(peer);
+      this.startPing(peer);
+    } catch {
+      peer.socket.write(signMessage("auth-fail", { ok: false, reason: "Invalid message format" }, this.hmacKey));
+      this.disconnectPeer(peer, "Invalid message format");
+    }
+  }
+  sendSigned(peer, message) {
+    if (!peer.socket.destroyed) {
+      peer.socket.write(message);
+    }
+  }
+  startDataStream(peer) {
+    const send = async () => {
+      if (!peer.authenticated || peer.socket.destroyed) return;
+      try {
+        const data = await collectAll({ detailed: this.options.detailed });
+        this.sendSigned(peer, signMessage("data", { stats: data }, this.hmacKey));
+      } catch {
+      }
+    };
+    send();
+    peer.intervalHandle = setInterval(send, this.options.intervalMs);
+  }
+  startPing(peer) {
+    peer.pingHandle = setInterval(() => {
+      if (peer.socket.destroyed) return;
+      this.sendSigned(peer, signMessage("ping", { ts: Date.now() }, this.hmacKey));
+    }, 5e3);
+  }
+  onPeerClose(peer) {
+    this.cleanupPeer(peer);
+    console.log(chalk7.yellow(`Peer disconnected: ${peer.socket.remoteAddress}`));
+    this.audit(peer.ip, "DISCONNECT", "Peer closed connection");
+  }
+  onPeerError(peer, err) {
+    const code = err.code;
+    if (code === "ECONNRESET") {
+      console.log(chalk7.yellow(`Peer connection reset: ${peer.socket.remoteAddress}`));
+      this.audit(peer.ip, "ERROR", "Connection reset");
+    } else {
+      console.log(chalk7.red(`Peer error: ${err.message}`));
+      this.audit(peer.ip, "ERROR", err.message);
+    }
+    this.cleanupPeer(peer);
+  }
+  disconnectPeer(peer, reason) {
+    try {
+      this.sendSigned(peer, signMessage("disconnect", { reason }, this.hmacKey));
+    } catch {
+    }
+    peer.socket.destroy();
+  }
+  cleanupPeer(peer) {
+    if (peer.intervalHandle) {
+      clearInterval(peer.intervalHandle);
+      peer.intervalHandle = null;
+    }
+    if (peer.pingHandle) {
+      clearInterval(peer.pingHandle);
+      peer.pingHandle = null;
+    }
+    this.peers.delete(peer.socket);
+  }
+};
+
+// src/p2p/client.ts
+import net2 from "net";
+import tls2 from "tls";
+import fs3 from "fs";
+import crypto3 from "crypto";
+import chalk8 from "chalk";
+var P2PClient = class {
+  socket = null;
+  options;
+  running = false;
+  readState = { buffer: Buffer.alloc(0), expectingHeader: true, messageLength: 0 };
+  onDataCallback = null;
+  onStatusCallback = null;
+  reconnectTimer = null;
+  pingHandle = null;
+  pendingNonce = null;
+  auditStream = null;
+  hmacKey;
+  constructor(options) {
+    this.options = options;
+    this.hmacKey = deriveHMACKey2(options.password);
+  }
+  setOnData(cb) {
+    this.onDataCallback = cb;
+  }
+  setOnStatus(cb) {
+    this.onStatusCallback = cb;
+  }
+  async connect() {
+    if (this.options.auditLog) {
+      try {
+        fs3.mkdirSync(this.options.auditLog, { recursive: true });
+        const logFile = `${this.options.auditLog}/p2p-client-audit.log`;
+        this.auditStream = fs3.createWriteStream(logFile, { flags: "a" });
+      } catch {
+        console.log(chalk8.yellow("Warning: could not open audit log"));
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const useTLS = !!this.options.tls;
+      if (useTLS) {
+        const tlsOptions = {
+          host: this.options.host,
+          port: this.options.port,
+          rejectUnauthorized: !this.options.tlsInsecure
+        };
+        if (this.options.tlsCA) {
+          tlsOptions.ca = fs3.readFileSync(this.options.tlsCA);
+        }
+        this.socket = tls2.connect(tlsOptions, () => {
+          this.status("Connecting...");
+        });
+      } else {
+        this.socket = new net2.Socket();
+        this.socket.on("data", (data) => this.onData(data));
+        this.socket.on("close", () => this.onClose());
+        this.socket.on("error", (err) => this.onError(err));
+        this.socket.on("timeout", () => this.onTimeout());
+        this.socket.setTimeout(1e4);
+        this.socket.connect(this.options.port, this.options.host, () => {
+          this.status("Connecting...");
+        });
+        this.socket.once("error", (err) => {
+          reject(err);
+        });
+      }
+      this.socket.on("data", (data) => this.onData(data));
+      this.socket.on("close", () => this.onClose());
+      this.socket.on("error", (err) => this.onError(err));
+      this.socket.on("timeout", () => this.onTimeout());
+    });
+  }
+  disconnect() {
+    this.running = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.pingHandle) {
+      clearInterval(this.pingHandle);
+      this.pingHandle = null;
+    }
+    if (this.socket) {
+      try {
+        this.sendSigned(encodeDisconnect("Client closing"));
+      } catch {
+      }
+      this.socket.destroy();
+      this.socket = null;
+    }
+    if (this.auditStream) {
+      this.auditStream.end();
+      this.auditStream = null;
+    }
+    this.status("Disconnected");
+  }
+  onData(data) {
+    this.readState.buffer = Buffer.concat([this.readState.buffer, data]);
+    while (this.readState.buffer.length > 0) {
+      if (this.readState.expectingHeader) {
+        if (this.readState.buffer.length >= 4) {
+          this.readState.messageLength = this.readState.buffer.readUInt32BE(0);
+          this.readState.buffer = this.readState.buffer.subarray(4);
+          this.readState.expectingHeader = false;
+        } else {
+          break;
+        }
+      }
+      if (!this.readState.expectingHeader) {
+        if (this.readState.buffer.length >= this.readState.messageLength) {
+          const body = this.readState.buffer.subarray(0, this.readState.messageLength);
+          this.readState.buffer = this.readState.buffer.subarray(this.readState.messageLength);
+          this.readState.expectingHeader = true;
+          this.handleMessage(body);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  handleMessage(body) {
+    try {
+      const raw = body.toString("utf-8");
+      const msg = decodeMessage(body);
+      if (!verifyHMAC(raw, msg.hmac ?? "", this.hmacKey)) {
+        this.status("Message integrity check failed");
+        return;
+      }
+      switch (msg.kind) {
+        case "challenge":
+          const challengePayload = msg.payload;
+          if (challengePayload.nonce) {
+            this.pendingNonce = challengePayload.nonce;
+            const passwordHash = hashPassword(this.options.password, challengePayload.nonce);
+            this.sendSigned(signMessage("auth", { passwordHash, nonce: challengePayload.nonce }, this.hmacKey));
+            this.status("Authenticating...");
+          }
+          break;
+        case "auth-ok":
+          this.status("Authenticated \u2014 receiving live data");
+          this.startPing();
+          break;
+        case "auth-fail":
+          const failPayload = msg.payload;
+          this.status(`Authentication failed: ${failPayload.reason || "unknown"}`);
+          this.disconnect();
+          break;
+        case "data":
+          if (this.onDataCallback) {
+            const dataPayload = msg.payload;
+            if (dataPayload.stats) {
+              this.onDataCallback(dataPayload.stats);
+            }
+          }
+          break;
+        case "ping":
+          if (this.socket && !this.socket.destroyed) {
+            const ts = msg.payload.ts;
+            this.sendSigned(signMessage("pong", { ts }, this.hmacKey));
+          }
+          break;
+        case "pong":
+          break;
+        case "disconnect":
+          const disconnectPayload = msg.payload;
+          this.status(`Server disconnected: ${disconnectPayload.reason || "unknown"}`);
+          this.disconnect();
+          break;
+        default:
+          break;
+      }
+    } catch {
+    }
+  }
+  sendSigned(message) {
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.write(message);
+    }
+  }
+  startPing() {
+    this.pingHandle = setInterval(() => {
+      if (this.socket && !this.socket.destroyed) {
+        this.sendSigned(signMessage("ping", { ts: Date.now() }, this.hmacKey));
+      }
+    }, 15e3);
+  }
+  onClose() {
+    if (this.running) {
+      this.status("Connection closed \u2014 reconnecting in 3s");
+      this.reconnectTimer = setTimeout(() => {
+        if (this.running) this.connect().catch(() => {
+        });
+      }, 3e3);
+    }
+  }
+  onError(err) {
+    const code = err.code;
+    if (code === "ECONNREFUSED") {
+      this.status("Connection refused \u2014 is the server running?");
+    } else if (code === "ETIMEDOUT") {
+      this.status("Connection timed out");
+    } else if (code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE") {
+      this.status("TLS certificate verification failed \u2014 use --p2p-insecure to skip");
+    } else {
+      this.status(`Connection error: ${err.message}`);
+    }
+  }
+  onTimeout() {
+    this.status("Connection timed out");
+    this.disconnect();
+  }
+  status(msg) {
+    if (this.onStatusCallback) {
+      this.onStatusCallback(msg);
+    }
+  }
+  audit(event, detail) {
+    if (!this.auditStream) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const ip = this.options.host;
+    this.auditStream.write(`${ts} ${ip} ${event} ${detail}
+`);
+  }
+};
+function deriveHMACKey2(password) {
+  return crypto3.createHash("sha256").update(password).digest("hex").slice(0, 32);
+}
+
 // src/index.ts
 var program = new Command();
-program.name("pyre").version("2.0.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").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");
+program.name("pyre").version("2.0.0").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("--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)", "0.0.0.0").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() {
@@ -1638,8 +2786,11 @@ 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 cmd = program.args[0];
+  if (cmd === "live" || !isExportMode() && !opts.once && cmd !== "p2p") {
+    if (cmd === "live") {
+      program.args.shift();
+    }
     await showSplash();
     const interval = parseFloat(opts.interval) || 2;
     await startLive({
@@ -1650,21 +2801,162 @@ async function main() {
     });
     return;
   }
-  const data = await collectAll({ detailed: opts.detailed });
+  if (cmd === "p2p") {
+    const subcommand = program.args[1];
+    if (subcommand === "server") {
+      await runP2PServer();
+      return;
+    } else if (subcommand === "connect") {
+      await runP2PConnect();
+      return;
+    } else {
+      console.log(chalk9.red("Usage: pyre p2p <server|connect> [options]"));
+      process.exit(1);
+    }
+  }
+  const requestedLimit = parseInt(opts.limit, 10);
+  const processLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? requestedLimit : void 0;
+  const data = await collectAll({ detailed: opts.detailed, processLimit });
   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, sortBy: opts.sort, treeView: opts.tree });
+  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree, visible: { packets: opts.packets ? true : void 0 } });
   console.log(output);
   if (opts.out) {
-    fs2.writeFileSync(opts.out, stripAnsi(output));
-    console.log(chalk7.dim(`
+    fs4.writeFileSync(opts.out, stripAnsi(output));
+    console.log(chalk9.dim(`
 Saved to ${opts.out}`));
   }
 }
 main().catch((err) => {
-  console.error(chalk7.red(`Error: ${err.message}`));
-  stopLive();
+  console.error(chalk9.red(`Error: ${err.message}`));
   process.exit(1);
 });
+async function runP2PServer() {
+  const host = opts.p2pHost || "0.0.0.0";
+  const port = parseInt(opts.p2pPort, 10) || 9876;
+  const password = opts.p2pPassword || "";
+  const interval = parseFloat(opts.interval) || 2;
+  const detailed = !!opts.detailed;
+  const tlsCert = opts.p2pCert;
+  const tlsKey = opts.p2pKey;
+  const tlsCA = opts.p2pCA;
+  const rateLimit = parseInt(opts.p2pRateLimit, 10) || 5;
+  const allowList = opts.p2pAllow ? opts.p2pAllow.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  const denyList = opts.p2pDeny ? opts.p2pDeny.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  if (!password) {
+    console.log(chalk9.red("Error: a password is required for P2P server mode. Use --p2p-password <password>"));
+    process.exit(1);
+  }
+  if (tlsCert && !tlsKey) {
+    console.log(chalk9.red("Error: --p2p-key is required when --p2p-cert is specified"));
+    process.exit(1);
+  }
+  if (tlsKey && !tlsCert) {
+    console.log(chalk9.red("Error: --p2p-cert is required when --p2p-key is specified"));
+    process.exit(1);
+  }
+  const server = new P2PServer({
+    host,
+    port,
+    password,
+    intervalMs: interval * 1e3,
+    detailed,
+    tlsCert,
+    tlsKey,
+    tlsCA,
+    rateLimitMaxAttempts: rateLimit,
+    rateLimitWindowMs: 6e4,
+    allowedIPs: allowList,
+    deniedIPs: denyList,
+    auditLog: opts.p2pAuditLog,
+    hmacKey: opts.p2pHmacKey
+  });
+  const tlsEnabled = !!(tlsCert && tlsKey);
+  console.log(chalk9.bold(`
+  pyre P2P Server`));
+  console.log(chalk9.dim(`  Host: ${host}`));
+  console.log(chalk9.dim(`  Port: ${port}`));
+  console.log(chalk9.dim(`  Protocol: ${tlsEnabled ? "TLS" : "TCP"}`));
+  console.log(chalk9.dim(`  Password: ${password}`));
+  console.log(chalk9.dim(`  Interval: ${interval}s`));
+  console.log(chalk9.dim(`  Detailed: ${detailed ? "on" : "off"}`));
+  console.log(chalk9.dim(`  Rate limit: ${rateLimit} attempts/min`));
+  if (allowList.length > 0) console.log(chalk9.dim(`  Allowed IPs: ${allowList.join(", ")}`));
+  if (denyList.length > 0) console.log(chalk9.dim(`  Denied IPs: ${denyList.join(", ")}`));
+  console.log(chalk9.dim(`  Waiting for peers...
+`));
+  await server.start();
+  const rl = readline2.createInterface({ input: process.stdin });
+  rl.on("line", (line) => {
+    const trimmed = line.trim().toLowerCase();
+    if (trimmed === "q" || trimmed === "quit" || trimmed === "exit") {
+      server.stop();
+      rl.close();
+      process.exit(0);
+    } else if (trimmed === "status") {
+      const info = server.info;
+      console.log(chalk9.dim(`  Peers connected: ${info.peersConnected}`));
+    }
+  });
+  process.once("SIGINT", () => {
+    server.stop();
+    rl.close();
+    process.exit(0);
+  });
+}
+async function runP2PConnect() {
+  const host = opts.p2pHost || "127.0.0.1";
+  const port = parseInt(opts.p2pPort, 10) || 9876;
+  const password = opts.p2pPassword || "";
+  const useTLS = !!opts.p2pTls;
+  const tlsCA = opts.p2pCA;
+  const tlsInsecure = !!opts.p2pInsecure;
+  if (!password) {
+    console.log(chalk9.red("Error: a password is required for P2P connect mode. Use --p2p-password <password>"));
+    process.exit(1);
+  }
+  const client = new P2PClient({
+    host,
+    port,
+    password,
+    tls: useTLS,
+    tlsCA,
+    tlsInsecure,
+    auditLog: opts.p2pAuditLog,
+    hmacKey: opts.p2pHmacKey
+  });
+  client.setOnStatus((msg) => {
+    process.stdout.write(`\r${chalk9.dim(msg)}${" ".repeat(40)}\r`);
+  });
+  client.setOnData((data) => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    console.log(chalk9.bold(`  pyre P2P Client \u2014 ${data.header.hostname}`));
+    console.log(chalk9.dim(`  ${data.timestamp}`));
+    console.log();
+    console.log(formatTable(data, {
+      width: process.stdout.columns || 80,
+      sortBy: "cpu",
+      treeView: false,
+      visible: { packets: true }
+    }));
+  });
+  const protocolLabel = useTLS ? "TLS" : "TCP";
+  console.log(chalk9.bold(`
+  pyre P2P Client`));
+  console.log(chalk9.dim(`  Protocol: ${protocolLabel}`));
+  console.log(chalk9.dim(`  Connecting to ${host}:${port}...`));
+  console.log(chalk9.dim(`  Press Ctrl+C to disconnect
+`));
+  try {
+    await client.connect();
+  } catch (err) {
+    console.log(chalk9.red(`Connection failed: ${err.message}`));
+    process.exit(1);
+  }
+  process.once("SIGINT", () => {
+    client.disconnect();
+    process.exit(0);
+  });
+}