pyre-cli 10.3.0 → 10.5.0

package/src/topoCmd.ts

@@ -8,7 +8,7 @@
 import net from 'node:net';
 import os from 'node:os';
 import chalk from 'chalk';
-import { run } from './monitors/run.js';
+import { run, runPowerShell } from './monitors/run.js';
 import { collectNetwork } from './monitors/collectors.js';
 
 export interface TopoOptions {
@@ -16,7 +16,7 @@ export interface TopoOptions {
   json?: boolean;
 }
 
-interface LanPeer {
+export interface LanPeer {
   ip: string;
   mac: string;
   interface: string;
@@ -46,21 +46,73 @@ async function probePort(ip: string, port: number, timeoutMs = 400): Promise<boo
   });
 }
 
-async function getDefaultGateway(): Promise<string> {
+export async function getDefaultGateway(): Promise<string> {
+  if (process.platform === 'win32') {
+    try {
+      const raw = await runPowerShell(
+        `(Get-NetRoute -DestinationPrefix '0.0.0.0/0' -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty NextHop)`,
+        ''
+      );
+      if (raw.trim() && raw.trim() !== '0.0.0.0') return raw.trim();
+    } catch {}
+
+    try {
+      const rawCim = await runPowerShell(
+        `(Get-CimInstance Win32_NetworkAdapterConfiguration -Filter "IPEnabled = TRUE" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty DefaultIPGateway) -join ''`,
+        ''
+      );
+      if (rawCim.trim()) return rawCim.trim();
+    } catch {}
+  }
+
   try {
     const raw = await run("route -n get default 2>/dev/null | grep gateway | awk '{print $2}'", '');
     if (raw.trim()) return raw.trim();
   } catch {}
   try {
-    const raw = await run("netstat -nr | grep default | awk '{print $2}' | head -n1", '');
+    const raw = await run("netstat -nr 2>/dev/null | grep default | awk '{print $2}' | head -n1", '');
     if (raw.trim()) return raw.trim();
   } catch {}
   return '192.168.1.1';
 }
 
-async function getArpNeighbors(gatewayIp: string): Promise<LanPeer[]> {
+export function parseWindowsArpOutput(raw: string, gatewayIp: string): LanPeer[] {
+  const peers: LanPeer[] = [];
+  let currentIface = 'Ethernet';
+
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    const ifaceMatch = trimmed.match(/Interface:\s*([\d.]+)/i);
+    if (ifaceMatch) {
+      currentIface = ifaceMatch[1];
+      continue;
+    }
+
+    const match = trimmed.match(/^([\d.]+)\s+([0-9a-fA-F-]+)\s+(\w+)/);
+    if (match) {
+      const ip = match[1];
+      const mac = match[2].replace(/-/g, ':');
+      if (ip === '255.255.255.255' || ip.startsWith('224.') || mac.includes('ff:ff:ff')) continue;
+      peers.push({
+        ip,
+        mac,
+        interface: currentIface,
+        isGateway: ip === gatewayIp,
+      });
+    }
+  }
+
+  return peers;
+}
+
+export async function getArpNeighbors(gatewayIp: string): Promise<LanPeer[]> {
   const peers: LanPeer[] = [];
   try {
+    if (process.platform === 'win32') {
+      const raw = await run('arp -a 2>nul', '');
+      return parseWindowsArpOutput(raw, gatewayIp);
+    }
+
     const raw = await run('arp -a -n 2>/dev/null', '');
     const lines = raw.split('\n');
     for (const line of lines) {
@@ -103,20 +155,17 @@ export async function runTopoCommand(opts: TopoOptions = {}): Promise<void> {
     );
   }
 
-  const establishedConns = (localNet.topRemoteHosts || []).slice(0, 6);
-
   if (opts.json) {
     console.log(
       JSON.stringify(
         {
-          localNode: {
+          local: {
             hostname,
             ip: localNet.ip,
             interface: localNet.interface,
+            gateway: gatewayIp,
           },
-          gateway: gatewayIp,
           lanPeers,
-          activeRemoteConnections: establishedConns,
         },
         null,
         2
@@ -125,52 +174,36 @@ export async function runTopoCommand(opts: TopoOptions = {}): Promise<void> {
     return;
   }
 
-  console.log(chalk.bold('\n  🔥 pyre topo — Network Topology Map\n'));
-
-  // Local Host Header Box
-  console.log(`  ${chalk.bgCyan.black.bold(' LOCAL HOST ')} ${chalk.bold(hostname)}`);
-  console.log(`    ├── IP Address:       ${chalk.green.bold(localNet.ip || '127.0.0.1')} (${localNet.interface})`);
-  console.log(`    ├── Active RX / TX:   ↓ ${chalk.cyan(localNet.rxBytes ? `${(localNet.rxBytes / 1e6).toFixed(1)} MB` : '0 MB')}  ↑ ${chalk.blue(localNet.txBytes ? `${(localNet.txBytes / 1e6).toFixed(1)} MB` : '0 MB')}`);
-  console.log('    │');
+  console.log(chalk.bold('\n  🗺  pyre topo — Network Topology Map\n'));
+  console.log(chalk.bold('  Local Node:'));
+  console.log(`    Hostname:  ${chalk.cyan(hostname)}`);
+  console.log(`    IP:        ${chalk.green(localNet.ip)}`);
+  console.log(`    Interface: ${localNet.interface}`);
+  console.log(`    Gateway:   ${chalk.yellow(gatewayIp)}`);
+  console.log();
 
-  // Gateway Node
-  console.log(`    ├── ${chalk.yellow.bold('DEFAULT GATEWAY / ROUTER')}`);
-  console.log(`    │    └── IP: ${chalk.yellow(gatewayIp)}  [Route → WAN / Internet]`);
-  console.log('    │');
+  console.log(chalk.bold(`  LAN Neighbors & Nodes (${lanPeers.length} discovered via ARP):`));
+  console.log(chalk.dim('  ' + '─'.repeat(74)));
 
-  // LAN Neighborhood
-  console.log(`    ├── ${chalk.magenta.bold('LAN NEIGHBORS & PEERS')} (${lanPeers.length} discovered via ARP)`);
   if (lanPeers.length === 0) {
-    console.log(`    │    └── ${chalk.dim('No neighboring ARP entries currently cached.')}`);
-  } else {
-    for (let i = 0; i < lanPeers.length; i++) {
-      const peer = lanPeers[i];
-      const isLast = i === lanPeers.length - 1;
-      const prefix = isLast ? '    │    └──' : '    │    ├──';
-      const gwBadge = peer.isGateway ? chalk.yellow(' [Gateway]') : '';
-      let pyreBadge = '';
-      if (peer.pyreP2P) pyreBadge += chalk.hex('#ff5500').bold(' [🔥 pyre P2P :9876]');
-      if (peer.pyreRest) pyreBadge += chalk.hex('#00ffcc').bold(' [🔥 pyre REST :8080]');
-
-      console.log(`${prefix} ${peer.ip.padEnd(16)} ${chalk.dim(peer.mac)}${gwBadge}${pyreBadge}`);
-    }
+    console.log(chalk.dim('    No active ARP neighbors found in cache.\n'));
+    return;
   }
-  console.log('    │');
 
-  // Active External Remote Sockets
-  console.log(`    └── ${chalk.cyan.bold('TOP ACTIVE REMOTE CONNECTIONS')}`);
-  if (establishedConns.length === 0) {
-    console.log(`         └── ${chalk.dim('No active established sockets detected.')}`);
-  } else {
-    for (let i = 0; i < establishedConns.length; i++) {
-      const conn = establishedConns[i];
-      const isLast = i === establishedConns.length - 1;
-      const prefix = isLast ? '         └──' : '         ├──';
-      const connsBadge = chalk.dim(`(${conn.connectionCount} socket${conn.connectionCount > 1 ? 's' : ''})`);
-      console.log(`${prefix} ${chalk.white(conn.host.padEnd(24))} ${chalk.green('ESTABLISHED')} ${connsBadge}`);
-    }
+  for (const peer of lanPeers) {
+    const isGw = peer.isGateway ? chalk.yellow(' [Default Gateway]') : '';
+    const pyreBadge = peer.pyreP2P ? chalk.green.bold(' 🔥 PYRE PEER') : '';
+    const restBadge = peer.pyreRest ? chalk.blue(' (REST API)') : '';
+
+    console.log(`    • ${chalk.bold(peer.ip.padEnd(16))} ${chalk.dim(peer.mac.padEnd(20))} [${peer.interface}]${isGw}${pyreBadge}${restBadge}`);
   }
 
   console.log();
-  console.log(chalk.dim('  Tip: Run "pyre p2p server" on any node to allow automatic live cluster streaming.\n'));
+  const pyrePeers = lanPeers.filter(p => p.pyreP2P);
+  if (pyrePeers.length > 0) {
+    console.log(chalk.green(`  ✔ Found ${pyrePeers.length} active Pyre node(s) on your LAN!`));
+    console.log(chalk.dim(`  Connect using: pyre p2p connect --p2p-host ${pyrePeers[0].ip}\n`));
+  } else {
+    console.log(chalk.dim('  Tip: Pass --scan to sweep and test pyre ports on discovered LAN neighbors.\n'));
+  }
 }

package/src/watchdogCmd.ts

@@ -17,6 +17,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { execSync } from 'node:child_process';
 import chalk from 'chalk';
 import { collectAll } from './monitors/collectors.js';
 import { sendAlert } from './alertChannels.js';
@@ -28,7 +29,9 @@ export interface WatchdogRule {
   process?: string;
   threshold: number;
   durationSec?: number;
-  action: 'kill' | 'notify' | 'alert';
+  action: 'kill' | 'notify' | 'alert' | 'renice' | 'command';
+  command?: string;
+  dumpFlight?: boolean;
   cooldownSec?: number;
 }
 
@@ -157,13 +160,47 @@ export async function runWatchdogCommand(opts: WatchdogOptions = {}): Promise<vo
 
           if (rule.action === 'kill' && targetPid) {
             try {
-              process.kill(targetPid, 'SIGTERM');
-              console.log(chalk.green(`    ✔ Killed PID ${targetPid} with SIGTERM`));
+              if (process.platform === 'win32') {
+                execSync(`taskkill /F /PID ${targetPid} /T`, { stdio: 'pipe' });
+                console.log(chalk.green(`    ✔ Killed PID ${targetPid} with taskkill /F /T`));
+              } else {
+                process.kill(targetPid, 'SIGTERM');
+                console.log(chalk.green(`    ✔ Killed PID ${targetPid} with SIGTERM`));
+              }
             } catch (err: any) {
               console.log(chalk.red(`    ✖ Failed to kill PID ${targetPid}: ${err.message}`));
             }
           }
 
+          if (rule.action === 'renice' && targetPid) {
+            try {
+              execSync(`renice +10 -p ${targetPid}`, { stdio: 'pipe' });
+              console.log(chalk.green(`    ✔ Deprioritized runaway PID ${targetPid} to nice +10`));
+            } catch (err: any) {
+              console.log(chalk.red(`    ✖ Failed to renice PID ${targetPid}: ${err.message}`));
+            }
+          }
+
+          if (rule.action === 'command' && rule.command) {
+            try {
+              console.log(chalk.cyan(`    ▶ Executing remediation command: ${rule.command}`));
+              execSync(rule.command, { stdio: 'pipe' });
+              console.log(chalk.green(`    ✔ Remediation command executed successfully.`));
+            } catch (err: any) {
+              console.log(chalk.red(`    ✖ Remediation command failed: ${err.message}`));
+            }
+          }
+
+          if (rule.dumpFlight) {
+            try {
+              const { captureCurrentFlightFrame, globalFlightRecorder } = await import('./flightRecorder.js');
+              const frame = await captureCurrentFlightFrame();
+              globalFlightRecorder.push(frame);
+              const path = globalFlightRecorder.dump();
+              console.log(chalk.green(`    ✔ Forensic flight recording dumped: ${path}`));
+            } catch {}
+          }
+
           if (rule.action === 'alert') {
             await sendAlert({
               metric: rule.name,

package/src/xbar.ts

@@ -1,9 +1,55 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import readline from 'node:readline';
+import { execSync } from 'node:child_process';
 import chalk from 'chalk';
 
-export function generateXbarPlugin() {
+export interface XbarOptions {
+  install?: boolean;
+  yes?: boolean;
+  dir?: string;
+}
+
+export function isSwiftBarInstalled(): boolean {
+  if (process.platform !== 'darwin') return false;
+  return (
+    fs.existsSync('/Applications/SwiftBar.app') ||
+    fs.existsSync(path.join(os.homedir(), 'Applications', 'SwiftBar.app'))
+  );
+}
+
+export function isXbarInstalled(): boolean {
+  if (process.platform !== 'darwin') return false;
+  return (
+    fs.existsSync('/Applications/xbar.app') ||
+    fs.existsSync(path.join(os.homedir(), 'Applications', 'xbar.app'))
+  );
+}
+
+export function isBrewAvailable(): boolean {
+  try {
+    execSync('brew --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function confirmPrompt(question: string, yes?: boolean): Promise<boolean> {
+  if (yes) return true;
+  if (!process.stdin.isTTY) return false;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (ans) => {
+      rl.close();
+      const a = ans.trim().toLowerCase();
+      resolve(a === 'y' || a === 'yes');
+    });
+  });
+}
+
+export async function generateXbarPlugin(opts: XbarOptions = {}): Promise<string> {
   const pyrePath = process.argv[1];
   const nodePath = process.execPath;
 
@@ -39,26 +85,158 @@ echo "Open Dashboard | bash='${nodePath}' param1='${pyrePath}' param2='live' ter
 `;
 
   const filename = 'pyre-monitor.2s.sh';
-  const outPath = path.join(process.cwd(), filename);
 
-  fs.writeFileSync(outPath, script);
-  try {
-    fs.chmodSync(outPath, 0o755);
-  } catch {
-    // ignore on non-POSIX filesystems
+  // 1. Explicit target directory passed by caller
+  if (opts.dir) {
+    const targetDir = path.resolve(opts.dir);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const destFile = path.join(targetDir, filename);
+    fs.writeFileSync(destFile, script);
+    try {
+      fs.chmodSync(destFile, 0o755);
+    } catch {}
+    console.log(chalk.green(`\n  ✔ Installed menu bar plugin script directly to:`));
+    console.log(chalk.bold.cyan(`    ${destFile}\n`));
+    return destFile;
   }
 
-  console.log(chalk.green(`Generated menu bar plugin script at ${outPath}`));
-
+  // 2. macOS handling with SwiftBar auto-installation
   if (process.platform === 'darwin') {
-    const pluginDir = path.join(os.homedir(), 'Library', 'Application Support', 'xbar', 'plugins');
-    console.log(`To install in xbar or SwiftBar on macOS:`);
-    console.log(chalk.cyan(`  mv ${filename} "${pluginDir}/"`));
-  } else if (process.platform === 'linux') {
+    let hasSwiftBar = isSwiftBarInstalled();
+    const hasXbar = isXbarInstalled();
+
+    if (!hasSwiftBar && !hasXbar) {
+      if (isBrewAvailable()) {
+        console.log(chalk.bold.yellow(`\n  💡 SwiftBar is required to display Pyre live stats in your macOS menu bar.`));
+        const proceed = await confirmPrompt(
+          chalk.cyan(`  Would you like Pyre to install SwiftBar via Homebrew? [y/N]: `),
+          opts.yes
+        );
+
+        if (proceed) {
+          console.log(chalk.cyan(`\n  ▶ Installing SwiftBar via Homebrew (brew install --cask swiftbar)...`));
+          try {
+            execSync('brew install --cask swiftbar', { stdio: 'inherit' });
+            hasSwiftBar = isSwiftBarInstalled();
+            if (hasSwiftBar) {
+              console.log(chalk.green(`  ✔ SwiftBar installed successfully!`));
+            }
+          } catch (err: any) {
+            console.error(chalk.red(`  ✖ Failed to install SwiftBar: ${err.message}`));
+          }
+        }
+      }
+    }
+
+    // If SwiftBar is available (either pre-existing or freshly installed)
+    if (hasSwiftBar) {
+      const swiftBarDir = path.join(os.homedir(), 'Library', 'Application Support', 'SwiftBar', 'plugins');
+      if (!fs.existsSync(swiftBarDir)) {
+        fs.mkdirSync(swiftBarDir, { recursive: true });
+      }
+      const destFile = path.join(swiftBarDir, filename);
+      fs.writeFileSync(destFile, script);
+      try {
+        fs.chmodSync(destFile, 0o755);
+      } catch {}
+
+      // Configure default SwiftBar plugin directory so it doesn't show an initial folder picker modal
+      try {
+        execSync(`defaults write com.ameba.SwiftBar PluginDirectory "${swiftBarDir}"`, { stdio: 'ignore' });
+      } catch {}
+
+      // Launch SwiftBar if not currently running
+      let isRunning = false;
+      try {
+        execSync('pgrep -il swiftbar', { stdio: 'ignore' });
+        isRunning = true;
+      } catch {}
+
+      if (!isRunning) {
+        try {
+          execSync('open -a SwiftBar', { stdio: 'ignore' });
+        } catch {}
+      }
+
+      console.log(chalk.bold.green(`\n  🔥 Pyre is now active in your macOS menu bar!`));
+      console.log(chalk.dim(`  Look at the top right of your screen for live CPU, RAM, and temperature.`));
+      console.log(chalk.dim(`  Plugin location: ${destFile}\n`));
+      return destFile;
+    }
+
+    // If xbar is available
+    if (hasXbar) {
+      const xbarDir = path.join(os.homedir(), 'Library', 'Application Support', 'xbar', 'plugins');
+      if (!fs.existsSync(xbarDir)) {
+        fs.mkdirSync(xbarDir, { recursive: true });
+      }
+      const destFile = path.join(xbarDir, filename);
+      fs.writeFileSync(destFile, script);
+      try {
+        fs.chmodSync(destFile, 0o755);
+      } catch {}
+
+      try {
+        execSync('open -a xbar', { stdio: 'ignore' });
+      } catch {}
+
+      console.log(chalk.bold.green(`\n  🔥 Pyre is now active in your macOS menu bar via xbar!`));
+      console.log(chalk.dim(`  Plugin location: ${destFile}\n`));
+      return destFile;
+    }
+
+    // Neither app is installed and user declined or brew wasn't available
+    const outPath = path.join(process.cwd(), filename);
+    fs.writeFileSync(outPath, script);
+    try {
+      fs.chmodSync(outPath, 0o755);
+    } catch {}
+
+    const swiftBarDir = path.join(os.homedir(), 'Library', 'Application Support', 'SwiftBar', 'plugins');
+    console.log(chalk.green(`\n  ✔ Generated menu bar plugin script at ${outPath}\n`));
+    console.log(chalk.bold(`  To view this in your menu bar, install SwiftBar or xbar:`));
+    console.log(chalk.cyan(`    brew install --cask swiftbar`));
+    console.log(chalk.dim(`    mkdir -p "${swiftBarDir}" && mv "${filename}" "${swiftBarDir}/"`));
+    console.log(chalk.dim(`    open -a SwiftBar\n`));
+    return outPath;
+  }
+
+  // 3. Linux / Argos handling
+  if (process.platform === 'linux') {
     const argosDir = path.join(os.homedir(), '.config', 'argos');
-    console.log(`To install in Argos (GNOME Shell) on Linux:`);
-    console.log(chalk.cyan(`  mkdir -p "${argosDir}" && mv ${filename} "${argosDir}/"`));
-  } else {
-    console.log(chalk.dim(`Compatible with BitBar, xbar, and Argos shell plugins.`));
+    if (opts.install) {
+      if (!fs.existsSync(argosDir)) {
+        fs.mkdirSync(argosDir, { recursive: true });
+      }
+      const destFile = path.join(argosDir, filename);
+      fs.writeFileSync(destFile, script);
+      try {
+        fs.chmodSync(destFile, 0o755);
+      } catch {}
+      console.log(chalk.green(`\n  ✔ Installed menu bar plugin script to ${destFile}\n`));
+      return destFile;
+    }
+
+    const outPath = path.join(process.cwd(), filename);
+    fs.writeFileSync(outPath, script);
+    try {
+      fs.chmodSync(outPath, 0o755);
+    } catch {}
+    console.log(chalk.green(`\n  ✔ Generated menu bar plugin script at ${outPath}\n`));
+    console.log(`  To install in Argos (GNOME Shell) on Linux:`);
+    console.log(chalk.cyan(`    mkdir -p "${argosDir}" && mv "${filename}" "${argosDir}/"\n`));
+    return outPath;
   }
+
+  // Fallback for Windows / other
+  const outPath = path.join(process.cwd(), filename);
+  fs.writeFileSync(outPath, script);
+  try {
+    fs.chmodSync(outPath, 0o755);
+  } catch {}
+  console.log(chalk.green(`\n  ✔ Generated menu bar plugin script at ${outPath}\n`));
+  console.log(chalk.dim(`  Compatible with BitBar, xbar, and Argos shell plugins.\n`));
+  return outPath;
 }

package/dist/chunk-M73HCQD2.js

@@ -1,95 +0,0 @@
-import {
-  run
-} from "./chunk-MZO5QKUR.js";
-
-// src/monitors/buildTracker.ts
-async function collectBuilds() {
-  try {
-    const raw = await run("ps -eo pid,ppid,pcpu,pmem,etime,command -r", "");
-    if (!raw) return [];
-    const lines = raw.split("\n").slice(1);
-    const builds = /* @__PURE__ */ new Map();
-    const buildToolPatterns = [
-      { name: "xcodebuild", match: /xcodebuild/i },
-      { name: "cargo", match: /\bcargo\s+(build|check|test|run)\b/i },
-      { name: "swift", match: /\bswift\s+(build|test)\b/i },
-      { name: "make", match: /\bmake\b/i },
-      { name: "ninja", match: /\bninja\b/i },
-      { name: "bazel", match: /\bbazel\b/i },
-      { name: "go", match: /\bgo\s+(build|test|run)\b/i }
-    ];
-    const compilerMatch = /(clang|swift-frontend|rustc|go tool compile|gcc|g\+\+|ghc)/i;
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 6) continue;
-      const pid = parseInt(parts[0], 10);
-      const cpu = parseFloat(parts[2]) || 0;
-      const mem = parseFloat(parts[3]) || 0;
-      const etimeStr = parts[4];
-      const cmd = parts.slice(5).join(" ");
-      for (const pattern of buildToolPatterns) {
-        if (pattern.match.test(cmd)) {
-          let elapsedSec = 0;
-          const etimeParts = etimeStr.split(":").map(Number);
-          if (etimeParts.length === 2) elapsedSec = etimeParts[0] * 60 + etimeParts[1];
-          else if (etimeParts.length === 3) elapsedSec = etimeParts[0] * 3600 + etimeParts[1] * 60 + etimeParts[2];
-          builds.set(pattern.name, {
-            tool: pattern.name,
-            rootPid: pid,
-            command: cmd.slice(0, 80),
-            compilerProcesses: 1,
-            totalCpu: cpu,
-            totalMem: mem,
-            elapsedSec,
-            target: cmd.split(" ").slice(1, 4).join(" ")
-          });
-          break;
-        }
-      }
-    }
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 6) continue;
-      const cpu = parseFloat(parts[2]) || 0;
-      const mem = parseFloat(parts[3]) || 0;
-      const cmd = parts.slice(5).join(" ");
-      if (compilerMatch.test(cmd)) {
-        if (builds.size > 0) {
-          const firstBuild = builds.values().next().value;
-          if (firstBuild) {
-            firstBuild.compilerProcesses += 1;
-            firstBuild.totalCpu += cpu;
-            firstBuild.totalMem += mem;
-          }
-        } else {
-          const key = "compiler";
-          const existing = builds.get(key);
-          if (existing) {
-            existing.compilerProcesses += 1;
-            existing.totalCpu += cpu;
-            existing.totalMem += mem;
-          } else {
-            builds.set(key, {
-              tool: "compiler",
-              rootPid: parseInt(parts[0], 10),
-              command: cmd.slice(0, 80),
-              compilerProcesses: 1,
-              totalCpu: cpu,
-              totalMem: mem,
-              elapsedSec: 0
-            });
-          }
-        }
-      }
-    }
-    return Array.from(builds.values());
-  } catch {
-    return [];
-  }
-}
-
-export {
-  collectBuilds
-};