pyre-cli 10.2.0 → 10.4.0

package/src/platform.test.ts

@@ -82,6 +82,141 @@ describe('Windows Telemetry Parsers', () => {
   });
 });
 
+describe('Intel, AMD & NVIDIA Hardware Telemetry', () => {
+  it('should parse NVIDIA GPU telemetry from nvidia-smi correctly', async () => {
+    const { parseNvidiaSmiOutput } = await import('./monitors/platform/windows.js');
+    const sampleCsv = `NVIDIA GeForce RTX 4090, 24564, 42, 58, 215.4\n`;
+    const gpu = parseNvidiaSmiOutput(sampleCsv);
+    assert.ok(gpu !== null);
+    assert.strictEqual(gpu.model, 'NVIDIA GeForce RTX 4090');
+    assert.strictEqual(gpu.memory, 24564 * 1024 * 1024);
+    assert.strictEqual(gpu.utilization, 42);
+    assert.strictEqual(gpu.temperature, 58);
+    assert.strictEqual(gpu.powerDraw, 215.4);
+  });
+
+  it('should parse and prioritize AMD and Intel GPUs over integrated adapters', async () => {
+    const { parseWindowsVideoControllers, prioritizeGpuControllers } = await import('./monitors/platform/windows.js');
+    const sampleCsv = `"Name","AdapterRAM","DriverVersion","VideoProcessor","PNPDeviceID"
+"AMD Radeon(TM) Graphics","536870912","31.0.12.0","AMD Radeon Graphics Processor","PCI\\VEN_1002&DEV_164E"
+"AMD Radeon RX 7900 XTX","4294967295","31.0.24.0","Navi 31","PCI\\VEN_1002&DEV_744C"`;
+
+    const controllers = parseWindowsVideoControllers(sampleCsv);
+    assert.strictEqual(controllers.length, 2);
+
+    const prioritized = prioritizeGpuControllers(controllers);
+    assert.strictEqual(prioritized[0].name, 'AMD Radeon RX 7900 XTX');
+  });
+
+  it('should parse Intel Arc discrete GPU correctly', async () => {
+    const { parseWindowsVideoControllers, prioritizeGpuControllers } = await import('./monitors/platform/windows.js');
+    const sampleCsv = `"Name","AdapterRAM","DriverVersion","VideoProcessor","PNPDeviceID"
+"Intel(R) UHD Graphics 770","1073741824","31.0.101.4000","Intel(R) UHD Graphics Family","PCI\\VEN_8086&DEV_4680"
+"Intel(R) Arc(TM) A770 Graphics","4294967295","31.0.101.5000","Intel(R) Arc(TM) A-Series Graphics","PCI\\VEN_8086&DEV_56A0"`;
+
+    const controllers = parseWindowsVideoControllers(sampleCsv);
+    const prioritized = prioritizeGpuControllers(controllers);
+    assert.strictEqual(prioritized[0].name, 'Intel(R) Arc(TM) A770 Graphics');
+  });
+
+  it('should detect CPU vendors and estimate architecture TDP accurately', async () => {
+    const { detectProcessorVendor, estimateCpuTdp } = await import('./monitors/platform/windows.js');
+    // AMD tests
+    assert.strictEqual(detectProcessorVendor('AMD Ryzen 9 7950X 16-Core Processor'), 'amd');
+    assert.strictEqual(estimateCpuTdp('AMD Ryzen 9 7950X'), 170);
+    assert.strictEqual(estimateCpuTdp('AMD Ryzen 7 7800X3D'), 105);
+    assert.strictEqual(estimateCpuTdp('AMD Ryzen 5 5600'), 65);
+
+    // Intel tests
+    assert.strictEqual(detectProcessorVendor('13th Gen Intel(R) Core(TM) i9-13900K'), 'intel');
+    assert.strictEqual(estimateCpuTdp('Intel(R) Core(TM) i9-13900K'), 125);
+    assert.strictEqual(estimateCpuTdp('Intel(R) Core(TM) Ultra 7 155H'), 45);
+    assert.strictEqual(estimateCpuTdp('Intel(R) Core(TM) i5-12400'), 65);
+  });
+
+  it('should parse Windows processes with ParentProcessId (ppid) for tree view', async () => {
+    const { parseWindowsProcessCsv } = await import('./monitors/platform/windows.js');
+    const sampleCsv = `"Name","ProcessId","ParentProcessId","ThreadCount","WorkingSetSize","UserModeTime","KernelModeTime","CommandLine"
+"explorer.exe","1024","512","48","157286400","50000000","25000000","C:\\Windows\\explorer.exe"
+"chrome.exe","2048","1024","32","314572800","100000000","50000000","chrome.exe"
+"python.exe","4096","1024","8","524288000","150000000","75000000","python.exe -m torch"`;
+
+    const cache = new Map();
+    const procs = parseWindowsProcessCsv(sampleCsv, 32 * 1024 * 1024 * 1024, cache, Date.now());
+
+    assert.strictEqual(procs.length, 3);
+    const explorer = procs.find(p => p.pid === 1024);
+    const chrome = procs.find(p => p.pid === 2048);
+    const python = procs.find(p => p.pid === 4096);
+
+    assert.ok(explorer);
+    assert.strictEqual(explorer?.ppid, 512);
+
+    assert.ok(chrome);
+    assert.strictEqual(chrome?.ppid, 1024); // Parent is explorer! Process tree works!
+
+    assert.ok(python);
+    assert.strictEqual(python?.ppid, 1024);
+    assert.strictEqual(python?.isGpuOrMlAttributed, true);
+  });
+
+  it('should parse Windows TCP sockets and build per-app network usage', async () => {
+    const { parseWindowsTcpConnections, buildWindowsNetworkProcesses } = await import('./monitors/platform/windows.js');
+    const sampleConns = `"LocalPort","RemoteAddress","RemotePort","State","OwningProcess"
+"51234","142.250.190.46","443","Established","2048"
+"51235","142.250.190.46","443","Established","2048"
+"8080","0.0.0.0","0","Listen","4096"`;
+
+    const conns = parseWindowsTcpConnections(sampleConns);
+    assert.strictEqual(conns.length, 3);
+
+    const procMap = new Map([[2048, 'chrome.exe'], [4096, 'node.exe']]);
+    const netProcs = buildWindowsNetworkProcesses(conns, procMap);
+
+    assert.strictEqual(netProcs.length, 2);
+    assert.strictEqual(netProcs[0].command, 'chrome.exe');
+    assert.strictEqual(netProcs[0].connections.length, 2);
+  });
+
+  it('should parse Windows physical disk health and reliability', async () => {
+    const { parseWindowsPhysicalDiskCsv, parseWindowsReliabilityCsv } = await import('./smartCmd.js');
+    const sampleDiskCsv = `"DeviceId","FriendlyName","SerialNumber","MediaType","HealthStatus","Size"
+"0","Samsung SSD 980 PRO 2TB","S5GXNX0T123456","SSD","Healthy","2000398934016"`;
+
+    const disks = parseWindowsPhysicalDiskCsv(sampleDiskCsv);
+    assert.strictEqual(disks.length, 1);
+    assert.strictEqual(disks[0].model, 'Samsung SSD 980 PRO 2TB');
+    assert.strictEqual(disks[0].health, 'PASSED');
+    assert.strictEqual(disks[0].protocol, 'SSD');
+    assert.strictEqual(disks[0].capacity, '2.0 TB');
+
+    const sampleRelCsv = `"Temperature","Wear","PowerOnHours","ReadErrorsTotal","WriteErrorsTotal"
+"42","3","4500","0","0"`;
+    const rel = parseWindowsReliabilityCsv(sampleRelCsv);
+    assert.strictEqual(rel.tempC, 42);
+    assert.strictEqual(rel.percentUsed, 3);
+    assert.strictEqual(rel.powerOnHours, 4500);
+    assert.strictEqual(rel.reallocatedSectors, 0);
+  });
+
+  it('should parse Windows ARP table for topology discovery', async () => {
+    const { parseWindowsArpOutput } = await import('./topoCmd.js');
+    const sampleArp = `
+Interface: 192.168.1.150 --- 0x3
+  Internet Address      Physical Address      Type
+  192.168.1.1           00-11-22-33-44-55     dynamic
+  192.168.1.200         aa-bb-cc-dd-ee-ff     dynamic
+`;
+    const peers = parseWindowsArpOutput(sampleArp, '192.168.1.1');
+    assert.strictEqual(peers.length, 2);
+    assert.strictEqual(peers[0].ip, '192.168.1.1');
+    assert.strictEqual(peers[0].mac, '00:11:22:33:44:55');
+    assert.strictEqual(peers[0].isGateway, true);
+    assert.strictEqual(peers[1].ip, '192.168.1.200');
+    assert.strictEqual(peers[1].isGateway, false);
+  });
+});
+
 describe('Cross-Platform Service & Package Management', () => {
   it('should report package manager health without crashing', async () => {
     const { getBrewHealth } = await import('./brewHealth.js');

package/src/playbookCmd.ts

@@ -0,0 +1,156 @@
+/**
+ * pyre playbook — Multi-Step Macro Recipes & Playbooks.
+ *
+ * Runs sequenced Pyre diagnostic, optimization, and benchmark workflows
+ * with progress reporting and consolidated summary logs.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import chalk from 'chalk';
+import { getConfigDir } from './state/config.js';
+
+export interface PlaybookStep {
+  name: string;
+  command: string; // e.g. "check --detailed"
+  description?: string;
+  allowFailure?: boolean;
+}
+
+export interface Playbook {
+  id: string;
+  name: string;
+  description: string;
+  category: 'audit' | 'bench' | 'maintenance' | 'triage';
+  steps: PlaybookStep[];
+}
+
+export const BUILTIN_PLAYBOOKS: Playbook[] = [
+  {
+    id: 'audit',
+    name: 'Full System Health Audit',
+    description: 'Run health check, diagnostic doctor, drive S.M.A.R.T., and package manager audit',
+    category: 'audit',
+    steps: [
+      { name: 'System Health Check', command: 'check' },
+      { name: 'Doctor Diagnostics', command: 'doctor' },
+      { name: 'Drive S.M.A.R.T. Health', command: 'smart', allowFailure: true },
+      { name: 'Package Manager Health', command: 'brew', allowFailure: true },
+    ],
+  },
+  {
+    id: 'clean',
+    name: 'Complete Mac Maintenance & Cleanup',
+    description: 'Quit long-idle background apps, purge inactive memory, clean caches, flush DNS',
+    category: 'maintenance',
+    steps: [
+      { name: 'Quit Idle Apps', command: 'optimize apps --idle 2h -y' },
+      { name: 'Purge Inactive Memory', command: 'optimize memory -y' },
+      { name: 'Clean Application Caches', command: 'optimize caches --clean -y' },
+      { name: 'Flush DNS Resolver Cache', command: 'optimize dns -y' },
+    ],
+  },
+  {
+    id: 'triage',
+    name: 'Performance Spike & Incident Triage',
+    description: 'Detect historical anomalies, inspect active network usage, and audit drivers',
+    category: 'triage',
+    steps: [
+      { name: 'Z-Score Anomaly Digest', command: 'anomalies --since 1d' },
+      { name: 'Per-Application Network Usage', command: 'netusage --top 10' },
+      { name: 'System Extensions Audit', command: 'extensions', allowFailure: true },
+    ],
+  },
+  {
+    id: 'bench',
+    name: 'Quick Compute & Storage Baseline',
+    description: 'Execute CPU Pi benchmark and query physical disk health',
+    category: 'bench',
+    steps: [
+      { name: 'CPU Pi Benchmark', command: 'benchmark' },
+      { name: 'Physical Disk Health', command: 'smart', allowFailure: true },
+    ],
+  },
+];
+
+export function getCustomPlaybooks(): Playbook[] {
+  const filePath = path.join(getConfigDir(), 'playbooks.json');
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function getAllPlaybooks(): Playbook[] {
+  return [...BUILTIN_PLAYBOOKS, ...getCustomPlaybooks()];
+}
+
+export async function runPlaybook(playbookId: string): Promise<boolean> {
+  const all = getAllPlaybooks();
+  const playbook = all.find((p) => p.id === playbookId || p.name.toLowerCase() === playbookId.toLowerCase());
+
+  if (!playbook) {
+    console.error(chalk.red(`\n  ✖ Unknown playbook: '${playbookId}'`));
+    console.log(chalk.dim(`  Available playbooks: ${all.map((p) => p.id).join(', ')}\n`));
+    return false;
+  }
+
+  console.log(chalk.bold(`\n  🔥 pyre playbook: ${chalk.hex('#ff6a39')(playbook.name)}`));
+  console.log(chalk.dim(`  ${playbook.description}`));
+  console.log(chalk.dim(`  Steps (${playbook.steps.length}):`));
+  playbook.steps.forEach((step, idx) => {
+    console.log(chalk.dim(`    ${idx + 1}. ${step.name} (pyre ${step.command})`));
+  });
+  console.log(chalk.dim('  ─────────────────────────────────────────────────────────────\n'));
+
+  const scriptPath = process.argv[1];
+  const startTime = Date.now();
+  let stepIndex = 1;
+  let allSuccess = true;
+
+  for (const step of playbook.steps) {
+    console.log(chalk.bold.cyan(`\n▶ [${stepIndex}/${playbook.steps.length}] ${step.name} ...`));
+    console.log(chalk.dim(`  $ pyre ${step.command}\n`));
+
+    const tokens = step.command.trim().split(/\s+/).filter(Boolean);
+    const result = spawnSync(process.argv[0], [scriptPath, ...tokens], {
+      stdio: 'inherit',
+      env: process.env,
+    });
+
+    if (result.status !== 0 && !step.allowFailure) {
+      console.log(chalk.red(`\n  ✖ Step '${step.name}' failed with exit code ${result.status}`));
+      allSuccess = false;
+      break;
+    } else if (result.status !== 0 && step.allowFailure) {
+      console.log(chalk.yellow(`\n  ⚠ Step '${step.name}' failed but marked as optional — continuing...`));
+    } else {
+      console.log(chalk.green(`\n  ✔ Step '${step.name}' completed.`));
+    }
+    stepIndex++;
+  }
+
+  const durationSec = ((Date.now() - startTime) / 1000).toFixed(1);
+  console.log(chalk.dim('\n  ─────────────────────────────────────────────────────────────'));
+  if (allSuccess) {
+    console.log(chalk.bold.green(`  ✔ Playbook '${playbook.name}' completed successfully in ${durationSec}s\n`));
+  } else {
+    console.log(chalk.bold.red(`  ✖ Playbook '${playbook.name}' aborted after ${durationSec}s\n`));
+  }
+
+  return allSuccess;
+}
+
+export function listPlaybooks(): void {
+  const all = getAllPlaybooks();
+  console.log(chalk.bold('\n  🔥 pyre Playbooks & Macro Recipes:\n'));
+  for (const p of all) {
+    console.log(`  • ${chalk.bold.hex('#ff6a39')(p.id.padEnd(12))} ${p.name}`);
+    console.log(chalk.dim(`    ${p.description}`));
+    console.log(chalk.dim(`    Steps: ${p.steps.map((s) => s.command).join(' ➔ ')}\n`));
+  }
+}

package/src/power_features.test.ts

@@ -0,0 +1,251 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { FlightRecorder, FlightFrame } from './flightRecorder.js';
+import { BUILTIN_PLAYBOOKS } from './playbookCmd.js';
+import { parseBytesString, formatBytes, runWithBudget } from './budgetCmd.js';
+import { formatStatusline, StatuslineMetrics } from './statuslineCmd.js';
+import { detectContainerEngine, collectContainerStats } from './containersCmd.js';
+import { inspectProcess } from './inspectCmd.js';
+import { generateXbarPlugin } from './xbar.js';
+
+describe('Power-User Features', () => {
+  describe('In-Memory Flight Recorder (Black Box)', () => {
+    it('should push telemetry frames and respect max capacity', () => {
+      const recorder = new FlightRecorder(3);
+      assert.strictEqual(recorder.size(), 0);
+
+      const makeFrame = (cpuUsage: number, memUsage: number): FlightFrame => ({
+        timestamp: new Date().toISOString(),
+        cpu: { usage: cpuUsage, loadAvg: [1, 1, 1], temp: 45 },
+        memory: { usagePercent: memUsage, usedBytes: 1024 * 1024 * 500, totalBytes: 1024 * 1024 * 1000 },
+        network: { rxPackets: 100, txPackets: 80 },
+        topProcesses: [
+          { pid: 101, name: 'node', cpu: cpuUsage, mem: memUsage },
+          { pid: 102, name: 'ffmpeg', cpu: 12.5, mem: 5.0 },
+        ],
+      });
+
+      recorder.push(makeFrame(20, 30));
+      recorder.push(makeFrame(50, 60));
+      recorder.push(makeFrame(85, 75));
+      assert.strictEqual(recorder.size(), 3);
+
+      // Pushing 4th item should evict first frame (usage 20)
+      recorder.push(makeFrame(95, 80));
+      assert.strictEqual(recorder.size(), 3);
+
+      const frames = recorder.getFrames();
+      assert.strictEqual(frames[0].cpu.usage, 50);
+      assert.strictEqual(frames[2].cpu.usage, 95);
+    });
+
+    it('should generate structured forensic report with peak metrics', () => {
+      const recorder = new FlightRecorder(10);
+      recorder.push({
+        timestamp: '2026-10-12T10:00:00.000Z',
+        cpu: { usage: 40, loadAvg: [1.2], temp: 50 },
+        memory: { usagePercent: 55, usedBytes: 4000, totalBytes: 8000 },
+        network: { rxPackets: 10, txPackets: 5 },
+        topProcesses: [{ pid: 100, name: 'worker1', cpu: 35, mem: 20 }],
+      });
+      recorder.push({
+        timestamp: '2026-10-12T10:00:05.000Z',
+        cpu: { usage: 98, loadAvg: [3.5], temp: 88 },
+        memory: { usagePercent: 82, usedBytes: 7000, totalBytes: 8000 },
+        network: { rxPackets: 50, txPackets: 40 },
+        topProcesses: [
+          { pid: 200, name: 'runaway_app', cpu: 92, mem: 65 },
+          { pid: 100, name: 'worker1', cpu: 5, mem: 15 },
+        ],
+      });
+
+      const report = recorder.generateReport();
+      assert.strictEqual(report.frameCount, 2);
+      assert.strictEqual(report.timeSpanSec, 5);
+      assert.strictEqual(report.summary.peakCpuUsage, 98);
+      assert.strictEqual(report.summary.peakMemUsage, 82);
+      assert.strictEqual(report.summary.peakTempC, 88);
+      assert.strictEqual(report.summary.highestCpuProcess?.name, 'runaway_app');
+      assert.strictEqual(report.summary.highestCpuProcess?.pid, 200);
+      assert.strictEqual(report.summary.highestMemProcess?.name, 'runaway_app');
+    });
+
+    it('should dump forensic report to file', () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pyre-flight-test-'));
+      const recorder = new FlightRecorder(5);
+      recorder.push({
+        timestamp: new Date().toISOString(),
+        cpu: { usage: 10, loadAvg: [0.5] },
+        memory: { usagePercent: 20, usedBytes: 200, totalBytes: 1000 },
+        network: { rxPackets: 1, txPackets: 1 },
+        topProcesses: [{ pid: 1, name: 'init', cpu: 1, mem: 1 }],
+      });
+
+      const dumpPath = recorder.dump(tmpDir);
+      assert.ok(fs.existsSync(dumpPath));
+      const parsed = JSON.parse(fs.readFileSync(dumpPath, 'utf-8'));
+      assert.strictEqual(parsed.frameCount, 1);
+      assert.strictEqual(parsed.summary.peakCpuUsage, 10);
+
+      // Cleanup
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('Multi-Step Playbooks & Recipes', () => {
+    it('should provide built-in playbooks for audit, clean, triage, and bench', () => {
+      assert.ok(BUILTIN_PLAYBOOKS.length >= 4);
+      const ids = BUILTIN_PLAYBOOKS.map((p) => p.id);
+      assert.ok(ids.includes('audit'));
+      assert.ok(ids.includes('clean'));
+      assert.ok(ids.includes('triage'));
+      assert.ok(ids.includes('bench'));
+
+      for (const pb of BUILTIN_PLAYBOOKS) {
+        assert.ok(pb.name.length > 0);
+        assert.ok(pb.description.length > 0);
+        assert.ok(Array.isArray(pb.steps));
+        assert.ok(pb.steps.length > 0);
+        for (const s of pb.steps) {
+          assert.ok(s.name.length > 0);
+          assert.ok(s.command.length > 0);
+        }
+      }
+    });
+  });
+
+  describe('Performance Budgeting Runner (pyre run)', () => {
+    it('should parse human-readable byte strings accurately', () => {
+      assert.strictEqual(parseBytesString('500MB'), 500 * 1024 * 1024);
+      assert.strictEqual(parseBytesString('500m'), 500 * 1024 * 1024);
+      assert.strictEqual(parseBytesString('2GB'), 2 * 1024 * 1024 * 1024);
+      assert.strictEqual(parseBytesString('64KB'), 64 * 1024);
+      assert.strictEqual(parseBytesString('1024'), 1024);
+      assert.strictEqual(parseBytesString('invalid'), 0);
+    });
+
+    it('should format bytes cleanly', () => {
+      assert.strictEqual(formatBytes(1024 * 1024 * 1024 * 1.5), '1.50 GB');
+      assert.strictEqual(formatBytes(1024 * 1024 * 250), '250.00 MB');
+      assert.strictEqual(formatBytes(1024 * 45), '45.0 KB');
+      assert.strictEqual(formatBytes(512), '512 B');
+    });
+
+    it('should execute command and track duration and exit code', async () => {
+      const res = await runWithBudget([process.execPath, '-e', 'process.exit(0)'], {});
+      assert.strictEqual(res.exitCode, 0);
+      assert.ok(res.durationSec >= 0);
+      assert.strictEqual(res.violations.length, 0);
+    });
+
+    it('should detect budget violations when thresholds are exceeded', async () => {
+      // Artificial violation: 0.0001 seconds time budget for a 50ms command
+      const res = await runWithBudget(
+        [process.execPath, '-e', 'setTimeout(() => {}, 50)'],
+        { maxTimeSec: 0.0001 }
+      );
+      assert.ok(res.violations.length > 0);
+      assert.ok(res.violations.some((v) => v.includes('Runtime exceeded budget')));
+    });
+  });
+
+  describe('Headless Terminal Statusline Emitter', () => {
+    const mockMetrics: StatuslineMetrics = {
+      cpuUsage: 14.2,
+      memUsage: 62.8,
+      tempC: 48.0,
+      batteryPct: 95,
+      batteryCharging: true,
+    };
+
+    it('should format statusline for JSON', () => {
+      const json = formatStatusline(mockMetrics, 'json');
+      const parsed = JSON.parse(json);
+      assert.strictEqual(parsed.cpu, 14.2);
+      assert.strictEqual(parsed.mem, 62.8);
+      assert.strictEqual(parsed.temp, 48.0);
+      assert.strictEqual(parsed.battery, 95);
+      assert.strictEqual(parsed.charging, true);
+    });
+
+    it('should format statusline for tmux with ANSI/tmux color styling', () => {
+      const tmux = formatStatusline(mockMetrics, 'tmux');
+      assert.ok(tmux.includes('#[fg=cyan]CPU: 14%'));
+      assert.ok(tmux.includes('#[fg=magenta]RAM: 63%'));
+      assert.ok(tmux.includes('#[fg=yellow]48°C'));
+      assert.ok(tmux.includes('⚡95%'));
+    });
+
+    it('should format statusline for starship and plain text', () => {
+      const plain = formatStatusline(mockMetrics, 'plain');
+      assert.strictEqual(plain, '🔥 14% | 63% | 48°C | ⚡95%');
+
+      const starship = formatStatusline(mockMetrics, 'starship');
+      assert.ok(starship.includes('14%'));
+      assert.ok(starship.includes('63%'));
+    });
+
+    it('should format statusline for pango markup', () => {
+      const pango = formatStatusline(mockMetrics, 'pango');
+      assert.ok(pango.includes('<span color='));
+      assert.ok(pango.includes('CPU: 14%'));
+    });
+  });
+
+  describe('Container & Micro-VM Telemetry', () => {
+    it('should detect container engine or return null safely', () => {
+      const engine = detectContainerEngine();
+      assert.ok(engine === 'docker' || engine === 'podman' || engine === null);
+    });
+
+    it('should collect container stats safely without throwing', () => {
+      const stats = collectContainerStats();
+      assert.ok(Array.isArray(stats));
+    });
+  });
+
+  describe('Deep-Dive Process Inspector', () => {
+    it('should inspect current node process metadata', () => {
+      const details = inspectProcess(process.pid);
+      assert.strictEqual(details.pid, process.pid);
+      assert.ok(details.name.length > 0);
+      assert.ok(details.threads >= 1);
+      assert.ok(details.memRssBytes > 0);
+      assert.ok(Array.isArray(details.openFiles));
+      assert.ok(Array.isArray(details.sockets));
+    });
+
+    it('should throw an informative error when inspecting non-existent PID', () => {
+      assert.throws(() => {
+        inspectProcess(999999999);
+      }, /not found or permission denied/);
+    });
+  });
+
+  describe('Temperature Unit Support', () => {
+    it('should format temperatures with custom units without reference errors', () => {
+      const outC = execSync(`node dist/index.js --once --temp-unit c`, { encoding: 'utf-8' });
+      assert.ok(outC.includes('PYRE'));
+      const outF = execSync(`node dist/index.js --once --temp-unit f`, { encoding: 'utf-8' });
+      assert.ok(outF.includes('PYRE'));
+    });
+  });
+
+  describe('Menu Bar Plugin Generator (pyre xbar)', () => {
+    it('should generate xbar plugin script into a specified directory', async () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pyre-xbar-test-'));
+      const outPath = await generateXbarPlugin({ dir: tmpDir, install: true });
+      assert.ok(fs.existsSync(outPath));
+      const content = fs.readFileSync(outPath, 'utf-8');
+      assert.ok(content.includes('# <xbar.title>Pyre Monitor</xbar.title>'));
+      assert.ok(content.includes('--once --json'));
+
+      // Clean up
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+});