pyre-cli 4.14.0 → 4.16.0

package/README.md

@@ -9,6 +9,8 @@ Mac system monitoring CLI: temps, CPU, memory, disk, battery, live dashboard, pa
 
 > Note : things may not work as intended if your firewall settings do not allow inbound connections for this program
 
+> Additionally, you can skip init with enter but you may encounter some UI bugs. I am working on the issue at the moment.
+
 ## Features
 
 - **P2P live data streaming** — send live system stats to another system over TCP with password authentication, TLS encryption, rate limiting, IP allow/deny lists, audit logging, and HMAC message signing
@@ -81,6 +83,116 @@ pyre live --interval 5 --log   # Custom interval with auto-logging
 | `--log` | Start continuous CSV logging immediately when live mode starts |
 | `--packets` | Include packet monitor panel in static output |
 
+## Commands
+
+### Static snapshot
+
+| Command | Description |
+|---|---|
+| `pyre` | Show all system stats in a formatted table |
+| `pyre --detailed` | Include detailed sensor and powermetrics readings |
+| `pyre --json` | Output stats as JSON |
+| `pyre --csv` | Output stats as CSV |
+| `pyre --tsv` | Output stats as TSV |
+| `pyre --once` | Show a single static snapshot (same as default without live) |
+| `pyre --out <file>` | Write snapshot output to a file |
+| `pyre --packets` | Include packet monitor panel in static output |
+
+### Live dashboard
+
+| Command | Description |
+|---|---|
+| `pyre live` | Start the interactive live dashboard |
+| `pyre live --interval <seconds>` | Set refresh interval for live mode (default: `2`) |
+| `pyre live --detailed` | Live mode with detailed sensor readings |
+| `pyre live --export-dir <dir>` | Custom directory for snapshot exports and logs |
+| `pyre live --log` | Start continuous CSV logging immediately |
+
+### Quick P2P setup
+
+| Command | Description |
+|---|---|
+| `pyre server` | Detect the local IP and print ready-to-paste commands for starting a P2P server and connecting a client on the same LAN |
+
+`pyre server` automatically detects the machine's non-loopback IP address and outputs two copy-paste commands — one to start the server and one for a client on the same network to connect. Default port is `9876` and default password is `mysecret`.
+
+### P2P server
+
+| Command | Description |
+|---|---|
+| `pyre p2p server` | Start a P2P server that streams live stats to authenticated peers |
+| `pyre p2p server --p2p-host <host>` | Bind address (default: `0.0.0.0`) |
+| `pyre p2p server --p2p-port <port>` | Port number (default: `9876`) |
+| `pyre p2p server --p2p-password <password>` | Password for authentication (required) |
+| `pyre p2p server --interval <seconds>` | Data refresh interval (default: `2`) |
+| `pyre p2p server --detailed` | Include detailed sensor readings |
+| `pyre p2p server --p2p-cert <file>` | TLS certificate file (PEM) for encrypted connections |
+| `pyre p2p server --p2p-key <file>` | TLS private key file (PEM) for the server |
+| `pyre p2p server --p2p-ca <file>` | TLS CA certificate file (PEM) — required by clients using `--p2p-tls` |
+| `pyre p2p server --p2p-rate-limit <n>` | Max auth attempts per IP per minute (default: `5`) |
+| `pyre p2p server --p2p-allow <ips>` | Comma-separated list of allowed IPs (empty = all) |
+| `pyre p2p server --p2p-deny <ips>` | Comma-separated list of denied IPs |
+| `pyre p2p server --p2p-audit-log <dir>` | Directory for P2P audit logs |
+| `pyre p2p server --p2p-hmac-key <key>` | HMAC key for message signing (default: derived from password) |
+
+### P2P client
+
+| Command | Description |
+|---|---|
+| `pyre p2p connect` | Connect to a P2P server and display live stats |
+| `pyre p2p connect --p2p-host <host>` | Server address (default: `127.0.0.1`) |
+| `pyre p2p connect --p2p-port <port>` | Server port (default: `9876`) |
+| `pyre p2p connect --p2p-password <password>` | Password for authentication (required) |
+| `pyre p2p connect --p2p-tls` | Enable TLS encryption for the connection |
+| `pyre p2p connect --p2p-ca <file>` | TLS CA certificate file (PEM) — required when using `--p2p-tls` |
+| `pyre p2p connect --p2p-insecure` | Skip TLS certificate verification (client only) |
+| `pyre p2p connect --p2p-audit-log <dir>` | Directory for P2P client audit logs |
+| `pyre p2p connect --p2p-hmac-key <key>` | HMAC key for message signing (must match server) |
+
+### Options (shared)
+
+| Option | Description |
+|---|---|
+| `-j, --json` | Output as JSON |
+| `-c, --csv` | Output as CSV |
+| `-t, --tsv` | Output as TSV |
+| `--detailed` | Include detailed system info and sensor readings |
+| `--interval <seconds>` | Refresh interval for live mode (default: `2`) |
+| `--once` | Show a single static snapshot instead of live feed |
+| `--out <file>` | Write snapshot output to a file |
+| `--export-dir <dir>` | Directory for live-mode snapshot exports and logs (default: `./pyre-exports`) |
+| `--log` | Start continuous CSV logging immediately when live mode starts |
+| `--packets` | Include packet monitor panel in static output |
+
+### Live dashboard keyboard controls
+
+| Key | Action |
+|---|---|
+| `q` | Quit the dashboard |
+| `p` | Pause / resume the refresh cycle |
+| `d` | Toggle detailed sensor mode |
+| `g` | Show / hide sparkline graphs |
+| `s` | Cycle sort order (CPU → memory → PID) |
+| `f` | Cycle export format (JSON → CSV → TSV) |
+| `e` | Export a snapshot to the export directory |
+| `l` | Toggle continuous CSV logging |
+| `c` | Open the UI customizer |
+| `/` | Open process filter |
+| `k` | Open process kill (enter PID, then Enter to confirm) |
+| `+` | Increase refresh interval by 1 second |
+| `-` | Decrease refresh interval by 1 second |
+| `↑` / `k` | Navigate customizer options |
+| `↓` / `j` | Navigate customizer options |
+| `Enter` / `Space` | Toggle visibility or select theme in customizer |
+| `Esc` | Close customizer or clear filter/kill input |
+
+### P2P server controls
+
+| Command | Action |
+|---|---|
+| `status` | Print the number of currently connected peers |
+| `q` / `quit` / `exit` | Shut down the server gracefully |
+
 ## P2P Live Data Streaming
 
 Send live system stats to another system over a TCP connection with password authentication. The server streams `StatsData` snapshots to authenticated peers at the configured interval.

