formalconf 2.0.6 → 2.0.7

package/dist/formalconf.js

@@ -1,54 +1,11 @@
 #!/usr/bin/env node
-// src/cli/formalconf.tsx
-import { useState as useState11, useEffect as useEffect6 } from "react";
-import { render, useApp as useApp2, useInput as useInput11 } from "ink";
-import { Spinner as Spinner2 } from "@inkjs/ui";
-
-// src/components/layout/Layout.tsx
-import { Box as Box5 } from "ink";
-
-// src/hooks/useTerminalSize.ts
-import { useStdout } from "ink";
-import { useState, useEffect } from "react";
-function useTerminalSize() {
-  const { stdout } = useStdout();
-  const [size, setSize] = useState({
-    columns: stdout.columns || 80,
-    rows: stdout.rows || 24
-  });
-  useEffect(() => {
-    const handleResize = () => {
-      setSize({
-        columns: stdout.columns || 80,
-        rows: stdout.rows || 24
-      });
-    };
-    stdout.on("resize", handleResize);
-    return () => {
-      stdout.off("resize", handleResize);
-    };
-  }, [stdout]);
-  return size;
-}
-
-// src/components/Header.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-
-// src/hooks/useSystemStatus.ts
-import { useState as useState2, useEffect as useEffect2 } from "react";
-import { existsSync, readlinkSync, readdirSync, lstatSync } from "fs";
-
-// src/lib/paths.ts
-import { homedir } from "os";
-import { join } from "path";
-import { readdir } from "fs/promises";
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/lib/runtime.ts
 import { spawn as nodeSpawn } from "child_process";
 import { readFile as nodeReadFile, writeFile as nodeWriteFile, mkdir } from "fs/promises";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
