pyre-cli 10.3.0 → 10.5.0

package/dist/menu-AJFGDLBP.js

@@ -0,0 +1,1233 @@
+import "./chunk-UF3XQ3R3.js";
+import {
+  THEMES,
+  fitVisible,
+  panel,
+  visLen
+} from "./chunk-XTOOEKLM.js";
+import "./chunk-ZLVIVFSO.js";
+import {
+  readConfig
+} from "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/menu/index.ts
+import readline from "readline";
+import { spawnSync } from "child_process";
+import chalk2 from "chalk";
+
+// src/menu/commands.ts
+var CATEGORIES = [
+  { id: "all", name: "All Tools", icon: "\u26A1", badge: "ALL" },
+  { id: "health", name: "Health & Diagnostics", icon: "\u{1FA7A}", badge: "HEALTH" },
+  { id: "dashboards", name: "Dashboards & Live", icon: "\u{1F4CA}", badge: "LIVE" },
+  { id: "performance", name: "Performance & Benchmarks", icon: "\u{1F680}", badge: "PERF" },
+  { id: "maintenance", name: "System & Maintenance", icon: "\u{1F9F9}", badge: "SYS" },
+  { id: "network", name: "Network & Remote", icon: "\u{1F310}", badge: "NET" },
+  { id: "config", name: "Config & Utilities", icon: "\u2699\uFE0F", badge: "CFG" }
+];
+var ALL_COMMANDS = [
+  // --- Dashboards & Live ---
+  {
+    id: "live",
+    name: "Live Dashboard",
+    cli: "pyre live",
+    category: "dashboards",
+    badge: "LIVE",
+    description: "Interactive full-screen terminal dashboard with real-time graphs and telemetry",
+    detailedHelp: "Launches Pyre's signature full-terminal dashboard. Displays live sparklines for CPU/GPU/memory/network, Apple Silicon cluster telemetry, process tree, custom themes, and continuous CSV logging.",
+    tags: ["dashboard", "live", "monitor", "graph", "realtime", "cpu", "memory", "top", "htop"],
+    interactive: true,
+    flags: [
+      { flag: "--interval <sec>", desc: "Refresh interval (default: 2s)" },
+      { flag: "--theme <name>", desc: "Color theme (dracula, cyberpunk, nord, gruvbox)" },
+      { flag: "--detailed", desc: "Include powermetrics per-core sensors" },
+      { flag: "--log", desc: "Start continuous CSV logging immediately" },
+      { flag: "--tree", desc: "Show process hierarchy tree view" }
+    ],
+    examples: ["pyre live", "pyre live --interval 1 --theme dracula", "pyre live --detailed"]
+  },
+  {
+    id: "ui",
+    name: "Activity Monitor UI Window",
+    cli: "pyre ui",
+    category: "dashboards",
+    badge: "GUI",
+    description: "Launch native desktop window with real-time charts and process inspector",
+    detailedHelp: "Opens Pyre's native graphical desktop dashboard. Provides click-to-inspect process tree, live charts, dark mode, and compact widget mode.",
+    tags: ["gui", "window", "native", "desktop", "activity monitor", "widget"],
+    interactive: true,
+    flags: [
+      { flag: "--compact", desc: "Launch in minimalist compact widget mode" },
+      { flag: "--ontop", desc: "Keep window always on top of other apps" }
+    ],
+    examples: ["pyre ui", "pyre ui --compact", "pyre ui --ontop"]
+  },
+  {
+    id: "web",
+    name: "Web Dashboard Server",
+    cli: "pyre web",
+    category: "dashboards",
+    badge: "WEB",
+    description: "Serve an auto-refreshing live web portal with SSE streams and REST endpoints",
+    detailedHelp: "Starts a high-performance web dashboard accessible from your browser or mobile device on the same local network. Includes charts, process manager, and remote settings.",
+    tags: ["web", "browser", "server", "http", "sse", "mobile", "lan"],
+    interactive: true,
+    flags: [
+      { flag: "--port <port>", desc: "HTTP port number (default: 3000)" },
+      { flag: "--lan", desc: "Expose to Wi-Fi / local network" },
+      { flag: "--no-lan", desc: "Bind to localhost only" },
+      { flag: "--install", desc: "Install as background launchd / system service" }
+    ],
+    examples: ["pyre web", "pyre web --port 8080 --lan"]
+  },
+  {
+    id: "pipe",
+    name: "JSON Stream Pipe",
+    cli: "pyre pipe",
+    category: "dashboards",
+    badge: "PIPE",
+    description: "Continuous newline-delimited JSON stream for scripting and automation",
+    detailedHelp: "Emits a steady NDJSON (newline-delimited JSON) stream of system metrics to stdout. Ideal for piping into jq, Logstash, Vector, or custom scripts.",
+    tags: ["pipe", "json", "ndjson", "stream", "stdout", "scripting"],
+    flags: [
+      { flag: "--interval <sec>", desc: "Sampling interval (default: 1s)" },
+      { flag: "--detailed", desc: "Include full sensor readings" }
+    ],
+    examples: ["pyre pipe | jq .cpu", "pyre pipe --interval 5"]
+  },
+  {
+    id: "replay",
+    name: "Session Log Replay",
+    cli: "pyre replay",
+    category: "dashboards",
+    badge: "REPLAY",
+    description: "Play back a historical CSV log file inside the interactive TUI",
+    detailedHelp: "Replays previously recorded Pyre CSV sessions with controllable speed multiplier, play/pause controls, and time seeking.",
+    tags: ["replay", "log", "csv", "playback", "history"],
+    interactive: true,
+    requiresArgs: {
+      prompt: "Enter path to Pyre CSV log file:",
+      placeholder: "./pyre-exports/pyre-log-....csv",
+      defaultVal: "./pyre-exports"
+    },
+    flags: [
+      { flag: "--speed <n>", desc: "Playback speed multiplier (e.g. 2, 0.5)" },
+      { flag: "--plain", desc: "Plain text output without ANSI colors" }
+    ],
+    examples: ["pyre replay session.csv", "pyre replay session.csv --speed 2"]
+  },
+  {
+    id: "fleet",
+    name: "Fleet Monitor",
+    cli: "pyre fleet",
+    category: "dashboards",
+    badge: "FLEET",
+    description: "Multi-host live dashboard monitoring multiple servers simultaneously",
+    detailedHelp: "Combines telemetry streams from multiple machines over SSH or P2P into a unified multi-node dashboard.",
+    tags: ["fleet", "cluster", "multi-host", "servers", "ssh", "remote"],
+    interactive: true,
+    requiresArgs: {
+      prompt: "Enter host list (space-separated, e.g. user@host1 user@host2):",
+      placeholder: "user@server1.local user@server2.local",
+      defaultVal: "localhost"
+    },
+    examples: ["pyre fleet server1 server2 server3"]
+  },
+  {
+    id: "ssh",
+    name: "SSH Remote Stream",
+    cli: "pyre ssh",
+    category: "dashboards",
+    badge: "SSH",
+    description: "Stream live stats from a remote host securely over SSH",
+    detailedHelp: "Connects to a remote server via SSH, runs Pyre on the remote machine (or streams lightweight metrics), and visualizes it locally.",
+    tags: ["ssh", "remote", "stream", "server", "linux"],
+    interactive: true,
+    requiresArgs: {
+      prompt: "Enter SSH remote host (e.g. user@hostname):",
+      placeholder: "user@myserver.com"
+    },
+    examples: ["pyre ssh user@myserver.com"]
+  },
+  {
+    id: "containers",
+    name: "Container Telemetry",
+    cli: "pyre containers",
+    category: "dashboards",
+    badge: "CTNR",
+    description: "Inspect CPU, memory limits, and network I/O of Docker and Podman containers",
+    detailedHelp: "Queries active Docker, Podman, or OrbStack containers and reports container IDs, names, images, CPU percentage, memory usage against host limits, and network throughput.",
+    tags: ["containers", "docker", "podman", "orbstack", "cgroups", "microvm"],
+    examples: ["pyre containers", "pyre containers --json"]
+  },
+  // --- Health & Diagnostics ---
+  {
+    id: "check",
+    name: "System Health Check",
+    cli: "pyre check",
+    category: "health",
+    badge: "CHECK",
+    description: "One-line plain-English instant health and thermal check",
+    detailedHelp: "Performs an instant health audit of CPU load, memory pressure, thermals, battery, and storage. Returns green/yellow/red status with plain-English summary.",
+    tags: ["health", "check", "status", "quick", "summary", "temperature", "alert"],
+    flags: [
+      { flag: "--detailed", desc: "Include full sensor table in output" },
+      { flag: "--exit-code", desc: "Exit with non-zero status code if warnings/alerts are active (for CI/CD)" }
+    ],
+    examples: ["pyre check", "pyre check --detailed", "pyre check --exit-code"]
+  },
+  {
+    id: "doctor",
+    name: "Doctor Diagnostics",
+    cli: "pyre doctor",
+    category: "health",
+    badge: "DIAG",
+    description: "Comprehensive system diagnostic audit (SIP, sensors, permissions, battery)",
+    detailedHelp: "Audits hardware sensors, sudo powermetrics permissions, Apple Silicon SMC accessibility, System Integrity Protection (SIP), thermal pressure, and disk health.",
+    tags: ["doctor", "diagnostics", "audit", "permissions", "sip", "sensors", "troubleshoot"],
+    flags: [
+      { flag: "--plain", desc: "Output in plain accessible text" }
+    ],
+    examples: ["pyre doctor", "pyre doctor --plain"]
+  },
+  {
+    id: "smart",
+    name: "S.M.A.R.T. Disk Health",
+    cli: "pyre smart",
+    category: "health",
+    badge: "DISK",
+    description: "Read S.M.A.R.T. telemetry, SSD wear levels, and drive health indicators",
+    detailedHelp: "Queries physical drives via smartctl/NVMe telemetry. Reports remaining spare capacity, drive temperatures, wear percentage, read/write error counts, and failure warnings.",
+    tags: ["smart", "disk", "ssd", "nvme", "health", "storage", "hardware", "drive"],
+    examples: ["pyre smart"]
+  },
+  {
+    id: "anomalies",
+    name: "Anomaly Detection",
+    cli: "pyre anomalies",
+    category: "health",
+    badge: "ANOMALY",
+    description: "Detect z-score statistical resource spikes and unexpected system behaviors",
+    detailedHelp: "Analyzes historical metric logs using statistical z-score models. Identifies runaway background processes, memory leaks, thermal throttles, and abnormal network bursts.",
+    tags: ["anomalies", "zscore", "spikes", "leaks", "statistical", "digest", "history"],
+    flags: [
+      { flag: "--since <range>", desc: "Time range to analyze (default: 7d, e.g. 1d, 3d, 14d)" },
+      { flag: "--export-dir <dir>", desc: "Directory containing historical log files" }
+    ],
+    examples: ["pyre anomalies", "pyre anomalies --since 1d", "pyre anomalies --since 7d"]
+  },
+  {
+    id: "explain",
+    name: "AI Anomaly Explanation",
+    cli: "pyre explain",
+    category: "health",
+    badge: "AI",
+    description: "Plain-English AI diagnosis and remedy recommendations for detected anomalies",
+    detailedHelp: "Feeds detected performance anomalies into a local or cloud LLM (builtin zero-setup rules engine, Ollama, or OpenAI). Explains causes in plain English with concrete fix suggestions.",
+    tags: ["ai", "explain", "llm", "ollama", "openai", "diagnose", "remedy"],
+    flags: [
+      { flag: "--llm-backend <bkg>", desc: "Backend: builtin (zero-setup), ollama, or openai" },
+      { flag: "--llm-model <model>", desc: "Model name (e.g. llama3.2, gpt-4o-mini)" },
+      { flag: "--api-key <key>", desc: "OpenAI API key (or set OPENAI_API_KEY env)" },
+      { flag: "--since <range>", desc: "Time range for anomaly digestion (default: 7d)" }
+    ],
+    examples: ["pyre explain", "pyre explain --llm-backend ollama --llm-model llama3.2"]
+  },
+  {
+    id: "alert-test",
+    name: "Test Alert Notification",
+    cli: "pyre alert test",
+    category: "health",
+    badge: "ALERT",
+    description: "Send test notifications to Slack, Discord, Pushover, and ntfy.sh",
+    detailedHelp: "Dispatches a test notification through all configured webhook and push notification channels to verify that alert webhooks are functioning properly.",
+    tags: ["alert", "notification", "slack", "discord", "pushover", "ntfy", "test", "webhook"],
+    flags: [
+      { flag: "--alert-slack <url>", desc: "Test a Slack webhook URL" },
+      { flag: "--alert-discord <url>", desc: "Test a Discord webhook URL" },
+      { flag: "--alert-ntfy <url>", desc: "Test an ntfy.sh topic URL" }
+    ],
+    examples: ["pyre alert test"]
+  },
+  {
+    id: "flight",
+    name: "Forensic Flight Recorder",
+    cli: "pyre flight",
+    category: "health",
+    badge: "BLACKBOX",
+    description: "In-memory black box recording recent telemetry for post-mortem analysis",
+    detailedHelp: "Maintains a rolling circular buffer of high-resolution telemetry in RAM. Generates forensic reports showing peak CPU, memory, and top runaway processes leading up to a system freeze or crash.",
+    tags: ["flight", "blackbox", "forensic", "dump", "crash", "freeze", "ram"],
+    flags: [
+      { flag: "dump", desc: "Generate post-mortem forensic report file" },
+      { flag: "status", desc: "Display active buffer frames and RAM footprint" },
+      { flag: "record", desc: "Record fresh frames for a duration" }
+    ],
+    examples: ["pyre flight dump", "pyre flight status", "pyre flight record --duration 30"]
+  },
+  {
+    id: "inspect",
+    name: "Process Deep-Dive Inspector",
+    cli: "pyre inspect",
+    category: "health",
+    badge: "PROC",
+    description: "Inspect open file handles (lsof), active sockets, threads, and adjust nice priority",
+    detailedHelp: "Examines low-level process attributes for any PID: open files, network sockets, parent hierarchy, memory RSS, and allows dynamic priority adjustment via renice.",
+    tags: ["inspect", "lsof", "sockets", "files", "nice", "renice", "priority", "pid"],
+    requiresArgs: {
+      prompt: "Enter PID to inspect:",
+      placeholder: "1234"
+    },
+    flags: [
+      { flag: "--nice <val>", desc: "Adjust nice priority (-20 to 19)" },
+      { flag: "--json", desc: "Output details in structured JSON" }
+    ],
+    examples: ["pyre inspect 1234", "pyre inspect 1234 --nice 10"]
+  },
+  // --- Performance & Benchmarks ---
+  {
+    id: "benchmark",
+    name: "CPU Benchmark",
+    cli: "pyre benchmark",
+    category: "performance",
+    badge: "BENCH",
+    description: "Run standard 1-minute CPU benchmark calculating digits of PI",
+    detailedHelp: "Executes a multi-threaded compute benchmark calculating digits of Pi. Measures floating-point and integer performance, thermal climb, power wattage, and gives a standardized score.",
+    tags: ["benchmark", "cpu", "pi", "performance", "speed", "score", "stress"],
+    examples: ["pyre benchmark"]
+  },
+  {
+    id: "bench",
+    name: "Command Execution Benchmark",
+    cli: "pyre bench",
+    category: "performance",
+    badge: "BENCH",
+    description: "Profile execution time, CPU, memory, power draw, and real kWh cost of any command",
+    detailedHelp: "Wraps any shell command and monitors its full lifecycle: execution time, peak memory, average CPU, total joules consumed, and estimated electrical cost in dollars/kWh.",
+    tags: ["bench", "profile", "energy", "power", "kwh", "cost", "command", "exec"],
+    requiresArgs: {
+      prompt: "Enter shell command to benchmark (e.g. npm test):",
+      placeholder: "npm test",
+      defaultVal: "ls -la"
+    },
+    examples: ['pyre bench "npm run build"', 'pyre bench "cargo build --release"']
+  },
+  {
+    id: "stress",
+    name: "System Stress Test",
+    cli: "pyre stress",
+    category: "performance",
+    badge: "LOAD",
+    description: "Synthetic multi-threaded CPU load generator to test cooling and stability",
+    detailedHelp: "Spawns worker threads to saturate all CPU cores. Ideal for testing cooling efficiency, fan curves, thermal throttling thresholds, and power supply stability.",
+    tags: ["stress", "load", "burnin", "thermal", "cooling", "fans", "throttle"],
+    flags: [
+      { flag: "-d, --duration <sec>", desc: "Duration in seconds (default: 30s)" },
+      { flag: "--cores <n>", desc: "Number of worker threads (default: all cores)" }
+    ],
+    examples: ["pyre stress --duration 10", "pyre stress --duration 60 --cores 8"]
+  },
+  {
+    id: "profile-proc",
+    name: "Process Call-Tree Profiler",
+    cli: "pyre profile-proc",
+    category: "performance",
+    badge: "PROF",
+    description: "CPU call-tree profiler and hot function sampler for any running PID",
+    detailedHelp: "Attaches to a running process and takes stack trace samples to pinpoint CPU hotspots, spin-locks, and slow function call chains.",
+    tags: ["profile-proc", "profiler", "sampling", "calltree", "hotspots", "stacktrace", "pid"],
+    requiresArgs: {
+      prompt: "Enter PID to profile:",
+      placeholder: "1234"
+    },
+    flags: [
+      { flag: "-d, --duration <sec>", desc: "Sampling duration in seconds (default: 5s)" },
+      { flag: "--raw", desc: "Output unparsed profiler raw text" }
+    ],
+    examples: ["pyre profile-proc 1234", "pyre profile-proc 1234 --duration 10"]
+  },
+  {
+    id: "run",
+    name: "Performance Budgeting Runner",
+    cli: "pyre run",
+    category: "performance",
+    badge: "GATE",
+    description: "Execute command and enforce CPU, memory, or runtime ceilings for CI/CD gates",
+    detailedHelp: "Wraps any shell command and monitors its full execution lifecycle. Enforces performance ceilings (--budget-cpu, --budget-mem, --budget-time), exiting non-zero if limits are breached. Perfect for regression testing in CI.",
+    tags: ["run", "budget", "ci", "gate", "threshold", "ceiling", "benchmark"],
+    requiresArgs: {
+      prompt: "Enter command to run with budget (e.g. --budget-time 10 -- ls -la):",
+      placeholder: "--budget-cpu 80 -- ls -la",
+      defaultVal: "--budget-cpu 90 -- ls -la"
+    },
+    flags: [
+      { flag: "--budget-cpu <pct>", desc: "Maximum allowable peak CPU %" },
+      { flag: "--budget-mem <bytes>", desc: "Maximum allowable peak memory (e.g. 500MB, 2GB)" },
+      { flag: "--budget-time <sec>", desc: "Maximum allowable duration in seconds" },
+      { flag: "--markdown", desc: "Output formatted markdown report" }
+    ],
+    examples: ["pyre run --budget-time 30 -- npm test", "pyre run --budget-mem 1GB --budget-cpu 80 -- make"]
+  },
+  {
+    id: "bench-git",
+    name: "Git Branch Benchmark Differ",
+    cli: "pyre bench-git",
+    category: "performance",
+    badge: "GIT",
+    description: "Benchmark a command across two git branches and compute percentage deltas",
+    detailedHelp: "Checks out branch A, measures duration, memory, and CPU usage, checks out branch B, measures again, and outputs a formatted side-by-side comparison with green/red regression indicators.",
+    tags: ["bench-git", "git", "branch", "compare", "delta", "regression", "diff"],
+    requiresArgs: {
+      prompt: 'Enter branchA branchB "command":',
+      placeholder: 'main feature "npm test"',
+      defaultVal: 'main HEAD "npm test"'
+    },
+    examples: ['pyre bench-git main feature "npm test"']
+  },
+  // --- System & Maintenance ---
+  {
+    id: "optimize",
+    name: "Mac & System Optimizer",
+    cli: "pyre optimize",
+    category: "maintenance",
+    badge: "CLEAN",
+    description: "Mac optimizer: quit idle apps, purge memory, clean caches, empty trash",
+    detailedHelp: "Intelligently manages system resources: discovers foreground apps idle for hours and gracefully terminates them, flushes inactive memory caches, cleans build artifacts, and purges DNS caches.",
+    tags: ["optimize", "clean", "idle", "memory", "caches", "trash", "purge", "mac"],
+    flags: [
+      { flag: "apps", desc: "Quit long-idle background applications" },
+      { flag: "memory", desc: "Purge inactive memory pages" },
+      { flag: "caches", desc: "Clean system & user application cache files" },
+      { flag: "trash", desc: "Safely empty user Trash" },
+      { flag: "dns", desc: "Flush local DNS resolver cache" },
+      { flag: "--idle <dur>", desc: "Idle time threshold (e.g. 30m, 2h)" },
+      { flag: "-y, --yes", desc: "Skip interactive confirmation prompt" }
+    ],
+    examples: ["pyre optimize apps", "pyre optimize memory", "pyre optimize caches", "pyre optimize dns"]
+  },
+  {
+    id: "brew",
+    name: "Package Manager Health",
+    cli: "pyre brew",
+    category: "maintenance",
+    badge: "PKGS",
+    description: "Package manager health panel (Homebrew, apt, pacman, winget)",
+    detailedHelp: "Checks outdated packages, broken symlinks, orphaned dependencies, disk footprint of installed packages, and cache usage for Homebrew, apt, pacman, or winget.",
+    tags: ["brew", "homebrew", "apt", "packages", "outdated", "clean", "disk", "winget"],
+    examples: ["pyre brew"]
+  },
+  {
+    id: "extensions",
+    name: "System Extensions & Drivers",
+    cli: "pyre extensions",
+    category: "maintenance",
+    badge: "DRVR",
+    description: "Inspect active macOS system extensions, network filters, and endpoint drivers",
+    detailedHelp: "Scans driver extensions, network filter extensions, and endpoint security agents (CrowdStrike, SentinelOne, Little Snitch, VPNs) for performance impacts.",
+    tags: ["extensions", "drivers", "kext", "security", "antivirus", "filter", "macos"],
+    examples: ["pyre extensions"]
+  },
+  {
+    id: "watchdog",
+    name: "Autonomous Watchdog Daemon",
+    cli: "pyre watchdog",
+    category: "maintenance",
+    badge: "DAEMON",
+    description: "Autonomous background daemon enforcing memory limits and auto-killing rogues",
+    detailedHelp: "Runs a background rule engine that watches for run-away processes exceeding CPU or memory limits, dispatches alert notifications, and optionally terminates offenders.",
+    tags: ["watchdog", "daemon", "rules", "kill", "limits", "autonomous", "protect"],
+    flags: [
+      { flag: "--watchdog-config <file>", desc: "Path to custom rules JSON" },
+      { flag: "--dry-run", desc: "Simulate rules without executing kills" },
+      { flag: "--interval <sec>", desc: "Polling interval in seconds" }
+    ],
+    examples: ["pyre watchdog --dry-run", "pyre watchdog"]
+  },
+  {
+    id: "build",
+    name: "Compiler & Build Tracker",
+    cli: "pyre build",
+    category: "maintenance",
+    badge: "BUILD",
+    description: "Track active build systems (Xcode, cargo, clang, rustc, webpack, go)",
+    detailedHelp: "Detects active build processes across the system, monitors parallel compiler thread usage, CPU load, and estimated build completion.",
+    tags: ["build", "compile", "xcode", "cargo", "clang", "rustc", "webpack", "ninja"],
+    flags: [
+      { flag: "--json", desc: "Output build data as JSON" }
+    ],
+    examples: ["pyre build"]
+  },
+  {
+    id: "update",
+    name: "Check for Updates",
+    cli: "pyre update",
+    category: "maintenance",
+    badge: "UPD",
+    description: "Check for Pyre CLI updates from npm and GitHub releases",
+    detailedHelp: "Queries the registry to compare the running version with the latest release, showing change highlights and one-line upgrade commands.",
+    tags: ["update", "upgrade", "version", "npm", "new"],
+    examples: ["pyre update"]
+  },
+  {
+    id: "playbook",
+    name: "Macro Recipes & Playbooks",
+    cli: "pyre playbook",
+    category: "maintenance",
+    badge: "RECIPE",
+    description: "Execute sequenced multi-step audit, benchmark, or maintenance playbooks",
+    detailedHelp: "Runs pre-configured or custom multi-step Pyre sequences with progress reporting. Includes built-in recipes: audit (health+doctor+smart+brew), clean (optimize apps+mem+caches+dns), and triage (anomalies+netusage+extensions).",
+    tags: ["playbook", "recipe", "macro", "sequence", "audit", "clean", "triage"],
+    flags: [
+      { flag: "list", desc: "List all available playbooks" },
+      { flag: "run <id>", desc: "Run a playbook (audit, clean, triage, bench)" }
+    ],
+    examples: ["pyre playbook list", "pyre playbook run audit", "pyre playbook run clean"]
+  },
+  // --- Network & Remote ---
+  {
+    id: "netusage",
+    name: "Application Network Usage",
+    cli: "pyre netusage",
+    category: "network",
+    badge: "NET",
+    description: "Real-time per-application network bandwidth and socket connection breakdown",
+    detailedHelp: "Attributes active network throughput to individual running applications and processes. Shows upload/download rates, open sockets, and remote IP addresses.",
+    tags: ["netusage", "network", "bandwidth", "sockets", "rx", "tx", "apps", "connections"],
+    flags: [
+      { flag: "--top <n>", desc: "Number of top processes to show (default: 15)" },
+      { flag: "--sort <rx|tx|total>", desc: "Sort by download, upload, or total" },
+      { flag: "--json", desc: "Output in structured JSON" }
+    ],
+    examples: ["pyre netusage", "pyre netusage --top 10 --sort rx"]
+  },
+  {
+    id: "topo",
+    name: "Network Topology & Peer Discovery",
+    cli: "pyre topo",
+    category: "network",
+    badge: "TOPO",
+    description: "Map local network neighbors, gateways, and discover Pyre P2P peers",
+    detailedHelp: "Scans the local subnet for active devices, routers, access points, and peer Pyre instances broadcasting live metrics.",
+    tags: ["topo", "topology", "lan", "arp", "discovery", "mesh", "peers", "scanner"],
+    flags: [
+      { flag: "--scan", desc: "Perform active network sweep on LAN neighbors" },
+      { flag: "--json", desc: "Output topology as JSON" }
+    ],
+    examples: ["pyre topo", "pyre topo --scan"]
+  },
+  {
+    id: "p2p",
+    name: "P2P Mesh Streaming",
+    cli: "pyre p2p",
+    category: "network",
+    badge: "P2P",
+    description: "Encrypted peer-to-peer real-time metrics streaming between two systems over TCP/TLS",
+    detailedHelp: "Enables real-time system monitoring over local networks without requiring cloud relays. One machine runs `server` while the second connects as `client`.",
+    tags: ["p2p", "mesh", "tcp", "tls", "stream", "remote", "peer"],
+    flags: [
+      { flag: "server", desc: "Start streaming server on this machine" },
+      { flag: "connect", desc: "Connect to remote server instance" },
+      { flag: "--p2p-port <port>", desc: "Port number (default: 9876)" },
+      { flag: "--p2p-password <pwd>", desc: "Shared authentication password" },
+      { flag: "--p2p-tls", desc: "Enable TLS encryption" }
+    ],
+    examples: ["pyre server", "pyre p2p server --p2p-password secret", "pyre p2p connect --p2p-host 192.168.1.10 --p2p-password secret"]
+  },
+  {
+    id: "server",
+    name: "P2P Quick Setup Helper",
+    cli: "pyre server",
+    category: "network",
+    badge: "P2P",
+    description: "Generate copy-paste ready commands for P2P server and client connection",
+    detailedHelp: "Detects the local IP address, generates a cryptographically secure random session password, and prints exact commands to run on both machines.",
+    tags: ["server", "p2p", "helper", "quickstart", "connect"],
+    examples: ["pyre server"]
+  },
+  {
+    id: "serve",
+    name: "REST API Server",
+    cli: "pyre serve",
+    category: "network",
+    badge: "API",
+    description: "Lightweight structured JSON REST API server for external scrapers",
+    detailedHelp: "Runs a headless HTTP daemon providing JSON endpoints (`/api/stats`, `/api/health`, `/api/processes`) for custom integrations, Grafana, or monitoring tools.",
+    tags: ["serve", "rest", "api", "http", "json", "endpoints"],
+    flags: [
+      { flag: "--port <port>", desc: "Port number (default: 8080)" },
+      { flag: "--api-key <key>", desc: "Require Bearer API key authentication" },
+      { flag: "--detailed", desc: "Include full sensor readings in API responses" }
+    ],
+    examples: ["pyre serve --port 8080"]
+  },
+  {
+    id: "prometheus",
+    name: "Prometheus Exporter",
+    cli: "pyre prometheus",
+    category: "network",
+    badge: "PROM",
+    description: "Start standard Prometheus metrics exporter on localhost:9090",
+    detailedHelp: "Exposes Pyre metrics at `/metrics` formatted for Prometheus, Grafana, Datadog, and OpenTelemetry collectors.",
+    tags: ["prometheus", "grafana", "metrics", "exporter", "opentelemetry"],
+    flags: [
+      { flag: "--prometheus-port <port>", desc: "Port number (default: 9090)" },
+      { flag: "--interval <sec>", desc: "Scrape collection interval (default: 15s)" }
+    ],
+    examples: ["pyre prometheus", "pyre prometheus --prometheus-port 9100"]
+  },
+  // --- Configuration & Utilities ---
+  {
+    id: "info",
+    name: "Hardware Summary",
+    cli: "pyre info",
+    category: "config",
+    badge: "INFO",
+    description: "Concise summary of CPU architecture, memory, GPU, and OS build",
+    detailedHelp: "Prints a clean overview of processor brand, core configuration (Performance vs Efficiency cores), RAM speed, GPU adapter, and kernel release.",
+    tags: ["info", "hardware", "specs", "system", "cpu", "ram", "gpu", "os"],
+    examples: ["pyre info"]
+  },
+  {
+    id: "history",
+    name: "Historical Resource Trends",
+    cli: "pyre history",
+    category: "config",
+    badge: "HIST",
+    description: "Graph historical resource trends from recorded CSV logs",
+    detailedHelp: "Parses logged CSV telemetry files and displays multi-day terminal trend graphs for CPU, memory, and thermal levels.",
+    tags: ["history", "trends", "csv", "graph", "days", "analytics"],
+    flags: [
+      { flag: "--days <n>", desc: "Number of days to analyze (default: 7)" }
+    ],
+    examples: ["pyre history", "pyre history --days 14"]
+  },
+  {
+    id: "diff",
+    name: "Snapshot Side-by-Side Diff",
+    cli: "pyre diff",
+    category: "config",
+    badge: "DIFF",
+    description: "Compare two saved snapshot JSON files side-by-side",
+    detailedHelp: "Highlights system state changes between two points in time (e.g. before and after running a build or benchmark): process differences, memory shifts, and disk deltas.",
+    tags: ["diff", "compare", "snapshots", "deltas", "json"],
+    requiresArgs: {
+      prompt: "Enter two snapshot JSON file paths (file1 file2):",
+      placeholder: "snap1.json snap2.json"
+    },
+    examples: ["pyre diff snap1.json snap2.json"]
+  },
+  {
+    id: "config",
+    name: "Persistent Configuration",
+    cli: "pyre config",
+    category: "config",
+    badge: "CFG",
+    description: "View or reset persistent ~/.config/pyre/config.json settings",
+    detailedHelp: "Displays all stored user preferences: active theme, refresh rates, alert thresholds, webhook URLs, default launch mode, and panel visibility.",
+    tags: ["config", "settings", "defaults", "preferences", "reset", "json"],
+    flags: [
+      { flag: "show", desc: "Display current config JSON" },
+      { flag: "reset", desc: "Reset all settings to factory defaults" }
+    ],
+    examples: ["pyre config show", "pyre config reset"]
+  },
+  {
+    id: "profile",
+    name: "Config Profiles",
+    cli: "pyre profile",
+    category: "config",
+    badge: "PROF",
+    description: "Save, load, and manage atomic configuration profiles",
+    detailedHelp: 'Switch effortlessly between specialized monitoring setups (e.g. "gaming", "server", "coding", "minimal") by saving and loading named profiles.',
+    tags: ["profile", "presets", "save", "load", "switch", "themes"],
+    flags: [
+      { flag: "list", desc: "List all saved profiles" },
+      { flag: "save <name>", desc: "Save current state as a new profile" },
+      { flag: "load <name>", desc: "Activate an existing profile" }
+    ],
+    examples: ["pyre profile list", "pyre profile save coding", "pyre profile load coding"]
+  },
+  {
+    id: "sync",
+    name: "Cloud Profile Sync",
+    cli: "pyre sync",
+    category: "config",
+    badge: "SYNC",
+    description: "Synchronize config profiles across multiple Macs via iCloud/Drive/Firebase",
+    detailedHelp: "Synchronizes your custom themes, bookmarks, and alert rules across multiple workstations using iCloud Drive, Dropbox, or Firebase Firestore.",
+    tags: ["sync", "cloud", "icloud", "drive", "firebase", "workstations"],
+    flags: [
+      { flag: "status", desc: "Check synchronization state" },
+      { flag: "push", desc: "Upload local configuration to cloud" },
+      { flag: "pull", desc: "Download configuration from cloud" },
+      { flag: "--sync-dir <dir>", desc: "Custom cloud folder path" }
+    ],
+    examples: ["pyre sync status", "pyre sync push", "pyre sync pull"]
+  },
+  {
+    id: "blender",
+    name: "Blender Render Tracker",
+    cli: "pyre blender",
+    category: "config",
+    badge: "3D",
+    description: "Track active Blender 3D render jobs, frame progress, and engines",
+    detailedHelp: "Auto-detects active Blender render instances, displaying current frame number, total frames, rendering engine (Cycles/Eevee), and elapsed time.",
+    tags: ["blender", "render", "3d", "cycles", "eevee", "frames", "gpu"],
+    examples: ["pyre blender"]
+  },
+  {
+    id: "xbar",
+    name: "Menu Bar Plugin Generator",
+    cli: "pyre xbar",
+    category: "config",
+    badge: "MENU",
+    description: "Generate an xbar / SwiftBar macOS menu bar plugin script",
+    detailedHelp: "Creates a lightweight script that lives in your macOS menu bar, showing glanceable live CPU/memory stats and thermal warnings.",
+    tags: ["xbar", "swiftbar", "menubar", "macos", "plugin", "tray"],
+    examples: ["pyre xbar"]
+  },
+  {
+    id: "completions",
+    name: "Shell Auto-Completions",
+    cli: "pyre completions",
+    category: "config",
+    badge: "SHELL",
+    description: "Generate shell auto-completion scripts (zsh, bash, fish, PowerShell)",
+    detailedHelp: "Outputs full tab-completion scripts for your favorite shell, enabling instant command and flag autocomplete.",
+    tags: ["completions", "shell", "zsh", "bash", "fish", "powershell", "autocomplete"],
+    requiresArgs: {
+      prompt: "Select shell (zsh, bash, fish, powershell):",
+      placeholder: "zsh",
+      defaultVal: "zsh"
+    },
+    examples: ["pyre completions zsh", "pyre completions fish", "pyre completions bash"]
+  },
+  {
+    id: "statusline",
+    name: "Headless Terminal Statusline",
+    cli: "pyre statusline",
+    category: "config",
+    badge: "STATUS",
+    description: "Ultra-fast telemetry string for Tmux, Starship prompt, Waybar, or Neovim",
+    detailedHelp: "Emits sub-millisecond status strings formatted for Tmux status-right, Starship shell prompt, Pango markup (Waybar/Polybar), or minimal JSON for Neovim lualine.",
+    tags: ["statusline", "tmux", "starship", "waybar", "polybar", "neovim", "prompt"],
+    flags: [
+      { flag: "--format tmux", desc: "Format with Tmux color codes" },
+      { flag: "--format starship", desc: "Plain formatted string for Starship" },
+      { flag: "--format json", desc: "Raw minimal JSON object" },
+      { flag: "--format pango", desc: "Pango XML for Waybar and Polybar" }
+    ],
+    examples: ["pyre statusline --format tmux", "pyre statusline --format starship", "pyre statusline --format json"]
+  }
+];
+function filterCommands(commands, category, query) {
+  let list = commands;
+  if (category !== "all") {
+    list = list.filter((c) => c.category === category);
+  }
+  const q = query.trim().toLowerCase();
+  if (!q) {
+    return list;
+  }
+  return list.map((cmd) => {
+    let score = 0;
+    const id = cmd.id.toLowerCase();
+    const cli = cmd.cli.toLowerCase();
+    const name = cmd.name.toLowerCase();
+    const desc = cmd.description.toLowerCase();
+    if (id === q || cli === q) score += 100;
+    else if (id.startsWith(q) || cli.startsWith(q)) score += 50;
+    else if (name.toLowerCase().includes(q)) score += 30;
+    else if (cmd.tags.some((t) => t.toLowerCase() === q)) score += 40;
+    else if (cmd.tags.some((t) => t.toLowerCase().includes(q))) score += 20;
+    else if (desc.includes(q)) score += 10;
+    else if (cmd.detailedHelp.toLowerCase().includes(q)) score += 5;
+    return { cmd, score };
+  }).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).map((item) => item.cmd);
+}
+
+// src/menu/render.ts
+import chalk from "chalk";
+function renderMenuScreen(state, filteredCommands) {
+  const width = Math.max(60, state.termWidth || 80);
+  const height = Math.max(16, state.termHeight || 24);
+  const theme = THEMES[state.theme] || THEMES.default;
+  const accent = theme.cpu || chalk.cyan;
+  const border = theme.border || chalk.dim;
+  const highlight = theme.graphs || chalk.hex("#ff6a39");
+  const lines = [];
+  const title = ` \u{1F525} pyre \u2014 Command Center & Tools Navigator `;
+  const headerLeft = accent(chalk.bold(title));
+  const headerRight = chalk.dim(`[?] Help  [q] Quit  `);
+  const topBarInner = headerLeft + "\u2500".repeat(Math.max(0, width - visLen(title) - visLen(headerRight) - 2)) + headerRight;
+  lines.push(border("\u256D") + topBarInner + border("\u256E"));
+  const subtitle = " Browse, search and execute all 38 pyre commands without memorization";
+  lines.push(border("\u2502") + fitVisible(chalk.dim(subtitle), width - 2) + border("\u2502"));
+  let searchInput = state.searchQuery;
+  if (state.inputMode === "search") {
+    searchInput += chalk.bgWhite.black(" ");
+  }
+  const searchPrompt = ` \u{1F50D} Search: `;
+  const searchContent = searchPrompt + (state.searchQuery ? chalk.bold.yellow(searchInput) : chalk.dim("Type command, keyword or description... (e.g. doctor, clean, smart)"));
+  const matchCount = chalk.dim(`(${filteredCommands.length}/${38} tools) `);
+  const searchBar = fitVisible(searchContent, width - visLen(matchCount) - 2) + matchCount;
+  lines.push(border("\u251C") + border("\u2500".repeat(width - 2)) + border("\u2524"));
+  lines.push(border("\u2502") + fitVisible(searchBar, width - 2) + border("\u2502"));
+  const catTabs = CATEGORIES.map((cat) => {
+    const isSelected = cat.id === state.category;
+    if (isSelected) {
+      return chalk.bgHex("#ff6a39").black(` ${cat.icon} ${cat.name} `);
+    }
+    return chalk.dim(` ${cat.icon} ${cat.name} `);
+  }).join(chalk.dim("\u2502"));
+  lines.push(border("\u2502") + fitVisible(" " + catTabs, width - 2) + border("\u2502"));
+  lines.push(border("\u251C") + border("\u2500".repeat(width - 2)) + border("\u2524"));
+  const bodyHeight = Math.max(8, height - 9);
+  const isDualPane = width >= 80;
+  const listWidth = isDualPane ? Math.min(46, Math.floor(width * 0.42)) : width - 2;
+  const inspectorWidth = width - 2 - listWidth - (isDualPane ? 1 : 0);
+  const listLines = [];
+  const selectedIdx = Math.min(state.selectedIndex, Math.max(0, filteredCommands.length - 1));
+  let startIdx = state.scrollOffset;
+  if (selectedIdx < startIdx) {
+    startIdx = selectedIdx;
+  } else if (selectedIdx >= startIdx + bodyHeight) {
+    startIdx = selectedIdx - bodyHeight + 1;
+  }
+  state.scrollOffset = startIdx;
+  const endIdx = Math.min(filteredCommands.length, startIdx + bodyHeight);
+  if (filteredCommands.length === 0) {
+    listLines.push(chalk.yellow("  No commands match your search."));
+    listLines.push(chalk.dim("  Press Esc or backspace to clear query."));
+  } else {
+    for (let i = startIdx; i < endIdx; i++) {
+      const cmd = filteredCommands[i];
+      const isCur = i === selectedIdx;
+      const badgeText = `[${cmd.badge}]`;
+      if (isCur) {
+        const rowText = ` \u25B6 ${cmd.cli} ${badgeText}`;
+        listLines.push(chalk.bgHex("#ff6a39").black(fitVisible(rowText, listWidth)));
+      } else {
+        const badgeStyled = chalk.dim(badgeText);
+        const cliStyled = chalk.bold(cmd.cli);
+        const rowText = `   ${cliStyled} ${badgeStyled}`;
+        listLines.push(fitVisible(rowText, listWidth));
+      }
+    }
+  }
+  while (listLines.length < bodyHeight) {
+    listLines.push(" ".repeat(listWidth));
+  }
+  const inspectorLines = [];
+  const curCmd = filteredCommands[selectedIdx];
+  if (curCmd && isDualPane) {
+    inspectorLines.push(accent(chalk.bold(` ${curCmd.name} `)) + chalk.dim(`[${curCmd.badge}]`));
+    inspectorLines.push(chalk.dim(` Syntax: `) + highlight(chalk.bold(curCmd.cli)));
+    inspectorLines.push(chalk.dim("\u2500".repeat(inspectorWidth - 2)));
+    inspectorLines.push(fitVisible(` ${curCmd.description}`, inspectorWidth - 2));
+    inspectorLines.push("");
+    inspectorLines.push(fitVisible(` ${curCmd.detailedHelp}`, inspectorWidth - 2));
+    inspectorLines.push("");
+    if (curCmd.flags && curCmd.flags.length > 0) {
+      inspectorLines.push(chalk.bold.dim(" Options & Flags:"));
+      for (const f of curCmd.flags.slice(0, 4)) {
+        const flagLabel = chalk.yellow(`  ${f.flag}`);
+        const flagDesc = chalk.dim(` - ${f.desc}`);
+        inspectorLines.push(fitVisible(`${flagLabel}${flagDesc}`, inspectorWidth - 2));
+      }
+      inspectorLines.push("");
+    }
+    if (curCmd.examples && curCmd.examples.length > 0) {
+      inspectorLines.push(chalk.bold.dim(" Examples:"));
+      for (const ex of curCmd.examples.slice(0, 2)) {
+        inspectorLines.push(chalk.cyan(`  $ ${ex}`));
+      }
+      inspectorLines.push("");
+    }
+    inspectorLines.push(chalk.dim("\u2500".repeat(inspectorWidth - 2)));
+    const runPrompt = curCmd.requiresArgs ? chalk.yellow(" [Enter] Enter arguments & Run   [c] Copy   [e] Edit Flags") : chalk.green(" [Enter] Execute Command   [c] Copy   [e] Edit Flags");
+    inspectorLines.push(fitVisible(runPrompt, inspectorWidth - 2));
+  }
+  while (inspectorLines.length < bodyHeight) {
+    inspectorLines.push(" ".repeat(inspectorWidth));
+  }
+  for (let r = 0; r < bodyHeight; r++) {
+    const left = fitVisible(listLines[r] || "", listWidth);
+    if (isDualPane) {
+      const right = fitVisible(inspectorLines[r] || "", inspectorWidth);
+      lines.push(border("\u2502") + left + border("\u2502") + right + border("\u2502"));
+    } else {
+      lines.push(border("\u2502") + left + border("\u2502"));
+    }
+  }
+  lines.push(border("\u251C") + border("\u2500".repeat(width - 2)) + border("\u2524"));
+  const statusMsg = state.statusMessage ? chalk.yellow(` ${state.statusMessage} `) : "";
+  const shortcuts = ` [\u2191/\u2193] Select  [Enter] Run  [Tab] Category  [/] Search  [e] Edit  [?] Help  [q] Quit`;
+  const footerRow = fitVisible(shortcuts, width - visLen(statusMsg) - 2) + statusMsg;
+  lines.push(border("\u2502") + fitVisible(footerRow, width - 2) + border("\u2502"));
+  lines.push(border("\u2570") + border("\u2500".repeat(width - 2)) + border("\u256F"));
+  if (state.inputMode === "prompt-args" && state.activeCommand) {
+    overlayPromptModal(lines, width, height, state.activeCommand, state.argPromptValue, accent, border);
+  } else if (state.inputMode === "edit-cmd" && state.activeCommand) {
+    overlayEditCmdModal(lines, width, height, state.activeCommand, state.argPromptValue, accent, border);
+  } else if (state.inputMode === "help") {
+    overlayHelpModal(lines, width, height, accent, border);
+  }
+  return lines.join("\r\n");
+}
+function overlayPromptModal(lines, width, height, cmd, val, accent, border) {
+  const modalW = Math.min(width - 4, 64);
+  const promptText = cmd.requiresArgs?.prompt || "Enter arguments:";
+  const modalLines = [
+    chalk.bold.yellow(`  Run: ${cmd.cli}`),
+    chalk.dim(`  ${cmd.description}`),
+    "",
+    chalk.white(`  ${promptText}`),
+    `  > ${chalk.bold.cyan(val)}${chalk.bgWhite.black(" ")}`,
+    "",
+    chalk.dim("  [Enter] Run Command    [Esc] Cancel")
+  ];
+  const box = panel(` Execute: ${cmd.name} `, modalLines, modalW, accent, border, modalLines.length);
+  stampOverlay(lines, box, width, height);
+}
+function overlayEditCmdModal(lines, width, height, cmd, val, accent, border) {
+  const modalW = Math.min(width - 4, 70);
+  const modalLines = [
+    chalk.bold.yellow(`  Customize Command Line:`),
+    chalk.dim(`  Edit flags or arguments and press Enter to execute.`),
+    "",
+    `  $ ${chalk.bold.cyan(val)}${chalk.bgWhite.black(" ")}`,
+    "",
+    chalk.dim("  [Enter] Execute Custom Command    [Esc] Cancel")
+  ];
+  const box = panel(` Edit & Run `, modalLines, modalW, accent, border, modalLines.length);
+  stampOverlay(lines, box, width, height);
+}
+function overlayHelpModal(lines, width, height, accent, border) {
+  const modalW = Math.min(width - 4, 66);
+  const modalLines = [
+    chalk.bold.yellow("  Pyre Command Center \u2014 Keyboard Shortcuts"),
+    "",
+    `  ${chalk.cyan("\u2191 / k, \u2193 / j")}       Navigate command list`,
+    `  ${chalk.cyan("PgUp / PgDn")}       Scroll command list fast`,
+    `  ${chalk.cyan("Tab / Shift+Tab")}   Cycle category filters`,
+    `  ${chalk.cyan("1 - 7")}             Jump directly to category`,
+    `  ${chalk.cyan("Enter")}             Execute selected command`,
+    `  ${chalk.cyan("e")}                 Edit flags/arguments before running`,
+    `  ${chalk.cyan("c")}                 Copy command to clipboard / show snippet`,
+    `  ${chalk.cyan("/ (or type)")}       Search / filter commands instantly`,
+    `  ${chalk.cyan("Backspace")}         Delete search query character`,
+    `  ${chalk.cyan("Esc")}               Clear search or close modal`,
+    `  ${chalk.cyan("q")}                 Quit to shell`,
+    "",
+    chalk.dim("  Press any key or Esc to close help...")
+  ];
+  const box = panel(" Help & Shortcuts ", modalLines, modalW, accent, border, modalLines.length);
+  stampOverlay(lines, box, width, height);
+}
+function stampOverlay(screenLines, box, width, height) {
+  const boxH = box.length;
+  const startRow = Math.max(0, Math.floor((screenLines.length - boxH) / 2));
+  const boxW = visLen(box[0] || "");
+  const startCol = Math.max(0, Math.floor((width - boxW) / 2));
+  for (let r = 0; r < boxH; r++) {
+    const targetRow = startRow + r;
+    if (targetRow < screenLines.length) {
+      const orig = screenLines[targetRow];
+      const left = orig.slice(0, startCol);
+      const right = orig.slice(startCol + boxW);
+      screenLines[targetRow] = fitVisible(left, startCol) + box[r] + fitVisible(right, Math.max(0, width - startCol - boxW));
+    }
+  }
+}
+
+// src/menu/index.ts
+async function runMenu(opts) {
+  const config = readConfig();
+  const theme = opts?.theme || config.theme || "default";
+  const state = {
+    category: opts?.initialCategory || "all",
+    categoryIndex: CATEGORIES.findIndex((c) => c.id === (opts?.initialCategory || "all")) || 0,
+    searchQuery: "",
+    selectedIndex: 0,
+    scrollOffset: 0,
+    inputMode: "search",
+    argPromptValue: "",
+    activeCommand: null,
+    statusMessage: "",
+    termWidth: process.stdout.columns || 80,
+    termHeight: process.stdout.rows || 24,
+    theme
+  };
+  let isRunning = true;
+  let statusTimer = null;
+  function setStatus(msg, durationMs = 3e3) {
+    state.statusMessage = msg;
+    if (statusTimer) clearTimeout(statusTimer);
+    statusTimer = setTimeout(() => {
+      state.statusMessage = "";
+      if (isRunning) render();
+    }, durationMs);
+  }
+  function getFiltered() {
+    return filterCommands(ALL_COMMANDS, state.category, state.searchQuery);
+  }
+  function render() {
+    if (!isRunning) return;
+    const filtered = getFiltered();
+    const output = renderMenuScreen(state, filtered);
+    process.stdout.write("\x1B[H" + output);
+  }
+  function onResize() {
+    state.termWidth = process.stdout.columns || 80;
+    state.termHeight = process.stdout.rows || 24;
+    render();
+  }
+  function enterTui() {
+    process.stdout.write("\x1B[?1049h");
+    process.stdout.write("\x1B[?25l");
+    process.stdout.write("\x1B[2J\x1B[H");
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.on("resize", onResize);
+    render();
+  }
+  function leaveTui() {
+    process.stdout.removeListener("resize", onResize);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdout.write("\x1B[?25h");
+    process.stdout.write("\x1B[?1049l");
+  }
+  function executeCommand(rawCommandLine, isInteractive = false) {
+    leaveTui();
+    const tokens = rawCommandLine.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0] === "pyre") {
+      tokens.shift();
+    }
+    console.log(chalk2.bold(`
+  \u{1F525} Executing: ${chalk2.hex("#ff6a39")(rawCommandLine)}
+`));
+    try {
+      const scriptPath = process.argv[1];
+      spawnSync(process.argv[0], [scriptPath, ...tokens], {
+        stdio: "inherit",
+        env: process.env
+      });
+    } catch (err) {
+      console.error(chalk2.red(`
+  \u2716 Error executing command: ${err.message}`));
+    }
+    if (!isInteractive) {
+      console.log(chalk2.dim("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk2.yellow("  Press any key to return to Command Center (or [q] to exit)..."));
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.once("data", (buf) => {
+          const str = buf.toString().toLowerCase();
+          if (str === "q" || str === "") {
+            process.exit(0);
+          }
+          enterTui();
+        });
+        return;
+      }
+    }
+    enterTui();
+  }
+  enterTui();
+  return new Promise((resolve) => {
+    function onKeypress(str, key) {
+      if (!isRunning) return;
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        isRunning = false;
+        leaveTui();
+        if (opts?.onExit) opts.onExit();
+        else process.exit(0);
+        resolve();
+        return;
+      }
+      if (state.inputMode === "help") {
+        state.inputMode = "search";
+        render();
+        return;
+      }
+      if (state.inputMode === "prompt-args") {
+        if (key.name === "escape") {
+          state.inputMode = "search";
+          state.argPromptValue = "";
+          render();
+          return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+          const cmd = state.activeCommand;
+          const args = state.argPromptValue.trim();
+          state.inputMode = "search";
+          state.argPromptValue = "";
+          if (cmd) {
+            const fullCmd = args ? `${cmd.cli} ${args}` : cmd.cli;
+            executeCommand(fullCmd, cmd.interactive);
+          }
+          return;
+        }
+        if (key.name === "backspace") {
+          state.argPromptValue = state.argPromptValue.slice(0, -1);
+          render();
+          return;
+        }
+        if (str && str.length === 1 && !key.ctrl && !key.meta) {
+          state.argPromptValue += str;
+          render();
+          return;
+        }
+        return;
+      }
+      if (state.inputMode === "edit-cmd") {
+        if (key.name === "escape") {
+          state.inputMode = "search";
+          state.argPromptValue = "";
+          render();
+          return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+          const fullCmd = state.argPromptValue.trim();
+          const cmd = state.activeCommand;
+          state.inputMode = "search";
+          state.argPromptValue = "";
+          if (fullCmd) {
+            executeCommand(fullCmd, cmd?.interactive);
+          }
+          return;
+        }
+        if (key.name === "backspace") {
+          state.argPromptValue = state.argPromptValue.slice(0, -1);
+          render();
+          return;
+        }
+        if (str && str.length === 1 && !key.ctrl && !key.meta) {
+          state.argPromptValue += str;
+          render();
+          return;
+        }
+        return;
+      }
+      const filtered = getFiltered();
+      const count = filtered.length;
+      if (key.name === "up" || key.name === "k" && state.searchQuery === "") {
+        if (count > 0) {
+          state.selectedIndex = (state.selectedIndex - 1 + count) % count;
+          render();
+        }
+        return;
+      }
+      if (key.name === "down" || key.name === "j" && state.searchQuery === "") {
+        if (count > 0) {
+          state.selectedIndex = (state.selectedIndex + 1) % count;
+          render();
+        }
+        return;
+      }
+      if (key.name === "pageup") {
+        state.selectedIndex = Math.max(0, state.selectedIndex - 6);
+        render();
+        return;
+      }
+      if (key.name === "pagedown") {
+        state.selectedIndex = Math.min(count - 1, state.selectedIndex + 6);
+        render();
+        return;
+      }
+      if (key.name === "tab") {
+        const dir = key.shift ? -1 : 1;
+        state.categoryIndex = (state.categoryIndex + dir + CATEGORIES.length) % CATEGORIES.length;
+        state.category = CATEGORIES[state.categoryIndex].id;
+        state.selectedIndex = 0;
+        state.scrollOffset = 0;
+        render();
+        return;
+      }
+      if (str === "?" || str === "h" && state.searchQuery === "") {
+        state.inputMode = "help";
+        render();
+        return;
+      }
+      if (str === "c" && state.searchQuery === "") {
+        const cur = filtered[state.selectedIndex];
+        if (cur) {
+          setStatus(`CLI command: ${cur.cli}`);
+        }
+        return;
+      }
+      if (str === "e" && state.searchQuery === "") {
+        const cur = filtered[state.selectedIndex];
+        if (cur) {
+          state.inputMode = "edit-cmd";
+          state.activeCommand = cur;
+          state.argPromptValue = cur.cli;
+          render();
+        }
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const cur = filtered[state.selectedIndex];
+        if (!cur) return;
+        if (cur.requiresArgs) {
+          state.inputMode = "prompt-args";
+          state.activeCommand = cur;
+          state.argPromptValue = cur.requiresArgs.defaultVal || "";
+          render();
+          return;
+        }
+        executeCommand(cur.cli, cur.interactive);
+        return;
+      }
+      if (key.name === "backspace") {
+        if (state.searchQuery.length > 0) {
+          state.searchQuery = state.searchQuery.slice(0, -1);
+          state.selectedIndex = 0;
+          state.scrollOffset = 0;
+          render();
+        }
+        return;
+      }
+      if (key.name === "escape") {
+        if (state.searchQuery.length > 0) {
+          state.searchQuery = "";
+          state.selectedIndex = 0;
+          state.scrollOffset = 0;
+          render();
+        } else {
+          isRunning = false;
+          leaveTui();
+          if (opts?.onExit) opts.onExit();
+          else process.exit(0);
+          resolve();
+        }
+        return;
+      }
+      if (str === "q" && state.searchQuery === "") {
+        isRunning = false;
+        leaveTui();
+        if (opts?.onExit) opts.onExit();
+        else process.exit(0);
+        resolve();
+        return;
+      }
+      if (str && str.length === 1 && !key.ctrl && !key.meta) {
+        state.searchQuery += str;
+        state.selectedIndex = 0;
+        state.scrollOffset = 0;
+        render();
+        return;
+      }
+    }
+    process.stdin.on("keypress", onKeypress);
+  });
+}
+export {
+  runMenu
+};