pyre-cli 10.2.0 → 10.4.0

package/src/profileProcCmd.ts

@@ -1,13 +1,14 @@
 /**
  * pyre profile-proc — Process CPU Profiler.
  *
- * Samples a process for a given duration (default 5 seconds) using macOS `sample`
- * or fallback thread analysis, then presents an annotated call-tree and
- * hot frames summary.
+ * Samples a process for a given duration (default 5 seconds) using macOS `sample`,
+ * Windows PowerShell thread & module profiling, or fallback thread analysis,
+ * presenting an annotated call-tree, thread states, and hot frames summary.
  */
-import { execFile } from 'node:child_process';
+import { execFile, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
 import chalk from 'chalk';
+import { runPowerShell } from './monitors/run.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -25,10 +26,21 @@ export async function runProfileProcCommand(opts: ProfileProcOptions): Promise<v
     process.exit(1);
   }
 
-  // 1. Verify process exists
+  // 1. Verify process exists (cross-platform)
+  let processAlive = false;
   try {
     process.kill(pid, 0);
+    processAlive = true;
   } catch {
+    if (process.platform === 'win32') {
+      try {
+        const out = execSync(`tasklist /fi "PID eq ${pid}" /nh`, { stdio: 'pipe' }).toString();
+        processAlive = out.includes(String(pid));
+      } catch {}
+    }
+  }
+
+  if (!processAlive) {
     console.error(chalk.red(`\n  ✖ Error: Process with PID ${pid} is not running or accessible.\n`));
     process.exit(1);
   }
@@ -38,8 +50,40 @@ export async function runProfileProcCommand(opts: ProfileProcOptions): Promise<v
   let sampleOutput = '';
   let usedFallback = false;
 
