pyre-cli 7.0.0 → 8.0.0

package/dist/chunk-RVGKEJXT.js

@@ -0,0 +1,121 @@
+// src/state/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "pyre");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  theme: "default",
+  interval: 2,
+  exportDir: "./pyre-exports",
+  detailed: false,
+  sortMode: "cpu",
+  treeView: false,
+  graphMode: "spark",
+  showGraphs: true,
+  autoLog: false,
+  mouseEnabled: true,
+  cpuAlertPct: 90,
+  tempAlertC: 95,
+  electricityRateKwH: 0.15,
+  watchdogProcess: "",
+  watchdogCpu: 80,
+  watchdogMem: 80,
+  notificationsEnabled: true,
+  p2pPort: 9876,
+  p2pPassword: "pyre",
+  splashEnabled: true,
+  splashColorScheme: "fire",
+  splashAnimation: "classic",
+  webhookUrl: "",
+  alertCmd: "",
+  visiblePanels: {
+    cpu: true,
+    mem: true,
+    gpu: true,
+    power: true,
+    battery: true,
+    thermal: true,
+    network: true,
+    packets: true,
+    tasks: true,
+    disk: true,
+    process: true,
+    tree: false
+  },
+  panelLayout: ["mem", "disk", "net"]
+};
+function readConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(DEFAULT_CONFIG, parsed);
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(config) {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const merged = deepMerge(readConfig(), config);
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n");
+  } catch {
+  }
+}
+var PROFILES_DIR = path.join(CONFIG_DIR, "profiles");
+function saveProfile(name) {
+  if (!name || name.includes("/") || name.includes("\\")) {
+    throw new Error("Invalid profile name.");
+  }
+  if (!fs.existsSync(PROFILES_DIR)) {
+    fs.mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+  const currentConfig = readConfig();
+  const profileFile = path.join(PROFILES_DIR, `${name}.json`);
+  fs.writeFileSync(profileFile, JSON.stringify(currentConfig, null, 2) + "\n");
+}
+function loadProfile(name) {
+  const profileFile = path.join(PROFILES_DIR, `${name}.json`);
+  if (!fs.existsSync(profileFile)) {
+    throw new Error(`Profile '${name}' does not exist.`);
+  }
+  const raw = fs.readFileSync(profileFile, "utf-8");
+  const parsed = JSON.parse(raw);
+  writeConfig(parsed);
+}
+function listProfiles() {
+  if (!fs.existsSync(PROFILES_DIR)) return [];
+  const files = fs.readdirSync(PROFILES_DIR);
+  return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] !== void 0 && source[key] !== null) {
+      if (typeof source[key] === "object" && !Array.isArray(source[key]) && typeof target[key] === "object" && !Array.isArray(target[key])) {
+        result[key] = deepMerge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+export {
+  CONFIG_FILE,
+  DEFAULT_CONFIG,
+  readConfig,
+  writeConfig,
+  PROFILES_DIR,
+  saveProfile,
+  loadProfile,
+  listProfiles,
+  getConfigPath
+};

package/dist/collectors-4VYRJVRO.js

@@ -0,0 +1,33 @@
+import {
+  collectAll,
+  collectBattery,
+  collectCpu,
+  collectDisk,
+  collectGpu,
+  collectMemory,
+  collectNetwork,
+  collectPackets,
+  collectPower,
+  collectProcesses,
+  collectTasks,
+  collectThermal,
+  getDisplayInfo,
+  getTimeMachineStatus
+} from "./chunk-KBKXU2ZV.js";
+import "./chunk-GLH7EKAX.js";
+export {
+  collectAll,
+  collectBattery,
+  collectCpu,
+  collectDisk,
+  collectGpu,
+  collectMemory,
+  collectNetwork,
+  collectPackets,
+  collectPower,
+  collectProcesses,
+  collectTasks,
+  collectThermal,
+  getDisplayInfo,
+  getTimeMachineStatus
+};

package/dist/completions-VQMHQCXE.js

@@ -0,0 +1,122 @@
+// src/completions.ts
+function generateZshCompletions() {
+  return `#compdef pyre
+
+_pyre() {
+    local -a commands
+    commands=(
+        'live:Start interactive live monitoring dashboard'
+        'info:Display static system overview'
+        'doctor:Run system permissions and diagnostic checks'
+        'web:Launch web dashboard server'
+        'config:Show or reset configuration options'
+        'p2p:P2P streaming server or client'
+        'ssh:Stream metrics over SSH'
+        'bench:Benchmark command while logging system stats'
+        'completions:Generate shell completion scripts'
+    )
+
+    _arguments -s \\
+        '(-j --json)'{-j,--json}'[Output snapshot as JSON]' \\
+        '--html[Output snapshot as HTML]' \\
+        '--md[Output snapshot as Markdown]' \\
+        '(-c --csv)'{-c,--csv}'[Output snapshot as CSV]' \\
+        '(-t --tsv)'{-t,--tsv}'[Output snapshot as TSV]' \\
+        '--detailed[Include detailed system info and sensor readings]' \\
+        '--theme[Default theme]:theme:(default dracula cyberpunk monochrome nord gruvbox)' \\
+        '--interval[Refresh interval in seconds]:seconds:' \\
+        '--once[Show a single static snapshot]' \\
+        '--out[Write snapshot output to file]:file:_files' \\
+        '--export-dir[Directory for snapshot exports and logs]:directory:_files -/' \\
+        '--log[Start continuous CSV logging]' \\
+        '--tree[Show process tree view]' \\
+        '--sort[Sort processes by]:key:(cpu mem pid user command state threads runtime)' \\
+        '--packets[Include packet monitor panel]' \\
+        '--limit[Max processes to include]:count:' \\
+        '--alert-cpu[CPU alert threshold pct]:pct:' \\
+        '--alert-temp[CPU alert threshold temp C]:temp:' \\
+        '--temp-unit[Temperature display unit]:unit:(c f)' \\
+        '*::command:->command'
+
+    case $state in
+        command)
+            _describe -t commands 'pyre command' commands
+            ;;
+    esac
+}
+
+_pyre "$@"
+`;
+}
+function generateBashCompletions() {
+  return `# bash completion for pyre
+
+_pyre_completions() {
+    local cur prev opts commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    commands="live info doctor web config p2p ssh bench completions"
+    opts="--json --html --md --csv --tsv --detailed --theme --interval --once --out --export-dir --log --tree --sort --packets --limit --alert-cpu --alert-temp --temp-unit"
+
+    case "\${prev}" in
+        --theme)
+            COMPREPLY=( $(compgen -W "default dracula cyberpunk monochrome nord gruvbox" -- \${cur}) )
+            return 0
+            ;;
+        --sort)
+            COMPREPLY=( $(compgen -W "cpu mem pid user command state threads runtime" -- \${cur}) )
+            return 0
+            ;;
+        --temp-unit)
+            COMPREPLY=( $(compgen -W "c f" -- \${cur}) )
+            return 0
+            ;;
+        config)
+            COMPREPLY=( $(compgen -W "show reset" -- \${cur}) )
+            return 0
+            ;;
+        p2p)
+            COMPREPLY=( $(compgen -W "server connect" -- \${cur}) )
+            return 0
+            ;;
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+
+    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+}
+
+complete -F _pyre_completions pyre
+`;
+}
+function generateFishCompletions() {
+  return `# fish completion for pyre
+
+complete -c pyre -n "__fish_use_subcommand" -a live -d "Start interactive live monitoring dashboard"
+complete -c pyre -n "__fish_use_subcommand" -a info -d "Display static system overview"
+complete -c pyre -n "__fish_use_subcommand" -a doctor -d "Run system diagnostics"
+complete -c pyre -n "__fish_use_subcommand" -a web -d "Launch web dashboard server"
+complete -c pyre -n "__fish_use_subcommand" -a config -d "Show or reset configuration options"
+complete -c pyre -n "__fish_use_subcommand" -a p2p -d "P2P streaming mode"
+complete -c pyre -n "__fish_use_subcommand" -a completions -d "Generate shell completions"
+
+complete -c pyre -l json -s j -d "Output snapshot as JSON"
+complete -c pyre -l html -d "Output snapshot as HTML"
+complete -c pyre -l md -d "Output snapshot as Markdown"
+complete -c pyre -l csv -s c -d "Output snapshot as CSV"
+complete -c pyre -l tsv -s t -d "Output snapshot as TSV"
+complete -c pyre -l detailed -d "Include detailed system info and sensor readings"
+complete -c pyre -l theme -x -a "default dracula cyberpunk monochrome nord gruvbox" -d "Set color theme"
+complete -c pyre -l sort -x -a "cpu mem pid user command state threads runtime" -d "Sort processes by key"
+complete -c pyre -l temp-unit -x -a "c f" -d "Temperature unit"
+`;
+}
+export {
+  generateBashCompletions,
+  generateFishCompletions,
+  generateZshCompletions
+};

package/dist/config-4ZLF4HTS.js

@@ -0,0 +1,22 @@
+import {
+  CONFIG_FILE,
+  DEFAULT_CONFIG,
+  PROFILES_DIR,
+  getConfigPath,
+  listProfiles,
+  loadProfile,
+  readConfig,
+  saveProfile,
+  writeConfig
+} from "./chunk-RVGKEJXT.js";
+export {
+  CONFIG_FILE,
+  DEFAULT_CONFIG,
+  PROFILES_DIR,
+  getConfigPath,
+  listProfiles,
+  loadProfile,
+  readConfig,
+  saveProfile,
+  writeConfig
+};

package/dist/doctor-LJQAABZ4.js

@@ -0,0 +1,184 @@
+import {
+  CONFIG_FILE,
+  readConfig
+} from "./chunk-RVGKEJXT.js";
+import {
+  run
+} from "./chunk-GLH7EKAX.js";
+
+// src/doctor.ts
+import chalk from "chalk";
+async function runDoctor() {
+  const checks = [];
+  try {
+    const pmResult = await run("sudo -n powermetrics --samplers cpu_power -n 1 2>&1", "");
+    if (pmResult.includes("Password:") || pmResult.includes("Permission denied") || pmResult.includes("sudo: a password is required")) {
+      checks.push({
+        name: "Sudo / Powermetrics",
+        status: "warn",
+        message: "Passwordless sudo for powermetrics is not configured.",
+        details: "Powermetrics allows high-precision GPU & CPU power sampling. Run with sudo or configure passwordless sudo in /etc/sudoers."
+      });
+    } else {
+      checks.push({
+        name: "Sudo / Powermetrics",
+        status: "ok",
+        message: "Powermetrics access available."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Sudo / Powermetrics",
+      status: "warn",
+      message: "Powermetrics check failed."
+    });
+  }
+  try {
+    const psCheck = await run("ps -ax -o pid,user,command", "");
+    if (psCheck.length > 0) {
+      checks.push({
+        name: "TCC / Process Visibility",
+        status: "ok",
+        message: "Process listing access available."
+      });
+    } else {
+      checks.push({
+        name: "TCC / Process Visibility",
+        status: "warn",
+        message: "Restricted process visibility.",
+        details: "Grant Full Disk Access or Terminal permissions in System Settings -> Privacy & Security."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "TCC / Process Visibility",
+      status: "error",
+      message: "Unable to list system processes."
+    });
+  }
+  try {
+    const netCheck = await run("netstat -rn", "");
+    if (netCheck.includes("default") || netCheck.includes("gateway")) {
+      checks.push({
+        name: "Network Reachability",
+        status: "ok",
+        message: "Network interface active with default gateway."
+      });
+    } else {
+      checks.push({
+        name: "Network Reachability",
+        status: "warn",
+        message: "No active network route detected for P2P mode."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Network Reachability",
+      status: "warn",
+      message: "Could not verify network routes."
+    });
+  }
+  try {
+    const spctlOut = await run("spctl --status 2>&1", "");
+    if (spctlOut.includes("assessments enabled")) {
+      checks.push({
+        name: "Gatekeeper",
+        status: "ok",
+        message: "Gatekeeper enforcement is enabled."
+      });
+    } else {
+      checks.push({
+        name: "Gatekeeper",
+        status: "warn",
+        message: "Gatekeeper is disabled or status check unconfirmed.",
+        details: 'Re-enable Gatekeeper using "sudo spctl --master-enable" to protect against untrusted software.'
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Gatekeeper",
+      status: "warn",
+      message: "Could not query Gatekeeper status."
+    });
+  }
+  try {
+    const sipOut = await run("csrutil status 2>&1", "");
+    if (sipOut.includes("enabled")) {
+      checks.push({
+        name: "System Integrity Protection",
+        status: "ok",
+        message: "SIP is enabled."
+      });
+    } else {
+      checks.push({
+        name: "System Integrity Protection",
+        status: "warn",
+        message: "SIP is disabled or restricted.",
+        details: "System Integrity Protection protects core system files. Enable it from macOS Recovery."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "System Integrity Protection",
+      status: "warn",
+      message: "Could not query SIP status."
+    });
+  }
+  try {
+    const xprotectOut = await run("system_profiler SPInstallHistoryDataType 2>&1", "");
+    const xpMatches = Array.from(xprotectOut.matchAll(/XProtect(?:Remediator)?ConfigData.*?\n.*?Install Date:\s*(.+)/gi));
+    if (xpMatches.length > 0) {
+      const latestDateStr = xpMatches[xpMatches.length - 1][1];
+      checks.push({
+        name: "XProtect Definitions",
+        status: "ok",
+        message: `XProtect active (last updated ${latestDateStr.trim()}).`
+      });
+    } else {
+      checks.push({
+        name: "XProtect Definitions",
+        status: "ok",
+        message: "XProtect definitions installed."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "XProtect Definitions",
+      status: "warn",
+      message: "Could not determine XProtect update history."
+    });
+  }
+  try {
+    const cfg = readConfig();
+    checks.push({
+      name: "Configuration File",
+      status: "ok",
+      message: `Config file valid (${CONFIG_FILE}).`
+    });
+  } catch (err) {
+    checks.push({
+      name: "Configuration File",
+      status: "error",
+      message: "Failed to parse config file.",
+      details: err.message
+    });
+  }
+  return checks;
+}
+function printDoctorReport(checks) {
+  console.log(chalk.bold("\n  pyre doctor \u2014 System Diagnostics\n"));
+  for (const check of checks) {
+    let icon = chalk.green("\u2714");
+    if (check.status === "warn") icon = chalk.yellow("\u26A0");
+    if (check.status === "error") icon = chalk.red("\u2716");
+    console.log(`  ${icon} ${chalk.bold(check.name.padEnd(26))} ${check.message}`);
+    if (check.details) {
+      console.log(chalk.dim(`     \u21B3 ${check.details}`));
+    }
+  }
+  console.log();
+}
+export {
+  printDoctorReport,
+  runDoctor
+};

package/dist/extensions-QCFSVCL5.js

@@ -0,0 +1,74 @@
+import {
+  run
+} from "./chunk-GLH7EKAX.js";
+
+// src/extensions.ts
+import chalk from "chalk";
+async function getSystemExtensions() {
+  try {
+    const raw = await run("systemextensionsctl list 2>&1", "");
+    return parseSystemExtensionsOutput(raw);
+  } catch (err) {
+    return [];
+  }
+}
+function parseSystemExtensionsOutput(output) {
+  const result = [];
+  let currentCategory = "Other Extensions";
+  let currentList = [];
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("--- category") || trimmed.startsWith("--- ")) {
+      if (currentList.length > 0 || result.length > 0) {
+        result.push({ category: currentCategory, extensions: currentList });
+        currentList = [];
+      }
+      const catMatch = trimmed.match(/category\s+([\w\.-]+)/i);
+      currentCategory = catMatch ? catMatch[1] : trimmed.replace(/^-+\s*/, "").replace(/\s*-+$/, "");
+      continue;
+    }
+    const extMatch = trimmed.match(/^(?:\*\s*)*([A-Z0-9]{10}|\?\?\?\?\?\?\?\?\?\?)\s+([\w\.-]+)\s+\(([^)]+)\)\s+\[([^\]]+)\]/i);
+    if (extMatch) {
+      currentList.push({
+        teamId: extMatch[1],
+        bundleId: extMatch[2],
+        version: extMatch[3],
+        state: extMatch[4],
+        category: currentCategory
+      });
+    }
+  }
+  if (currentList.length > 0 || result.length === 0) {
+    result.push({ category: currentCategory, extensions: currentList });
+  }
+  return result.filter((group) => group.extensions.length > 0 || result.length === 1);
+}
+async function printExtensionsReport() {
+  console.log(chalk.bold("\n  pyre extensions \u2014 System Extensions Inspector\n"));
+  const categories = await getSystemExtensions();
+  let totalCount = 0;
+  for (const cat of categories) {
+    totalCount += cat.extensions.length;
+    console.log(chalk.cyan.bold(`  \u{1F4C2} ${cat.category}`));
+    if (cat.extensions.length === 0) {
+      console.log(chalk.dim("     (No extensions registered in this category)"));
+      continue;
+    }
+    for (const ext of cat.extensions) {
+      const stateColor = ext.state.includes("activated") || ext.state.includes("enabled") ? chalk.green : chalk.yellow;
+      console.log(`     \u2022 ${chalk.bold(ext.bundleId)} (${ext.version})`);
+      console.log(chalk.dim(`       Team: ${ext.teamId} | State: `) + stateColor(ext.state));
+    }
+    console.log();
+  }
+  if (totalCount === 0) {
+    console.log(chalk.dim("  No active system extensions detected on this system.\n"));
+  }
+}
+export {
+  getSystemExtensions,
+  parseSystemExtensionsOutput,
+  printExtensionsReport
+};