pyre-cli 7.0.0 → 8.0.0

package/src/formatters/render.ts

@@ -10,7 +10,7 @@
  * all layout-related code is co-located.
  */
 import chalk from 'chalk';
-import { sparkline, multiRowSparkline, brailleGraph } from '../sparkline.js';
+import { sparkline, multiRowSparkline, brailleGraph, multiRowBrailleGraph } from '../sparkline.js';
 import type { History } from '../history.js';
 import type { StatsData, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
 import { THEMES, type ThemeName, type ThemeColors } from './themes.js';
@@ -730,7 +730,7 @@ function btopCpuBox(data: StatsData, width: number, theme: ThemeColors, opts: Ta
 
     const cpuHistory = opts.history?.cpuUsage || [];
     if (cpuHistory.length > 1) {
-      const graphRows = multiRowSparkline(cpuHistory, 3, { min: 0, max: 100 });
+      const graphRows = multiRowBrailleGraph(cpuHistory, 3, { min: 0, max: 100 });
       for (const gr of graphRows) {
         leftLines.push(theme.cpu(fitVisible(gr, leftW)));
       }

package/src/index.ts

@@ -13,7 +13,7 @@ import readline from 'node:readline';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { collectAll } from './monitors/index.js';
-import { formatTable, formatJson, formatCsv, formatTsv, formatHtml, formatMarkdown, formatBytes } from './formatters/index.js';
+import { formatTable, formatJson, formatCsv, formatTsv, formatHtml, getDashboardHtml, formatMarkdown, formatBytes } from './formatters/index.js';
 import { startLive, stopLive } from './live/index.js';
 import { showSplash } from './splash.js';
 import { P2PServer, P2PClient } from './p2p/index.js';
@@ -67,6 +67,9 @@ program
     .option('--p2p-deny <ips>', 'Comma-separated list of denied IPs')
     .option('--p2p-audit-log <dir>', 'Directory for P2P audit logs')
     .option('--p2p-hmac-key <key>', 'HMAC key for message signing (default: derived from password)')
+    .option('--since <range>', 'Time range for anomalies digest (e.g. 1d, 7d, yesterday)')
+    .option('--plain', 'Output in plain accessible text without ANSI colors or line-drawing characters')
+    .option('--a11y', 'Alias for --plain')
     .option('--webhook-url <url>', 'URL to POST to on alert')
     .option('--alert-cmd <cmd>', 'Command to execute on alert')
     .option('--port <port>', 'Port number for web server mode', '3000');
@@ -75,6 +78,10 @@ program.parse(process.argv);
 
 const opts = program.opts();
 
+if (opts.plain || opts.a11y) {
+  chalk.level = 0;
+}
+
 function isExportMode() {
   return opts.json || opts.csv || opts.tsv || opts.html || opts.md;
 }
@@ -145,6 +152,61 @@ async function runServerCommand(): Promise<void> {
 async function main() {
   const cmd = program.args[0];
 
+  if (cmd === 'anomalies') {
+    const { runAnomaliesDigest } = await import('./anomaliesCmd.js');
+    runAnomaliesDigest({ since: opts.since || '7d', dir: opts.exportDir });
+    return;
+  }
+
+  if (cmd === 'extensions') {
+    const { printExtensionsReport } = await import('./extensions.js');
+    await printExtensionsReport();
+    return;
+  }
+
+  if (cmd === 'brew') {
+    const { printBrewHealthReport } = await import('./brewHealth.js');
+    await printBrewHealthReport();
+    return;
+  }
+
+  if (cmd === 'update') {
+    const { printUpdateReport } = await import('./updateCheck.js');
+    await printUpdateReport(pkg.version);
+    return;
+  }
+
+  if (cmd === 'profile') {
+    const sub = program.args[1];
+    const name = program.args[2];
+    const { saveProfile, loadProfile, listProfiles } = await import('./state/config.js');
+    if (sub === 'save' && name) {
+      saveProfile(name);
+      console.log(chalk.green(`  ✔ Profile '${name}' saved successfully.`));
+    } else if (sub === 'load' && name) {
+      try {
+        loadProfile(name);
+        console.log(chalk.green(`  ✔ Profile '${name}' loaded successfully.`));
+      } catch (err: any) {
+        console.log(chalk.red(`  ✖ ${err.message}`));
+      }
+    } else if (sub === 'list') {
+      const profiles = listProfiles();
+      console.log(chalk.bold('\n  pyre Profiles:\n'));
+      if (profiles.length === 0) {
+        console.log(chalk.dim('  No saved profiles found. Save one with `pyre profile save <name>`.'));
+      } else {
+        for (const p of profiles) {
+          console.log(`  • ${p}`);
+        }
+      }
+      console.log();
+    } else {
+      console.log('Usage: pyre profile <save|load|list> [name]');
+    }
+    return;
+  }
+
   if (cmd === 'history') {
     const daysIdx = program.args.indexOf('--days');
     const days = daysIdx !== -1 ? parseInt(program.args[daysIdx + 1], 10) || 7 : 7;
@@ -178,6 +240,11 @@ async function main() {
     return;
   }
 
+  if (cmd === 'ui') {
+    await runUiCommand();
+    return;
+  }
+
   if (cmd === 'bench') {
     const benchCmd = program.args.slice(1).join(' ');
     if (!benchCmd) {
@@ -212,6 +279,25 @@ async function main() {
     return;
   }
 
+  if (cmd === 'doctor') {
+    const { runDoctor, printDoctorReport } = await import('./doctor.js');
+    const checks = await runDoctor();
+    printDoctorReport(checks);
+    return;
+  }
+
+  if (cmd === 'info') {
+    await runInfoCommand();
+    return;
+  }
+
+  if (cmd === 'completions') {
+    const { printCompletions } = await import('./completions.js');
+    const shell = program.args[1] || 'zsh';
+    printCompletions(shell);
+    return;
+  }
+
   if (cmd === 'fleet') {
     const hosts = program.args.slice(1);
     if (hosts.length === 0) {
@@ -492,8 +578,12 @@ async function runP2PConnect(): Promise<void> {
 
 async function runInfoCommand(): Promise<void> {
   const data = await collectAll({ detailed: true });
+  const { getDisplayInfo, getTimeMachineStatus } = await import('./monitors/collectors.js');
+  const displays = await getDisplayInfo();
+  const tmStatus = await getTimeMachineStatus();
+
   const lines: string[] = [];
-  lines.push(chalk.bold('  pyre info'));
+  lines.push(chalk.bold('  pyre info — Mac System Information'));
   lines.push('');
   lines.push(`  Hostname:  ${data.header.hostname}`);
   lines.push(`  OS:        ${data.header.os}`);
@@ -501,13 +591,34 @@ async function runInfoCommand(): Promise<void> {
   lines.push(`  CPU:       ${data.cpu.brand}`);
   lines.push(`  Cores:     ${data.cpu.physicalCores}/${data.cpu.cores} (phys/log)`);
   lines.push(`  Frequency: ${data.cpu.frequency} MHz`);
-  lines.push(`  Memory:    ${formatBytes(data.memory.total)}`);
+  lines.push(`  Memory:    ${formatBytes(data.memory.total)}${data.memory.pressureLevel ? ` (Pressure: ${data.memory.pressureLevel})` : ''}`);
+  if (data.memory.wiredBytes !== undefined && data.memory.compressedBytes !== undefined) {
+    lines.push(`             Wired: ${formatBytes(data.memory.wiredBytes)} | Compressed: ${formatBytes(data.memory.compressedBytes)}`);
+  }
   if (data.gpu) lines.push(`  GPU:       ${data.gpu.model} (${formatBytes(data.gpu.memory)})`);
   if (data.battery) {
     lines.push(`  Battery:   ${data.battery.level}% (${data.battery.state})`);
     lines.push(`  Health:    ${data.battery.health}`);
   }
   lines.push(`  Thermal:   ${data.thermal.state}`);
+
+  if (displays.length > 0) {
+    lines.push('');
+    lines.push(chalk.cyan.bold('  🖥 Displays:'));
+    for (const d of displays) {
+      lines.push(`    • ${d.name}: ${d.resolution}${d.isMain ? ' (Main)' : ''}${d.connectionType ? ` [${d.connectionType}]` : ''}`);
+    }
+  }
+
+  lines.push('');
+  lines.push(chalk.cyan.bold('  ⏱ Time Machine Backup:'));
+  if (!tmStatus.configured) {
+    lines.push('    • Not configured');
+  } else {
+    lines.push(`    • Status: ${tmStatus.running ? chalk.yellow(`Backup in progress (${tmStatus.percent || 0}%)`) : chalk.green('Idle')}`);
+    lines.push(`    • Latest Backup: ${tmStatus.latestBackup}`);
+  }
+
   console.log(lines.join('\n'));
 }
 
@@ -541,9 +652,9 @@ async function runSshCommand(host: string): Promise<void> {
   });
 }
 
-async function runWebCommand(): Promise<void> {
+async function runWebCommand(): Promise<number> {
   const http = await import('node:http');
-  const port = parseInt(opts.port || process.env.PORT || '3000', 10) || 3000;
+  const port = parseInt(opts.port || process.env.PORT || '3000', 10) || (opts.port === '0' ? 0 : 3000);
 
   const server = http.createServer(async (req, res) => {
     const url = req.url || '/';
@@ -585,17 +696,14 @@ async function runWebCommand(): Promise<void> {
     // 4. Static/Dynamic HTML live dashboard & API snapshot endpoints
     if (url === '/' || url === '/index.html') {
       res.writeHead(200, { 'Content-Type': 'text/html' });
-      const data = await collectAll({ detailed: true });
-      const htmlContent = formatHtml(data);
-      res.end(htmlContent);
+      res.end(getDashboardHtml());
     } else if (url === '/setup') {
       res.writeHead(200, { 'Content-Type': 'text/html' });
       const indexPath = path.join(process.cwd(), 'index.html');
       if (fs.existsSync(indexPath)) {
         res.end(fs.readFileSync(indexPath, 'utf-8'));
       } else {
-        const data = await collectAll({ detailed: true });
-        res.end(formatHtml(data));
+        res.end(getDashboardHtml());
       }
     } else if (url === '/api' || url === '/api/stats' || url === '/data') {
       const data = await collectAll({ detailed: true });
@@ -625,20 +733,145 @@ async function runWebCommand(): Promise<void> {
 
   const ip = detectLocalIP() || 'localhost';
 
-  server.listen(port, '0.0.0.0', () => {
-    console.log(chalk.bold(`\n  pyre web server running on port ${port}`));
-    console.log(chalk.dim(`  Local URL:   http://localhost:${port}/`));
-    console.log(chalk.hex('#ff6a39').bold(`  Network URL: http://${ip}:${port}/  (Accessible on same Wi-Fi / LAN)`));
-    console.log(chalk.dim(`  API:         http://${ip}:${port}/api`));
-    console.log(chalk.dim(`  SSE Stream:  http://${ip}:${port}/api/stream`));
-    console.log(chalk.yellow(`\n  Troubleshooting connection from phone/other devices:`));
-    console.log(chalk.dim(`  1. macOS Firewall: System Settings -> Network -> Firewall -> Allow incoming node/pyre connections`));
-    console.log(chalk.dim(`  2. Wi-Fi Router: Ensure "AP Isolation" / "Guest Mode" is OFF on your Wi-Fi router`));
-    console.log(chalk.dim(`  3. Verify phone is connected to the exact same Wi-Fi network\n`));
+  return new Promise((resolve) => {
+    server.listen(port, '0.0.0.0', () => {
+      const address = server.address();
+      const actualPort = typeof address === 'object' && address ? address.port : port;
+      
+      console.log(chalk.bold(`\n  pyre web server running on port ${actualPort}`));
+      console.log(chalk.dim(`  Local URL:   http://localhost:${actualPort}/`));
+      console.log(chalk.hex('#ff6a39').bold(`  Network URL: http://${ip}:${actualPort}/  (Accessible on same Wi-Fi / LAN)`));
+      console.log(chalk.dim(`  API:         http://${ip}:${actualPort}/api`));
+      console.log(chalk.dim(`  SSE Stream:  http://${ip}:${actualPort}/api/stream`));
+      
+      resolve(actualPort);
+    });
+
+    process.once('SIGINT', () => {
+      server.close();
+      process.exit(0);
+    });
+  });
+}
+
+async function runUiCommand(): Promise<void> {
+  // Use a random ephemeral port to avoid collisions
+  opts.port = '0';
+  const port = await runWebCommand();
+  
+  const swiftScript = `
+import Cocoa
+import WebKit
+
+// WKWebView subclass that allows the window to be dragged from any pixel
+class DraggableWebView: WKWebView {
+    override var mouseDownCanMoveWindow: Bool { return true }
+}
+
+class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
+    var window: NSWindow!
+    var webView: DraggableWebView!
+    var dataTimer: Timer?
+    let serverPort = ${port}
+
+    func applicationDidFinishLaunching(_ n: Notification) {
+        // Window
+        let screen = NSScreen.main?.visibleFrame ?? NSRect(x:0, y:0, width:1280, height:800)
+        let W = min(1180.0, screen.width - 80)
+        let H = min(820.0, screen.height - 80)
+        let rect = NSRect(x: screen.minX + (screen.width - W) / 2,
+                          y: screen.minY + (screen.height - H) / 2,
+                          width: W, height: H)
+
+        window = NSWindow(contentRect: rect,
+                          styleMask: [.titled, .closable, .miniaturizable, .resizable],
+                          backing: .buffered, defer: false)
+        window.title = "Pyre"
+        window.minSize = NSSize(width: 800, height: 600)
+        window.appearance = NSAppearance(named: .darkAqua)
+        window.backgroundColor = NSColor(white: 0, alpha: 1)
+        window.isReleasedWhenClosed = false
+        window.delegate = self
+
+        // WebView
+        let cfg = WKWebViewConfiguration()
+        webView = DraggableWebView(frame: window.contentView!.bounds, configuration: cfg)
+        webView.autoresizingMask = [.width, .height]
+        webView.setValue(NSColor(white: 0, alpha: 1),
+                         forKey: "backgroundColor")
+
+        // Load the dashboard HTML from the local server
+        var req = URLRequest(url: URL(string: "http://localhost:\\(serverPort)/")!)
+        req.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
+        webView.load(req)
+
+        window.contentView?.addSubview(webView)
+        window.makeKeyAndOrderFront(nil)
+        NSApp.activate(ignoringOtherApps: true)
+
+        // Start native data timer (URLSession has full network access — no sandbox issues)
+        // We wait 1.5 s for the page to load, then start pushing data every 2 s.
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) { [weak self] in
+            self?.fetchAndPush()
+            self?.dataTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: true) { [weak self] _ in
+                self?.fetchAndPush()
+            }
+        }
+    }
+
+    // URLSession fetch (runs in the main app process — not sandboxed like WebContent)
+    func fetchAndPush() {
+        guard let url = URL(string: "http://localhost:\\(serverPort)/api/stats") else { return }
+        URLSession.shared.dataTask(with: url) { [weak self] data, _, err in
+            if let err = err {
+                print("Swift UI Fetch Error: \\(err)")
+                return
+            }
+            guard let data = data else {
+                print("Swift UI Fetch Error: No data")
+                return
+            }
+            let b64 = data.base64EncodedString()
+            let js = "if(window.__pyreUpdate){window.__pyreUpdate(decodeURIComponent(escape(atob('\\(b64)'))))}"
+            DispatchQueue.main.async {
+                self?.webView.evaluateJavaScript(js) { res, err in
+                    if let err = err {
+                        print("Swift UI JS Eval Error: \\(err)")
+                    }
+                }
+            }
+        }.resume()
+    }
+
+    func windowWillClose(_ n: Notification) {
+        dataTimer?.invalidate()
+        NSApplication.shared.terminate(self)
+    }
+    func applicationShouldTerminateAfterLastWindowClosed(_ s: NSApplication) -> Bool { true }
+}
+
+let app = NSApplication.shared
+app.setActivationPolicy(.regular)
+let delegate = AppDelegate()
+app.delegate = delegate
+app.run()
+`;
+
+
+  const scriptPath = path.join(os.tmpdir(), 'pyre-ui.swift');
+  fs.writeFileSync(scriptPath, swiftScript);
+
+  const { spawn } = await import('node:child_process');
+  console.log(chalk.cyan(`\n  Launching native UI window...`));
+  const ui = spawn('swift', [scriptPath], { stdio: 'inherit' });
+  
+  ui.on('close', () => {
+    console.log(chalk.dim('UI window closed, shutting down server...'));
+    process.exit(0);
   });
 
   process.once('SIGINT', () => {
-    server.close();
+    ui.kill();
     process.exit(0);
   });
 }
@@ -650,12 +883,16 @@ async function runBenchCommand(benchCmd: string): Promise<void> {
 
   if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
   const stream = fs.createWriteStream(file, { flags: 'a' });
-  stream.write('timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,net_rx_packets,net_tx_packets,connections,thermal_state\n');
+  stream.write('timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,net_rx_packets,net_tx_packets,connections,thermal_state,power_watts\n');
 
   console.log(chalk.bold(`\n  pyre bench`));
   console.log(chalk.dim(`  Command: ${benchCmd}`));
   console.log(chalk.dim(`  Log: ${file}\n`));
 
+  const startTime = Date.now();
+  let accumulatedWattSeconds = 0;
+  let powerSamplesCount = 0;
+
   const child = spawn('sh', ['-c', benchCmd]);
   child.stdout.on('data', d => process.stdout.write(d));
   child.stderr.on('data', d => process.stdout.write(d));
@@ -668,23 +905,40 @@ async function runBenchCommand(benchCmd: string): Promise<void> {
       const rxPackets = data.network.rxPackets ?? 0;
       const txPackets = data.network.txPackets ?? 0;
       const connections = data.network.connections ?? 0;
-      stream.write(`${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${rxPackets},${txPackets},${connections},${data.thermal.state}\n`);
+      const watts = data.power?.combinedWatts ?? data.power?.cpuWatts;
+      if (watts !== undefined && watts > 0) {
+        accumulatedWattSeconds += watts * interval;
+        powerSamplesCount++;
+      }
+      stream.write(`${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${rxPackets},${txPackets},${connections},${data.thermal.state},${watts ?? ''}\n`);
     } catch {
       // skip bad tick
     }
   }, interval * 1000);
 
-  child.on('close', () => {
+  const printSummary = () => {
     clearInterval(handle);
     stream.end();
-    console.log(chalk.green(`\n  Bench complete. Log saved to ${file}`));
+    const durationSec = Math.max(0.1, (Date.now() - startTime) / 1000);
+    console.log(chalk.green(`\n  ✔ Bench complete (${durationSec.toFixed(2)}s). Log saved to ${file}`));
+
+    if (powerSamplesCount > 0 && accumulatedWattSeconds > 0) {
+      const kWh = accumulatedWattSeconds / (3600 * 1000);
+      const rate = config.electricityRateKwH ?? 0.15;
+      const cost = kWh * rate;
+      console.log(chalk.cyan(`  ⚡ Energy Consumption: ${kWh.toFixed(6)} kWh | Est. Cost: $${cost.toFixed(6)} (@ $${rate}/kWh)`));
+    }
+  };
+
+  child.on('close', () => {
+    printSummary();
     process.exit(0);
   });
 
   process.once('SIGINT', () => {
     clearInterval(handle);
     child.kill('SIGTERM');
-    stream.end();
+    printSummary();
     process.exit(0);
   });
 }

package/src/live/input.ts

@@ -42,10 +42,10 @@ import { writeConfig } from '../state/config.js';
   }
 
   function isUpKey(key: readline.Key, str?: string): boolean {
-  return key.name === 'up' || str === 'k' || key.sequence === '\x1b[A' || key.sequence === '\x1bOA';
+  return key.name === 'up' || key.sequence === '\x1b[A' || key.sequence === '\x1bOA';
 }
 function isDownKey(key: readline.Key, str?: string): boolean {
-  return key.name === 'down' || str === 'j' || key.sequence === '\x1b[B' || key.sequence === '\x1bOB';
+  return key.name === 'down' || key.sequence === '\x1b[B' || key.sequence === '\x1bOB';
 }
 function isEnterKey(key: readline.Key, str?: string): boolean {
   return key.name === 'return' || key.name === 'enter' || key.sequence === '\r' || key.sequence === '\n' || str === '\r' || str === '\n';
@@ -207,12 +207,24 @@ function handleInputModeKey(str: string, key: readline.Key) {
    }
  }
 
+let confirmKillPid: number | null = null;
+
 function killProcess(pidStr: string, signal: string = 'SIGTERM') {
    const pid = parseInt(pidStr, 10);
    if (!pid || pid <= 0) {
      setStatus(`Invalid PID: ${pidStr}`);
      return;
    }
+
+   const isProtected = pid === 1 || pid === process.pid || pid === process.ppid;
+   if (isProtected && confirmKillPid !== pid) {
+     confirmKillPid = pid;
+     const name = pid === 1 ? 'launchd (system init)' : (pid === process.pid ? 'pyre itself' : 'parent process');
+     setStatus(`⚠️ PROTECTED PID ${pid} (${name})! Re-enter PID ${pid} to confirm termination.`, 8000);
+     return;
+   }
+
+   confirmKillPid = null;
    try {
      process.kill(pid, signal as NodeJS.Signals);
      setStatus(`Sent ${signal} to PID ${pid}`);

package/src/monitors/collectors.ts

@@ -466,6 +466,14 @@ export async function collectMemory(): Promise<MemoryData> {
   const wiredPages = getPageCount('wired down');
   const compressedPages = getPageCount('occupied by compressor');
 
+  const purgeablePages = getPageCount('purgeable');
+  const getStatCount = (label: string) => {
+    const m = vmStat.match(new RegExp(`${label}:\\s+(\\d+)\\.`));
+    return m ? parseInt(m[1]) : 0;
+  };
+  const swapIns = getStatCount('Swapins') || getStatCount('Pageins');
+  const swapOuts = getStatCount('Swapouts') || getStatCount('Pageouts');
+
   const free = freePages * pageSize;
   const used = (activePages + inactivePages + wiredPages + compressedPages) * pageSize;
   const usagePercent = totalBytes > 0 ? Math.round((used / totalBytes) * 100) : 0;
@@ -475,11 +483,6 @@ export async function collectMemory(): Promise<MemoryData> {
   let swapFree = 0;
   try {
     const swapRaw = (await run('sysctl -n vm.swapusage')).trim();
-    // Real output is "total = 3072.00M  used = 1497.75M  free = 1574.25M
-    // (encrypted)" — the parentheses wrap the trailing "(encrypted)" note,
-    // not the used value. The old regex required a literal "(" right before
-    // "used", which never appears, so this never matched and swap stayed at
-    // 0 forever instead of updating.
     const swapMatch = swapRaw.match(
       /total\s*=\s*([\d.]+)([KMGkmg])\s+used\s*=\s*([\d.]+)([KMGkmg])\s+free\s*=\s*([\d.]+)([KMGkmg])/
     );
@@ -492,6 +495,18 @@ export async function collectMemory(): Promise<MemoryData> {
     // ignore
   }
 
+  let pressureLevel = 'Normal';
+  try {
+    const pressVal = (await run('sysctl -n kern.memorystatus_vm_pressure_level')).trim();
+    const pressNum = parseInt(pressVal, 10);
+    if (pressNum === 2) pressureLevel = 'Warning';
+    else if (pressNum >= 4) pressureLevel = 'Critical';
+    else if (!isNaN(pressNum)) pressureLevel = 'Normal';
+    else pressureLevel = pressVal || 'Normal';
+  } catch {
+    pressureLevel = 'Normal';
+  }
+
   return {
     total: totalBytes,
     used,
@@ -501,6 +516,12 @@ export async function collectMemory(): Promise<MemoryData> {
     swapFree,
     pageSize,
     usagePercent,
+    wiredBytes: wiredPages * pageSize,
+    compressedBytes: compressedPages * pageSize,
+    purgeableBytes: purgeablePages * pageSize,
+    swapIns,
+    swapOuts,
+    pressureLevel,
   };
 }
 
@@ -855,7 +876,91 @@ export async function collectTasks(limit = 12): Promise<TaskData[]> {
           return { pid: parseInt(parts[1]), user: parts[2], cpu: parseFloat(parts[3]), mem: parseFloat(parts[4]), state: parts[5], runtime: runtimeSec, command: parts[7] };
        })
        .filter((t): t is TaskData => t !== null && t.pid > 0);
+   } catch {
+     return [];
+   }
+ }
+
+export interface DisplayInfo {
+  name: string;
+  resolution: string;
+  connectionType?: string;
+  isMain?: boolean;
+}
+
+export async function getDisplayInfo(): Promise<DisplayInfo[]> {
+  try {
+    const raw = await run('system_profiler SPDisplaysDataType 2>&1', '');
+    const displays: DisplayInfo[] = [];
+    const lines = raw.split('\n');
+    let currentName = '';
+    let currentRes = '';
+    let isMain = false;
+    let connType = '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith(':') && !trimmed.startsWith('Chipset') && !trimmed.startsWith('Displays') && !trimmed.startsWith('Graphics')) {
+        if (currentName && currentRes) {
+          displays.push({ name: currentName, resolution: currentRes, isMain, connectionType: connType || undefined });
+          currentRes = '';
+          isMain = false;
+          connType = '';
+        }
+        currentName = trimmed.slice(0, -1);
+      } else if (trimmed.startsWith('Resolution:')) {
+        currentRes = trimmed.replace('Resolution:', '').trim();
+      } else if (trimmed.startsWith('Main Display: Yes')) {
+        isMain = true;
+      } else if (trimmed.startsWith('Connection Type:')) {
+        connType = trimmed.replace('Connection Type:', '').trim();
+      }
+    }
+    if (currentName && currentRes) {
+      displays.push({ name: currentName, resolution: currentRes, isMain, connectionType: connType || undefined });
+    }
+    return displays;
   } catch {
     return [];
   }
+}
+
+export interface TimeMachineStatus {
+  configured: boolean;
+  running: boolean;
+  percent?: number;
+  latestBackup?: string;
+}
+
+export async function getTimeMachineStatus(): Promise<TimeMachineStatus> {
+  try {
+    const statusRaw = await run('tmutil status 2>&1', '');
+    if (statusRaw.includes('No Time Machine destination') || statusRaw.includes('not configured')) {
+      return { configured: false, running: false };
+    }
+
+    const running = statusRaw.includes('Running = 1;');
+    let percent: number | undefined = undefined;
+    const pctMatch = statusRaw.match(/Percent\s*=\s*"?(0\.\d+|\d+)"?/i);
+    if (pctMatch) {
+      percent = Math.round(parseFloat(pctMatch[1]) * 100);
+    }
+
+    let latestBackup = 'Unknown';
+    try {
+      const latestRaw = await run('tmutil latestbackup 2>&1', '');
+      if (latestRaw.trim() && !latestRaw.includes('error') && !latestRaw.includes('No backups')) {
+        const basename = latestRaw.trim().split('/').pop() || latestRaw.trim();
+        latestBackup = basename.replace('.previous', '').replace('.backup', '');
+      } else {
+        latestBackup = 'No backup found / Unmounted';
+      }
+    } catch {
+      latestBackup = 'Not mounted';
+    }
+
+    return { configured: true, running, percent, latestBackup };
+  } catch {
+    return { configured: false, running: false };
+  }
 }

package/src/monitors/types.ts

@@ -80,6 +80,12 @@ export interface MemoryData {
   swapFree: number;
   pageSize: number;
   usagePercent: number;
+  wiredBytes?: number;
+  compressedBytes?: number;
+  purgeableBytes?: number;
+  swapIns?: number;
+  swapOuts?: number;
+  pressureLevel?: string;
 }
 
 export interface ThermalData {