-  // Try macOS native `sample` command (available on macOS)
-  if (process.platform === 'darwin') {
+  // 1. Windows Native Profiler
+  if (process.platform === 'win32') {
+    try {
+      const psScript = `
+$p1 = Get-Process -Id ${pid} -ErrorAction SilentlyContinue
+if (-not $p1) { exit 1 }
+$cpu1 = $p1.TotalProcessorTime.TotalSeconds
+$start = Get-Date
+Start-Sleep -Seconds ${durationSec}
+$p2 = Get-Process -Id ${pid} -ErrorAction SilentlyContinue
+$cpu2 = if ($p2) { $p2.TotalProcessorTime.TotalSeconds } else { $cpu1 }
+$elapsed = ((Get-Date) - $start).TotalSeconds
+$cpuPct = if ($elapsed -gt 0) { [math]::Round((($cpu2 - $cpu1) / $elapsed) * 100, 1) } else { 0 }
+
+Write-Output "Process: $($p1.ProcessName) (PID $($p1.Id))"
+Write-Output "Path: $($p1.Path)"
+Write-Output "Average CPU Utilization: $cpuPct%"
+Write-Output "Working Set (RAM): $([math]::Round($p1.WorkingSet64 / 1MB, 1)) MB"
+Write-Output "Threads Total: $($p1.Threads.Count)"
+Write-Output ""
+Write-Output "Call graph / Active Threads:"
+$p1.Threads | Select-Object -First 25 | ForEach-Object {
+    $state = $_.ThreadState
+    $wait = $_.WaitReason
+    $time = [math]::Round($_.TotalProcessorTime.TotalSeconds, 3)
+    Write-Output "  + [TID $($_.Id)] CPU: $($time)s | State: $state | WaitReason: $wait"
+}
+`;
+      sampleOutput = await runPowerShell(psScript, '', (durationSec + 8) * 1000);
+    } catch {}
+  }
+
+  // 2. macOS native `sample` command
+  if (!sampleOutput && process.platform === 'darwin') {
     try {
       const { stdout } = await execFileAsync('sample', [String(pid), String(durationSec), '-file', '/dev/stdout'], {
         timeout: (durationSec + 5) * 1000,
@@ -47,19 +91,22 @@ export async function runProfileProcCommand(opts: ProfileProcOptions): Promise<v
       });
       sampleOutput = stdout;
     } catch (err: any) {
-      // Sample might fail if SIP restricts it on system processes or timeout
       sampleOutput = err.stdout || '';
     }
   }
 
-  // Fallback: If sample produced no usable output or running on Linux, sample via thread / proc stats
-  if (!sampleOutput || sampleOutput.length < 100) {
+  // 3. POSIX Fallback (Linux / fallback macOS)
+  if (!sampleOutput || sampleOutput.length < 50) {
     usedFallback = true;
-    try {
-      const { stdout } = await execFileAsync('ps', ['-M', '-p', String(pid), '-o', 'pid,thread,pcpu,pmem,state,time,command']);
-      sampleOutput = stdout;
-    } catch {
-      sampleOutput = `Process PID ${pid} active. Deep stack sampling requires elevated permissions or user-owned process.`;
+    if (process.platform !== 'win32') {
+      try {
+        const { stdout } = await execFileAsync('ps', ['-M', '-p', String(pid), '-o', 'pid,thread,pcpu,pmem,state,time,command']);
+        sampleOutput = stdout;
+      } catch {
+        sampleOutput = `Process PID ${pid} active. Deep stack sampling requires elevated permissions or user-owned process.`;
+      }
+    } else {
+      sampleOutput = `Process PID ${pid} active. Profiling finished.`;
     }
   }
 
@@ -70,17 +117,17 @@ export async function runProfileProcCommand(opts: ProfileProcOptions): Promise<v
 
   // Parse and display clean call-tree analysis
   if (!usedFallback) {
-    // Extract Call graph section
     const lines = sampleOutput.split('\n');
     const headerLines: string[] = [];
     const stackLines: string[] = [];
     let inCallGraph = false;
 
     for (const line of lines) {
-      if (line.includes('Analysis of sampling') || line.includes('Process:') || line.includes('Path:') || line.includes('Identifier:')) {
+      if (line.includes('Analysis of sampling') || line.includes('Process:') || line.includes('Path:') ||
+          line.includes('Identifier:') || line.includes('Average CPU Utilization:') || line.includes('Working Set') || line.includes('Threads Total:')) {
         headerLines.push(line.trim());
       }
-      if (line.includes('Call graph:') || line.includes('+ Line Coverage')) {
+      if (line.includes('Call graph:') || line.includes('Call graph / Active Threads:') || line.includes('+ Line Coverage')) {
         inCallGraph = true;
         continue;
       }
@@ -95,13 +142,13 @@ export async function runProfileProcCommand(opts: ProfileProcOptions): Promise<v
 
     if (headerLines.length > 0) {
       console.log(chalk.dim('  Process Info:'));
-      for (const h of headerLines.slice(0, 4)) {
+      for (const h of headerLines.slice(0, 6)) {
         console.log(`    ${chalk.cyan(h)}`);
       }
       console.log();
     }
 
-    console.log(chalk.bold('  Top Call Stacks & Hot Functions:'));
+    console.log(chalk.bold('  Top Call Stacks & Hot Threads:'));
     console.log(chalk.dim('  ' + '─'.repeat(70)));
 
     if (stackLines.length === 0) {
@@ -120,7 +167,7 @@ export async function runProfileProcCommand(opts: ProfileProcOptions): Promise<v
       }
     }
   } else {
-    console.log(chalk.yellow('  Note: Kernel/SIP restriction prevented deep call-graph unwind.'));
+    console.log(chalk.yellow('  Note: Operating system permissions prevented deep call-graph unwind.'));
     console.log(chalk.dim('  Showing process thread snapshot:\n'));
     for (const l of sampleOutput.split('\n')) {
       if (l.trim()) console.log(`    ${l}`);

package/src/replayCmd.ts

@@ -100,14 +100,15 @@ function renderFrame(row: LogRow, idx: number, total: number, speed: number, pau
   lines.push('  ' + divider);
 
   // Scrub bar
-  const progWidth = 30;
+  const progWidth = Math.min(40, Math.max(20, cols - 30));
+  const pct = total > 1 ? (idx / (total - 1)) * 100 : 0;
   const progress = total > 1 ? Math.round((idx / (total - 1)) * progWidth) : 0;
-  const progressBar = chalk.cyan('█'.repeat(progress)) + chalk.dim('░'.repeat(progWidth - progress));
+  const progressBar = chalk.cyan('━'.repeat(progress)) + chalk.bold.yellow('◆') + chalk.dim('─'.repeat(Math.max(0, progWidth - progress)));
   const icon = paused ? chalk.yellow('⏸') : chalk.green('▶');
   const spStr = speed === 1 ? '1×' : `${speed}×`;
-  lines.push(`  ${icon} ${progressBar}  ${chalk.bold(`${idx + 1}/${total}`)}  ${chalk.dim(spStr)}`);
+  lines.push(`  ${icon} [${progressBar}] ${chalk.bold(`${pct.toFixed(0)}%`)} (${idx + 1}/${total})  ${chalk.dim(spStr)}`);
   lines.push('');
-  lines.push(chalk.dim('  Space/p=pause  ]/[=speed  ←/→=step  q=quit'));
+  lines.push(chalk.dim('  Space/p=pause  ]/[=speed  ←/→=step  0-9=jump %  Home/End=seek  q=quit'));
 
   return lines;
 }
@@ -166,8 +167,16 @@ export async function runReplayCommand(opts: ReplayOptions): Promise<void> {
     if (key.name === 'space' || key.name === 'p') { paused = !paused; renderCurrent(); return; }
     if (str === ']') { speed = Math.min(speed * 2, 32); renderCurrent(); return; }
     if (str === '[') { speed = Math.max(speed / 2, 0.125); renderCurrent(); return; }
-    if (key.name === 'right') { frameIdx = Math.min(frameIdx + 1, rows.length - 1); renderCurrent(); return; }
-    if (key.name === 'left') { frameIdx = Math.max(frameIdx - 1, 0); renderCurrent(); return; }
+    if (key.name === 'right') { frameIdx = Math.min(frameIdx + (key.shift ? 10 : 1), rows.length - 1); renderCurrent(); return; }
+    if (key.name === 'left') { frameIdx = Math.max(frameIdx - (key.shift ? 10 : 1), 0); renderCurrent(); return; }
+    if (key.name === 'home' || str === '0') { frameIdx = 0; renderCurrent(); return; }
+    if (key.name === 'end') { frameIdx = rows.length - 1; renderCurrent(); return; }
+    if (str >= '1' && str <= '9') {
+      const frac = parseInt(str, 10) / 10;
+      frameIdx = Math.min(rows.length - 1, Math.round(frac * (rows.length - 1)));
+      renderCurrent();
+      return;
+    }
   });
 
   const BASE_MS = 2000;

package/src/smartCmd.ts

@@ -1,17 +1,20 @@
 /**
  * pyre smart — S.M.A.R.T. disk health inspector.
  *
- * Uses smartctl (from smartmontools, via brew install smartmontools)
- * for detailed SMART data. Falls back to diskutil info when
- * smartctl is not installed.
+ * Uses smartctl (from smartmontools) for detailed SMART data across macOS, Linux, and Windows.
+ * Falls back to native platform inspectors when smartctl is not installed:
+ *  - macOS: diskutil
+ *  - Windows: Get-PhysicalDisk & Get-StorageReliabilityCounter & Win32_DiskDrive
+ *  - Linux: lsblk & hdparm
  */
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import chalk from 'chalk';
+import { runPowerShell } from './monitors/run.js';
 
 const execFileAsync = promisify(execFile);
 
-interface DiskInfo {
+export interface DiskInfo {
   device: string;
   model: string;
   serialNumber: string;
@@ -35,6 +38,74 @@ async function runCmd(cmd: string, args: string[], timeoutMs = 5000): Promise<st
   }
 }
 
+export function parseWindowsPhysicalDiskCsv(csvRaw: string): DiskInfo[] {
+  const lines = csvRaw.split('\n').filter(l => l.trim().length > 0);
+  if (lines.length < 2) return [];
+
+  const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+  const disks: DiskInfo[] = [];
+
+  for (const line of lines.slice(1)) {
+    const values = line.split(',').map(v => v.trim().replace(/^"|"$/g, ''));
+    const row: Record<string, string> = {};
+    headers.forEach((h, i) => { row[h] = values[i] || ''; });
+
+    const deviceId = row.DeviceId || row.DeviceID || '0';
+    const friendlyName = row.FriendlyName || row.Model || 'Physical Disk';
+    const serialNumber = row.SerialNumber || '';
+    const mediaType = row.MediaType || row.InterfaceType || '';
+    const healthStatus = (row.HealthStatus || row.Status || '').toUpperCase();
+    const sizeBytes = parseFloat(row.Size) || 0;
+
+    let health: DiskInfo['health'] = 'Unknown';
+    if (healthStatus.includes('HEALTHY') || healthStatus.includes('OK') || healthStatus.includes('PASSED')) {
+      health = 'PASSED';
+    } else if (healthStatus.includes('UNHEALTHY') || healthStatus.includes('ERROR') || healthStatus.includes('FAILED')) {
+      health = 'FAILED';
+    }
+
+    const capacity = sizeBytes > 0
+      ? sizeBytes >= 1e12 ? `${(sizeBytes / 1e12).toFixed(1)} TB`
+        : sizeBytes >= 1e9 ? `${(sizeBytes / 1e9).toFixed(0)} GB`
+        : `${(sizeBytes / 1e6).toFixed(0)} MB`
+      : undefined;
+
+    disks.push({
+      device: `\\\\.\\PhysicalDrive${deviceId}`,
+      model: friendlyName,
+      serialNumber,
+      health,
+      protocol: mediaType,
+      capacity,
+    });
+  }
+
+  return disks;
+}
+
+export function parseWindowsReliabilityCsv(csvRaw: string): Partial<DiskInfo> {
+  const lines = csvRaw.split('\n').filter(l => l.trim().length > 0);
+  if (lines.length < 2) return {};
+
+  const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+  const values = lines[1].split(',').map(v => v.trim().replace(/^"|"$/g, ''));
+  const row: Record<string, string> = {};
+  headers.forEach((h, i) => { row[h] = values[i] || ''; });
+
+  const temp = parseFloat(row.Temperature);
+  const wear = parseFloat(row.Wear);
+  const poh = parseFloat(row.PowerOnHours);
+  const readErrors = parseFloat(row.ReadErrorsTotal);
+  const writeErrors = parseFloat(row.WriteErrorsTotal);
+
+  return {
+    tempC: Number.isFinite(temp) && temp > 0 && temp < 120 ? temp : undefined,
+    percentUsed: Number.isFinite(wear) && wear >= 0 && wear <= 100 ? wear : undefined,
+    powerOnHours: Number.isFinite(poh) && poh >= 0 ? poh : undefined,
+    reallocatedSectors: (Number.isFinite(readErrors) ? readErrors : 0) + (Number.isFinite(writeErrors) ? writeErrors : 0),
+  };
+}
+
 async function getPhysicalDisks(): Promise<string[]> {
   // 1. First try smartctl --scan --json on all platforms
   const scanRaw = await runCmd('smartctl', ['--scan', '--json']);
@@ -59,9 +130,19 @@ async function getPhysicalDisks(): Promise<string[]> {
     return ['/dev/sda'];
   }
 
-  // 3. Windows fallback
+  // 3. Windows native query
   if (process.platform === 'win32') {
-    return ['/dev/sda', '/dev/csmi0,0'];
+    try {
+      const raw = await runPowerShell(
+        `Get-PhysicalDisk -ErrorAction SilentlyContinue | Select-Object -ExpandProperty DeviceId`,
+        ''
+      );
+      const ids = raw.split('\n').map(s => s.trim()).filter(Boolean);
+      if (ids.length > 0) {
+        return ids.map(id => `\\\\.\\PhysicalDrive${id}`);
+      }
+    } catch {}
+    return ['\\\\.\\PhysicalDrive0'];
   }
 
   // 4. macOS fallback: diskutil
@@ -121,6 +202,60 @@ async function collectSmartctlDisk(device: string): Promise<DiskInfo | null> {
   }
 }
 
+async function collectWindowsDiskFallback(device: string): Promise<DiskInfo | null> {
+  const match = device.match(/PhysicalDrive(\d+)/i);
+  const diskNumber = match ? match[1] : '0';
+
+  try {
+    const rawDisk = await runPowerShell(
+      `Get-PhysicalDisk -DeviceId '${diskNumber}' -ErrorAction SilentlyContinue | Select-Object DeviceId, FriendlyName, SerialNumber, MediaType, HealthStatus, Size | ConvertTo-Csv -NoTypeInformation`,
+      ''
+    );
+    const parsed = parseWindowsPhysicalDiskCsv(rawDisk);
+    if (parsed.length > 0) {
+      const info = parsed[0];
+      info.device = device;
+
+      // Query storage reliability counters for wear, temp, and power on hours
+      try {
+        const rawReliability = await runPowerShell(
+          `Get-StorageReliabilityCounter -Disk (Get-Disk -Number ${diskNumber} -ErrorAction SilentlyContinue) -ErrorAction SilentlyContinue | Select-Object Temperature, Wear, PowerOnHours, ReadErrorsTotal, WriteErrorsTotal | ConvertTo-Csv -NoTypeInformation`,
+          ''
+        );
+        const rel = parseWindowsReliabilityCsv(rawReliability);
+        if (rel.tempC !== undefined) info.tempC = rel.tempC;
+        if (rel.percentUsed !== undefined) info.percentUsed = rel.percentUsed;
+        if (rel.powerOnHours !== undefined) info.powerOnHours = rel.powerOnHours;
+        if (rel.reallocatedSectors !== undefined) info.reallocatedSectors = rel.reallocatedSectors;
+      } catch {}
+
+      return info;
+    }
+  } catch {}
+
+  // Fallback to Win32_DiskDrive
+  try {
+    const rawWmi = await runPowerShell(
+      `Get-CimInstance Win32_DiskDrive -Filter "Index = ${diskNumber}" -ErrorAction SilentlyContinue | Select-Object Model, SerialNumber, Status, Size | ConvertTo-Csv -NoTypeInformation`,
+      ''
+    );
+    const lines = rawWmi.split('\n').filter(l => l.trim());
+    if (lines.length >= 2) {
+      const values = lines[1].split(',').map(s => s.trim().replace(/^"|"$/g, ''));
+      const sizeBytes = parseFloat(values[3]) || 0;
+      return {
+        device,
+        model: values[0] || 'Physical Disk',
+        serialNumber: values[1] || '',
+        health: values[2]?.toUpperCase().includes('OK') ? 'PASSED' : 'Unknown',
+        capacity: sizeBytes >= 1e12 ? `${(sizeBytes / 1e12).toFixed(1)} TB` : `${(sizeBytes / 1e9).toFixed(0)} GB`,
+      };
+    }
+  } catch {}
+
+  return null;
+}
+
 async function collectDiskutilFallback(device: string): Promise<DiskInfo | null> {
   const raw = await runCmd('diskutil', ['info', device]);
   if (!raw) return null;
@@ -156,8 +291,11 @@ export async function runSmartCommand(): Promise<void> {
   const hasSmartctl = smartctlVersion.includes('smartmontools');
 
   if (!hasSmartctl) {
-    console.log(chalk.yellow('  ⚠ smartctl not found. Showing basic disk info.'));
-    console.log(chalk.dim('  For full SMART data: ') + chalk.cyan('brew install smartmontools') + '\n');
+    console.log(chalk.yellow('  ⚠ smartctl not found. Showing native storage health metrics.'));
+    const installHint = process.platform === 'win32'
+      ? 'winget install smartmontools'
+      : (process.platform === 'linux' ? 'sudo apt install smartmontools' : 'brew install smartmontools');
+    console.log(chalk.dim('  For full SMART data: ') + chalk.cyan(installHint) + '\n');
   }
 
   const devices = await getPhysicalDisks();
@@ -169,7 +307,8 @@ export async function runSmartCommand(): Promise<void> {
   for (const device of devices) {
     let info: DiskInfo | null = null;
     if (hasSmartctl) info = await collectSmartctlDisk(device);
-    if (!info) info = await collectDiskutilFallback(device);
+    if (!info && process.platform === 'win32') info = await collectWindowsDiskFallback(device);
+    if (!info && process.platform === 'darwin') info = await collectDiskutilFallback(device);
     if (!info) continue;
 
     console.log(chalk.bold(`  ${info.device}`));
@@ -200,6 +339,6 @@ export async function runSmartCommand(): Promise<void> {
   }
 
   if (!hasSmartctl) {
-    console.log(chalk.dim('  Install smartmontools for full SMART attributes.\n'));
+    console.log(chalk.dim('  Install smartmontools for complete SMART attribute dump.\n'));
   }
 }

package/src/state/config.ts

@@ -41,6 +41,7 @@ export interface PyreConfig {
   mouseEnabled?: boolean;
   cpuAlertPct?: number;
   tempAlertC?: number;
+  tempUnit?: 'c' | 'f';
   electricityRateKwH?: number;
   notificationsEnabled?: boolean;
   p2pPort?: number;
@@ -104,6 +105,14 @@ export interface PyreConfig {
   tableDensity?: string;
   defaultFilter?: string;
   defaultSort?: string;
+  /** Extra apps (name or bundle id) that `pyre optimize` will never quit */
+  optimizeProtectedApps?: string[];
+  /** Default idle threshold for `pyre optimize apps` (e.g. "2h") */
+  optimizeIdleThreshold?: string;
+  /** Number of most-recently-used apps `pyre optimize apps` always keeps open */
+  optimizeKeepRecent?: number;
+  /** Default launch action when pyre is executed without arguments ('live' | 'menu') */
+  defaultAction?: 'live' | 'menu';
 }
 
 export const DEFAULT_CONFIG: Required<PyreConfig> = {
@@ -169,6 +178,10 @@ export const DEFAULT_CONFIG: Required<PyreConfig> = {
   tableDensity: 'standard',
   defaultFilter: 'all',
   defaultSort: 'cpu',
+  optimizeProtectedApps: [],
+  optimizeIdleThreshold: '2h',
+  optimizeKeepRecent: 5,
+  defaultAction: 'live',
 };
 
 export function getConfigDir(): string {

package/src/statuslineCmd.ts

@@ -0,0 +1,87 @@
+/**
+ * pyre statusline — Headless Terminal Statusline Emitter.
+ *
+ * Emits lightweight, high-performance telemetry strings designed for
+ * Tmux status-right, Starship prompt, Waybar, Polybar, and Neovim lualine.
+ */
+import os from 'node:os';
+import chalk from 'chalk';
+import { collectAll } from './monitors/collectors.js';
+
+export type StatuslineFormat = 'tmux' | 'starship' | 'json' | 'pango' | 'plain';
+
+export interface StatuslineMetrics {
+  cpuUsage: number;
+  memUsage: number;
+  tempC?: number;
+  batteryPct?: number;
+  batteryCharging?: boolean;
+}
+
+export async function collectStatuslineMetrics(): Promise<StatuslineMetrics> {
+  const data = await collectAll();
+  const cpuUsage = data.cpu.usage;
+  const memUsage = data.memory.usagePercent;
+  const tempC = data.cpu.temperature;
+  const batteryPct = data.battery ? data.battery.percent : undefined;
+  const batteryCharging = data.battery ? data.battery.isCharging : undefined;
+
+  return {
+    cpuUsage,
+    memUsage,
+    tempC,
+    batteryPct,
+    batteryCharging,
+  };
+}
+
+export function formatStatusline(m: StatuslineMetrics, format: StatuslineFormat): string {
+  const cpu = Math.round(m.cpuUsage);
+  const mem = Math.round(m.memUsage);
+  const temp = m.tempC !== undefined ? `${Math.round(m.tempC)}°C` : '';
+  const batt = m.batteryPct !== undefined ? `${m.batteryCharging ? '⚡' : ''}${m.batteryPct}%` : '';
+
+  switch (format) {
+    case 'json':
+      return JSON.stringify({
+        cpu: m.cpuUsage,
+        mem: m.memUsage,
+        temp: m.tempC,
+        battery: m.batteryPct,
+        charging: m.batteryCharging,
+      });
+
+    case 'tmux': {
+      const parts: string[] = [];
+      parts.push(`#[fg=cyan]CPU: ${cpu}%`);
+      parts.push(`#[fg=magenta]RAM: ${mem}%`);
+      if (temp) parts.push(`#[fg=yellow]${temp}`);
+      if (batt) parts.push(`#[fg=green]${batt}`);
+      return parts.join(' #[fg=dim]| ');
+    }
+
+    case 'pango': {
+      const parts: string[] = [];
+      parts.push(`<span color="#22d3ee">CPU: ${cpu}%</span>`);
+      parts.push(`<span color="#a78bfa">RAM: ${mem}%</span>`);
+      if (temp) parts.push(`<span color="#fb923c">${temp}</span>`);
+      if (batt) parts.push(`<span color="#34d399">${batt}</span>`);
+      return parts.join(' | ');
+    }
+
+    case 'starship':
+    case 'plain':
+    default: {
+      const parts = [`🔥 ${cpu}%`, `${mem}%`];
+      if (temp) parts.push(temp);
+      if (batt) parts.push(batt);
+      return parts.join(' | ');
+    }
+  }
+}
+
+export async function runStatuslineCommand(format: StatuslineFormat = 'plain'): Promise<void> {
+  const metrics = await collectStatuslineMetrics();
+  const output = formatStatusline(metrics, format);
+  process.stdout.write(output + '\n');
+}

package/src/syncCmd.ts

@@ -41,6 +41,18 @@ interface SyncManifest {
 function getDefaultSyncDir(): string {
   if (process.env.PYRE_SYNC_DIR) return process.env.PYRE_SYNC_DIR;
 
+  // Windows native OneDrive path
+  if (process.platform === 'win32') {
+    const oneDriveEnv = process.env.OneDrive || process.env.OneDriveConsumer;
+    if (oneDriveEnv && fs.existsSync(oneDriveEnv)) {
+      return path.join(oneDriveEnv, 'PyreSync');
+    }
+    const userOneDrive = path.join(os.homedir(), 'OneDrive');
+    if (fs.existsSync(userOneDrive)) {
+      return path.join(userOneDrive, 'PyreSync');
+    }
+  }
+
   // macOS native iCloud Drive path
   const icloudPath = path.join(os.homedir(), 'Library', 'Mobile Documents', 'com~apple~CloudDocs', 'PyreSync');
   if (fs.existsSync(path.dirname(icloudPath))) {