pyre-cli 10.2.0 → 10.4.0

package/dist/optimizeCmd-WZKLFYZU.js

@@ -0,0 +1,1110 @@
+import {
+  getConfigDir,
+  readConfig,
+  writeConfig
+} from "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/optimizeCmd.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import readline from "readline/promises";
+import { execFile, spawn, spawnSync } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+var execFileAsync = promisify(execFile);
+var BUILTIN_PROTECTED = [
+  "com.apple.finder",
+  "com.apple.Terminal",
+  "com.googlecode.iterm2",
+  "dev.warp.Warp-Stable",
+  "com.mitchellh.ghostty",
+  "net.kovidgoyal.kitty",
+  "com.github.wez.wezterm",
+  "io.alacritty",
+  "com.apple.systempreferences"
+];
+var MEDIA_BUNDLES = /* @__PURE__ */ new Set([
+  "com.apple.music",
+  "com.spotify.client",
+  "com.apple.podcasts",
+  "com.apple.tv",
+  "com.colliderli.iina",
+  "org.videolan.vlc"
+]);
+var DEFAULT_CPU_BUSY_PCT = 5;
+var MEDIA_CPU_BUSY_PCT = 1;
+var TRACK_INTERVAL_MS = 5e3;
+var TRACK_FRESH_MS = 12e4;
+var TRACKER_LABEL = "com.pyre.optimize-tracker";
+var TRACKER_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", `${TRACKER_LABEL}.plist`);
+function usageFile() {
+  return path.join(getConfigDir(), "app-usage.json");
+}
+function parseDuration(input, fallbackMs) {
+  if (input === void 0 || input === null || String(input).trim() === "") return fallbackMs;
+  const m = String(input).trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)?$/);
+  if (!m) return NaN;
+  const n = parseFloat(m[1]);
+  const unit = m[2] ?? "m";
+  if (unit.startsWith("s")) return n * 1e3;
+  if (unit.startsWith("h")) return n * 36e5;
+  if (unit.startsWith("d")) return n * 864e5;
+  return n * 6e4;
+}
+function formatDuration(ms) {
+  const totalMin = Math.floor(ms / 6e4);
+  if (totalMin < 1) return `${Math.max(0, Math.floor(ms / 1e3))}s`;
+  const d = Math.floor(totalMin / 1440);
+  const h = Math.floor(totalMin % 1440 / 60);
+  const m = totalMin % 60;
+  if (d > 0) return `${d}d ${h}h`;
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+function formatKb(kb) {
+  const bytes = kb * 1024;
+  if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  if (bytes >= 1024 ** 2) return `${(bytes / 1024 ** 2).toFixed(0)} MB`;
+  return `${Math.round(kb)} KB`;
+}
+function parseAsnList(raw) {
+  const out = [];
+  const re = /ASN:(0x[0-9a-f]+-0x[0-9a-f]+)/gi;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    const asn = `ASN:${m[1].toLowerCase()}`;
+    if (!out.includes(asn)) out.push(asn);
+  }
+  return out;
+}
+function parseLsappinfoList(raw) {
+  const apps = [];
+  const blocks = raw.split(/\r?\n(?=\s*\d+\)\s+")/);
+  for (const block of blocks) {
+    const header2 = block.match(/^\s*\d+\)\s+"(.*?)"\s+ASN:(0x[0-9a-f]+-0x[0-9a-f]+):/i);
+    if (!header2) continue;
+    if (!/type="Foreground"/.test(block)) continue;
+    const pidMatch = block.match(/\bpid\s*=\s*(\d+)/);
+    if (!pidMatch) continue;
+    const bundleMatch = block.match(/bundleID="([^"]+)"/);
+    const checkin = block.match(/checkin time = (\d{4})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2}):(\d{2})/);
+    let launchedAt;
+    if (checkin) {
+      const [, y, mo, d, h, mi, s] = checkin;
+      launchedAt = new Date(+y, +mo - 1, +d, +h, +mi, +s).getTime();
+    }
+    apps.push({
+      asn: `ASN:${header2[2].toLowerCase()}`,
+      name: header2[1],
+      bundleId: bundleMatch?.[1] ?? "",
+      pid: parseInt(pidMatch[1], 10),
+      launchedAt
+    });
+  }
+  return apps;
+}
+function isTrackingFresh(usage, now) {
+  return !!usage && now - usage.updatedAt < TRACK_FRESH_MS;
+}
+function computeIdleMs(app, usage, now) {
+  if (app.frontmost) return 0;
+  if (!isTrackingFresh(usage, now)) return void 0;
+  const last = usage.apps[app.bundleId]?.lastActive ?? 0;
+  const base = Math.max(usage.trackingSince, app.launchedAt ?? 0);
+  return Math.max(0, now - Math.max(last, base));
+}
+function isProtected(app, protectedApps) {
+  const list = [...BUILTIN_PROTECTED, ...protectedApps].map((s) => s.toLowerCase());
+  return list.includes(app.bundleId.toLowerCase()) || list.includes(app.name.toLowerCase());
+}
+function selectIdleApps(apps, ctx) {
+  const candidates = [];
+  const skipped = [];
+  const fresh = isTrackingFresh(ctx.usage, ctx.now);
+  const busyPct = ctx.cpuBusyPct ?? DEFAULT_CPU_BUSY_PCT;
+  for (const app of [...apps].sort((a, b) => a.rank - b.rank)) {
+    if (app.frontmost) {
+      skipped.push({ app, reason: "frontmost" });
+      continue;
+    }
+    if (isProtected(app, ctx.protectedApps)) {
+      skipped.push({ app, reason: "protected" });
+      continue;
+    }
+    if (ctx.selfPids.has(app.pid)) {
+      skipped.push({ app, reason: "running pyre" });
+      continue;
+    }
+    if (app.rank < ctx.keepRecent) {
+      skipped.push({ app, reason: `top ${ctx.keepRecent} recent` });
+      continue;
+    }
+    const threshold = MEDIA_BUNDLES.has(app.bundleId.toLowerCase()) ? MEDIA_CPU_BUSY_PCT : busyPct;
+    if (app.cpu >= threshold) {
+      skipped.push({ app, reason: `busy (${app.cpu.toFixed(1)}% CPU)` });
+      continue;
+    }
+    if (app.launchedAt && ctx.now - app.launchedAt < ctx.idleThresholdMs) {
+      skipped.push({ app, reason: `launched ${formatDuration(ctx.now - app.launchedAt)} ago` });
+      continue;
+    }
+    if (fresh) {
+      const idleMs = computeIdleMs(app, ctx.usage, ctx.now);
+      if (idleMs < ctx.idleThresholdMs) {
+        skipped.push({ app, reason: `used ${formatDuration(idleMs)} ago` });
+        continue;
+      }
+      candidates.push({ app, idleMs });
+    } else {
+      candidates.push({ app });
+    }
+  }
+  return { candidates, skipped };
+}
+async function run(cmd, args, timeoutMs = 8e3) {
+  try {
+    const { stdout } = await execFileAsync(cmd, args, { timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+    return stdout;
+  } catch (err) {
+    return typeof err?.stdout === "string" ? err.stdout : "";
+  }
+}
+async function listRunningApps() {
+  const [listRaw, visibleRaw, frontRaw] = await Promise.all([
+    run("lsappinfo", ["list"]),
+    run("lsappinfo", ["visibleProcessList"]),
+    run("lsappinfo", ["front"])
+  ]);
+  const base = parseLsappinfoList(listRaw);
+  const order = parseAsnList(visibleRaw);
+  const front = parseAsnList(frontRaw)[0];
+  const stats = /* @__PURE__ */ new Map();
+  if (base.length) {
+    const ps = await run("ps", ["-axo", "pid=,ppid=,%cpu=,rss="]);
+    const children = /* @__PURE__ */ new Map();
+    const own = /* @__PURE__ */ new Map();
+    for (const line of ps.split("\n")) {
+      const [pid, ppid, cpu, rss] = line.trim().split(/\s+/);
+      if (!pid) continue;
+      const p = parseInt(pid, 10);
+      const pp = parseInt(ppid, 10);
+      own.set(p, { cpu: parseFloat(cpu) || 0, rss: parseInt(rss, 10) || 0 });
+      if (!children.has(pp)) children.set(pp, []);
+      children.get(pp).push(p);
+    }
+    for (const app of base) {
+      if (!own.has(app.pid)) continue;
+      let cpu = 0;
+      let rss = 0;
+      const stack = [app.pid];
+      const seen = /* @__PURE__ */ new Set();
+      while (stack.length) {
+        const p = stack.pop();
+        if (seen.has(p)) continue;
+        seen.add(p);
+        const s = own.get(p);
+        if (s) {
+          cpu += s.cpu;
+          rss += s.rss;
+        }
+        stack.push(...children.get(p) ?? []);
+      }
+      stats.set(app.pid, { cpu, rss });
+    }
+  }
+  const unranked = base.filter((a) => !order.includes(a.asn)).sort((a, b) => (b.launchedAt ?? 0) - (a.launchedAt ?? 0));
+  return base.filter((a) => stats.has(a.pid)).map((a) => {
+    const idx = order.indexOf(a.asn);
+    const s = stats.get(a.pid);
+    return {
+      ...a,
+      rank: idx >= 0 ? idx : order.length + unranked.indexOf(a),
+      cpu: s.cpu,
+      rssKb: s.rss,
+      frontmost: a.asn === front
+    };
+  }).sort((a, b) => a.rank - b.rank);
+}
+async function getSelfPids() {
+  const raw = await run("ps", ["-axo", "pid=,ppid="]);
+  const parent = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const [pid, ppid] = line.trim().split(/\s+/).map((n) => parseInt(n, 10));
+    if (pid) parent.set(pid, ppid);
+  }
+  const set = /* @__PURE__ */ new Set();
+  let cur = process.pid;
+  while (cur && cur > 1 && !set.has(cur)) {
+    set.add(cur);
+    cur = parent.get(cur);
+  }
+  return set;
+}
+function loadUsage() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(usageFile(), "utf-8"));
+    if (parsed?.version === 1 && parsed.apps) return parsed;
+  } catch {
+  }
+  return null;
+}
+function saveUsage(data) {
+  try {
+    fs.mkdirSync(getConfigDir(), { recursive: true });
+    const tmp = usageFile() + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+    fs.renameSync(tmp, usageFile());
+  } catch {
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function quitApp(app, force = false, timeoutMs = 1e4) {
+  const script = `ObjC.import('AppKit');
+var a = $.NSRunningApplication.runningApplicationWithProcessIdentifier(${Math.trunc(app.pid)});
+a.isNil() ? 'gone' : (a.terminate ? 'ok' : 'refused');`;
+  const out = (await run("osascript", ["-l", "JavaScript", "-e", script], 5e3)).trim();
+  if (out === "gone") return "quit";
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(app.pid)) return "quit";
+    await sleep(250);
+  }
+  if (!force) return out === "ok" || out === "refused" ? "still-open" : "failed";
+  try {
+    process.kill(app.pid, "SIGTERM");
+  } catch {
+    return isAlive(app.pid) ? "failed" : "quit";
+  }
+  await sleep(3e3);
+  return isAlive(app.pid) ? "failed" : "forced";
+}
+async function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim().toLowerCase();
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(question, yes) {
+  if (yes) return true;
+  if (!process.stdin.isTTY) return false;
+  const a = await ask(`  ${question} ${chalk.dim("[y/N]")} `);
+  return a === "y" || a === "yes";
+}
+function notify(title, message) {
+  const esc = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  execFile("osascript", ["-e", `display notification "${esc(message)}" with title "${esc(title)}"`], () => {
+  });
+}
+function pad(s, n) {
+  return s.length >= n ? s.slice(0, n - 1) + "\u2026" : s + " ".repeat(n - s.length);
+}
+function header(title) {
+  console.log(chalk.bold(`
+  \u{1F525} pyre optimize \u2014 ${title}
+`));
+}
+function resolveSettings(opts) {
+  const cfg = readConfig();
+  const idleMs = parseDuration(opts.idle, parseDuration(cfg.optimizeIdleThreshold, 2 * 36e5));
+  if (isNaN(idleMs)) {
+    console.error(chalk.red(`  \u2716 Invalid --idle value "${opts.idle}". Use e.g. 30m, 2h, 1d.`));
+    process.exit(1);
+  }
+  const keepRaw = opts.keep !== void 0 ? parseInt(opts.keep, 10) : cfg.optimizeKeepRecent;
+  const keep = Number.isFinite(keepRaw) && keepRaw >= 0 ? keepRaw : 5;
+  return { idleMs, keep, protectedApps: cfg.optimizeProtectedApps ?? [] };
+}
+async function analyzeApps(settings) {
+  const [apps, selfPids] = await Promise.all([listRunningApps(), getSelfPids()]);
+  const usage = loadUsage();
+  const now = Date.now();
+  const result = selectIdleApps(apps, {
+    now,
+    idleThresholdMs: settings.idleMs,
+    keepRecent: settings.keep,
+    protectedApps: settings.protectedApps,
+    selfPids,
+    usage
+  });
+  return { apps, usage, now, fresh: isTrackingFresh(usage, now), ...result };
+}
+function printCandidates(candidates, fresh) {
+  console.log(chalk.dim(`  ${pad("App", 28)}${pad(fresh ? "Idle" : "Recency", 12)}${pad("RAM", 10)}CPU`));
+  for (const c of candidates) {
+    const when = c.idleMs !== void 0 ? formatDuration(c.idleMs) : `#${c.app.rank + 1}`;
+    console.log(`  ${pad(c.app.name, 28)}${chalk.yellow(pad(when, 12))}${pad(formatKb(c.app.rssKb), 10)}${c.app.cpu.toFixed(1)}%`);
+  }
+  const total = candidates.reduce((s, c) => s + c.app.rssKb, 0);
+  console.log(chalk.dim(`
+  ${candidates.length} app(s) using ~${formatKb(total)} RAM`));
+}
+function trackingHint(fresh) {
+  if (!fresh) {
+    console.log(chalk.dim("  \u2139 No live usage tracking. Ranking is based on activation order only."));
+    console.log(chalk.dim("    For real idle times run: ") + chalk.cyan("pyre optimize track --install") + "\n");
+  }
+}
+async function runApps(opts) {
+  header("Idle Apps");
+  const settings = resolveSettings(opts);
+  const { candidates, skipped, fresh } = await analyzeApps(settings);
+  trackingHint(fresh);
+  console.log(chalk.dim(`  Rules: idle \u2265 ${formatDuration(settings.idleMs)}, keep ${settings.keep} most recent, skip busy/protected apps
+`));
+  if (skipped.length) {
+    console.log(chalk.dim("  Keeping:"));
+    for (const s of skipped) console.log(chalk.dim(`    ${pad(s.app.name, 28)}${s.reason}`));
+    console.log();
+  }
+  if (!candidates.length) {
+    console.log(chalk.green("  \u2714 No idle apps to quit.\n"));
+    return;
+  }
+  console.log(chalk.bold("  Idle apps:"));
+  printCandidates(candidates, fresh);
+  console.log();
+  if (opts.dryRun) {
+    console.log(chalk.dim("  Dry run: nothing was quit.\n"));
+    return;
+  }
+  let selected = [];
+  if (opts.yes) {
+    selected = candidates;
+  } else if (!process.stdin.isTTY) {
+    console.log(chalk.yellow("  Not an interactive terminal. Re-run with --yes to quit these apps.\n"));
+    return;
+  } else {
+    const a = await ask(`  Quit these apps? ${chalk.dim("[a]ll / [s]elect / [N]one")} `);
+    if (a === "a" || a === "all" || a === "y" || a === "yes") {
+      selected = candidates;
+    } else if (a === "s" || a === "select") {
+      for (const c of candidates) {
+        if (await confirm(`Quit ${chalk.bold(c.app.name)} (${formatKb(c.app.rssKb)})?`)) selected.push(c);
+      }
+    }
+  }
+  if (!selected.length) {
+    console.log(chalk.dim("  Nothing quit.\n"));
+    return;
+  }
+  console.log();
+  let freed = 0;
+  for (const c of selected) {
+    process.stdout.write(`  Quitting ${c.app.name}\u2026 `);
+    const res = await quitApp(c.app, !!opts.force);
+    if (res === "quit" || res === "forced") {
+      freed += c.app.rssKb;
+      console.log(res === "forced" ? chalk.yellow("force-quit") : chalk.green("\u2714"));
+    } else if (res === "still-open") {
+      console.log(chalk.yellow("still open (it may be waiting for you to save; use --force to terminate)"));
+    } else {
+      console.log(chalk.red("failed"));
+    }
+  }
+  console.log(chalk.green(`
+  \u2714 Freed ~${formatKb(freed)} RAM
+`));
+}
+async function frontApp() {
+  const asn = parseAsnList(await run("lsappinfo", ["front"], 3e3))[0];
+  if (!asn) return null;
+  const info = await run("lsappinfo", ["info", "-only", "bundleid", "-only", "name", asn], 3e3);
+  const bundleId = info.match(/"CFBundleIdentifier"="([^"]+)"/)?.[1];
+  const name = info.match(/"LSDisplayName"="([^"]+)"/)?.[1] ?? bundleId ?? "";
+  return bundleId ? { bundleId, name } : null;
+}
+async function runTracker(opts) {
+  if (opts.install) return installTracker(opts);
+  if (opts.uninstall) return uninstallTracker();
+  const autoQuitMs = opts.autoQuit ? parseDuration(opts.autoQuit, NaN) : void 0;
+  if (autoQuitMs !== void 0 && (isNaN(autoQuitMs) || autoQuitMs < 6e4)) {
+    console.error(chalk.red(`  \u2716 Invalid --auto-quit value "${opts.autoQuit}". Use e.g. 2h (minimum 1m).`));
+    process.exit(1);
+  }
+  const now = Date.now();
+  let usage = loadUsage();
+  if (!usage) {
+    usage = { version: 1, trackingSince: now, updatedAt: now, apps: {} };
+  } else if (now - usage.updatedAt > TRACK_FRESH_MS) {
+    usage.trackingSince = now;
+  }
+  usage.updatedAt = now;
+  saveUsage(usage);
+  console.log(chalk.bold("\n  \u{1F525} pyre optimize \u2014 usage tracker"));
+  console.log(chalk.dim(`  Recording frontmost app every ${TRACK_INTERVAL_MS / 1e3}s \u2192 ${usageFile()}`));
+  if (autoQuitMs) console.log(chalk.yellow(`  Auto-quit enabled: apps idle \u2265 ${formatDuration(autoQuitMs)} will be asked to quit`));
+  console.log(chalk.dim("  Press Ctrl+C to stop.\n"));
+  let lastFront = "";
+  let lastSave = 0;
+  let lastAutoQuit = 0;
+  const attempted = /* @__PURE__ */ new Set();
+  const settings = resolveSettings({ ...opts, idle: opts.autoQuit });
+  const stop = () => {
+    saveUsage(usage);
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  for (; ; ) {
+    const t = Date.now();
+    const front = await frontApp();
+    if (front) {
+      usage.apps[front.bundleId] = { name: front.name, lastActive: t };
+    }
+    usage.updatedAt = t;
+    const frontKey = front?.bundleId ?? "";
+    if (frontKey !== lastFront || t - lastSave > 3e4) {
+      saveUsage(usage);
+      lastSave = t;
+      if (frontKey !== lastFront && process.stdout.isTTY && front) {
+        console.log(chalk.dim(`  ${new Date(t).toLocaleTimeString()}  `) + front.name);
+      }
+      lastFront = frontKey;
+    }
+    if (autoQuitMs && t - lastAutoQuit > 6e4) {
+      lastAutoQuit = t;
+      try {
+        const { candidates } = await analyzeApps(settings);
+        const quitNames = [];
+        for (const c of candidates) {
+          if (c.idleMs === void 0 || attempted.has(c.app.pid)) continue;
+          attempted.add(c.app.pid);
+          const res = await quitApp(c.app, false, 8e3);
+          if (res === "quit") quitNames.push(c.app.name);
+          console.log(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}  auto-quit ${c.app.name} (idle ${formatDuration(c.idleMs)}): ${res}`);
+        }
+        if (quitNames.length) {
+          notify("pyre optimize", `Quit ${quitNames.length} idle app(s): ${quitNames.join(", ")}`);
+        }
+      } catch {
+      }
+    }
+    await sleep(TRACK_INTERVAL_MS);
+  }
+}
+function installTracker(opts) {
+  const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const args = [process.execPath, path.resolve(process.argv[1]), "optimize", "track", "--no-wizard"];
+  if (opts.autoQuit) {
+    if (isNaN(parseDuration(opts.autoQuit, NaN))) {
+      console.error(chalk.red(`  \u2716 Invalid --auto-quit value "${opts.autoQuit}".`));
+      process.exit(1);
+    }
+    args.push("--auto-quit", opts.autoQuit);
+  }
+  const logDir = getConfigDir();
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${TRACKER_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+${args.map((a) => `        <string>${xml(a)}</string>`).join("\n")}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ProcessType</key>
+    <string>Background</string>
+    <key>StandardOutPath</key>
+    <string>${xml(path.join(logDir, "optimize-tracker.log"))}</string>
+    <key>StandardErrorPath</key>
+    <string>${xml(path.join(logDir, "optimize-tracker.err"))}</string>
+</dict>
+</plist>
+`;
+  try {
+    fs.mkdirSync(path.dirname(TRACKER_PLIST), { recursive: true });
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.writeFileSync(TRACKER_PLIST, plist);
+    spawnSyncQuiet("launchctl", ["unload", TRACKER_PLIST]);
+    spawnSyncQuiet("launchctl", ["load", TRACKER_PLIST]);
+    console.log(chalk.green(`
+  \u2714 Usage tracker installed and started (${TRACKER_LABEL})`));
+    if (opts.autoQuit) console.log(chalk.yellow(`  Auto-quit: apps idle \u2265 ${opts.autoQuit} will be asked to quit`));
+    console.log(chalk.dim(`  Plist: ${TRACKER_PLIST}`));
+    console.log(chalk.dim("  Remove with: pyre optimize track --uninstall\n"));
+  } catch (err) {
+    console.log(chalk.red(`  \u2716 Failed to install tracker: ${err.message}`));
+  }
+}
+function uninstallTracker() {
+  if (!fs.existsSync(TRACKER_PLIST)) {
+    console.log(chalk.yellow(`
+  No tracker installed at ${TRACKER_PLIST}
+`));
+    return;
+  }
+  spawnSyncQuiet("launchctl", ["unload", TRACKER_PLIST]);
+  fs.unlinkSync(TRACKER_PLIST);
+  console.log(chalk.green(`
+  \u2714 Usage tracker uninstalled
+`));
+}
+function spawnSyncQuiet(cmd, args) {
+  try {
+    spawnSync(cmd, args, { stdio: "ignore" });
+  } catch {
+  }
+}
+async function collectMemory() {
+  const [pressure, swap, vm, ps] = await Promise.all([
+    run("memory_pressure", ["-Q"], 5e3),
+    run("sysctl", ["-n", "vm.swapusage"]),
+    run("vm_stat", []),
+    run("ps", ["-axo", "rss=,pid=,comm="])
+  ]);
+  const freePct = pressure.match(/free percentage:\s*(\d+)%/i)?.[1];
+  const swapTotal = swap.match(/total = ([\d.]+)M/)?.[1];
+  const swapUsed = swap.match(/used = ([\d.]+)M/)?.[1];
+  const pageSize = parseInt(vm.match(/page size of (\d+) bytes/)?.[1] ?? "16384", 10);
+  const compressedPages = vm.match(/Pages occupied by compressor:\s+(\d+)/)?.[1];
+  const top = ps.split("\n").map((l) => l.trim().match(/^(\d+)\s+(\d+)\s+(.+)$/)).filter((m) => !!m).map((m) => ({ rssKb: parseInt(m[1], 10), pid: parseInt(m[2], 10), name: path.basename(m[3]) })).sort((a, b) => b.rssKb - a.rssKb).slice(0, 10);
+  return {
+    totalBytes: os.totalmem(),
+    freePct: freePct ? parseInt(freePct, 10) : void 0,
+    swapUsedMb: swapUsed ? parseFloat(swapUsed) : void 0,
+    swapTotalMb: swapTotal ? parseFloat(swapTotal) : void 0,
+    compressedBytes: compressedPages ? parseInt(compressedPages, 10) * pageSize : void 0,
+    top
+  };
+}
+function pressureLabel(freePct) {
+  if (freePct === void 0) return chalk.dim("unknown");
+  if (freePct >= 50) return chalk.green(`normal (${freePct}% free)`);
+  if (freePct >= 25) return chalk.yellow(`elevated (${freePct}% free)`);
+  return chalk.red(`high (${freePct}% free)`);
+}
+function printMemorySummary(m) {
+  console.log(`  Memory pressure:  ${pressureLabel(m.freePct)}`);
+  if (m.swapUsedMb !== void 0) {
+    const c = m.swapUsedMb > 2048 ? chalk.yellow : chalk.reset;
+    console.log(`  Swap used:        ${c(formatKb(m.swapUsedMb * 1024))}${m.swapTotalMb ? chalk.dim(` / ${formatKb(m.swapTotalMb * 1024)}`) : ""}`);
+  }
+  if (m.compressedBytes !== void 0) console.log(`  Compressed:       ${formatKb(m.compressedBytes / 1024)}`);
+}
+async function runMemory(opts) {
+  header("Memory");
+  const m = await collectMemory();
+  console.log(`  Installed RAM:    ${formatKb(m.totalBytes / 1024)}`);
+  printMemorySummary(m);
+  console.log(chalk.bold("\n  Top memory users:"));
+  for (const p of m.top) console.log(`    ${pad(p.name, 32)}${pad(formatKb(p.rssKb), 10)}${chalk.dim(`pid ${p.pid}`)}`);
+  console.log();
+  if (opts.dryRun) return;
+  if (await confirm("Run `sudo purge` to flush inactive file cache? (asks for your password)", opts.yes)) {
+    await runInherited("sudo", ["purge"]);
+    const after = await collectMemory();
+    console.log(`
+  After purge:      ${pressureLabel(after.freePct)}
+`);
+  }
+}
+function runInherited(cmd, args) {
+  return new Promise((resolve) => {
+    const p = spawn(cmd, args, { stdio: "inherit" });
+    p.on("close", (code) => resolve(code ?? 1));
+    p.on("error", () => resolve(1));
+  });
+}
+async function duKb(paths) {
+  const out = /* @__PURE__ */ new Map();
+  const existing = paths.filter((p) => fs.existsSync(p));
+  if (!existing.length) return out;
+  const raw = await run("du", ["-sk", ...existing], 12e4);
+  for (const line of raw.split("\n")) {
+    const m = line.match(/^(\d+)\s+(.+)$/);
+    if (m) out.set(m[2], parseInt(m[1], 10));
+  }
+  return out;
+}
+async function collectCaches() {
+  const home = os.homedir();
+  const libCaches = path.join(home, "Library", "Caches");
+  const known = [
+    { name: "Xcode DerivedData", dir: path.join(home, "Library", "Developer", "Xcode", "DerivedData") },
+    { name: "Homebrew downloads", dir: path.join(libCaches, "Homebrew") },
+    { name: "npm cache", dir: path.join(home, ".npm", "_cacache") },
+    { name: "Yarn cache", dir: path.join(libCaches, "Yarn") },
+    { name: "pnpm store", dir: path.join(home, "Library", "pnpm", "store") },
+    { name: "pip cache", dir: path.join(libCaches, "pip") }
+  ];
+  const knownDirs = new Set(known.map((k) => k.dir));
+  const running = new Set((await listRunningApps()).map((a) => a.bundleId.toLowerCase()).filter(Boolean));
+  let otherChildren = [];
+  let skippedRunning = 0;
+  try {
+    otherChildren = fs.readdirSync(libCaches).map((n) => path.join(libCaches, n)).filter((p) => {
+      const n = path.basename(p).toLowerCase();
+      if (knownDirs.has(p) || n.startsWith("com.apple.") || n.startsWith(".")) return false;
+      if (running.has(n)) {
+        skippedRunning++;
+        return false;
+      }
+      return true;
+    });
+  } catch {
+  }
+  const sizes = await duKb([...known.map((k) => k.dir), ...otherChildren]);
+  const cats = known.map((k) => ({ ...k, sizeKb: sizes.get(k.dir) ?? 0 }));
+  cats.push({
+    name: "Other app caches",
+    dir: libCaches,
+    children: otherChildren,
+    sizeKb: otherChildren.reduce((s, c) => s + (sizes.get(c) ?? 0), 0),
+    note: skippedRunning ? `${skippedRunning} cache(s) of running apps skipped` : void 0
+  });
+  return cats;
+}
+function removeContents(cat) {
+  let failed = 0;
+  let targets = cat.children ?? [];
+  if (!cat.children) {
+    try {
+      targets = fs.readdirSync(cat.dir).map((n) => path.join(cat.dir, n));
+    } catch {
+      return 1;
+    }
+  }
+  for (const t of targets) {
+    try {
+      fs.rmSync(t, { recursive: true, force: true });
+    } catch {
+      failed++;
+    }
+  }
+  return failed;
+}
+async function runCaches(opts) {
+  header("Caches");
+  process.stdout.write(chalk.dim("  Measuring cache sizes\u2026\r"));
+  const cats = await collectCaches();
+  const total = cats.reduce((s, c) => s + c.sizeKb, 0);
+  for (const c of cats) {
+    const size = c.sizeKb > 1024 * 1024 ? chalk.yellow(formatKb(c.sizeKb)) : formatKb(c.sizeKb);
+    console.log(`  ${pad(c.name, 24)}${pad(size, 12)}${chalk.dim(c.note ?? "")}`);
+  }
+  console.log(chalk.bold(`
+  Total: ${formatKb(total)}
+`));
+  if (!opts.clean) {
+    console.log(chalk.dim("  To delete caches: ") + chalk.cyan("pyre optimize caches --clean") + "\n");
+    return;
+  }
+  if (opts.dryRun) {
+    console.log(chalk.dim("  Dry run: nothing was deleted.\n"));
+    return;
+  }
+  if (!opts.yes && !process.stdin.isTTY) {
+    console.log(chalk.yellow("  Not an interactive terminal. Re-run with --yes to delete.\n"));
+    return;
+  }
+  console.log(chalk.dim("  Tip: quit the related apps first. Caches are rebuilt automatically when needed.\n"));
+  let freed = 0;
+  for (const c of cats) {
+    if (c.sizeKb < 1024) continue;
+    if (!await confirm(`Delete ${c.name} (${formatKb(c.sizeKb)})?`, opts.yes)) continue;
+    const failed = removeContents(c);
+    const after = c.children ? 0 : (await duKb([c.dir])).get(c.dir) ?? 0;
+    freed += Math.max(0, c.sizeKb - after);
+    console.log(failed ? chalk.yellow(`    \u2714 cleaned (${failed} item(s) could not be removed)`) : chalk.green("    \u2714 cleaned"));
+  }
+  console.log(chalk.green(`
+  \u2714 Freed ~${formatKb(freed)}
+`));
+}
+async function trashSizeKb() {
+  const trash = path.join(os.homedir(), ".Trash");
+  try {
+    fs.readdirSync(trash);
+  } catch {
+    return void 0;
+  }
+  return (await duKb([trash])).get(trash) ?? 0;
+}
+async function runTrash(opts) {
+  header("Trash");
+  const size = await trashSizeKb();
+  console.log(`  Trash size: ${size === void 0 ? chalk.dim("unknown (grant your terminal Full Disk Access to measure)") : formatKb(size)}
+`);
+  if (!opts.empty) {
+    console.log(chalk.dim("  To empty: ") + chalk.cyan("pyre optimize trash --empty") + "\n");
+    return;
+  }
+  if (size === 0) {
+    console.log(chalk.green("  \u2714 Trash is already empty.\n"));
+    return;
+  }
+  if (opts.dryRun) {
+    console.log(chalk.dim("  Dry run: nothing was deleted.\n"));
+    return;
+  }
+  if (!await confirm("Permanently delete everything in the Trash?", opts.yes)) return;
+  const trash = path.join(os.homedir(), ".Trash");
+  let ok = false;
+  if (size !== void 0) {
+    let failed = 0;
+    for (const n of fs.readdirSync(trash)) {
+      try {
+        fs.rmSync(path.join(trash, n), { recursive: true, force: true });
+      } catch {
+        failed++;
+      }
+    }
+    ok = failed === 0;
+  }
+  if (!ok) {
+    ok = await runInherited("osascript", ["-e", 'tell application "Finder" to empty trash']) === 0;
+  }
+  console.log(ok ? chalk.green("\n  \u2714 Trash emptied\n") : chalk.red("\n  \u2716 Could not empty the Trash\n"));
+}
+async function collectLaunchItems() {
+  const dirs = [
+    [path.join(os.homedir(), "Library", "LaunchAgents"), "user agent"],
+    ["/Library/LaunchAgents", "global agent"],
+    ["/Library/LaunchDaemons", "daemon"]
+  ];
+  const loadedRaw = await run("launchctl", ["list"]);
+  const loaded = new Set(loadedRaw.split("\n").slice(1).map((l) => l.trim().split(/\s+/)[2]).filter(Boolean));
+  const jobs = [];
+  for (const [dir, scope] of dirs) {
+    let files = [];
+    try {
+      files = fs.readdirSync(dir).filter((f) => f.endsWith(".plist"));
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      const file = path.join(dir, f);
+      jobs.push((async () => {
+        const raw = await run("plutil", ["-convert", "json", "-o", "-", file], 3e3);
+        let j = {};
+        try {
+          j = JSON.parse(raw);
+        } catch {
+        }
+        const label = j.Label ?? f.replace(/\.plist$/, "");
+        const program = j.Program ?? (Array.isArray(j.ProgramArguments) ? j.ProgramArguments[0] : void 0);
+        const missing = !!program && path.isAbsolute(program) && !fs.existsSync(program);
+        return { label, file, scope, program, missing, disabled: j.Disabled === true, loaded: loaded.has(label) };
+      })());
+    }
+  }
+  return (await Promise.all(jobs)).filter((x) => !!x);
+}
+async function runStartup() {
+  header("Startup Items");
+  const loginRaw = await run("osascript", ["-e", 'tell application "System Events" to get the name of every login item'], 8e3);
+  const loginItems = loginRaw.trim() ? loginRaw.trim().split(/,\s*/) : [];
+  console.log(chalk.bold("  Login items:"));
+  if (loginItems.length) for (const li of loginItems) console.log(`    \u2022 ${li}`);
+  else console.log(chalk.dim("    none found (or System Events access was denied)"));
+  const items = await collectLaunchItems();
+  console.log(chalk.bold(`
+  Launch agents & daemons (${items.length}):`));
+  console.log(chalk.dim(`    ${pad("Label", 52)}${pad("Scope", 14)}Status`));
+  for (const it of items.sort((a, b) => a.scope.localeCompare(b.scope) || a.label.localeCompare(b.label))) {
+    const status = it.missing ? chalk.red("broken: program missing") : it.disabled ? chalk.dim("disabled") : it.loaded ? chalk.green("loaded") : chalk.dim("not loaded");
+    console.log(`    ${pad(it.label, 52)}${pad(it.scope, 14)}${status}`);
+  }
+  const broken = items.filter((i) => i.missing);
+  if (broken.length) {
+    console.log(chalk.yellow(`
+  \u26A0 ${broken.length} item(s) point to programs that no longer exist (leftovers from uninstalled apps):`));
+    for (const b of broken) console.log(chalk.dim(`    ${b.file}`));
+    console.log(chalk.dim("  Review and delete these plist files manually if you no longer need them."));
+  }
+  console.log(chalk.dim("\n  Manage login items in System Settings \u2192 General \u2192 Login Items.\n"));
+}
+async function runDns(opts) {
+  header("DNS Cache");
+  if (opts.dryRun) {
+    console.log(chalk.dim("  Dry run: would run `sudo dscacheutil -flushcache` and `sudo killall -HUP mDNSResponder`.\n"));
+    return;
+  }
+  if (!await confirm("Flush the DNS cache? (asks for your password)", opts.yes)) return;
+  const a = await runInherited("sudo", ["dscacheutil", "-flushcache"]);
+  const b = a === 0 ? await runInherited("sudo", ["killall", "-HUP", "mDNSResponder"]) : 1;
+  console.log(a === 0 && b === 0 ? chalk.green("\n  \u2714 DNS cache flushed\n") : chalk.red("\n  \u2716 Failed to flush DNS cache\n"));
+}
+function runProtect(add, names) {
+  const cfg = readConfig();
+  const list = new Set(cfg.optimizeProtectedApps ?? []);
+  if (!names.length) {
+    console.log(chalk.bold("\n  Protected apps (never quit):\n"));
+    for (const b of BUILTIN_PROTECTED) console.log(chalk.dim(`    ${b}  (built-in)`));
+    for (const p of list) console.log(`    ${p}`);
+    console.log(chalk.dim('\n  Add with: pyre optimize protect "<App Name or bundle id>"\n'));
+    return;
+  }
+  for (const n of names) {
+    if (add) list.add(n);
+    else {
+      for (const existing of [...list]) if (existing.toLowerCase() === n.toLowerCase()) list.delete(existing);
+      if (BUILTIN_PROTECTED.some((b) => b.toLowerCase() === n.toLowerCase())) {
+        console.log(chalk.yellow(`  \u26A0 ${n} is built-in protected and can't be removed.`));
+      }
+    }
+  }
+  writeConfig({ optimizeProtectedApps: [...list] });
+  console.log(chalk.green(`  \u2714 ${add ? "Protected" : "Unprotected"}: ${names.join(", ")}`));
+}
+async function runOverview(opts) {
+  header("Overview");
+  const settings = resolveSettings(opts);
+  const [analysis, mem, trash, launch] = await Promise.all([
+    analyzeApps(settings),
+    collectMemory(),
+    trashSizeKb(),
+    collectLaunchItems()
+  ]);
+  const { candidates, fresh, apps } = analysis;
+  console.log(chalk.bold("  Apps"));
+  console.log(`  Open apps:        ${apps.length}`);
+  console.log(`  Usage tracker:    ${fresh ? chalk.green("running") : fs.existsSync(TRACKER_PLIST) ? chalk.yellow("installed, not reporting") : chalk.dim("off")}`);
+  if (candidates.length) {
+    const ram = candidates.reduce((s, c) => s + c.app.rssKb, 0);
+    console.log(`  Idle apps:        ${chalk.yellow(String(candidates.length))} ${chalk.dim(`(~${formatKb(ram)} RAM)`)}: ${candidates.map((c) => c.app.name).join(", ")}`);
+  } else {
+    console.log(`  Idle apps:        ${chalk.green("none")}`);
+  }
+  console.log(chalk.bold("\n  Memory"));
+  printMemorySummary(mem);
+  console.log(chalk.bold("\n  Storage"));
+  console.log(`  Trash:            ${trash === void 0 ? chalk.dim("unknown") : formatKb(trash)}`);
+  console.log(chalk.dim("  Caches:           run `pyre optimize caches` to measure"));
+  const broken = launch.filter((i) => i.missing).length;
+  console.log(chalk.bold("\n  Startup"));
+  console.log(`  Launch items:     ${launch.length}${broken ? chalk.yellow(` (${broken} broken)`) : ""}`);
+  const tips = [];
+  if (candidates.length) tips.push(`${chalk.cyan("pyre optimize apps")}           quit ${candidates.length} idle app(s)`);
+  if (!fresh) tips.push(`${chalk.cyan("pyre optimize track --install")} track real app idle times`);
+  if (mem.freePct !== void 0 && mem.freePct < 25) tips.push(`${chalk.cyan("pyre optimize memory")}         memory pressure is high`);
+  if (trash !== void 0 && trash > 1024 * 1024) tips.push(`${chalk.cyan("pyre optimize trash --empty")}  free ${formatKb(trash)}`);
+  if (broken) tips.push(`${chalk.cyan("pyre optimize startup")}        review ${broken} broken launch item(s)`);
+  tips.push(`${chalk.cyan("pyre optimize caches")}         see reclaimable cache space`);
+  console.log(chalk.bold("\n  Suggestions"));
+  for (const t of tips) console.log(`  \u2022 ${t}`);
+  console.log();
+}
+var USAGE = `
+  Usage: pyre optimize [subcommand] [options]
+
+  Subcommands:
+    (none)                 Overview report with suggestions (changes nothing)
+    apps                   Quit apps that are open but haven't been used recently
+    track                  Record app usage for real idle times (--install / --uninstall / --auto-quit <dur>)
+    memory                 Memory pressure, swap, top RAM users, optional purge
+    caches                 Measure caches (--clean to delete after confirmation)
+    trash                  Trash size (--empty to empty after confirmation)
+    startup                Login items and launch agents, flags broken leftovers
+    dns                    Flush the DNS cache
+    protect [app]          List or add apps that are never quit
+    unprotect <app>        Remove an app from the protected list
+
+  Options:
+    --idle <dur>           Idle threshold, e.g. 30m, 2h (default from config: 2h)
+    --keep <n>             Always keep the N most recently used apps (default 5)
+    --dry-run              Show what would happen without changing anything
+    -y, --yes              Don't ask for confirmation
+    --force                Terminate apps that don't quit within 10s
+`;
+async function runWindowsDns() {
+  console.log(chalk.bold("\n  pyre optimize dns \u2014 Flush DNS Resolver Cache\n"));
+  try {
+    const { execSync } = await import("child_process");
+    execSync("ipconfig /flushdns", { stdio: "inherit" });
+    console.log(chalk.green("\n  \u2714 Windows DNS Resolver Cache flushed successfully.\n"));
+  } catch (err) {
+    console.log(chalk.red(`
+  \u2716 Failed to flush DNS cache: ${err.message}
+`));
+  }
+}
+async function runWindowsTrash(opts) {
+  console.log(chalk.bold("\n  pyre optimize trash \u2014 Windows Recycle Bin\n"));
+  if (opts.empty || opts.yes) {
+    try {
+      const { runPowerShell } = await import("./run-UJQYT2TO.js");
+      await runPowerShell("Clear-RecycleBin -Force -ErrorAction SilentlyContinue", "");
+      console.log(chalk.green("  \u2714 Emptied Recycle Bin.\n"));
+    } catch (err) {
+      console.log(chalk.red(`  \u2716 Could not empty Recycle Bin: ${err.message}
+`));
+    }
+  } else {
+    console.log(chalk.cyan("  Pass --empty or -y to empty the Recycle Bin.\n"));
+  }
+}
+async function runWindowsCaches(opts) {
+  console.log(chalk.bold("\n  pyre optimize caches \u2014 Windows Temporary Files\n"));
+  const tempDir = os.tmpdir();
+  let totalBytes = 0;
+  let fileCount = 0;
+  try {
+    if (fs.existsSync(tempDir)) {
+      const files = fs.readdirSync(tempDir);
+      for (const f of files) {
+        try {
+          const stat = fs.statSync(path.join(tempDir, f));
+          if (stat.isFile()) {
+            totalBytes += stat.size;
+            fileCount++;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  const mb = Math.round(totalBytes / (1024 * 1024) * 10) / 10;
+  console.log(`  Temporary files: ${chalk.bold(String(fileCount))} files (${chalk.yellow(`${mb} MB`)}) in ${chalk.dim(tempDir)}`);
+  if (opts.clean || opts.yes) {
+    let deleted = 0;
+    try {
+      const files = fs.readdirSync(tempDir);
+      for (const f of files) {
+        try {
+          const full = path.join(tempDir, f);
+          const stat = fs.statSync(full);
+          if (stat.isFile()) {
+            fs.unlinkSync(full);
+            deleted++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    console.log(chalk.green(`  \u2714 Cleaned ${deleted} temporary cache files.
+`));
+  } else {
+    console.log(chalk.dim("  Run with --clean or -y to remove temporary cache files.\n"));
+  }
+}
+async function runWindowsStartup() {
+  console.log(chalk.bold("\n  pyre optimize startup \u2014 Windows Startup Applications\n"));
+  try {
+    const { runPowerShell } = await import("./run-UJQYT2TO.js");
+    const raw = await runPowerShell(
+      `$hkcu = Get-ItemProperty 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run' -ErrorAction SilentlyContinue; $hklm = Get-ItemProperty 'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run' -ErrorAction SilentlyContinue; if ($hkcu) { $hkcu.PSObject.Properties | Where-Object { $_.Name -notmatch '^PS' } | ForEach-Object { "User|$($_.Name)|$($_.Value)" } }; if ($hklm) { $hklm.PSObject.Properties | Where-Object { $_.Name -notmatch '^PS' } | ForEach-Object { "System|$($_.Name)|$($_.Value)" } }`,
+      ""
+    );
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length === 0) {
+      console.log(chalk.dim("  No registry startup entries found.\n"));
+      return;
+    }
+    for (const l of lines) {
+      const [scope, name, val] = l.split("|");
+      console.log(`  \u2022 ${chalk.bold(name)} [${chalk.cyan(scope)}]`);
+      console.log(`    ${chalk.dim(val)}`);
+    }
+    console.log();
+  } catch {
+    console.log(chalk.dim("  Could not query startup entries.\n"));
+  }
+}
+async function runOptimizeCommand(sub, args, opts) {
+  if (process.platform === "win32") {
+    switch (sub) {
+      case "dns":
+        return runWindowsDns();
+      case "caches":
+      case "cache":
+        return runWindowsCaches(opts);
+      case "trash":
+        return runWindowsTrash(opts);
+      case "startup":
+        return runWindowsStartup();
+      case "protect":
+        return runProtect(true, args);
+      case "unprotect":
+        return runProtect(false, args);
+      case "help":
+        console.log(USAGE);
+        return;
+      case void 0:
+      case "report":
+        console.log(chalk.bold("\n  pyre optimize \u2014 Windows Housekeeping\n"));
+        console.log("  Available subcommands on Windows:");
+        console.log(`    ${chalk.cyan("pyre optimize dns")}      Flush DNS Resolver Cache`);
+        console.log(`    ${chalk.cyan("pyre optimize caches")}   Scan and clean temporary files (%TEMP%)`);
+        console.log(`    ${chalk.cyan("pyre optimize trash")}    Inspect and empty Recycle Bin`);
+        console.log(`    ${chalk.cyan("pyre optimize startup")}  Inspect Windows startup items
+`);
+        return;
+      default:
+        console.log(chalk.yellow(`  Subcommand "${sub}" requires macOS WindowServer APIs.`));
+        console.log("  On Windows, use: dns, caches, trash, startup, protect, unprotect.\n");
+        return;
+    }
+  }
+  if (process.platform !== "darwin") {
+    console.log(chalk.yellow("  pyre optimize is only available on macOS and Windows."));
+    return;
+  }
+  switch (sub) {
+    case void 0:
+    case "report":
+      return runOverview(opts);
+    case "apps":
+      return runApps(opts);
+    case "track":
+      return runTracker(opts);
+    case "memory":
+    case "mem":
+      return runMemory(opts);
+    case "caches":
+    case "cache":
+      return runCaches(opts);
+    case "trash":
+      return runTrash(opts);
+    case "startup":
+      return runStartup();
+    case "dns":
+      return runDns(opts);
+    case "protect":
+      return runProtect(true, args);
+    case "unprotect":
+      return runProtect(false, args);
+    case "help":
+      console.log(USAGE);
+      return;
+    default:
+      console.log(chalk.red(`  \u2716 Unknown subcommand "${sub}"`));
+      console.log(USAGE);
+      process.exitCode = 1;
+  }
+}
+export {
+  BUILTIN_PROTECTED,
+  computeIdleMs,
+  formatDuration,
+  formatKb,
+  isProtected,
+  isTrackingFresh,
+  listRunningApps,
+  loadUsage,
+  parseAsnList,
+  parseDuration,
+  parseLsappinfoList,
+  quitApp,
+  runOptimizeCommand,
+  selectIdleApps
+};