-var isBun = typeof Bun !== "undefined";
 async function exec(command, cwd) {
   if (isBun) {
     const proc = Bun.spawn(command, {
@@ -261,20 +218,95 @@ async function commandExists(cmd) {
   return result.success;
 }
 async function checkPrerequisites() {
-  const required = [
-    { name: "stow", install: "brew install stow" },
-    { name: "brew", install: "https://brew.sh" }
+  const isMacOS = process.platform === "darwin";
+  const common = [
+    {
+      name: "stow",
+      macInstall: "brew install stow",
+      linuxInstall: "Install via your package manager (pacman -S stow, apt install stow, etc.)"
+    }
   ];
+  const platformSpecific = isMacOS ? [{ name: "brew", install: "https://brew.sh" }] : [];
   const missing = [];
-  for (const dep of required) {
+  for (const dep of common) {
+    if (!await commandExists(dep.name)) {
+      missing.push({
+        name: dep.name,
+        install: isMacOS ? dep.macInstall : dep.linuxInstall
+      });
+    }
+  }
+  for (const dep of platformSpecific) {
     if (!await commandExists(dep.name)) {
       missing.push(dep);
     }
   }
+  if (!isMacOS) {
+    const packageManagers = ["pacman", "apt", "dnf"];
+    const hasPackageManager = await Promise.all(packageManagers.map((pm) => commandExists(pm))).then((results) => results.some(Boolean));
+    if (!hasPackageManager) {
+      missing.push({
+        name: "package manager",
+        install: "No supported package manager found (pacman, apt, or dnf)"
+      });
+    }
+  }
   return { ok: missing.length === 0, missing };
 }
+var isBun;
+var init_runtime = __esm(() => {
+  isBun = typeof Bun !== "undefined";
+});
+
+// src/lib/shell.ts
+var init_shell = __esm(() => {
+  init_runtime();
+});
+
+// src/cli/formalconf.tsx
+import { useState as useState11, useEffect as useEffect7 } from "react";
+import { render, useApp as useApp2, useInput as useInput11 } from "ink";
+import { Spinner as Spinner2 } from "@inkjs/ui";
+
+// src/components/layout/Layout.tsx
+import { Box as Box5 } from "ink";
+
+// src/hooks/useTerminalSize.ts
+import { useStdout } from "ink";
+import { useState, useEffect } from "react";
+function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState({
+    columns: stdout.columns || 80,
+    rows: stdout.rows || 24
+  });
+  useEffect(() => {
+    const handleResize = () => {
+      setSize({
+        columns: stdout.columns || 80,
+        rows: stdout.rows || 24
+      });
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+}
+
+// src/components/Header.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/hooks/useSystemStatus.ts
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { existsSync, readlinkSync, readdirSync, lstatSync } from "fs";
 
 // src/lib/paths.ts
+init_runtime();
+import { homedir } from "os";
+import { join } from "path";
+import { readdir } from "fs/promises";
 var HOME_DIR = homedir();
 var CONFIG_DIR = join(HOME_DIR, ".config", "formalconf");
 var THEME_TARGET_DIR = join(CONFIG_DIR, "current", "theme");
@@ -414,7 +446,7 @@ function StatusIndicator({
 // package.json
 var package_default = {
   name: "formalconf",
-  version: "2.0.6",
+  version: "2.0.7",
   description: "Dotfiles management TUI for macOS - config management, package sync, and theme switching",
   type: "module",
   main: "./dist/formalconf.js",
@@ -739,6 +771,7 @@ function VimSelect({ options, onChange, isDisabled = false }) {
 // src/lib/templates.ts
 import { join as join3 } from "path";
 import { existsSync as existsSync2 } from "fs";
+init_runtime();
 var EXAMPLE_CONFIG_README = `# Example Stow Config Package
 
 This is an example dotfiles package for use with GNU Stow.
@@ -1337,6 +1370,7 @@ function useBackNavigation({
 }
 
 // src/cli/config-manager.ts
+init_shell();
 import { parseArgs } from "util";
 import { readdirSync as readdirSync2, existsSync as existsSync3, lstatSync as lstatSync2, readlinkSync as readlinkSync2 } from "fs";
 var colors2 = {
@@ -1349,7 +1383,9 @@ var colors2 = {
 };
 async function checkStow() {
   if (!await commandExists("stow")) {
-    console.error(`${colors2.red}Error: GNU Stow is not installed. Install with: brew install stow${colors2.reset}`);
+    const isMacOS = process.platform === "darwin";
+    const installHint = isMacOS ? "brew install stow" : "Install via your package manager (pacman -S stow, apt install stow, dnf install stow)";
+    console.error(`${colors2.red}Error: GNU Stow is not installed. ${installHint}${colors2.reset}`);
     process.exit(1);
   }
 }
@@ -1674,7 +1710,7 @@ function ConfigMenu({ onBack }) {
 }
 
 // src/components/menus/PackageMenu.tsx
-import { useState as useState8, useCallback as useCallback2, useMemo as useMemo2, useRef } from "react";
+import { useState as useState8, useCallback as useCallback2, useMemo as useMemo2, useRef, useEffect as useEffect4 } from "react";
 import { Box as Box14, Text as Text13, useInput as useInput9 } from "ink";
 
 // src/components/ScrollableLog.tsx
@@ -1938,29 +1974,76 @@ function OrphanTable({ result, onAction, onDismiss }) {
 }
 
 // src/cli/pkg-sync.ts
+init_shell();
+init_runtime();
 import { parseArgs as parseArgs2 } from "util";
 
 // src/lib/config.ts
+init_runtime();
 import { existsSync as existsSync4 } from "fs";
-var DEFAULT_CONFIG = {
+var DEFAULT_CONFIG_V2 = {
+  version: 2,
   config: {
     purge: false,
     purgeInteractive: true,
     autoUpdate: true
   },
-  taps: [],
-  packages: [],
-  casks: [],
-  mas: {}
+  global: {
+    packages: []
+  },
+  macos: {
+    taps: [],
+    formulas: [],
+    casks: [],
+    mas: {}
+  }
 };
+function migrateV1toV2(v1Config) {
+  return {
+    version: 2,
+    config: {
+      purge: v1Config.config.purge,
+      purgeInteractive: v1Config.config.purgeInteractive,
+      autoUpdate: v1Config.config.autoUpdate
+    },
+    global: {
+      packages: []
+    },
+    macos: {
+      taps: v1Config.taps,
+      formulas: v1Config.packages,
+      casks: v1Config.casks,
+      mas: v1Config.mas
+    }
+  };
+}
+function isV1Config(config) {
+  if (!config || typeof config !== "object")
+    return false;
+  const c = config;
+  return !("version" in c) && "config" in c && "taps" in c && "packages" in c && "casks" in c;
+}
+function configIsV2(config) {
+  return "version" in config && config.version === 2;
+}
 async function loadPkgConfig(path) {
   await ensureConfigDir();
   const configPath = path || PKG_CONFIG_PATH;
   if (!existsSync4(configPath)) {
-    await savePkgConfig(DEFAULT_CONFIG, configPath);
-    return DEFAULT_CONFIG;
+    await savePkgConfig(DEFAULT_CONFIG_V2, configPath);
+    return DEFAULT_CONFIG_V2;
+  }
+  const rawConfig = await readJson(configPath);
+  if (isV1Config(rawConfig)) {
+    const v2Config = migrateV1toV2(rawConfig);
+    await savePkgConfig(v2Config, configPath);
+    return v2Config;
   }
-  return readJson(configPath);
+  if (configIsV2(rawConfig)) {
+    return rawConfig;
+  }
+  await savePkgConfig(DEFAULT_CONFIG_V2, configPath);
+  return DEFAULT_CONFIG_V2;
 }
 async function savePkgConfig(config, path) {
   await ensureConfigDir();
@@ -1979,249 +2062,1486 @@ async function savePkgLock(lock) {
 }
 
 // src/lib/lockfile.ts
-async function fetchInstalledVersions() {
-  const config = await loadPkgConfig();
-  const now = new Date().toISOString();
-  const formulas = {};
-  const casks = {};
-  if (config.packages.length > 0) {
-    const result = await exec([
-      "brew",
-      "info",
-      "--json=v2",
-      ...config.packages
-    ]);
-    if (result.success && result.stdout) {
-      const info = JSON.parse(result.stdout);
-      for (const formula of info.formulae) {
-        if (formula.installed.length > 0) {
-          formulas[formula.name] = {
-            version: formula.installed[0].version,
-            tap: formula.tap,
-            installedAt: now
-          };
+init_shell();
+
+// src/lib/platform.ts
+init_runtime();
+var cachedPlatformInfo = null;
+function getOS() {
+  return process.platform === "darwin" ? "darwin" : "linux";
+}
+async function getLinuxDistro() {
+  if (getOS() !== "linux") {
+    return "unknown";
+  }
+  try {
+    const result = await exec(["cat", "/etc/os-release"]);
+    if (!result.success) {
+      return "unknown";
+    }
+    const lines = result.stdout.split(`
+`);
+    for (const line of lines) {
+      if (line.startsWith("ID=")) {
+        const id = line.slice(3).replace(/"/g, "").toLowerCase();
+        switch (id) {
+          case "arch":
+          case "manjaro":
+          case "endeavouros":
+          case "artix":
+            return "arch";
+          case "debian":
+            return "debian";
+          case "ubuntu":
+          case "linuxmint":
+          case "pop":
+          case "elementary":
+            return "ubuntu";
+          case "fedora":
+            return "fedora";
+          case "rhel":
+          case "centos":
+          case "rocky":
+          case "almalinux":
+            return "rhel";
+          case "opensuse":
+          case "opensuse-leap":
+          case "opensuse-tumbleweed":
+            return "opensuse";
+          default:
+            const idLikeLine = lines.find((l) => l.startsWith("ID_LIKE="));
+            if (idLikeLine) {
+              const idLike = idLikeLine.slice(8).replace(/"/g, "").toLowerCase();
+              if (idLike.includes("arch"))
+                return "arch";
+              if (idLike.includes("debian") || idLike.includes("ubuntu"))
+                return "debian";
+              if (idLike.includes("fedora") || idLike.includes("rhel"))
+                return "fedora";
+            }
+            return "unknown";
         }
       }
     }
+  } catch {
+    return "unknown";
   }
-  if (config.casks.length > 0) {
-    const result = await exec([
-      "brew",
-      "info",
-      "--json=v2",
-      "--cask",
-      ...config.casks
-    ]);
-    if (result.success && result.stdout) {
-      const info = JSON.parse(result.stdout);
-      for (const cask of info.casks) {
-        if (cask.installed) {
-          casks[cask.token] = {
-            version: cask.installed,
-            installedAt: now
-          };
-        }
+  return "unknown";
+}
+async function detectAurHelper() {
+  const helpers = ["yay", "paru", "trizen"];
+  for (const helper of helpers) {
+    if (await commandExists(helper)) {
+      return helper;
+    }
+  }
+  return "none";
+}
+async function detectAvailablePackageManagers() {
+  const os = getOS();
+  const managers = [];
+  if (os === "darwin") {
+    if (await commandExists("brew")) {
+      managers.push("homebrew");
+    }
+    if (await commandExists("mas")) {
+      managers.push("mas");
+    }
+  } else {
+    if (await commandExists("pacman")) {
+      managers.push("pacman");
+      const aurHelper = await detectAurHelper();
+      if (aurHelper !== "none") {
+        managers.push("aur");
       }
     }
+    if (await commandExists("apt")) {
+      managers.push("apt");
+    }
+    if (await commandExists("dnf")) {
+      managers.push("dnf");
+    }
+    if (await commandExists("flatpak")) {
+      managers.push("flatpak");
+    }
   }
-  return { formulas, casks };
+  return managers;
 }
-async function generateLockfile() {
-  const { formulas, casks } = await fetchInstalledVersions();
-  return {
-    version: 1,
-    lastUpdated: new Date().toISOString(),
-    formulas,
-    casks
+async function getPlatformInfo() {
+  if (cachedPlatformInfo) {
+    return cachedPlatformInfo;
+  }
+  const os = getOS();
+  const distro = os === "linux" ? await getLinuxDistro() : null;
+  const aurHelper = distro === "arch" ? await detectAurHelper() : null;
+  const availableManagers = await detectAvailablePackageManagers();
+  cachedPlatformInfo = {
+    os,
+    distro,
+    aurHelper,
+    availableManagers
   };
+  return cachedPlatformInfo;
 }
-async function updateLockfile() {
-  const existing = await loadPkgLock();
-  const { formulas, casks } = await fetchInstalledVersions();
-  const mergedFormulas = {};
-  for (const [name, info] of Object.entries(formulas)) {
-    const prev = existing?.formulas[name];
-    if (prev && prev.version === info.version) {
-      mergedFormulas[name] = prev;
-    } else {
-      mergedFormulas[name] = info;
-    }
+function getPlatformDisplayName(info) {
+  if (info.os === "darwin") {
+    return "macOS";
   }
-  const mergedCasks = {};
-  for (const [name, info] of Object.entries(casks)) {
-    const prev = existing?.casks[name];
-    if (prev && prev.version === info.version) {
-      mergedCasks[name] = prev;
-    } else {
-      mergedCasks[name] = info;
-    }
+  switch (info.distro) {
+    case "arch":
+      return "Arch Linux";
+    case "debian":
+      return "Debian";
+    case "ubuntu":
+      return "Ubuntu";
+    case "fedora":
+      return "Fedora";
+    case "rhel":
+      return "RHEL/CentOS";
+    case "opensuse":
+      return "openSUSE";
+    default:
+      return "Linux";
   }
-  const lock = {
-    version: 1,
-    lastUpdated: new Date().toISOString(),
-    formulas: mergedFormulas,
-    casks: mergedCasks
-  };
-  await savePkgLock(lock);
-  return lock;
 }
-async function getChangedPackages() {
-  const existing = await loadPkgLock();
-  const { formulas, casks } = await fetchInstalledVersions();
-  const added = [];
-  const removed = [];
-  const upgraded = [];
-  if (!existing) {
-    added.push(...Object.keys(formulas), ...Object.keys(casks));
-    return { added, removed, upgraded };
+
+// src/lib/package-managers/homebrew.ts
+init_runtime();
+init_runtime();
+async function runBrewCommand(args, callbacks) {
+  const cmd = ["brew", ...args];
+  if (callbacks?.onLog) {
+    const exitCode = await execStreaming(cmd, callbacks.onLog);
+    return exitCode === 0;
   }
-  for (const [name, info] of Object.entries(formulas)) {
-    if (!existing.formulas[name]) {
-      added.push(name);
-    } else if (existing.formulas[name].version !== info.version) {
-      upgraded.push({
-        name,
-        from: existing.formulas[name].version,
-        to: info.version
-      });
+  const result = await exec(cmd);
+  return result.success;
+}
+
+class HomebrewFormulas {
+  type = "homebrew";
+  displayName = "Homebrew Formulas";
+  async isAvailable() {
+    return commandExists("brew");
+  }
+  async update(callbacks) {
+    return runBrewCommand(["update"], callbacks);
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runBrewCommand(["install", ...packages], callbacks);
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runBrewCommand(["uninstall", ...packages], callbacks);
+  }
+  async upgrade(packages, callbacks) {
+    const args = ["upgrade", "--formula"];
+    if (packages && packages.length > 0) {
+      args.push(...packages);
     }
+    return runBrewCommand(args, callbacks);
   }
-  for (const name of Object.keys(existing.formulas)) {
-    if (!formulas[name]) {
-      removed.push(name);
+  async listInstalled() {
+    const result = await exec(["brew", "info", "--json=v2", "--installed"]);
+    if (!result.success)
+      return [];
+    try {
+      const info = JSON.parse(result.stdout);
+      return info.formulae.map((f) => ({
+        name: f.name,
+        version: f.installed[0]?.version || "unknown"
+      }));
+    } catch {
+      return [];
     }
   }
-  for (const [name, info] of Object.entries(casks)) {
-    if (!existing.casks[name]) {
-      added.push(name);
-    } else if (existing.casks[name].version !== info.version) {
-      upgraded.push({
+  async listOutdated() {
+    const result = await exec(["brew", "outdated", "--formula", "--json"]);
+    if (!result.success || !result.stdout)
+      return [];
+    try {
+      const outdated = JSON.parse(result.stdout);
+      return outdated.formulae?.map((f) => ({
+        name: f.name,
+        currentVersion: f.installed_versions?.[0] || "unknown",
+        newVersion: f.current_version
+      })) || [];
+    } catch {
+      const quietResult = await exec(["brew", "outdated", "--formula", "--quiet"]);
+      if (!quietResult.success)
+        return [];
+      return quietResult.stdout.split(`
+`).filter(Boolean).map((name) => ({
         name,
-        from: existing.casks[name].version,
-        to: info.version
-      });
+        currentVersion: "unknown",
+        newVersion: "unknown"
+      }));
     }
   }
-  for (const name of Object.keys(existing.casks)) {
-    if (!casks[name]) {
-      removed.push(name);
+  async listLeaves() {
+    const result = await exec(["brew", "leaves"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean);
+  }
+  async cleanup(callbacks) {
+    const autoremove = await runBrewCommand(["autoremove"], callbacks);
+    const cleanup = await runBrewCommand(["cleanup"], callbacks);
+    return autoremove && cleanup;
+  }
+  async addRepository(repo, callbacks) {
+    return runBrewCommand(["tap", repo], callbacks);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    const listResult = await exec(["brew", "list", "--formula"]);
+    const installed = new Set(listResult.stdout.split(`
+`).filter(Boolean));
+    for (const pkg of packages) {
+      const shortName = pkg.split("/").pop() || pkg;
+      result.set(pkg, installed.has(shortName) || installed.has(pkg));
     }
+    return result;
+  }
+  async getTappedRepos() {
+    const result = await exec(["brew", "tap"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean);
+  }
+  async hasDependents(pkg) {
+    const result = await exec(["brew", "uses", "--installed", pkg]);
+    return result.success && result.stdout.trim().length > 0;
   }
-  return { added, removed, upgraded };
 }
 
-// src/types/pkg-config.ts
-var SYSTEM_APP_IDS = [
-  409183694,
-  409203825,
-  409201541,
-  408981434,
-  682658836,
-  424389933,
-  424390742,
-  413897608,
-  1274495053,
-  425424353,
-  497799835,
-  634148309,
-  1480068668,
-  803453959,
-  1295203466,
-  1444383602,
-  640199958,
-  899247664,
-  1176895641,
-  1451685025
-];
-
-// src/cli/pkg-sync.ts
-var colors3 = {
-  red: "\x1B[0;31m",
-  green: "\x1B[0;32m",
-  blue: "\x1B[0;34m",
-  yellow: "\x1B[1;33m",
-  cyan: "\x1B[0;36m",
-  bold: "\x1B[1m",
-  reset: "\x1B[0m"
-};
-async function runCommand(command, callbacks, cwd, needsTTY = false) {
-  if (callbacks) {
-    if (needsTTY) {
-      return execStreamingWithTTY(command, callbacks.onLog, cwd);
-    }
-    return execStreaming(command, callbacks.onLog, cwd);
+class HomebrewCasks {
+  type = "homebrew";
+  displayName = "Homebrew Casks";
+  async isAvailable() {
+    return commandExists("brew");
   }
-  return execLive(command, cwd);
-}
-async function checkDependencies() {
-  if (!await commandExists("brew")) {
-    console.error(`${colors3.red}Error: Homebrew not installed${colors3.reset}`);
-    process.exit(1);
+  async update(callbacks) {
+    return runBrewCommand(["update"], callbacks);
   }
-}
-async function getOutdatedPackages() {
-  const [formulas, casks] = await Promise.all([
-    exec(["brew", "outdated", "--formula", "--quiet"]),
-    exec(["brew", "outdated", "--cask", "--quiet"])
-  ]);
-  const packages = [];
-  if (formulas.stdout) {
-    packages.push(...formulas.stdout.split(`
-`).filter(Boolean).map((name) => ({ name, type: "formula" })));
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runBrewCommand(["install", "--cask", ...packages], callbacks);
   }
-  if (casks.stdout) {
-    packages.push(...casks.stdout.split(`
-`).filter(Boolean).map((name) => ({ name, type: "cask" })));
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runBrewCommand(["uninstall", "--cask", ...packages], callbacks);
   }
-  return packages;
-}
-async function getOutdatedMas() {
-  const result = await exec(["mas", "outdated"]);
-  if (!result.success || !result.stdout)
-    return [];
-  return result.stdout.split(`
-`).filter(Boolean).map((line) => {
-    const match = line.match(/^(\d+)\s+(.+?)(?:\s+\(|$)/);
+  async upgrade(packages, callbacks) {
+    const args = ["upgrade", "--cask", "--greedy"];
+    if (packages && packages.length > 0) {
+      args.push(...packages);
+    }
+    return runBrewCommand(args, callbacks);
+  }
+  async listInstalled() {
+    const result = await exec(["brew", "info", "--json=v2", "--cask", "--installed"]);
+    if (!result.success)
+      return [];
+    try {
+      const info = JSON.parse(result.stdout);
+      return info.casks.map((c) => ({
+        name: c.token,
+        version: c.installed || "unknown"
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async listOutdated() {
+    const result = await exec(["brew", "outdated", "--cask", "--quiet"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((name) => ({
+      name,
+      currentVersion: "unknown",
+      newVersion: "unknown"
+    }));
+  }
+  async cleanup(callbacks) {
+    return runBrewCommand(["cleanup"], callbacks);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    const listResult = await exec(["brew", "list", "--cask"]);
+    const installed = new Set(listResult.stdout.split(`
+`).filter(Boolean));
+    for (const pkg of packages) {
+      result.set(pkg, installed.has(pkg));
+    }
+    return result;
+  }
+}
+
+// src/lib/package-managers/mas.ts
+init_runtime();
+init_runtime();
+function parseMasOutput(output) {
+  const results = [];
+  for (const line of output.split(`
+`).filter(Boolean)) {
+    const match = line.match(/^(\d+)\s+(.+?)(?:\s+\(([^)]+)\))?$/);
     if (match) {
-      return { id: parseInt(match[1], 10), name: match[2].trim() };
+      results.push({
+        id: parseInt(match[1], 10),
+        name: match[2].trim(),
+        version: match[3]
+      });
+    }
+  }
+  return results;
+}
+
+class MacAppStore {
+  type = "mas";
+  displayName = "Mac App Store";
+  async isAvailable() {
+    return commandExists("mas");
+  }
+  async update(_callbacks) {
+    return true;
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    for (const appId of packages) {
+      const cmd = ["mas", "install", appId];
+      if (callbacks?.onLog) {
+        const exitCode = await execStreamingWithTTY(cmd, callbacks.onLog);
+        if (exitCode !== 0)
+          return false;
+      } else {
+        const result = await exec(cmd);
+        if (!result.success)
+          return false;
+      }
+    }
+    return true;
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    for (const appId of packages) {
+      const cmd = ["mas", "uninstall", appId];
+      if (callbacks?.onLog) {
+        const exitCode = await execStreamingWithTTY(cmd, callbacks.onLog);
+        if (exitCode !== 0)
+          return false;
+      } else {
+        const result = await exec(cmd);
+        if (!result.success)
+          return false;
+      }
+    }
+    return true;
+  }
+  async upgrade(_packages, callbacks) {
+    const cmd = ["mas", "upgrade"];
+    if (callbacks?.onLog) {
+      const exitCode = await execStreamingWithTTY(cmd, callbacks.onLog);
+      return exitCode === 0;
+    }
+    const result = await exec(cmd);
+    return result.success;
+  }
+  async listInstalled() {
+    const result = await exec(["mas", "list"]);
+    if (!result.success)
+      return [];
+    const apps = parseMasOutput(result.stdout);
+    return apps.map((app) => ({
+      name: String(app.id),
+      version: app.version || "unknown"
+    }));
+  }
+  async listOutdated() {
+    const result = await exec(["mas", "outdated"]);
+    if (!result.success)
+      return [];
+    const apps = parseMasOutput(result.stdout);
+    return apps.map((app) => ({
+      name: String(app.id),
+      currentVersion: app.version || "unknown",
+      newVersion: "available"
+    }));
+  }
+  async cleanup(_callbacks) {
+    return true;
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    const listResult = await exec(["mas", "list"]);
+    const apps = parseMasOutput(listResult.stdout);
+    const installedIds = new Set(apps.map((app) => String(app.id)));
+    for (const appId of packages) {
+      result.set(appId, installedIds.has(appId));
+    }
+    return result;
+  }
+  async getInstalledApps() {
+    const result = await exec(["mas", "list"]);
+    if (!result.success)
+      return [];
+    return parseMasOutput(result.stdout);
+  }
+}
+
+// src/lib/package-managers/pacman.ts
+init_runtime();
+init_runtime();
+async function runPacmanCommand(args, callbacks, sudo = false) {
+  const cmd = sudo ? ["sudo", "pacman", ...args] : ["pacman", ...args];
+  if (callbacks?.onLog) {
+    const exitCode = await execStreaming(cmd, callbacks.onLog);
+    return exitCode === 0;
+  }
+  const result = await exec(cmd);
+  return result.success;
+}
+
+class Pacman {
+  type = "pacman";
+  displayName = "Pacman";
+  async isAvailable() {
+    return commandExists("pacman");
+  }
+  async update(callbacks) {
+    return runPacmanCommand(["-Sy", "--noconfirm"], callbacks, true);
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runPacmanCommand(["-S", "--noconfirm", "--needed", ...packages], callbacks, true);
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runPacmanCommand(["-Rs", "--noconfirm", ...packages], callbacks, true);
+  }
+  async upgrade(packages, callbacks) {
+    if (packages && packages.length > 0) {
+      return runPacmanCommand(["-S", "--noconfirm", ...packages], callbacks, true);
+    }
+    return runPacmanCommand(["-Syu", "--noconfirm"], callbacks, true);
+  }
+  async listInstalled() {
+    const result = await exec(["pacman", "-Qe"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const [name, version] = line.split(" ");
+      return { name, version: version || "unknown" };
+    });
+  }
+  async listOutdated() {
+    const checkupdatesExists = await commandExists("checkupdates");
+    if (checkupdatesExists) {
+      const result2 = await exec(["checkupdates"]);
+      if (!result2.stdout)
+        return [];
+      return result2.stdout.split(`
+`).filter(Boolean).map((line) => {
+        const match = line.match(/^(\S+)\s+(\S+)\s+->\s+(\S+)$/);
+        if (match) {
+          return {
+            name: match[1],
+            currentVersion: match[2],
+            newVersion: match[3]
+          };
+        }
+        return { name: line, currentVersion: "unknown", newVersion: "unknown" };
+      });
+    }
+    await exec(["sudo", "pacman", "-Sy"]);
+    const result = await exec(["pacman", "-Qu"]);
+    if (!result.success || !result.stdout)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const [name, ...rest] = line.split(" ");
+      const versionPart = rest.join(" ");
+      const match = versionPart.match(/(\S+)\s+->\s+(\S+)/);
+      return {
+        name,
+        currentVersion: match?.[1] || "unknown",
+        newVersion: match?.[2] || "unknown"
+      };
+    });
+  }
+  async listLeaves() {
+    const result = await exec(["pacman", "-Qqe"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean);
+  }
+  async cleanup(callbacks) {
+    const orphansResult = await exec(["pacman", "-Qdtq"]);
+    if (orphansResult.success && orphansResult.stdout.trim()) {
+      const orphans = orphansResult.stdout.split(`
+`).filter(Boolean);
+      if (orphans.length > 0) {
+        await runPacmanCommand(["-Rs", "--noconfirm", ...orphans], callbacks, true);
+      }
+    }
+    return runPacmanCommand(["-Sc", "--noconfirm"], callbacks, true);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    const listResult = await exec(["pacman", "-Qq"]);
+    const installed = new Set(listResult.stdout.split(`
+`).filter(Boolean));
+    for (const pkg of packages) {
+      result.set(pkg, installed.has(pkg));
+    }
+    return result;
+  }
+}
+
+// src/lib/package-managers/aur.ts
+init_runtime();
+init_runtime();
+async function runAurCommand(helper, args, callbacks) {
+  if (helper === "none")
+    return false;
+  const cmd = [helper, ...args];
+  if (callbacks?.onLog) {
+    const exitCode = await execStreaming(cmd, callbacks.onLog);
+    return exitCode === 0;
+  }
+  const result = await exec(cmd);
+  return result.success;
+}
+
+class AurPackageManager {
+  type = "aur";
+  displayName = "AUR";
+  helper = "none";
+  helperDetected = false;
+  async getHelper() {
+    if (!this.helperDetected) {
+      this.helper = await detectAurHelper();
+      this.helperDetected = true;
+    }
+    return this.helper;
+  }
+  async isAvailable() {
+    const helper = await this.getHelper();
+    return helper !== "none";
+  }
+  async ensureAurHelper(callbacks) {
+    const helper = await this.getHelper();
+    if (helper !== "none")
+      return true;
+    const log = callbacks?.onLog || console.log;
+    log("No AUR helper found. Installing yay...");
+    const hasGit = await commandExists("git");
+    const hasMakepkg = await commandExists("makepkg");
+    const hasBaseDevel = await exec(["pacman", "-Qq", "base-devel"]);
+    if (!hasGit) {
+      log("Installing git...");
+      const gitResult = await exec(["sudo", "pacman", "-S", "--noconfirm", "git"]);
+      if (!gitResult.success) {
+        log("Failed to install git");
+        return false;
+      }
+    }
+    if (!hasBaseDevel.success) {
+      log("Installing base-devel...");
+      const baseResult = await exec(["sudo", "pacman", "-S", "--noconfirm", "base-devel"]);
+      if (!baseResult.success) {
+        log("Failed to install base-devel");
+        return false;
+      }
+    }
+    const tmpDir = "/tmp/yay-install";
+    await exec(["rm", "-rf", tmpDir]);
+    log("Cloning yay from AUR...");
+    const cloneResult = await exec(["git", "clone", "https://aur.archlinux.org/yay.git", tmpDir]);
+    if (!cloneResult.success) {
+      log(`Failed to clone yay: ${cloneResult.stderr}`);
+      return false;
+    }
+    log("Building and installing yay...");
+    const buildExitCode = await execLive(["makepkg", "-si", "--noconfirm"], tmpDir);
+    if (buildExitCode !== 0) {
+      log("Failed to build yay");
+      return false;
+    }
+    await exec(["rm", "-rf", tmpDir]);
+    this.helper = "yay";
+    log("yay installed successfully!");
+    return true;
+  }
+  async update(callbacks) {
+    const helper = await this.getHelper();
+    if (helper === "none")
+      return false;
+    return runAurCommand(helper, ["-Sy"], callbacks);
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    const helper = await this.getHelper();
+    if (helper === "none") {
+      const installed = await this.ensureAurHelper(callbacks);
+      if (!installed)
+        return false;
+    }
+    const currentHelper = await this.getHelper();
+    return runAurCommand(currentHelper, ["-S", "--noconfirm", "--needed", ...packages], callbacks);
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    const helper = await this.getHelper();
+    if (helper === "none")
+      return false;
+    return runAurCommand(helper, ["-Rs", "--noconfirm", ...packages], callbacks);
+  }
+  async upgrade(packages, callbacks) {
+    const helper = await this.getHelper();
+    if (helper === "none")
+      return false;
+    if (packages && packages.length > 0) {
+      return runAurCommand(helper, ["-S", "--noconfirm", ...packages], callbacks);
+    }
+    return runAurCommand(helper, ["-Syu", "--noconfirm"], callbacks);
+  }
+  async listInstalled() {
+    const result = await exec(["pacman", "-Qm"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const [name, version] = line.split(" ");
+      return { name, version: version || "unknown" };
+    });
+  }
+  async listOutdated() {
+    const helper = await this.getHelper();
+    if (helper === "none")
+      return [];
+    const result = await exec([helper, "-Qua"]);
+    if (!result.success || !result.stdout)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const match = line.match(/^(\S+)\s+(\S+)\s+->\s+(\S+)$/);
+      if (match) {
+        return {
+          name: match[1],
+          currentVersion: match[2],
+          newVersion: match[3]
+        };
+      }
+      return { name: line.split(" ")[0], currentVersion: "unknown", newVersion: "unknown" };
+    });
+  }
+  async cleanup(callbacks) {
+    const helper = await this.getHelper();
+    if (helper === "none")
+      return true;
+    return runAurCommand(helper, ["-Sc", "--noconfirm"], callbacks);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    const listResult = await exec(["pacman", "-Qmq"]);
+    const installed = new Set(listResult.stdout.split(`
+`).filter(Boolean));
+    for (const pkg of packages) {
+      result.set(pkg, installed.has(pkg));
+    }
+    return result;
+  }
+  getHelperName() {
+    return this.getHelper();
+  }
+}
+
+// src/lib/package-managers/apt.ts
+init_runtime();
+init_runtime();
+async function runAptCommand(args, callbacks, sudo = false) {
+  const cmd = sudo ? ["sudo", "apt-get", ...args] : ["apt-get", ...args];
+  if (callbacks?.onLog) {
+    const exitCode = await execStreaming(cmd, callbacks.onLog);
+    return exitCode === 0;
+  }
+  const result = await exec(cmd);
+  return result.success;
+}
+
+class Apt {
+  type = "apt";
+  displayName = "APT";
+  async isAvailable() {
+    return commandExists("apt-get");
+  }
+  async update(callbacks) {
+    return runAptCommand(["update", "-y"], callbacks, true);
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runAptCommand(["install", "-y", ...packages], callbacks, true);
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runAptCommand(["remove", "-y", ...packages], callbacks, true);
+  }
+  async upgrade(packages, callbacks) {
+    if (packages && packages.length > 0) {
+      return runAptCommand(["install", "-y", "--only-upgrade", ...packages], callbacks, true);
+    }
+    await runAptCommand(["update", "-y"], callbacks, true);
+    return runAptCommand(["upgrade", "-y"], callbacks, true);
+  }
+  async listInstalled() {
+    const result = await exec(["dpkg-query", "-W", "-f=${Package} ${Version}\n"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const [name, version] = line.split(" ");
+      return { name, version: version || "unknown" };
+    });
+  }
+  async listOutdated() {
+    await exec(["sudo", "apt-get", "update", "-y"]);
+    const result = await exec(["apt", "list", "--upgradable"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter((line) => line.includes("[upgradable")).map((line) => {
+      const match = line.match(/^(\S+)\/\S+\s+(\S+)\s+\S+\s+\[upgradable from:\s+(\S+)\]/);
+      if (match) {
+        return {
+          name: match[1],
+          currentVersion: match[3],
+          newVersion: match[2]
+        };
+      }
+      return null;
+    }).filter((pkg) => pkg !== null);
+  }
+  async listLeaves() {
+    const result = await exec(["apt-mark", "showmanual"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean);
+  }
+  async cleanup(callbacks) {
+    const autoremove = await runAptCommand(["autoremove", "-y"], callbacks, true);
+    const autoclean = await runAptCommand(["autoclean"], callbacks, true);
+    return autoremove && autoclean;
+  }
+  async addRepository(repo, callbacks) {
+    const cmd = ["sudo", "add-apt-repository", "-y", repo];
+    if (callbacks?.onLog) {
+      const exitCode = await execStreaming(cmd, callbacks.onLog);
+      if (exitCode !== 0)
+        return false;
+    } else {
+      const result = await exec(cmd);
+      if (!result.success)
+        return false;
+    }
+    return runAptCommand(["update", "-y"], callbacks, true);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    for (const pkg of packages) {
+      const checkResult = await exec(["dpkg", "-s", pkg]);
+      result.set(pkg, checkResult.success && checkResult.stdout.includes("Status: install ok installed"));
+    }
+    return result;
+  }
+}
+
+// src/lib/package-managers/dnf.ts
+init_runtime();
+init_runtime();
+async function runDnfCommand(args, callbacks, sudo = false) {
+  const cmd = sudo ? ["sudo", "dnf", ...args] : ["dnf", ...args];
+  if (callbacks?.onLog) {
+    const exitCode = await execStreaming(cmd, callbacks.onLog);
+    return exitCode === 0;
+  }
+  const result = await exec(cmd);
+  return result.success;
+}
+
+class Dnf {
+  type = "dnf";
+  displayName = "DNF";
+  async isAvailable() {
+    return commandExists("dnf");
+  }
+  async update(callbacks) {
+    return runDnfCommand(["check-update", "-y"], callbacks, true);
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runDnfCommand(["install", "-y", ...packages], callbacks, true);
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    return runDnfCommand(["remove", "-y", ...packages], callbacks, true);
+  }
+  async upgrade(packages, callbacks) {
+    if (packages && packages.length > 0) {
+      return runDnfCommand(["upgrade", "-y", ...packages], callbacks, true);
+    }
+    return runDnfCommand(["upgrade", "-y"], callbacks, true);
+  }
+  async listInstalled() {
+    const result = await exec(["dnf", "list", "installed", "-q"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).slice(1).map((line) => {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const fullName = parts[0];
+        const name = fullName.replace(/\.\w+$/, "");
+        return { name, version: parts[1] };
+      }
+      return null;
+    }).filter((pkg) => pkg !== null);
+  }
+  async listOutdated() {
+    const result = await exec(["dnf", "check-update", "-q"]);
+    if (!result.stdout)
+      return [];
+    return result.stdout.split(`
+`).filter((line) => line.trim() && !line.startsWith("Last metadata")).map((line) => {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const fullName = parts[0];
+        const name = fullName.replace(/\.\w+$/, "");
+        return {
+          name,
+          currentVersion: "installed",
+          newVersion: parts[1]
+        };
+      }
+      return null;
+    }).filter((pkg) => pkg !== null);
+  }
+  async listLeaves() {
+    const hasLeaves = await commandExists("dnf-leaves");
+    if (hasLeaves) {
+      const result2 = await exec(["dnf", "leaves"]);
+      if (result2.success) {
+        return result2.stdout.split(`
+`).filter(Boolean);
+      }
+    }
+    const result = await exec(["dnf", "repoquery", "--userinstalled", "-q"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => line.replace(/\.\w+$/, ""));
+  }
+  async cleanup(callbacks) {
+    const autoremove = await runDnfCommand(["autoremove", "-y"], callbacks, true);
+    const clean = await runDnfCommand(["clean", "all"], callbacks, true);
+    return autoremove && clean;
+  }
+  async addRepository(repo, callbacks) {
+    if (repo.startsWith("copr:")) {
+      const coprRepo = repo.replace("copr:", "");
+      return runDnfCommand(["copr", "enable", "-y", coprRepo], callbacks, true);
+    }
+    return runDnfCommand(["config-manager", "--add-repo", repo], callbacks, true);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    for (const pkg of packages) {
+      const checkResult = await exec(["rpm", "-q", pkg]);
+      result.set(pkg, checkResult.success);
+    }
+    return result;
+  }
+}
+
+// src/lib/package-managers/flatpak.ts
+init_runtime();
+init_runtime();
+async function runFlatpakCommand(args, callbacks) {
+  const cmd = ["flatpak", ...args];
+  if (callbacks?.onLog) {
+    const exitCode = await execStreaming(cmd, callbacks.onLog);
+    return exitCode === 0;
+  }
+  const result = await exec(cmd);
+  return result.success;
+}
+
+class Flatpak {
+  type = "flatpak";
+  displayName = "Flatpak";
+  async isAvailable() {
+    return commandExists("flatpak");
+  }
+  async update(callbacks) {
+    return true;
+  }
+  async install(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    for (const appId of packages) {
+      const success = await runFlatpakCommand(["install", "-y", "--noninteractive", "flathub", appId], callbacks);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async uninstall(packages, callbacks) {
+    if (packages.length === 0)
+      return true;
+    for (const appId of packages) {
+      const success = await runFlatpakCommand(["uninstall", "-y", "--noninteractive", appId], callbacks);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async upgrade(packages, callbacks) {
+    if (packages && packages.length > 0) {
+      for (const appId of packages) {
+        const success = await runFlatpakCommand(["update", "-y", "--noninteractive", appId], callbacks);
+        if (!success)
+          return false;
+      }
+      return true;
+    }
+    return runFlatpakCommand(["update", "-y", "--noninteractive"], callbacks);
+  }
+  async listInstalled() {
+    const result = await exec(["flatpak", "list", "--app", "--columns=application,version"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const [name, version] = line.split("\t");
+      return { name: name.trim(), version: version?.trim() || "unknown" };
+    });
+  }
+  async listOutdated() {
+    const result = await exec(["flatpak", "remote-ls", "--updates", "--columns=application,version"]);
+    if (!result.success)
+      return [];
+    return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const [name, newVersion] = line.split("\t");
+      return {
+        name: name.trim(),
+        currentVersion: "installed",
+        newVersion: newVersion?.trim() || "unknown"
+      };
+    });
+  }
+  async cleanup(callbacks) {
+    return runFlatpakCommand(["uninstall", "-y", "--unused", "--noninteractive"], callbacks);
+  }
+  async addRepository(repo, callbacks) {
+    if (repo === "flathub") {
+      return runFlatpakCommand(["remote-add", "--if-not-exists", "flathub", "https://flathub.org/repo/flathub.flatpakrepo"], callbacks);
+    }
+    const [name, url] = repo.split(" ");
+    if (!url)
+      return false;
+    return runFlatpakCommand(["remote-add", "--if-not-exists", name, url], callbacks);
+  }
+  async isInstalled(packages) {
+    const result = new Map;
+    const listResult = await exec(["flatpak", "list", "--app", "--columns=application"]);
+    const installed = new Set(listResult.stdout.split(`
+`).filter(Boolean).map((l) => l.trim()));
+    for (const appId of packages) {
+      result.set(appId, installed.has(appId));
+    }
+    return result;
+  }
+  async ensureFlathub(callbacks) {
+    const result = await exec(["flatpak", "remotes"]);
+    if (result.success && result.stdout.includes("flathub")) {
+      return true;
+    }
+    return this.addRepository("flathub", callbacks);
+  }
+}
+
+// src/lib/package-managers/index.ts
+var managerInstances = new Map;
+function getPackageManager(type) {
+  const existing = managerInstances.get(type);
+  if (existing)
+    return existing;
+  let manager;
+  switch (type) {
+    case "homebrew":
+      manager = new HomebrewFormulas;
+      break;
+    case "homebrew-casks":
+      manager = new HomebrewCasks;
+      break;
+    case "mas":
+      manager = new MacAppStore;
+      break;
+    case "pacman":
+      manager = new Pacman;
+      break;
+    case "aur":
+      manager = new AurPackageManager;
+      break;
+    case "apt":
+      manager = new Apt;
+      break;
+    case "dnf":
+      manager = new Dnf;
+      break;
+    case "flatpak":
+      manager = new Flatpak;
+      break;
+    default:
+      throw new Error(`Unknown package manager type: ${type}`);
+  }
+  managerInstances.set(type, manager);
+  return manager;
+}
+async function getAvailableManagers() {
+  const platformInfo = await getPlatformInfo();
+  const managers = [];
+  for (const type of platformInfo.availableManagers) {
+    const manager = getPackageManager(type);
+    if (await manager.isAvailable()) {
+      managers.push(manager);
+      if (type === "homebrew") {
+        const casks = getPackageManager("homebrew-casks");
+        if (await casks.isAvailable()) {
+          managers.push(casks);
+        }
+      }
+    }
+  }
+  return managers;
+}
+
+// src/lib/lockfile.ts
+async function fetchInstalledVersionsV2() {
+  const platform = await getPlatformInfo();
+  const config = await loadPkgConfig();
+  const now = new Date().toISOString();
+  const packages = {};
+  const managers = await getAvailableManagers();
+  for (const manager of managers) {
+    const installed = await manager.listInstalled();
+    for (const pkg of installed) {
+      const key = `${manager.type}:${pkg.name}`;
+      packages[key] = {
+        version: pkg.version,
+        installedAt: pkg.installedAt || now,
+        manager: manager.type
+      };
+    }
+  }
+  if (platform.os === "darwin") {
+    const formulaPackages = config.macos?.formulas || [];
+    const globalPackages = config.global?.packages || [];
+    const allFormulas = [...globalPackages, ...formulaPackages];
+    if (allFormulas.length > 0) {
+      const result = await exec([
+        "brew",
+        "info",
+        "--json=v2",
+        ...allFormulas
+      ]);
+      if (result.success && result.stdout) {
+        try {
+          const info = JSON.parse(result.stdout);
+          for (const formula of info.formulae) {
+            if (formula.installed.length > 0) {
+              const key = `homebrew:${formula.name}`;
+              if (packages[key]) {
+                packages[key].tap = formula.tap;
+              }
+            }
+          }
+        } catch {}
+      }
+    }
+  }
+  return packages;
+}
+async function updateLockfile() {
+  const existing = await loadPkgLock();
+  const packages = await fetchInstalledVersionsV2();
+  const mergedPackages = {};
+  for (const [key, info] of Object.entries(packages)) {
+    if (existing?.version === 2) {
+      const prev = existing.packages[key];
+      if (prev && prev.version === info.version) {
+        mergedPackages[key] = prev;
+      } else {
+        mergedPackages[key] = info;
+      }
+    } else if (existing?.version === 1) {
+      const [manager, name] = key.split(":");
+      let prev;
+      if (manager === "homebrew") {
+        prev = existing.formulas[name];
+      } else if (manager === "homebrew-casks") {
+        prev = existing.casks[name];
+      }
+      if (prev && prev.version === info.version) {
+        mergedPackages[key] = {
+          ...info,
+          installedAt: prev.installedAt
+        };
+      } else {
+        mergedPackages[key] = info;
+      }
+    } else {
+      mergedPackages[key] = info;
+    }
+  }
+  const lock = {
+    version: 2,
+    lastUpdated: new Date().toISOString(),
+    packages: mergedPackages
+  };
+  await savePkgLock(lock);
+  return lock;
+}
+async function fetchInstalledVersions() {
+  const config = await loadPkgConfig();
+  const now = new Date().toISOString();
+  const formulas = {};
+  const casks = {};
+  const allFormulas = [
+    ...config.global?.packages || [],
+    ...config.macos?.formulas || []
+  ];
+  if (allFormulas.length > 0) {
+    const result = await exec([
+      "brew",
+      "info",
+      "--json=v2",
+      ...allFormulas
+    ]);
+    if (result.success && result.stdout) {
+      const info = JSON.parse(result.stdout);
+      for (const formula of info.formulae) {
+        if (formula.installed.length > 0) {
+          formulas[formula.name] = {
+            version: formula.installed[0].version,
+            tap: formula.tap,
+            installedAt: now
+          };
+        }
+      }
+    }
+  }
+  const allCasks = config.macos?.casks || [];
+  if (allCasks.length > 0) {
+    const result = await exec([
+      "brew",
+      "info",
+      "--json=v2",
+      "--cask",
+      ...allCasks
+    ]);
+    if (result.success && result.stdout) {
+      const info = JSON.parse(result.stdout);
+      for (const cask of info.casks) {
+        if (cask.installed) {
+          casks[cask.token] = {
+            version: cask.installed,
+            installedAt: now
+          };
+        }
+      }
+    }
+  }
+  return { formulas, casks };
+}
+async function generateLockfile() {
+  const { formulas, casks } = await fetchInstalledVersions();
+  return {
+    version: 1,
+    lastUpdated: new Date().toISOString(),
+    formulas,
+    casks
+  };
+}
+async function getChangedPackages() {
+  const existing = await loadPkgLock();
+  const packages = await fetchInstalledVersionsV2();
+  const added = [];
+  const removed = [];
+  const upgraded = [];
+  if (!existing) {
+    added.push(...Object.keys(packages));
+    return { added, removed, upgraded };
+  }
+  if (existing.version === 2) {
+    for (const [key, info] of Object.entries(packages)) {
+      if (!existing.packages[key]) {
+        added.push(key);
+      } else if (existing.packages[key].version !== info.version) {
+        upgraded.push({
+          name: key,
+          from: existing.packages[key].version,
+          to: info.version
+        });
+      }
     }
-    return null;
-  }).filter((app) => app !== null);
+    for (const key of Object.keys(existing.packages)) {
+      if (!packages[key]) {
+        removed.push(key);
+      }
+    }
+  } else {
+    const { formulas, casks } = await fetchInstalledVersions();
+    for (const [name, info] of Object.entries(formulas)) {
+      if (!existing.formulas[name]) {
+        added.push(name);
+      } else if (existing.formulas[name].version !== info.version) {
+        upgraded.push({
+          name,
+          from: existing.formulas[name].version,
+          to: info.version
+        });
+      }
+    }
+    for (const name of Object.keys(existing.formulas)) {
+      if (!formulas[name]) {
+        removed.push(name);
+      }
+    }
+    for (const [name, info] of Object.entries(casks)) {
+      if (!existing.casks[name]) {
+        added.push(name);
+      } else if (existing.casks[name].version !== info.version) {
+        upgraded.push({
+          name,
+          from: existing.casks[name].version,
+          to: info.version
+        });
+      }
+    }
+    for (const name of Object.keys(existing.casks)) {
+      if (!casks[name]) {
+        removed.push(name);
+      }
+    }
+  }
+  return { added, removed, upgraded };
+}
+
+// src/types/pkg-config.ts
+var SYSTEM_APP_IDS = [
+  409183694,
+  409203825,
+  409201541,
+  408981434,
+  682658836,
+  424389933,
+  424390742,
+  413897608,
+  1274495053,
+  425424353,
+  497799835,
+  634148309,
+  1480068668,
+  803453959,
+  1295203466,
+  1444383602,
+  640199958,
+  899247664,
+  1176895641,
+  1451685025
+];
+
+// src/cli/pkg-sync.ts
+var colors3 = {
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  blue: "\x1B[0;34m",
+  yellow: "\x1B[1;33m",
+  cyan: "\x1B[0;36m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
+async function getPackageSetsForPlatform(config, platform) {
+  const sets = [];
+  if (platform.os === "darwin") {
+    const formulas = getPackageManager("homebrew");
+    const casks = getPackageManager("homebrew-casks");
+    const mas = getPackageManager("mas");
+    const globalPkgs = config.global?.packages || [];
+    const macosFormulas = config.macos?.formulas || [];
+    const allFormulas = [...globalPkgs, ...macosFormulas];
+    if (allFormulas.length > 0 || (config.macos?.taps || []).length > 0) {
+      sets.push({
+        manager: formulas,
+        packages: allFormulas,
+        repositories: config.macos?.taps
+      });
+    }
+    const macosCasks = config.macos?.casks || [];
+    if (macosCasks.length > 0) {
+      sets.push({
+        manager: casks,
+        packages: macosCasks
+      });
+    }
+    const masMappings = config.macos?.mas || {};
+    const masIds = Object.values(masMappings).map(String);
+    if (masIds.length > 0 && await mas.isAvailable()) {
+      sets.push({
+        manager: mas,
+        packages: masIds
+      });
+    }
+  } else {
+    const distro = platform.distro;
+    const globalPkgs = config.global?.packages || [];
+    const linuxPkgs = config.linux?.packages || [];
+    if (distro === "arch") {
+      const pacman = getPackageManager("pacman");
+      const aur = getPackageManager("aur");
+      const archPkgs = config.arch?.packages || [];
+      const allPacmanPkgs = [...globalPkgs, ...linuxPkgs, ...archPkgs];
+      if (allPacmanPkgs.length > 0) {
+        sets.push({
+          manager: pacman,
+          packages: allPacmanPkgs
+        });
+      }
+      const aurPkgs = config.arch?.aur || [];
+      if (aurPkgs.length > 0 && await aur.isAvailable()) {
+        sets.push({
+          manager: aur,
+          packages: aurPkgs
+        });
+      }
+    } else if (distro === "debian" || distro === "ubuntu") {
+      const apt = getPackageManager("apt");
+      const debianPkgs = config.debian?.packages || [];
+      const allAptPkgs = [...globalPkgs, ...linuxPkgs, ...debianPkgs];
+      if (allAptPkgs.length > 0 || (config.debian?.ppas || []).length > 0) {
+        sets.push({
+          manager: apt,
+          packages: allAptPkgs,
+          repositories: config.debian?.ppas
+        });
+      }
+    } else if (distro === "fedora" || distro === "rhel") {
+      const dnf = getPackageManager("dnf");
+      const fedoraPkgs = config.fedora?.packages || [];
+      const allDnfPkgs = [...globalPkgs, ...linuxPkgs, ...fedoraPkgs];
+      if (allDnfPkgs.length > 0 || (config.fedora?.copr || []).length > 0) {
+        sets.push({
+          manager: dnf,
+          packages: allDnfPkgs,
+          repositories: config.fedora?.copr?.map((r) => `copr:${r}`)
+        });
+      }
+    } else {
+      const managers = await getAvailableManagers();
+      const primaryManager = managers.find((m) => m.type === "pacman" || m.type === "apt" || m.type === "dnf");
+      if (primaryManager) {
+        const allPkgs = [...globalPkgs, ...linuxPkgs];
+        if (allPkgs.length > 0) {
+          sets.push({
+            manager: primaryManager,
+            packages: allPkgs
+          });
+        }
+      }
+    }
+    const flatpak = getPackageManager("flatpak");
+    const flatpakApps = config.linux?.flatpak || [];
+    if (flatpakApps.length > 0 && await flatpak.isAvailable()) {
+      sets.push({
+        manager: flatpak,
+        packages: flatpakApps
+      });
+    }
+  }
+  return sets;
+}
+async function checkDependencies(platform) {
+  if (platform.os === "darwin") {
+    if (!await commandExists("brew")) {
+      console.error(`${colors3.red}Error: Homebrew not installed${colors3.reset}`);
+      process.exit(1);
+    }
+  } else {
+    const hasPackageManager = await Promise.all([
+      commandExists("pacman"),
+      commandExists("apt"),
+      commandExists("dnf")
+    ]).then((results) => results.some(Boolean));
+    if (!hasPackageManager) {
+      console.error(`${colors3.red}Error: No supported package manager found (pacman, apt, or dnf)${colors3.reset}`);
+      process.exit(1);
+    }
+  }
 }
 async function upgradeWithVerification(cb = null) {
   const log = cb?.onLog ?? console.log;
+  const platform = await getPlatformInfo();
   const result = {
     attempted: [],
     succeeded: [],
     failed: [],
     stillOutdated: []
   };
+  const callbacks = cb ? { onLog: cb.onLog } : undefined;
   log(`
 ${colors3.cyan}=== Checking for updates ===${colors3.reset}
 `);
-  await runCommand(["brew", "update"], cb);
-  const beforeUpgrade = await getOutdatedPackages();
-  result.attempted = beforeUpgrade.map((p) => p.name);
-  if (beforeUpgrade.length === 0) {
-    log(`
-${colors3.green}All brew packages are up to date${colors3.reset}`);
-  } else {
-    log(`
-${colors3.yellow}Found ${beforeUpgrade.length} outdated packages${colors3.reset}
-`);
-    log(`${colors3.cyan}=== Upgrading formulas ===${colors3.reset}
-`);
-    await runCommand(["brew", "upgrade", "--formula"], cb);
+  const managers = await getAvailableManagers();
+  for (const manager of managers) {
     log(`
-${colors3.cyan}=== Upgrading casks ===${colors3.reset}
+${colors3.cyan}--- ${manager.displayName} ---${colors3.reset}
 `);
-    await runCommand(["brew", "upgrade", "--cask", "--greedy"], cb);
-    log(`
-${colors3.cyan}=== Verifying upgrades ===${colors3.reset}
+    await manager.update(callbacks);
+    const outdated = await manager.listOutdated();
+    if (outdated.length === 0) {
+      log(`${colors3.green}All packages are up to date${colors3.reset}`);
+      continue;
+    }
+    log(`${colors3.yellow}Found ${outdated.length} outdated packages${colors3.reset}
 `);
-    const afterUpgrade = await getOutdatedPackages();
-    const stillOutdatedSet = new Set(afterUpgrade.map((p) => p.name));
-    for (const pkg of beforeUpgrade) {
+    result.attempted.push(...outdated.map((p) => p.name));
+    await manager.upgrade(undefined, callbacks);
+    const stillOutdated = await manager.listOutdated();
+    const stillOutdatedSet = new Set(stillOutdated.map((p) => p.name));
+    for (const pkg of outdated) {
       if (stillOutdatedSet.has(pkg.name)) {
         result.stillOutdated.push(pkg.name);
       } else {
@@ -2232,93 +3552,70 @@ ${colors3.cyan}=== Verifying upgrades ===${colors3.reset}
       log(`${colors3.yellow}${result.stillOutdated.length} packages still outdated, retrying individually...${colors3.reset}
 `);
       for (const pkgName of [...result.stillOutdated]) {
-        const pkg = afterUpgrade.find((p) => p.name === pkgName);
-        if (!pkg)
-          continue;
         log(`  Retrying ${colors3.blue}${pkgName}${colors3.reset}...`);
-        const upgradeCmd = pkg.type === "cask" ? ["brew", "upgrade", "--cask", pkgName] : ["brew", "upgrade", pkgName];
-        const retryResult = await exec(upgradeCmd);
-        const checkResult = await exec([
-          "brew",
-          "outdated",
-          pkg.type === "cask" ? "--cask" : "--formula",
-          "--quiet"
-        ]);
-        const stillOutdatedNow = checkResult.stdout.split(`
-`).filter(Boolean);
-        if (!stillOutdatedNow.includes(pkgName)) {
+        const upgradeSuccess = await manager.upgrade([pkgName], callbacks);
+        const checkOutdated = await manager.listOutdated();
+        const stillFailing = checkOutdated.some((p) => p.name === pkgName);
+        if (!stillFailing) {
           result.succeeded.push(pkgName);
           result.stillOutdated = result.stillOutdated.filter((n) => n !== pkgName);
           log(`    ${colors3.green}✓ Success${colors3.reset}`);
         } else {
           result.failed.push(pkgName);
           result.stillOutdated = result.stillOutdated.filter((n) => n !== pkgName);
-          log(`    ${colors3.red}✗ Failed${colors3.reset} ${retryResult.stderr ? `(${retryResult.stderr.split(`
-`)[0]})` : ""}`);
+          log(`    ${colors3.red}✗ Failed${colors3.reset}`);
         }
       }
     }
   }
-  if (await commandExists("mas")) {
-    const masOutdated = await getOutdatedMas();
-    if (masOutdated.length > 0) {
-      log(`
-${colors3.cyan}=== Upgrading Mac App Store apps ===${colors3.reset}
-`);
-      await runCommand(["mas", "upgrade"], cb, undefined, true);
-    }
-  }
   log(`
 ${colors3.cyan}=== Cleanup ===${colors3.reset}
 `);
-  await runCommand(["brew", "cleanup"], cb);
+  for (const manager of managers) {
+    await manager.cleanup(callbacks);
+  }
   log(`
 ${colors3.cyan}=== Updating lockfile ===${colors3.reset}
 `);
   const lock = await updateLockfile();
-  const lockTotal = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+  const lockTotal = lock.version === 2 ? Object.keys(lock.packages).length : Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
   log(`  Locked ${lockTotal} packages`);
   return result;
 }
 async function upgradeInteractive(cb = null) {
   const log = cb?.onLog ?? console.log;
   const askPrompt = cb?.onPrompt ?? (async (q) => (prompt(q) || "").trim().toLowerCase());
-  log(`
-${colors3.cyan}=== Checking for updates ===${colors3.reset}
-`);
-  await runCommand(["brew", "update"], cb);
-  const outdated = await getOutdatedPackages();
-  if (outdated.length === 0) {
+  const callbacks = cb ? { onLog: cb.onLog } : undefined;
+  const managers = await getAvailableManagers();
+  for (const manager of managers) {
     log(`
-${colors3.green}All packages are up to date${colors3.reset}
+${colors3.cyan}=== ${manager.displayName} ===${colors3.reset}
 `);
-    return;
-  }
-  log(`
-${colors3.yellow}Found ${outdated.length} outdated packages${colors3.reset}
+    await manager.update(callbacks);
+    const outdated = await manager.listOutdated();
+    if (outdated.length === 0) {
+      log(`${colors3.green}All packages are up to date${colors3.reset}
 `);
-  for (const pkg of outdated) {
-    const question = `Upgrade ${colors3.blue}${pkg.name}${colors3.reset} (${pkg.type})?`;
-    const answer = await askPrompt(question, ["y", "n", "q"]);
-    if (answer === "q") {
-      log(`
-${colors3.yellow}Upgrade cancelled${colors3.reset}`);
-      return;
+      continue;
     }
-    if (answer === "y" || answer === "yes") {
-      const cmd = pkg.type === "cask" ? ["brew", "upgrade", "--cask", pkg.name] : ["brew", "upgrade", pkg.name];
-      await runCommand(cmd, cb);
+    log(`${colors3.yellow}Found ${outdated.length} outdated packages${colors3.reset}
+`);
+    for (const pkg of outdated) {
+      const question = `Upgrade ${colors3.blue}${pkg.name}${colors3.reset} (${pkg.currentVersion} -> ${pkg.newVersion})?`;
+      const answer = await askPrompt(question, ["y", "n", "q"]);
+      if (answer === "q") {
+        log(`
+${colors3.yellow}Upgrade cancelled${colors3.reset}`);
+        return;
+      }
+      if (answer === "y" || answer === "yes") {
+        await manager.upgrade([pkg.name], callbacks);
+      }
     }
   }
-  const stillOutdated = await getOutdatedPackages();
-  if (stillOutdated.length > 0) {
-    log(`
-${colors3.yellow}Still outdated: ${stillOutdated.map((p) => p.name).join(", ")}${colors3.reset}`);
-  } else {
-    log(`
-${colors3.green}All selected packages upgraded successfully${colors3.reset}`);
+  for (const manager of managers) {
+    await manager.cleanup(callbacks);
   }
-  await runCommand(["brew", "cleanup"], cb);
   log(`
 ${colors3.cyan}=== Updating lockfile ===${colors3.reset}
 `);
@@ -2326,61 +3623,50 @@ ${colors3.cyan}=== Updating lockfile ===${colors3.reset}
 }
 async function syncPackages(config, cb = null) {
   const log = cb?.onLog ?? console.log;
-  if (config.config.autoUpdate) {
-    log(`
-${colors3.cyan}=== Updating Homebrew ===${colors3.reset}
-`);
-    await runCommand(["brew", "update"], cb);
-  }
-  log(`
-${colors3.cyan}=== Installing taps ===${colors3.reset}
-`);
-  const tappedResult = await exec(["brew", "tap"]);
-  const tapped = tappedResult.stdout.split(`
-`).filter(Boolean);
-  for (const tap of config.taps) {
-    if (!tapped.includes(tap)) {
-      log(`  Adding tap: ${colors3.blue}${tap}${colors3.reset}`);
-      await runCommand(["brew", "tap", tap], cb);
-    }
-  }
+  const platform = await getPlatformInfo();
+  const callbacks = cb ? { onLog: cb.onLog } : undefined;
   log(`
-${colors3.cyan}=== Installing packages ===${colors3.reset}
+${colors3.cyan}Platform: ${getPlatformDisplayName(platform)}${colors3.reset}
 `);
-  const installedFormulas = (await exec(["brew", "list", "--formula"])).stdout.split(`
-`).filter(Boolean);
-  for (const pkg of config.packages) {
-    if (!installedFormulas.includes(pkg)) {
-      log(`  Installing: ${colors3.blue}${pkg}${colors3.reset}`);
-      await runCommand(["brew", "install", pkg], cb);
-    }
+  const packageSets = await getPackageSetsForPlatform(config, platform);
+  if (packageSets.length === 0) {
+    log(`${colors3.yellow}No packages configured for this platform${colors3.reset}`);
+    return;
   }
-  log(`
-${colors3.cyan}=== Installing casks ===${colors3.reset}
+  if (config.config.autoUpdate) {
+    log(`
+${colors3.cyan}=== Updating package managers ===${colors3.reset}
 `);
-  const installedCasks = (await exec(["brew", "list", "--cask"])).stdout.split(`
-`).filter(Boolean);
-  for (const cask of config.casks) {
-    if (!installedCasks.includes(cask)) {
-      log(`  Installing: ${colors3.blue}${cask}${colors3.reset}`);
-      await runCommand(["brew", "install", "--cask", cask], cb);
+    for (const set of packageSets) {
+      log(`  Updating ${set.manager.displayName}...`);
+      await set.manager.update(callbacks);
     }
   }
-  if (await commandExists("mas")) {
+  for (const set of packageSets) {
     log(`
-${colors3.cyan}=== Installing Mac App Store apps ===${colors3.reset}
+${colors3.cyan}=== ${set.manager.displayName} ===${colors3.reset}
 `);
-    const masResult = await exec(["mas", "list"]);
-    const installedMas = masResult.stdout.split(`
-`).filter(Boolean).map((line) => {
-      const match = line.match(/^(\d+)/);
-      return match ? parseInt(match[1], 10) : 0;
-    });
-    for (const [name, id] of Object.entries(config.mas)) {
-      if (!installedMas.includes(id)) {
-        log(`  Installing: ${colors3.blue}${name}${colors3.reset}`);
-        await runCommand(["mas", "install", String(id)], cb, undefined, true);
+    if (set.repositories && set.repositories.length > 0 && set.manager.addRepository) {
+      log(`  Adding repositories...`);
+      for (const repo of set.repositories) {
+        log(`    ${colors3.blue}${repo}${colors3.reset}`);
+        await set.manager.addRepository(repo, callbacks);
+      }
+    }
+    if (set.packages.length === 0) {
+      log(`  No packages to install`);
+      continue;
+    }
+    const installedMap = await set.manager.isInstalled(set.packages);
+    const toInstall = set.packages.filter((pkg) => !installedMap.get(pkg));
+    if (toInstall.length === 0) {
+      log(`  All ${set.packages.length} packages already installed`);
+    } else {
+      log(`  Installing ${toInstall.length} packages...`);
+      for (const pkg of toInstall) {
+        log(`    ${colors3.blue}${pkg}${colors3.reset}`);
       }
+      await set.manager.install(toInstall, callbacks);
     }
   }
   if (config.config.purge) {
@@ -2390,7 +3676,7 @@ ${colors3.cyan}=== Installing Mac App Store apps ===${colors3.reset}
 ${colors3.cyan}=== Updating lockfile ===${colors3.reset}
 `);
   const lock = await updateLockfile();
-  const lockTotal = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+  const lockTotal = lock.version === 2 ? Object.keys(lock.packages).length : Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
   log(`  Locked ${lockTotal} packages`);
   log(`
 ${colors3.green}=== Sync complete ===${colors3.reset}
@@ -2399,74 +3685,53 @@ ${colors3.green}=== Sync complete ===${colors3.reset}
 async function purgeUnlisted(config, interactive, cb = null) {
   const log = cb?.onLog ?? console.log;
   const askPrompt = cb?.onPrompt ?? (async (q) => (prompt(q) || "").trim().toLowerCase());
+  const platform = await getPlatformInfo();
+  const callbacks = cb ? { onLog: cb.onLog } : undefined;
   log(`
 ${colors3.cyan}=== Checking for unlisted packages ===${colors3.reset}
 `);
-  const installedFormulas = (await exec(["brew", "list", "--formula"])).stdout.split(`
-`).filter(Boolean);
-  for (const pkg of installedFormulas) {
-    if (!config.packages.includes(pkg)) {
-      const usesResult = await exec(["brew", "uses", "--installed", pkg]);
-      if (usesResult.stdout.trim()) {
-        log(`  ${colors3.yellow}Skipping ${pkg} (has dependents)${colors3.reset}`);
+  const packageSets = await getPackageSetsForPlatform(config, platform);
+  for (const set of packageSets) {
+    const configuredSet = new Set(set.packages);
+    let installedLeaves;
+    if (set.manager.listLeaves) {
+      installedLeaves = await set.manager.listLeaves();
+    } else {
+      const installed = await set.manager.listInstalled();
+      installedLeaves = installed.map((p) => p.name);
+    }
+    for (const pkg of installedLeaves) {
+      if (configuredSet.has(pkg))
         continue;
+      if (set.manager.type === "mas") {
+        const appId = parseInt(pkg, 10);
+        if (SYSTEM_APP_IDS.includes(appId))
+          continue;
       }
-      if (interactive) {
-        const answer = await askPrompt(`Remove ${colors3.red}${pkg}${colors3.reset}?`, ["y", "n"]);
-        if (answer === "y") {
-          await runCommand(["brew", "uninstall", pkg], cb);
+      if (set.manager.type === "homebrew") {
+        const formulas = set.manager;
+        if (await formulas.hasDependents(pkg)) {
+          log(`  ${colors3.yellow}Skipping ${pkg} (has dependents)${colors3.reset}`);
+          continue;
         }
-      } else {
-        log(`  Removing: ${colors3.red}${pkg}${colors3.reset}`);
-        await runCommand(["brew", "uninstall", pkg], cb);
       }
-    }
-  }
-  const installedCasks = (await exec(["brew", "list", "--cask"])).stdout.split(`
-`).filter(Boolean);
-  for (const cask of installedCasks) {
-    if (!config.casks.includes(cask)) {
       if (interactive) {
-        const answer = await askPrompt(`Remove cask ${colors3.red}${cask}${colors3.reset}?`, ["y", "n"]);
+        const answer = await askPrompt(`Remove ${colors3.red}${pkg}${colors3.reset} (${set.manager.displayName})?`, ["y", "n"]);
         if (answer === "y") {
-          await runCommand(["brew", "uninstall", "--cask", cask], cb);
+          await set.manager.uninstall([pkg], callbacks);
         }
       } else {
-        log(`  Removing cask: ${colors3.red}${cask}${colors3.reset}`);
-        await runCommand(["brew", "uninstall", "--cask", cask], cb);
-      }
-    }
-  }
-  if (await commandExists("mas")) {
-    const masResult = await exec(["mas", "list"]);
-    const installedMas = masResult.stdout.split(`
-`).filter(Boolean).map((line) => {
-      const match = line.match(/^(\d+)\s+(.+?)(?:\s+\(|$)/);
-      return match ? { id: parseInt(match[1], 10), name: match[2].trim() } : null;
-    }).filter((app) => app !== null);
-    const configMasIds = Object.values(config.mas);
-    for (const app of installedMas) {
-      if (SYSTEM_APP_IDS.includes(app.id)) {
-        continue;
-      }
-      if (!configMasIds.includes(app.id)) {
-        if (interactive) {
-          const answer = await askPrompt(`Remove app ${colors3.red}${app.name}${colors3.reset}?`, ["y", "n"]);
-          if (answer === "y") {
-            await runCommand(["mas", "uninstall", String(app.id)], cb, undefined, true);
-          }
-        } else {
-          log(`  Removing app: ${colors3.red}${app.name}${colors3.reset}`);
-          await runCommand(["mas", "uninstall", String(app.id)], cb, undefined, true);
-        }
+        log(`  Removing: ${colors3.red}${pkg}${colors3.reset}`);
+        await set.manager.uninstall([pkg], callbacks);
       }
     }
   }
   log(`
 ${colors3.cyan}=== Cleaning up ===${colors3.reset}
 `);
-  await runCommand(["brew", "autoremove"], cb);
-  await runCommand(["brew", "cleanup"], cb);
+  for (const set of packageSets) {
+    await set.manager.cleanup(callbacks);
+  }
 }
 function printUsage2() {
   console.log(`
@@ -2494,13 +3759,12 @@ async function runPkgSyncWithCallbacks(args, callbacks) {
     },
     allowPositionals: true
   });
+  const platform = await getPlatformInfo();
   try {
-    if (!await commandExists("brew")) {
-      callbacks.onLog(`${colors3.red}Error: Homebrew not installed${colors3.reset}`);
-      return { output: "Homebrew not installed", success: false };
-    }
+    await checkDependencies(platform);
   } catch {
-    return { output: "Homebrew not installed", success: false };
+    callbacks.onLog(`${colors3.red}Error: Required dependencies not installed${colors3.reset}`);
+    return { output: "Dependencies not installed", success: false };
   }
   if (values["upgrade-interactive"]) {
     await upgradeInteractive(callbacks);
@@ -2542,7 +3806,8 @@ async function main2() {
     printUsage2();
     process.exit(0);
   }
-  await checkDependencies();
+  const platform = await getPlatformInfo();
+  await checkDependencies(platform);
   if (values["upgrade-interactive"]) {
     await upgradeInteractive();
     return;
@@ -2645,21 +3910,30 @@ async function showLockfile() {
   console.log(`${colors4.bold}Package Lockfile${colors4.reset}`);
   console.log(`Last updated: ${lock.lastUpdated}
 `);
-  const formulaNames = Object.keys(lock.formulas).sort();
-  const caskNames = Object.keys(lock.casks).sort();
-  if (formulaNames.length > 0) {
-    console.log(`${colors4.cyan}Formulas (${formulaNames.length}):${colors4.reset}`);
-    for (const name of formulaNames) {
-      const { version, tap } = lock.formulas[name];
-      console.log(`  ${name} ${colors4.blue}${version}${colors4.reset} (${tap})`);
+  if (lock.version === 2) {
+    const packages = Object.entries(lock.packages).sort(([a], [b]) => a.localeCompare(b));
+    console.log(`${colors4.cyan}Packages (${packages.length}):${colors4.reset}`);
+    for (const [key, info] of packages) {
+      const [manager, name] = key.split(":");
+      console.log(`  ${name} ${colors4.blue}${info.version}${colors4.reset} (${manager}${info.tap ? `, ${info.tap}` : ""})`);
     }
-  }
-  if (caskNames.length > 0) {
-    console.log(`
+  } else {
+    const formulaNames = Object.keys(lock.formulas).sort();
+    const caskNames = Object.keys(lock.casks).sort();
+    if (formulaNames.length > 0) {
+      console.log(`${colors4.cyan}Formulas (${formulaNames.length}):${colors4.reset}`);
+      for (const name of formulaNames) {
+        const { version, tap } = lock.formulas[name];
+        console.log(`  ${name} ${colors4.blue}${version}${colors4.reset} (${tap})`);
+      }
+    }
+    if (caskNames.length > 0) {
+      console.log(`
 ${colors4.cyan}Casks (${caskNames.length}):${colors4.reset}`);
-    for (const name of caskNames) {
-      const { version } = lock.casks[name];
-      console.log(`  ${name} ${colors4.blue}${version}${colors4.reset}`);
+      for (const name of caskNames) {
+        const { version } = lock.casks[name];
+        console.log(`  ${name} ${colors4.blue}${version}${colors4.reset}`);
+      }
     }
   }
 }
@@ -2675,7 +3949,7 @@ async function runPkgLock(args) {
   switch (command) {
     case "update": {
       const lock = await updateLockfile();
-      const total = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+      const total = lock.version === 2 ? Object.keys(lock.packages).length : Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
       return { output: `Lockfile updated with ${total} packages`, success: true };
     }
     case "status": {
@@ -2720,7 +3994,7 @@ async function main3() {
     case "update": {
       console.log(`${colors4.cyan}Updating lockfile...${colors4.reset}`);
       const lock = await updateLockfile();
-      const total = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+      const total = lock.version === 2 ? Object.keys(lock.packages).length : Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
       console.log(`${colors4.green}Lockfile updated with ${total} packages.${colors4.reset}`);
       break;
     }
@@ -2754,64 +4028,248 @@ function getPackageName(fullName) {
   const parts = fullName.split("/");
   return parts[parts.length - 1];
 }
+function getOrphanPackageType(managerType) {
+  switch (managerType) {
+    case "homebrew":
+      return "formula";
+    case "homebrew-casks":
+      return "cask";
+    case "pacman":
+      return "pacman";
+    case "aur":
+      return "aur";
+    case "apt":
+      return "apt";
+    case "dnf":
+      return "dnf";
+    case "flatpak":
+      return "flatpak";
+    default:
+      return "formula";
+  }
+}
+async function getConfiguredPackagesForPlatform(config, platform) {
+  const result = [];
+  if (platform.os === "darwin") {
+    const formulas = getPackageManager("homebrew");
+    const casks = getPackageManager("homebrew-casks");
+    const globalPkgs = config.global?.packages || [];
+    const macosFormulas = config.macos?.formulas || [];
+    const allFormulas = [...globalPkgs, ...macosFormulas];
+    if (await formulas.isAvailable()) {
+      result.push({
+        manager: formulas,
+        configuredPackages: new Set(allFormulas.map((p) => getPackageName(p)))
+      });
+    }
+    const macosCasks = config.macos?.casks || [];
+    if (await casks.isAvailable()) {
+      result.push({
+        manager: casks,
+        configuredPackages: new Set(macosCasks)
+      });
+    }
+    const mas = getPackageManager("mas");
+    const masMappings = config.macos?.mas || {};
+    const masIds = Object.values(masMappings).map(String);
+    if (await mas.isAvailable()) {
+      result.push({
+        manager: mas,
+        configuredPackages: new Set(masIds)
+      });
+    }
+  } else {
+    const distro = platform.distro;
+    const globalPkgs = config.global?.packages || [];
+    const linuxPkgs = config.linux?.packages || [];
+    if (distro === "arch") {
+      const pacman = getPackageManager("pacman");
+      const aur = getPackageManager("aur");
+      const archPkgs = config.arch?.packages || [];
+      const allPacmanPkgs = [...globalPkgs, ...linuxPkgs, ...archPkgs];
+      if (await pacman.isAvailable()) {
+        result.push({
+          manager: pacman,
+          configuredPackages: new Set(allPacmanPkgs)
+        });
+      }
+      const aurPkgs = config.arch?.aur || [];
+      if (await aur.isAvailable()) {
+        result.push({
+          manager: aur,
+          configuredPackages: new Set(aurPkgs)
+        });
+      }
+    } else if (distro === "debian" || distro === "ubuntu") {
+      const apt = getPackageManager("apt");
+      const debianPkgs = config.debian?.packages || [];
+      const allAptPkgs = [...globalPkgs, ...linuxPkgs, ...debianPkgs];
+      if (await apt.isAvailable()) {
+        result.push({
+          manager: apt,
+          configuredPackages: new Set(allAptPkgs)
+        });
+      }
+    } else if (distro === "fedora" || distro === "rhel") {
+      const dnf = getPackageManager("dnf");
+      const fedoraPkgs = config.fedora?.packages || [];
+      const allDnfPkgs = [...globalPkgs, ...linuxPkgs, ...fedoraPkgs];
+      if (await dnf.isAvailable()) {
+        result.push({
+          manager: dnf,
+          configuredPackages: new Set(allDnfPkgs)
+        });
+      }
+    } else {
+      const managers = await getAvailableManagers();
+      const primaryManager = managers.find((m) => m.type === "pacman" || m.type === "apt" || m.type === "dnf");
+      if (primaryManager) {
+        const allPkgs = [...globalPkgs, ...linuxPkgs];
+        result.push({
+          manager: primaryManager,
+          configuredPackages: new Set(allPkgs)
+        });
+      }
+    }
+    const flatpak = getPackageManager("flatpak");
+    const flatpakApps = config.linux?.flatpak || [];
+    if (await flatpak.isAvailable()) {
+      result.push({
+        manager: flatpak,
+        configuredPackages: new Set(flatpakApps)
+      });
+    }
+  }
+  return result;
+}
 async function detectOrphanedPackages() {
   const config = await loadPkgConfig();
-  const leavesResult = await exec(["brew", "leaves"]);
-  const installedLeaves = leavesResult.success ? leavesResult.stdout.split(`
-`).filter(Boolean) : [];
-  const casksResult = await exec(["brew", "list", "--cask"]);
-  const installedCasks = casksResult.success ? casksResult.stdout.split(`
-`).filter(Boolean) : [];
+  const platform = await getPlatformInfo();
   const orphans = [];
-  const configPackages = config.packages.map((pkg) => ({
-    full: pkg,
-    short: getPackageName(pkg)
-  }));
-  for (const installed of installedLeaves) {
-    const installedShort = getPackageName(installed);
-    const isInConfig = configPackages.some((cfg) => installed === cfg.full || installed === cfg.short || installedShort === cfg.full || installedShort === cfg.short || installed.endsWith(`/${cfg.short}`));
-    if (!isInConfig) {
-      orphans.push({ name: installed, type: "formula" });
+  let totalConfigPackages = 0;
+  let totalInstalledPackages = 0;
+  const configuredPackagesPerManager = await getConfiguredPackagesForPlatform(config, platform);
+  for (const { manager, configuredPackages } of configuredPackagesPerManager) {
+    totalConfigPackages += configuredPackages.size;
+    let installedLeaves2;
+    if (manager.listLeaves) {
+      installedLeaves2 = await manager.listLeaves();
+    } else {
+      const installed = await manager.listInstalled();
+      installedLeaves2 = installed.map((p) => p.name);
     }
-  }
-  const configCasksSet = new Set(config.casks);
-  for (const cask of installedCasks) {
-    if (!configCasksSet.has(cask)) {
-      orphans.push({ name: cask, type: "cask" });
+    totalInstalledPackages += installedLeaves2.length;
+    for (const installed of installedLeaves2) {
+      const installedShort = getPackageName(installed);
+      const isInConfig = configuredPackages.has(installed) || configuredPackages.has(installedShort) || Array.from(configuredPackages).some((cfg) => installed === cfg || installedShort === cfg || getPackageName(cfg) === installedShort || installed.endsWith(`/${getPackageName(cfg)}`));
+      if (!isInConfig) {
+        if (manager.type === "mas") {
+          const appId = parseInt(installed, 10);
+          if (SYSTEM_APP_IDS.includes(appId))
+            continue;
+        }
+        if (manager.type === "homebrew") {
+          const formulas = manager;
+          if (await formulas.hasDependents(installed))
+            continue;
+        }
+        orphans.push({
+          name: installed,
+          type: getOrphanPackageType(manager.type),
+          manager: manager.type
+        });
+      }
     }
   }
   orphans.sort((a, b) => {
     if (a.type !== b.type)
-      return a.type === "formula" ? -1 : 1;
+      return a.type.localeCompare(b.type);
     return a.name.localeCompare(b.name);
   });
+  let configFormulas = 0;
+  let configCasks = 0;
+  let installedLeaves = 0;
+  let installedCasks = 0;
+  if (platform.os === "darwin") {
+    configFormulas = (config.global?.packages?.length || 0) + (config.macos?.formulas?.length || 0);
+    configCasks = config.macos?.casks?.length || 0;
+    const formulas = getPackageManager("homebrew");
+    const casks = getPackageManager("homebrew-casks");
+    if (await formulas.isAvailable()) {
+      const leaves = await formulas.listLeaves?.();
+      installedLeaves = leaves?.length || 0;
+    }
+    if (await casks.isAvailable()) {
+      const caskList = await casks.listInstalled();
+      installedCasks = caskList.length;
+    }
+  }
   return {
     orphans,
-    configFormulas: config.packages.length,
-    configCasks: config.casks.length,
-    installedLeaves: installedLeaves.length,
-    installedCasks: installedCasks.length
+    configPackages: totalConfigPackages,
+    installedPackages: totalInstalledPackages,
+    configFormulas,
+    configCasks,
+    installedLeaves,
+    installedCasks
   };
 }
 async function addToConfig(pkg) {
   const config = await loadPkgConfig();
-  if (pkg.type === "formula") {
-    if (!config.packages.includes(pkg.name)) {
-      config.packages.push(pkg.name);
-      config.packages.sort();
+  const platform = await getPlatformInfo();
+  if (platform.os === "darwin") {
+    if (pkg.type === "formula") {
+      const formulas = config.macos?.formulas || [];
+      if (!formulas.includes(pkg.name)) {
+        config.macos = config.macos || {};
+        config.macos.formulas = [...formulas, pkg.name].sort();
+      }
+    } else if (pkg.type === "cask") {
+      const casks = config.macos?.casks || [];
+      if (!casks.includes(pkg.name)) {
+        config.macos = config.macos || {};
+        config.macos.casks = [...casks, pkg.name].sort();
+      }
     }
   } else {
-    if (!config.casks.includes(pkg.name)) {
-      config.casks.push(pkg.name);
-      config.casks.sort();
+    if (pkg.type === "pacman") {
+      const packages = config.arch?.packages || [];
+      if (!packages.includes(pkg.name)) {
+        config.arch = config.arch || {};
+        config.arch.packages = [...packages, pkg.name].sort();
+      }
+    } else if (pkg.type === "aur") {
+      const aurPkgs = config.arch?.aur || [];
+      if (!aurPkgs.includes(pkg.name)) {
+        config.arch = config.arch || {};
+        config.arch.aur = [...aurPkgs, pkg.name].sort();
+      }
+    } else if (pkg.type === "apt") {
+      const packages = config.debian?.packages || [];
+      if (!packages.includes(pkg.name)) {
+        config.debian = config.debian || {};
+        config.debian.packages = [...packages, pkg.name].sort();
+      }
+    } else if (pkg.type === "dnf") {
+      const packages = config.fedora?.packages || [];
+      if (!packages.includes(pkg.name)) {
+        config.fedora = config.fedora || {};
+        config.fedora.packages = [...packages, pkg.name].sort();
+      }
+    } else if (pkg.type === "flatpak") {
+      const flatpakApps = config.linux?.flatpak || [];
+      if (!flatpakApps.includes(pkg.name)) {
+        config.linux = config.linux || {};
+        config.linux.flatpak = [...flatpakApps, pkg.name].sort();
+      }
     }
   }
   await savePkgConfig(config);
 }
 async function uninstallPackage(pkg) {
-  const cmd = pkg.type === "cask" ? ["brew", "uninstall", "--cask", pkg.name] : ["brew", "uninstall", pkg.name];
-  const result = await exec(cmd);
-  return result.success;
+  const manager = getPackageManager(pkg.manager);
+  await manager.uninstall([pkg.name]);
+  return true;
 }
 
 // src/components/menus/PackageMenu.tsx
@@ -2825,7 +4283,18 @@ function PackageMenu({ onBack }) {
   const [success, setSuccess] = useState8(true);
   const [orphanResult, setOrphanResult] = useState8(null);
   const [isOrphanView, setIsOrphanView] = useState8(false);
+  const [platformInfo, setPlatformInfo] = useState8(null);
+  const [availableManagerNames, setAvailableManagerNames] = useState8([]);
   const isRunningRef = useRef(false);
+  useEffect4(() => {
+    async function loadPlatformInfo() {
+      const info = await getPlatformInfo();
+      setPlatformInfo(info);
+      const managers = await getAvailableManagers();
+      setAvailableManagerNames(managers.map((m) => m.displayName));
+    }
+    loadPlatformInfo();
+  }, []);
   useInput9((input, key) => {
     if (state === "menu" && (key.escape || key.leftArrow || input === "h")) {
       onBack();
@@ -2978,26 +4447,60 @@ function PackageMenu({ onBack }) {
       ]
     }, undefined, true, undefined, this);
   }
+  const platformDisplay = platformInfo ? getPlatformDisplayName(platformInfo) : "Detecting...";
+  const managersDisplay = availableManagerNames.length > 0 ? availableManagerNames.join(", ") : "Detecting...";
   return /* @__PURE__ */ jsxDEV17(Panel, {
     title: "Package Sync",
-    children: /* @__PURE__ */ jsxDEV17(VimSelect, {
-      options: [
-        { label: "Sync packages", value: "sync" },
-        { label: "Sync with purge", value: "sync-purge" },
-        { label: "Upgrade all (with verification)", value: "upgrade" },
-        { label: "Upgrade interactive", value: "upgrade-interactive" },
-        { label: "Update lockfile", value: "lock-update" },
-        { label: "Lockfile status", value: "lock-status" },
-        { label: "Find orphaned packages", value: "orphans" },
-        { label: "Back", value: "back" }
-      ],
-      onChange: handleAction
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this);
+    children: [
+      /* @__PURE__ */ jsxDEV17(Box14, {
+        marginBottom: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV17(Text13, {
+            children: [
+              /* @__PURE__ */ jsxDEV17(Text13, {
+                dimColor: true,
+                children: "Platform: "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV17(Text13, {
+                color: colors.info,
+                children: platformDisplay
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV17(Text13, {
+            children: [
+              /* @__PURE__ */ jsxDEV17(Text13, {
+                dimColor: true,
+                children: "Managers: "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV17(Text13, {
+                color: colors.info,
+                children: managersDisplay
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV17(VimSelect, {
+        options: [
+          { label: "Sync packages", value: "sync" },
+          { label: "Sync with purge", value: "sync-purge" },
+          { label: "Upgrade all (with verification)", value: "upgrade" },
+          { label: "Upgrade interactive", value: "upgrade-interactive" },
+          { label: "Update lockfile", value: "lock-update" },
+          { label: "Lockfile status", value: "lock-status" },
+          { label: "Find orphaned packages", value: "orphans" },
+          { label: "Back", value: "back" }
+        ],
+        onChange: handleAction
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
 }
 
 // src/components/menus/ThemeMenu.tsx
-import { useState as useState10, useEffect as useEffect5, useMemo as useMemo4 } from "react";
+import { useState as useState10, useEffect as useEffect6, useMemo as useMemo4 } from "react";
 import { Box as Box16, Text as Text15 } from "ink";
 import { existsSync as existsSync7, readdirSync as readdirSync5 } from "fs";
 import { join as join6 } from "path";
@@ -3042,7 +4545,7 @@ function ThemeCard({ theme, isSelected, width }) {
 }
 
 // src/hooks/useThemeGrid.ts
-import { useState as useState9, useEffect as useEffect4 } from "react";
+import { useState as useState9, useEffect as useEffect5 } from "react";
 import { useInput as useInput10 } from "ink";
 function useThemeGrid({
   itemCount,
@@ -3063,7 +4566,7 @@ function useThemeGrid({
   const visibleRows = Math.max(1, Math.floor(availableHeight / cardHeight));
   const selectedRow = Math.floor(selectedIndex / cardsPerRow);
   const totalRows = Math.ceil(itemCount / cardsPerRow);
-  useEffect4(() => {
+  useEffect5(() => {
     if (selectedRow < scrollOffset) {
       setScrollOffset(selectedRow);
     } else if (selectedRow >= scrollOffset + visibleRows) {
@@ -3121,6 +4624,7 @@ function useThemeGrid({
 }
 
 // src/lib/theme-parser.ts
+init_runtime();
 import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
 import { join as join4 } from "path";
 function parseYaml(content) {
@@ -3197,8 +4701,7 @@ async function parseTheme(themePath, themeName) {
 // src/cli/set-theme.ts
 import { parseArgs as parseArgs4 } from "util";
 import { readdirSync as readdirSync4, existsSync as existsSync6, rmSync, symlinkSync, unlinkSync } from "fs";
-import { join as join5, dirname as dirname3 } from "path";
-var LYNK_BROWSER_CSS = join5(HOME_DIR, ".config", "lynk-browser", "style.css");
+import { join as join5 } from "path";
 var colors5 = {
   red: "\x1B[0;31m",
   green: "\x1B[0;32m",
@@ -3267,12 +4770,6 @@ async function applyTheme(themeName) {
     const backgroundsSource = join5(themeDir, "backgrounds");
     createSymlink(backgroundsSource, BACKGROUNDS_TARGET_DIR);
   }
-  const styleCssSource = join5(themeDir, "style.css");
-  if (existsSync6(styleCssSource)) {
-    const lynkBrowserDir = dirname3(LYNK_BROWSER_CSS);
-    await ensureDir2(lynkBrowserDir);
-    createSymlink(styleCssSource, LYNK_BROWSER_CSS);
-  }
   let output = `Theme '${theme.name}' applied successfully`;
   if (theme.metadata?.author) {
     output += `
@@ -3383,7 +4880,7 @@ function ThemeMenu({ onBack }) {
     onBack,
     enabled: state === "menu" && !loading && themes.length > 0
   });
-  useEffect5(() => {
+  useEffect6(() => {
     async function loadThemes() {
       if (!existsSync7(THEMES_DIR)) {
         setThemes([]);
@@ -3501,6 +4998,7 @@ function ThemeMenu({ onBack }) {
 }
 
 // src/cli/formalconf.tsx
+init_runtime();
 import { jsxDEV as jsxDEV20 } from "react/jsx-dev-runtime";
 var BREADCRUMBS = {
   main: ["Main"],
@@ -3517,7 +5015,7 @@ function App() {
     if (input === "q")
       exit();
   });
-  useEffect6(() => {
+  useEffect7(() => {
     async function init() {
       await ensureConfigDir();
       const result = await checkPrerequisites();