package/dist/index.js

@@ -2,6 +2,7 @@
 
 // src/index.ts
 import fs4 from "fs";
+import os from "os";
 import readline2 from "readline";
 import { Command } from "commander";
 import chalk9 from "chalk";
@@ -1549,7 +1550,10 @@ var state = {
     "Toggle Tasks",
     "Toggle Disk",
     "Toggle Processes",
-    "Toggle Tree View"
+    "Toggle Tree View",
+    "Splash Screen",
+    "Splash Color",
+    "Splash Animation"
   ],
   CPU_ALERT_PCT: 90,
   TEMP_ALERT_C: 95,
@@ -1575,7 +1579,10 @@ var state = {
   p2pServer: null,
   p2pServerRunning: false,
   p2pPort: 9876,
-  p2pPassword: "pyre"
+  p2pPassword: "pyre",
+  splashEnabled: true,
+  splashColorScheme: "fire",
+  splashAnimation: "classic"
 };
 function setStatus(msg, ms = 3e3) {
   state.statusMessage = msg;
@@ -1740,6 +1747,13 @@ 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 === "Splash Screen") {
+      const status = state.splashEnabled ? chalk5.green("[ON]") : chalk5.red("[OFF]");
+      lines.push(`${prefix}${opt}: ${status}`);
+    } else if (opt === "Splash Color") {
+      lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
+    } else if (opt === "Splash Animation") {
+      lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
     } else {
       const toggleKey = getToggleKey(opt);
       const isVisible = toggleKey ? toggleKey === "tree" ? state.treeView : state.visiblePanels[toggleKey] !== false : true;
@@ -2590,6 +2604,19 @@ function handleInputModeKey(str, key) {
         state.currentTheme = themesList[nextIdx];
       } else if (selected === "Graph Mode") {
         state.graphMode = state.graphMode === "spark" ? "bar" : "spark";
+      } else if (selected === "Splash Screen") {
+        state.splashEnabled = !state.splashEnabled;
+        setStatus(state.splashEnabled ? "Splash screen enabled" : "Splash screen disabled");
+      } else if (selected === "Splash Color") {
+        const schemes = ["fire", "ocean", "forest", "purple", "monochrome"];
+        const curIdx = schemes.indexOf(state.splashColorScheme);
+        state.splashColorScheme = schemes[(curIdx + 1) % schemes.length];
+        setStatus(`Splash color: ${state.splashColorScheme}`);
+      } else if (selected === "Splash Animation") {
+        const animations = ["classic", "wave", "sparks"];
+        const curIdx = animations.indexOf(state.splashAnimation);
+        state.splashAnimation = animations[(curIdx + 1) % animations.length];
+        setStatus(`Splash animation: ${state.splashAnimation}`);
       } else {
         const toggleKey = getToggleKey(selected);
         if (toggleKey) {
@@ -3000,6 +3027,12 @@ async function startLive(opts2, splashPromise) {
       case "tab":
         cycleTab(1);
         break;
+      case "escape":
+      case "esc":
+        state.activePanel = "grid";
+        setStatus("Grid view");
+        render();
+        break;
       default:
         if (str && str.length === 1) {
           const tabId = tabKeyToId(str);
@@ -3099,59 +3132,286 @@ function stopLive() {
 import chalk8 from "chalk";
 var MAXV = 36;
 var CHAR_RAMP = [" ", ".", "`", ",", ":", ";", "+", "*", "?", "%", "#", "@"];
-var palette = [
-  "#0a0505",
-  "#1a0806",
-  "#2a0b06",
-  "#3f1004",
-  "#591404",
-  "#791804",
-  "#9e1c04",
-  "#c92004",
-  "#d63004",
-  "#e34004",
-  "#f05004",
-  "#fd6004",
-  "#ff7004",
-  "#ff8004",
-  "#ff9004",
-  "#ffa004",
-  "#ffb004",
-  "#ffc004",
-  "#ffd004",
-  "#ffe004",
-  "#fff004",
-  "#fff820",
-  "#ffff40",
-  "#ffff60",
-  "#ffff80",
-  "#ffffa0",
-  "#ffffc0",
-  "#ffffe0",
-  "#ffffff",
-  "#ffffff",
-  "#ffffff",
-  "#ffffff",
-  "#ffffff",
-  "#ffffff",
-  "#ffffff",
-  "#ffffff"
-];
+var PALETTES = {
+  fire: [
+    "#0a0505",
+    "#1a0806",
+    "#2a0b06",
+    "#3f1004",
+    "#591404",
+    "#791804",
+    "#9e1c04",
+    "#c92004",
+    "#d63004",
+    "#e34004",
+    "#f05004",
+    "#fd6004",
+    "#ff7004",
+    "#ff8004",
+    "#ff9004",
+    "#ffa004",
+    "#ffb004",
+    "#ffc004",
+    "#ffd004",
+    "#ffe004",
+    "#fff004",
+    "#fff820",
+    "#ffff40",
+    "#ffff60",
+    "#ffff80",
+    "#ffffa0",
+    "#ffffc0",
+    "#ffffe0",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff"
+  ],
+  ocean: [
+    "#020a1a",
+    "#041428",
+    "#061e36",
+    "#0a2844",
+    "#0e3252",
+    "#123c60",
+    "#16466e",
+    "#1a507c",
+    "#1e5a8a",
+    "#226498",
+    "#266ea6",
+    "#2a78b4",
+    "#2e82c2",
+    "#328cd0",
+    "#3696de",
+    "#3aa0ec",
+    "#3eaae8",
+    "#42b4e4",
+    "#46bee0",
+    "#4ac8dc",
+    "#4fd2d8",
+    "#53dcd4",
+    "#57e6d0",
+    "#5befcc",
+    "#5ff6c8",
+    "#63ffc4",
+    "#67ffc0",
+    "#6bffbc",
+    "#6fffB8",
+    "#73ffb4",
+    "#77ffb0",
+    "#7bffac",
+    "#7fffA8",
+    "#83ffa4",
+    "#87ffa0",
+    "#8bff9c"
+  ],
+  forest: [
+    "#020a02",
+    "#041404",
+    "#061e06",
+    "#0a280a",
+    "#0e320e",
+    "#123c12",
+    "#164616",
+    "#1a501a",
+    "#1e5a1e",
+    "#226422",
+    "#266e26",
+    "#2a782a",
+    "#2e822e",
+    "#328c32",
+    "#369636",
+    "#3aa03a",
+    "#3eaa3e",
+    "#42b442",
+    "#46be46",
+    "#4ac84a",
+    "#4fd24f",
+    "#53dc53",
+    "#57e657",
+    "#5bf05b",
+    "#5ff65f",
+    "#63ff63",
+    "#67ff67",
+    "#6bff6b",
+    "#6fff6f",
+    "#73ff73",
+    "#77ff77",
+    "#7bff7b",
+    "#7fff7f",
+    "#83ff83",
+    "#87ff87",
+    "#8bff8b"
+  ],
+  purple: [
+    "#0a021a",
+    "#140428",
+    "#1e0636",
+    "#280844",
+    "#320a52",
+    "#3c0c60",
+    "#460e6e",
+    "#50107c",
+    "#5a128a",
+    "#641498",
+    "#6e16a6",
+    "#7818b4",
+    "#821ac2",
+    "#8c1cd0",
+    "#961ede",
+    "#a020ec",
+    "#aa22e8",
+    "#b424e4",
+    "#be26e0",
+    "#c828dc",
+    "#d22ad8",
+    "#dc2cd4",
+    "#e62ed0",
+    "#f030cc",
+    "#f432c8",
+    "#f834c4",
+    "#fc36c0",
+    "#ff38bc",
+    "#ff3ab8",
+    "#ff3cb4",
+    "#ff3eb0",
+    "#ff40ac",
+    "#ff42a8",
+    "#ff44a4",
+    "#ff46a0",
+    "#ff489c"
+  ],
+  monochrome: [
+    "#0a0a0a",
+    "#1a1a1a",
+    "#2a2a2a",
+    "#3a3a3a",
+    "#4a4a4a",
+    "#5a5a5a",
+    "#6a6a6a",
+    "#7a7a7a",
+    "#8a8a8a",
+    "#9a9a9a",
+    "#aaaaaa",
+    "#bAbAbA",
+    "#cacaca",
+    "#dAdAdA",
+    "#eaeaea",
+    "#f4f4f4",
+    "#f8f8f8",
+    "#fcfcfc",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff",
+    "#ffffff"
+  ]
+};
 function getRgb(hex) {
   const r = parseInt(hex.slice(1, 3), 16);
   const g = parseInt(hex.slice(3, 5), 16);
   const b = parseInt(hex.slice(5, 7), 16);
   return { r, g, b };
 }
-var rgbPalette = palette.map(getRgb);
+function getPalette(scheme) {
+  return (PALETTES[scheme] ?? PALETTES.fire).map(getRgb);
+}
 function getChar(val) {
   const idx = Math.min(CHAR_RAMP.length - 1, Math.floor(val / (MAXV + 1) * CHAR_RAMP.length));
   return CHAR_RAMP[idx];
 }
-async function showSplash() {
+function initFire(cols, rows) {
+  return new Uint8Array(cols * rows);
+}
+function spreadFireClassic(fire, cols, rows) {
+  for (let x = 0; x < cols; x++) {
+    fire[(rows - 1) * cols + x] = MAXV - Math.floor(Math.random() * 4);
+  }
+  for (let y = rows - 1; y >= 1; y--) {
+    for (let x = 0; x < cols; x++) {
+      const src = y * cols + x;
+      const val = fire[src];
+      if (val === 0) {
+        fire[(y - 1) * cols + x] = 0;
+        continue;
+      }
+      const decay = Math.floor(Math.random() * 3);
+      const drift = Math.floor(Math.random() * 3) - 1;
+      let nx = x + drift;
+      if (nx < 0) nx = 0;
+      else if (nx >= cols) nx = cols - 1;
+      fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+    }
+  }
+}
+function spreadFireWave(fire, cols, rows, time) {
+  for (let x = 0; x < cols; x++) {
+    const wave = Math.sin((x + time) * 0.3) * 0.5 + 0.5;
+    fire[(rows - 1) * cols + x] = Math.floor(MAXV * wave);
+  }
+  for (let y = rows - 1; y >= 1; y--) {
+    for (let x = 0; x < cols; x++) {
+      const src = y * cols + x;
+      const val = fire[src];
+      if (val === 0) {
+        fire[(y - 1) * cols + x] = 0;
+        continue;
+      }
+      const decay = Math.floor(Math.random() * 2);
+      const nx = x;
+      fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+    }
+  }
+}
+function spreadFireSparks(fire, cols, rows) {
+  for (let x = 0; x < cols; x++) {
+    fire[(rows - 1) * cols + x] = Math.random() < 0.3 ? MAXV - Math.floor(Math.random() * 4) : 0;
+  }
+  for (let y = rows - 1; y >= 1; y--) {
+    for (let x = 0; x < cols; x++) {
+      const src = y * cols + x;
+      const val = fire[src];
+      if (val === 0) {
+        fire[(y - 1) * cols + x] = 0;
+        continue;
+      }
+      const decay = Math.floor(Math.random() * 4);
+      const drift = Math.floor(Math.random() * 5) - 2;
+      let nx = x + drift;
+      if (nx < 0) nx = 0;
+      else if (nx >= cols) nx = cols - 1;
+      fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+    }
+  }
+}
+async function showSplash(config) {
+  const enabled = config?.enabled ?? true;
+  if (!enabled) return;
+  const colorScheme = config?.colorScheme ?? "fire";
+  const animation = config?.animation ?? "classic";
+  const palette = getPalette(colorScheme);
+  const rgbPalette = palette.map(getRgb);
   const cols = 60;
   const rows = 15;
-  let fire = new Uint8Array(cols * rows);
+  let fire = initFire(cols, rows);
+  let time = 0;
   process.stdout.write("\x1B[2J");
   const termRows = process.stdout.rows || 24;
   const termCols = process.stdout.columns || 80;
@@ -3159,24 +3419,13 @@ async function showSplash() {
   const startCol = Math.max(0, Math.floor((termCols - cols) / 2));
   return new Promise((resolve) => {
     const interval = setInterval(() => {
-      for (let x = 0; x < cols; x++) {
-        fire[(rows - 1) * cols + x] = MAXV - Math.floor(Math.random() * 4);
-      }
-      for (let y = rows - 1; y >= 1; y--) {
-        for (let x = 0; x < cols; x++) {
-          const src = y * cols + x;
-          const val = fire[src];
-          if (val === 0) {
-            fire[(y - 1) * cols + x] = 0;
-            continue;
-          }
-          const decay = Math.floor(Math.random() * 3);
-          const drift = Math.floor(Math.random() * 3) - 1;
-          let nx = x + drift;
-          if (nx < 0) nx = 0;
-          else if (nx >= cols) nx = cols - 1;
-          fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
-        }
+      time++;
+      if (animation === "wave") {
+        spreadFireWave(fire, cols, rows, time);
+      } else if (animation === "sparks") {
+        spreadFireSparks(fire, cols, rows);
+      } else {
+        spreadFireClassic(fire, cols, rows);
       }
       let output = "";
       for (let i = 0; i < startRow; i++) output += "\n";
@@ -3221,8 +3470,45 @@ function stripAnsi(s) {
 function sanitizeHost2(host) {
   return host.trim().replace(/%$/, "");
 }
+function detectLocalIP() {
+  const ifaces = os.networkInterfaces();
+  for (const [, addrs] of Object.entries(ifaces)) {
+    if (!addrs) continue;
+    for (const addr of addrs) {
+      if (addr.family === "IPv4" && !addr.internal) {
+        return addr.address;
+      }
+    }
+  }
+  return null;
+}
+async function runServerCommand() {
+  const ip = detectLocalIP();
+  if (!ip) {
+    console.log(chalk9.red("Could not detect a non-loopback IP address. Connect to a network first."));
+    process.exit(1);
+  }
+  const port = 9876;
+  const password = "mysecret";
+  console.log(chalk9.bold(`
+  pyre server`));
+  console.log(chalk9.dim(`  Detected IP: ${ip}`));
+  console.log(chalk9.dim(`  Port: ${port}`));
+  console.log(chalk9.dim(`  Password: ${password}`));
+  console.log();
+  console.log(chalk9.bold("Run this on THIS machine (server):"));
+  console.log(chalk9.hex("#ff6a39")(`pyre p2p server --p2p-host 0.0.0.0 --p2p-port ${port} --p2p-password ${password}`));
+  console.log();
+  console.log(chalk9.bold("Run this on the OTHER machine (client):"));
+  console.log(chalk9.hex("#ff6a39")(`pyre p2p connect --p2p-host ${ip} --p2p-port ${port} --p2p-password ${password}`));
+  console.log();
+}
 async function main() {
   const cmd = program.args[0];
+  if (cmd === "server") {
+    await runServerCommand();
+    return;
+  }
   if (cmd === "live" || !isExportMode() && !opts.once && cmd !== "p2p") {
     if (cmd === "live") {
       program.args.shift();
@@ -3343,6 +3629,22 @@ async function runP2PServer() {
     process.exit(0);
   });
 }
+var _prevFrameLines2 = [];
+function writeFrame2(lines) {
+  if (_prevFrameLines2.length === 0 || lines.length !== _prevFrameLines2.length) {
+    process.stdout.write("\x1B[?25l\x1B[H" + lines.map((l) => `\x1B[2K${l}`).join("\r\n") + "\x1B[0J");
+    _prevFrameLines2 = lines;
+    return;
+  }
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] !== _prevFrameLines2[i]) {
+      out += `\x1B[${i + 1};1H\x1B[2K${lines[i]}`;
+    }
+  }
+  if (out) process.stdout.write(out);
+  _prevFrameLines2 = lines;
+}
 async function runP2PConnect() {
   const host = sanitizeHost2(opts.p2pHost || "127.0.0.1");
   const port = parseInt(opts.p2pPort, 10) || 9876;
@@ -3368,16 +3670,23 @@ async function runP2PConnect() {
     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, {
+    const lines = [];
+    lines.push(chalk9.bold(`  pyre P2P Client \u2014 ${data.header.hostname}`));
+    lines.push(chalk9.dim(`  ${data.timestamp}`));
+    lines.push("");
+    lines.push(...formatTable(data, {
       width: process.stdout.columns || 80,
       sortBy: "cpu",
       treeView: false,
       visible: { packets: true }
-    }));
+    }).split("\n"));
+    while (lines.length < process.stdout.rows) {
+      lines.push("");
+    }
+    if (lines.length > process.stdout.rows) {
+      lines.length = process.stdout.rows;
+    }
+    writeFrame2(lines);
   });
   const protocolLabel = useTLS ? "TLS" : "TCP";
   console.log(chalk9.bold(`
@@ -3386,6 +3695,7 @@ async function runP2PConnect() {
   console.log(chalk9.dim(`  Connecting to ${host}:${port}...`));
   console.log(chalk9.dim(`  Press Ctrl+C to disconnect
 `));
+  process.stdout.write("\x1B[?25l");
   try {
     await client.connect();
   } catch (err) {
@@ -3409,10 +3719,13 @@ async function runP2PConnect() {
       console.log(chalk9.dim("  3. Check connectivity: ping " + host));
       console.log(chalk9.dim("  4. Ensure both machines are on the same LAN (ping each other first)"));
     }
+    process.stdout.write("\x1B[?25h");
     process.exit(1);
   }
   process.once("SIGINT", () => {
+    _prevFrameLines2 = [];
     client.disconnect();
+    process.stdout.write("\x1B[?25h\x1B[2J\x1B[H");
     process.exit(0);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "4.14.0",
+  "version": "4.16.0",
   "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",

package/src/index.ts

@@ -7,6 +7,7 @@
  * P2P mode enables live data streaming between two systems over TCP.
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import readline from 'node:readline';
 import { Command } from 'commander';
 import chalk from 'chalk';
@@ -69,9 +70,53 @@ function sanitizeHost(host: string): string {
   return host.trim().replace(/%$/, '');
 }
 
+function detectLocalIP(): string | null {
+  const ifaces = os.networkInterfaces();
+  for (const [, addrs] of Object.entries(ifaces)) {
+    if (!addrs) continue;
+    for (const addr of addrs) {
+      if (addr.family === 'IPv4' && !addr.internal) {
+        return addr.address;
+      }
+    }
+  }
+  return null;
+}
+
+async function runServerCommand(): Promise<void> {
+  const ip = detectLocalIP();
+
+  if (!ip) {
+    console.log(chalk.red('Could not detect a non-loopback IP address. Connect to a network first.'));
+    process.exit(1);
+  }
+
+  const port = 9876;
+  const password = 'mysecret';
+
+  console.log(chalk.bold(`\n  pyre server`));
+  console.log(chalk.dim(`  Detected IP: ${ip}`));
+  console.log(chalk.dim(`  Port: ${port}`));
+  console.log(chalk.dim(`  Password: ${password}`));
+  console.log();
+
+  console.log(chalk.bold('Run this on THIS machine (server):'));
+  console.log(chalk.hex('#ff6a39')(`pyre p2p server --p2p-host 0.0.0.0 --p2p-port ${port} --p2p-password ${password}`));
+  console.log();
+
+  console.log(chalk.bold('Run this on the OTHER machine (client):'));
+  console.log(chalk.hex('#ff6a39')(`pyre p2p connect --p2p-host ${ip} --p2p-port ${port} --p2p-password ${password}`));
+  console.log();
+}
+
 async function main() {
   const cmd = program.args[0];
 
+  if (cmd === 'server') {
+    await runServerCommand();
+    return;
+  }
+
   if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
     if (cmd === 'live') {
       program.args.shift();
@@ -208,6 +253,25 @@ async function runP2PServer(): Promise<void> {
   });
 }
 
+let _prevFrameLines: string[] = [];
+
+function writeFrame(lines: string[]) {
+  if (_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;
+    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;
+}
+
 async function runP2PConnect(): Promise<void> {
   const host = sanitizeHost(opts.p2pHost || '127.0.0.1');
   const port = parseInt(opts.p2pPort, 10) || 9876;
@@ -237,16 +301,25 @@ async function runP2PConnect(): Promise<void> {
   });
 
   client.setOnData((data) => {
-    process.stdout.write('\x1b[2J\x1b[H');
-    console.log(chalk.bold(`  pyre P2P Client — ${data.header.hostname}`));
-    console.log(chalk.dim(`  ${data.timestamp}`));
-    console.log();
-    console.log(formatTable(data, {
+    const lines: string[] = [];
+    lines.push(chalk.bold(`  pyre P2P Client — ${data.header.hostname}`));
+    lines.push(chalk.dim(`  ${data.timestamp}`));
+    lines.push('');
+    lines.push(...formatTable(data, {
       width: process.stdout.columns || 80,
       sortBy: 'cpu',
       treeView: false,
       visible: { packets: true },
-    }));
+    }).split('\n'));
+
+    while (lines.length < process.stdout.rows) {
+      lines.push('');
+    }
+    if (lines.length > process.stdout.rows) {
+      lines.length = process.stdout.rows;
+    }
+
+    writeFrame(lines);
   });
 
   const protocolLabel = useTLS ? 'TLS' : 'TCP';
@@ -255,6 +328,8 @@ async function runP2PConnect(): Promise<void> {
   console.log(chalk.dim(`  Connecting to ${host}:${port}...`));
   console.log(chalk.dim(`  Press Ctrl+C to disconnect\n`));
 
+  process.stdout.write('\x1b[?25l');
+
   try {
     await client.connect();
   } catch (err: any) {
@@ -278,11 +353,14 @@ async function runP2PConnect(): Promise<void> {
       console.log(chalk.dim('  3. Check connectivity: ping ' + host));
       console.log(chalk.dim('  4. Ensure both machines are on the same LAN (ping each other first)'));
     }
+    process.stdout.write('\x1b[?25h');
     process.exit(1);
   }
 
   process.once('SIGINT', () => {
+    _prevFrameLines = [];
     client.disconnect();
+    process.stdout.write('\x1b[?25h\x1b[2J\x1b[H');
     process.exit(0);
   });
 }

package/src/live/input.ts

@@ -10,7 +10,7 @@ import readline from 'node:readline';
 import chalk from 'chalk';
 import { collectAll, StatsData } from '../monitors/index.js';
 import { THEMES, type ThemeName, type VisibleItems, getTabHitboxes, TAB_BAR_ROW } from '../formatters/index.js';
-import { state, setStatus, getToggleKey } from './state.js';
+import { state, setStatus, getToggleKey, type SplashColorScheme, type SplashAnimation } from './state.js';
 import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow } from './export.js';
 import { render, footerLine, checkAlerts, invalidateTableCache, invalidateFrame } from './render.js';
 import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
@@ -51,18 +51,31 @@ function handleInputModeKey(str: string, key: readline.Key) {
          state.currentTheme = themesList[nextIdx];
        } else if (selected === 'Graph Mode') {
          state.graphMode = state.graphMode === 'spark' ? 'bar' : 'spark';
-       } else {
-         const toggleKey = getToggleKey(selected);
-         if (toggleKey) {
-           if (toggleKey === 'tree') {
-             state.treeView = !state.treeView;
-             state.visiblePanels.tree = state.treeView;
-           } else {
-             const isVisible = state.visiblePanels[toggleKey] !== false;
-             state.visiblePanels[toggleKey] = !isVisible;
-           }
-         }
-       }
+        } else if (selected === 'Splash Screen') {
+          state.splashEnabled = !state.splashEnabled;
+          setStatus(state.splashEnabled ? 'Splash screen enabled' : 'Splash screen disabled');
+        } else if (selected === 'Splash Color') {
+          const schemes: SplashColorScheme[] = ['fire', 'ocean', 'forest', 'purple', 'monochrome'];
+          const curIdx = schemes.indexOf(state.splashColorScheme);
+          state.splashColorScheme = schemes[(curIdx + 1) % schemes.length];
+          setStatus(`Splash color: ${state.splashColorScheme}`);
+        } else if (selected === 'Splash Animation') {
+          const animations: SplashAnimation[] = ['classic', 'wave', 'sparks'];
+          const curIdx = animations.indexOf(state.splashAnimation);
+          state.splashAnimation = animations[(curIdx + 1) % animations.length];
+          setStatus(`Splash animation: ${state.splashAnimation}`);
+        } else {
+          const toggleKey = getToggleKey(selected);
+          if (toggleKey) {
+            if (toggleKey === 'tree') {
+              state.treeView = !state.treeView;
+              state.visiblePanels.tree = state.treeView;
+            } else {
+              const isVisible = state.visiblePanels[toggleKey] !== false;
+              state.visiblePanels[toggleKey] = !isVisible;
+            }
+          }
+        }
        invalidateTableCache();
        invalidateFrame();
      }
@@ -492,6 +505,12 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
         case 'tab':
           cycleTab(1);
           break;
+        case 'escape':
+        case 'esc':
+          state.activePanel = 'grid';
+          setStatus('Grid view');
+          render();
+          break;
         default:
           if (str && str.length === 1) {
             const tabId = tabKeyToId(str);

package/src/live/render.ts

@@ -103,21 +103,28 @@ function renderCustomizerOverlay(): string {
      chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) '),
    ];
 
-   state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
-     const isSelected = idx === state.customizerIndex;
-     const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
-
-      if (opt === 'Theme') {
-        lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
-      } else if (opt === 'Graph Mode') {
-        lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
-      } else {
-        const toggleKey = getToggleKey(opt);
-        const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
-        const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
-        lines.push(`${prefix}${opt}: ${status}`);
-      }
-   });
+    state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
+      const isSelected = idx === state.customizerIndex;
+      const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
+
+       if (opt === 'Theme') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
+       } else if (opt === 'Graph Mode') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
+       } else if (opt === 'Splash Screen') {
+         const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       } else if (opt === 'Splash Color') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
+       } else if (opt === 'Splash Animation') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
+       } else {
+         const toggleKey = getToggleKey(opt);
+         const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
+         const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       }
+    });
 
    return lines.map(l => `  ${l}`).join('\n');
  }

package/src/live/state.ts

@@ -14,6 +14,10 @@ import type { ThemeName, VisibleItems } from '../formatters/types.js';
 
 export const SIGNAL_OPTIONS = ['SIGTERM', 'SIGKILL', 'SIGINT', 'SIGHUP', 'SIGSTOP', 'SIGCONT'] as const;
 
+import { type SplashColorScheme, type SplashAnimation } from '../splash.js';
+
+export { type SplashColorScheme, type SplashAnimation };
+
 const state = {
    intervalHandle: null as NodeJS.Timeout | null,
    uiIntervalHandle: null as NodeJS.Timeout | null,
@@ -59,48 +63,54 @@ const state = {
    treeView: false,
    SIGNAL_OPTIONS,
    customizerIndex: 0,
-    CUSTOMIZER_OPTIONS: [
-      'Theme',
-      '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,
-   activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',
-    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' },
-        { id: 'p2p', label: 'P2P', key: 'R' },
-      ] as const,
-     p2pEvents: [] as { type: string; detail: string; ts: number }[],
-     p2pBind: '',
-     p2pServer: null as { stop: () => void; peerEventHistory: { type: string; detail: string; ts: number }[] } | null,
-     p2pServerRunning: false,
-     p2pPort: 9876,
-     p2pPassword: 'pyre',
-  };
+     CUSTOMIZER_OPTIONS: [
+       'Theme',
+       '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',
+       'Splash Screen',
+       'Splash Color',
+       'Splash Animation',
+     ],
+    CPU_ALERT_PCT: 90,
+    TEMP_ALERT_C: 95,
+    alerted: false,
+    activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',
+     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' },
+         { id: 'p2p', label: 'P2P', key: 'R' },
+       ] as const,
+      p2pEvents: [] as { type: string; detail: string; ts: number }[],
+      p2pBind: '',
+      p2pServer: null as { stop: () => void; peerEventHistory: { type: string; detail: string; ts: number }[] } | null,
+      p2pServerRunning: false,
+      p2pPort: 9876,
+      p2pPassword: 'pyre',
+      splashEnabled: true,
+      splashColorScheme: 'fire' as SplashColorScheme,
+      splashAnimation: 'classic' as SplashAnimation,
+   };
 
 function setStatus(msg: string, ms = 3000) {
   state.statusMessage = msg;

package/src/splash.ts

@@ -1,19 +1,60 @@
 /**
  * ASCII Splash Screen implementation based on the doom-fire effect.
+ *
+ * Supports configurable colour schemes and animation types via
+ * the {@link SplashConfig} interface.
  */
 import chalk from 'chalk';
 
 const MAXV = 36;
 const CHAR_RAMP = [' ', '.', '`', ',', ':', ';', '+', '*', '?', '%', '#', '@'];
 
-// Colors for the fire effect
-const palette = [
-  '#0a0505', '#1a0806', '#2a0b06', '#3f1004', '#591404', '#791804', '#9e1c04', '#c92004',
-  '#d63004', '#e34004', '#f05004', '#fd6004', '#ff7004', '#ff8004', '#ff9004', '#ffa004',
-  '#ffb004', '#ffc004', '#ffd004', '#ffe004', '#fff004', '#fff820', '#ffff40', '#ffff60',
-  '#ffff80', '#ffffa0', '#ffffc0', '#ffffe0', '#ffffff', '#ffffff', '#ffffff', '#ffffff',
-  '#ffffff', '#ffffff', '#ffffff', '#ffffff'
-];
+export type SplashColorScheme = 'fire' | 'ocean' | 'forest' | 'purple' | 'monochrome';
+export type SplashAnimation = 'classic' | 'wave' | 'sparks';
+
+export interface SplashConfig {
+  enabled?: boolean;
+  colorScheme?: SplashColorScheme;
+  animation?: SplashAnimation;
+}
+
+const PALETTES: Record<SplashColorScheme, string[]> = {
+  fire: [
+    '#0a0505', '#1a0806', '#2a0b06', '#3f1004', '#591404', '#791804', '#9e1c04', '#c92004',
+    '#d63004', '#e34004', '#f05004', '#fd6004', '#ff7004', '#ff8004', '#ff9004', '#ffa004',
+    '#ffb004', '#ffc004', '#ffd004', '#ffe004', '#fff004', '#fff820', '#ffff40', '#ffff60',
+    '#ffff80', '#ffffa0', '#ffffc0', '#ffffe0', '#ffffff', '#ffffff', '#ffffff', '#ffffff',
+    '#ffffff', '#ffffff', '#ffffff', '#ffffff',
+  ],
+  ocean: [
+    '#020a1a', '#041428', '#061e36', '#0a2844', '#0e3252', '#123c60', '#16466e', '#1a507c',
+    '#1e5a8a', '#226498', '#266ea6', '#2a78b4', '#2e82c2', '#328cd0', '#3696de', '#3aa0ec',
+    '#3eaae8', '#42b4e4', '#46bee0', '#4ac8dc', '#4fd2d8', '#53dcd4', '#57e6d0', '#5befcc',
+    '#5ff6c8', '#63ffc4', '#67ffc0', '#6bffbc', '#6fffB8', '#73ffb4', '#77ffb0', '#7bffac',
+    '#7fffA8', '#83ffa4', '#87ffa0', '#8bff9c',
+  ],
+  forest: [
+    '#020a02', '#041404', '#061e06', '#0a280a', '#0e320e', '#123c12', '#164616', '#1a501a',
+    '#1e5a1e', '#226422', '#266e26', '#2a782a', '#2e822e', '#328c32', '#369636', '#3aa03a',
+    '#3eaa3e', '#42b442', '#46be46', '#4ac84a', '#4fd24f', '#53dc53', '#57e657', '#5bf05b',
+    '#5ff65f', '#63ff63', '#67ff67', '#6bff6b', '#6fff6f', '#73ff73', '#77ff77', '#7bff7b',
+    '#7fff7f', '#83ff83', '#87ff87', '#8bff8b',
+  ],
+  purple: [
+    '#0a021a', '#140428', '#1e0636', '#280844', '#320a52', '#3c0c60', '#460e6e', '#50107c',
+    '#5a128a', '#641498', '#6e16a6', '#7818b4', '#821ac2', '#8c1cd0', '#961ede', '#a020ec',
+    '#aa22e8', '#b424e4', '#be26e0', '#c828dc', '#d22ad8', '#dc2cd4', '#e62ed0', '#f030cc',
+    '#f432c8', '#f834c4', '#fc36c0', '#ff38bc', '#ff3ab8', '#ff3cb4', '#ff3eb0', '#ff40ac',
+    '#ff42a8', '#ff44a4', '#ff46a0', '#ff489c',
+  ],
+  monochrome: [
+    '#0a0a0a', '#1a1a1a', '#2a2a2a', '#3a3a3a', '#4a4a4a', '#5a5a5a', '#6a6a6a', '#7a7a7a',
+    '#8a8a8a', '#9a9a9a', '#aaaaaa', '#bAbAbA', '#cacaca', '#dAdAdA', '#eaeaea', '#f4f4f4',
+    '#f8f8f8', '#fcfcfc', '#ffffff', '#ffffff', '#ffffff', '#ffffff', '#ffffff', '#ffffff',
+    '#ffffff', '#ffffff', '#ffffff', '#ffffff', '#ffffff', '#ffffff', '#ffffff', '#ffffff',
+    '#ffffff', '#ffffff', '#ffffff', '#ffffff',
+  ],
+};
 
 function getRgb(hex: string) {
   const r = parseInt(hex.slice(1, 3), 16);
@@ -22,19 +63,95 @@ function getRgb(hex: string) {
   return { r, g, b };
 }
 
-const rgbPalette = palette.map(getRgb);
+function getPalette(scheme: SplashColorScheme) {
+  return (PALETTES[scheme] ?? PALETTES.fire).map(getRgb);
+}
 
 function getChar(val: number) {
   const idx = Math.min(CHAR_RAMP.length - 1, Math.floor((val / (MAXV + 1)) * CHAR_RAMP.length));
   return CHAR_RAMP[idx];
 }
 
-export async function showSplash() {
+function initFire(cols: number, rows: number): Uint8Array {
+  return new Uint8Array(cols * rows);
+}
+
+function spreadFireClassic(fire: Uint8Array, cols: number, rows: number) {
+  for (let x = 0; x < cols; x++) {
+    fire[(rows - 1) * cols + x] = MAXV - Math.floor(Math.random() * 4);
+  }
+  for (let y = rows - 1; y >= 1; y--) {
+    for (let x = 0; x < cols; x++) {
+      const src = y * cols + x;
+      const val = fire[src];
+      if (val === 0) {
+        fire[(y - 1) * cols + x] = 0;
+        continue;
+      }
+      const decay = Math.floor(Math.random() * 3);
+      const drift = Math.floor(Math.random() * 3) - 1;
+      let nx = x + drift;
+      if (nx < 0) nx = 0; else if (nx >= cols) nx = cols - 1;
+      fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+    }
+  }
+}
+
+function spreadFireWave(fire: Uint8Array, cols: number, rows: number, time: number) {
+  for (let x = 0; x < cols; x++) {
+    const wave = Math.sin((x + time) * 0.3) * 0.5 + 0.5;
+    fire[(rows - 1) * cols + x] = Math.floor(MAXV * wave);
+  }
+  for (let y = rows - 1; y >= 1; y--) {
+    for (let x = 0; x < cols; x++) {
+      const src = y * cols + x;
+      const val = fire[src];
+      if (val === 0) {
+        fire[(y - 1) * cols + x] = 0;
+        continue;
+      }
+      const decay = Math.floor(Math.random() * 2);
+      const nx = x;
+      fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+    }
+  }
+}
+
+function spreadFireSparks(fire: Uint8Array, cols: number, rows: number) {
+  for (let x = 0; x < cols; x++) {
+    fire[(rows - 1) * cols + x] = Math.random() < 0.3 ? MAXV - Math.floor(Math.random() * 4) : 0;
+  }
+  for (let y = rows - 1; y >= 1; y--) {
+    for (let x = 0; x < cols; x++) {
+      const src = y * cols + x;
+      const val = fire[src];
+      if (val === 0) {
+        fire[(y - 1) * cols + x] = 0;
+        continue;
+      }
+      const decay = Math.floor(Math.random() * 4);
+      const drift = Math.floor(Math.random() * 5) - 2;
+      let nx = x + drift;
+      if (nx < 0) nx = 0; else if (nx >= cols) nx = cols - 1;
+      fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+    }
+  }
+}
+
+export async function showSplash(config?: SplashConfig): Promise<void> {
+  const enabled = config?.enabled ?? true;
+  if (!enabled) return;
+
+  const colorScheme = config?.colorScheme ?? 'fire';
+  const animation = config?.animation ?? 'classic';
+  const palette = getPalette(colorScheme);
+  const rgbPalette = palette.map(getRgb);
+
   const cols = 60;
   const rows = 15;
-  let fire = new Uint8Array(cols * rows);
+  let fire = initFire(cols, rows);
+  let time = 0;
 
-  // Clear screen
   process.stdout.write('\x1b[2J');
   const termRows = process.stdout.rows || 24;
   const termCols = process.stdout.columns || 80;
@@ -43,29 +160,16 @@ export async function showSplash() {
 
   return new Promise<void>((resolve) => {
     const interval = setInterval(() => {
-      // Bottom row heat
-      for (let x = 0; x < cols; x++) {
-        fire[(rows - 1) * cols + x] = MAXV - Math.floor(Math.random() * 4);
-      }
+      time++;
 
-      // Spread fire
-      for (let y = rows - 1; y >= 1; y--) {
-        for (let x = 0; x < cols; x++) {
-          const src = y * cols + x;
-          const val = fire[src];
-          if (val === 0) {
-            fire[(y - 1) * cols + x] = 0;
-            continue;
-          }
-          const decay = Math.floor(Math.random() * 3);
-          const drift = Math.floor(Math.random() * 3) - 1;
-          let nx = x + drift;
-          if (nx < 0) nx = 0; else if (nx >= cols) nx = cols - 1;
-          fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
-        }
+      if (animation === 'wave') {
+        spreadFireWave(fire, cols, rows, time);
+      } else if (animation === 'sparks') {
+        spreadFireSparks(fire, cols, rows);
+      } else {
+        spreadFireClassic(fire, cols, rows);
       }
 
-      // Draw
       let output = '';
       for (let i = 0; i < startRow; i++) output += '\n';
 
@@ -80,8 +184,7 @@ export async function showSplash() {
       }
       output += ' '.repeat(Math.max(0, startCol + (cols - 45) / 2)) + chalk.bold.white('🔥 pyre — system monitor (warming up sensors...)\n');
       output += ' '.repeat(Math.max(0, startCol + (cols - 25) / 2)) + chalk.dim('[Press Enter to continue]');
-      
-      // Clear viewport area and redraw
+
       process.stdout.write(`\x1b[H${output}`);
     }, 65);
 
@@ -96,7 +199,6 @@ export async function showSplash() {
     process.stdin.resume();
     process.stdin.on('data', onEnter);
 
-    // Auto-exit after 5s
     setTimeout(onEnter, 5000);
   });
-}
+}