@dahch/heimdall 1.0.0

package/dist/cli.js

@@ -0,0 +1,2227 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/utils/exec.ts
+import { execa } from "execa";
+async function commandExists(command) {
+  try {
+    const result = await execa("which", [command], {
+      reject: false,
+      timeout: 3e3
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function safeExec(file, args = [], options = {}) {
+  const timeout = options.timeoutMs ?? 3e4;
+  try {
+    const subprocess = execa(file, args, {
+      timeout,
+      cwd: options.cwd,
+      env: {
+        ...process.env,
+        ...options.env,
+        // Suppress interactive prompts in subcommands
+        CI: "true",
+        DEBIAN_FRONTEND: "noninteractive"
+      },
+      reject: false,
+      stdin: options.stdin ?? "ignore"
+    });
+    if (options.onData && subprocess.stdout) {
+      subprocess.stdout.on("data", (data) => {
+        options.onData?.(data.toString());
+      });
+    }
+    if (options.onData && subprocess.stderr) {
+      subprocess.stderr.on("data", (data) => {
+        options.onData?.(data.toString());
+      });
+    }
+    const result = await subprocess;
+    return {
+      stdout: (result.stdout ?? "").toString(),
+      stderr: (result.stderr ?? "").toString(),
+      exitCode: result.exitCode ?? 0,
+      success: result.exitCode === 0,
+      timedOut: result.timedOut ?? false
+    };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    const isTimeout = error.name === "TimeoutError" || error.message.includes("timed out");
+    return {
+      stdout: "",
+      stderr: error.message,
+      exitCode: -1,
+      success: false,
+      timedOut: isTimeout,
+      error
+    };
+  }
+}
+
+// src/utils/error.ts
+var ANSI_REGEX = /\u001b\[[0-9;?]*[a-zA-Z]/g;
+function extractErrorMessage(rawError) {
+  if (!rawError) {
+    return "Command exited with error";
+  }
+  const stripped = rawError.replace(ANSI_REGEX, "").trim();
+  if (!stripped) {
+    return "Command exited with error";
+  }
+  const lines = stripped.split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) {
+    return "Command exited with error";
+  }
+  const isWarningOrNotice = (line) => {
+    const lower = line.toLowerCase();
+    return lower.startsWith("npm warn") || lower.startsWith("npm notice") || lower.startsWith("warning:") || lower.startsWith("[warn]") || lower.startsWith("warn:") || lower.startsWith("npm info");
+  };
+  const filteredLines = lines.filter((line) => !isWarningOrNotice(line));
+  if (filteredLines.length === 0) {
+    return "Command exited with error";
+  }
+  const npmErrorLines = [];
+  const otherErrorLines = [];
+  for (const line of filteredLines) {
+    const lower = line.toLowerCase();
+    if (lower.startsWith("npm error") || lower.startsWith("npm err!")) {
+      const cleaned = line.replace(/^npm\s+(?:error|err!)\s*:?\s*/i, "").trim();
+      if (cleaned) {
+        npmErrorLines.push(cleaned);
+      }
+    } else if (line.includes("error:") || line.includes("Error:") || line.includes("fatal:")) {
+      otherErrorLines.push(line);
+    }
+  }
+  let result = "";
+  if (npmErrorLines.length > 0) {
+    const specificLines = npmErrorLines.filter((l) => {
+      const low = l.toLowerCase();
+      return !low.startsWith("code ") && !low.startsWith("errno ") && !low.startsWith("syscall ") && !low.startsWith("path ") && !low.startsWith("a complete log of this run");
+    });
+    if (specificLines.length === 0) {
+      result = npmErrorLines[0];
+    } else if (specificLines.length === 1) {
+      result = specificLines[0];
+    } else {
+      const hasCommandFailed = specificLines[0].toLowerCase().startsWith("command failed");
+      if (hasCommandFailed && specificLines.length > 1) {
+        const rest = specificLines.slice(1).map((l) => l.replace(/^command\s+/i, "")).join("; ");
+        result = `command failed: ${rest}`;
+      } else {
+        result = specificLines.join("; ");
+      }
+    }
+  } else if (otherErrorLines.length > 0) {
+    result = otherErrorLines.join("; ");
+  } else {
+    result = filteredLines[filteredLines.length - 1];
+  }
+  result = result.replace(/[\{\[\:\,\s]+$/, "").trim();
+  if (!result) {
+    return "Command exited with error";
+  }
+  if (result.length > 120) {
+    return result.slice(0, 117).trim() + "...";
+  }
+  return result;
+}
+
+// src/managers/base.ts
+var BasePackageManager = class {
+  async isAvailable() {
+    return commandExists(this.binary);
+  }
+  async executeStep(stepName, file, args, options, extraExecOptions) {
+    const startTime = Date.now();
+    options.onStepStart?.(stepName);
+    if (options.dryRun) {
+      options.onStepProgress?.(stepName, `[DRY-RUN] Would run: ${file} ${args.join(" ")}`);
+      options.onStepEnd?.(stepName, true);
+      return {
+        name: stepName,
+        command: `${file} ${args.join(" ")}`,
+        status: "success",
+        durationMs: 0
+      };
+    }
+    const result = await safeExec(file, args, {
+      ...extraExecOptions,
+      timeoutMs: options.timeoutMs ?? 18e4,
+      // 3 min per step
+      onData: (data) => {
+        if (options.onStepProgress) {
+          const lines = data.split("\n").map((l) => l.trim()).filter(Boolean);
+          if (lines.length > 0) {
+            options.onStepProgress(stepName, lines[lines.length - 1]);
+          }
+        }
+      }
+    });
+    const durationMs = Date.now() - startTime;
+    const success = result.success;
+    const rawOutput = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
+    const errorMsg = !success ? result.timedOut ? `Step timed out after ${Math.round((options.timeoutMs ?? 18e4) / 1e3)}s` : extractErrorMessage(rawOutput) : void 0;
+    options.onStepEnd?.(stepName, success, errorMsg, durationMs);
+    return {
+      name: stepName,
+      command: `${file} ${args.join(" ")}`,
+      status: success ? "success" : "failed",
+      durationMs,
+      error: errorMsg
+    };
+  }
+};
+
+// src/managers/homebrew.ts
+var HomebrewManager = class extends BasePackageManager {
+  id = "homebrew";
+  name = "Homebrew";
+  icon = "\u{1F37A}";
+  category = "system";
+  binary = "brew";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("brew", ["outdated", "--json=v2"], {
+        timeoutMs: options?.timeoutMs ?? 3e4
+      });
+      if (!execRes.success) {
+        return {
+          managerId: this.id,
+          managerName: this.name,
+          icon: this.icon,
+          category: this.category,
+          available: true,
+          updates: [],
+          durationMs: Date.now() - startTime,
+          error: extractErrorMessage(execRes.stderr || execRes.stdout)
+        };
+      }
+      const updates = [];
+      if (execRes.stdout.trim()) {
+        try {
+          const parsed = JSON.parse(execRes.stdout);
+          if (Array.isArray(parsed.formulae)) {
+            for (const f of parsed.formulae) {
+              updates.push({
+                managerId: this.id,
+                managerName: this.name,
+                name: f.name,
+                currentVersion: f.installed_versions?.[0] ?? "unknown",
+                latestVersion: f.current_version ?? "latest",
+                type: "formula"
+              });
+            }
+          }
+          if (Array.isArray(parsed.casks)) {
+            for (const c of parsed.casks) {
+              const cur = Array.isArray(c.installed_versions) ? c.installed_versions[0] : c.installed_versions;
+              updates.push({
+                managerId: this.id,
+                managerName: this.name,
+                name: c.name,
+                currentVersion: cur ?? "unknown",
+                latestVersion: c.current_version ?? "latest",
+                type: "cask"
+              });
+            }
+          }
+        } catch {
+          const textRes = await safeExec("brew", ["outdated"], { timeoutMs: 15e3 });
+          if (textRes.stdout.trim()) {
+            const lines = textRes.stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+            for (const line of lines) {
+              const parts = line.split(/\s+/);
+              updates.push({
+                managerId: this.id,
+                managerName: this.name,
+                name: parts[0],
+                currentVersion: parts[1] ?? "unknown",
+                latestVersion: parts[2] ?? "latest",
+                type: "package"
+              });
+            }
+          }
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (items.length === 0) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        success: true,
+        updatedCount: 0,
+        durationMs: Date.now() - startTime,
+        steps: []
+      };
+    }
+    const updateStep = await this.executeStep(
+      "brew update",
+      "brew",
+      ["update"],
+      options
+    );
+    steps.push(updateStep);
+    const hasFormulae = items.some((i) => i.type === "formula" || !i.type || i.type === "package");
+    const hasCasks = items.some((i) => i.type === "cask");
+    let upgradeSucceeded = false;
+    if (hasCasks && !hasFormulae) {
+      const caskStep = await this.executeStep(
+        "brew upgrade --cask",
+        "brew",
+        ["upgrade", "--cask"],
+        options
+      );
+      steps.push(caskStep);
+      upgradeSucceeded = caskStep.status === "success";
+    } else if (hasFormulae && !hasCasks) {
+      const formulaStep = await this.executeStep(
+        "brew upgrade --formula",
+        "brew",
+        ["upgrade", "--formula"],
+        options
+      );
+      steps.push(formulaStep);
+      upgradeSucceeded = formulaStep.status === "success";
+    } else {
+      const upgradeStep = await this.executeStep(
+        "brew upgrade",
+        "brew",
+        ["upgrade"],
+        options
+      );
+      steps.push(upgradeStep);
+      upgradeSucceeded = upgradeStep.status === "success";
+    }
+    const cleanupStep = await this.executeStep(
+      "brew cleanup",
+      "brew",
+      ["cleanup"],
+      options
+    );
+    steps.push(cleanupStep);
+    const failedSteps = steps.filter((s) => s.status === "failed");
+    const success = failedSteps.length === 0;
+    let error;
+    if (failedSteps.length > 0) {
+      const failedDetails = failedSteps.map((s) => `${s.name}${s.error ? `: ${s.error}` : ""}`).join("; ");
+      error = `${failedSteps.length} step(s) failed: ${failedDetails}`;
+    }
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: upgradeSucceeded ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error
+    };
+  }
+};
+
+// src/managers/npm.ts
+var NpmManager = class extends BasePackageManager {
+  id = "npm";
+  name = "npm (global)";
+  icon = "\u{1F4E6}";
+  category = "runtime";
+  binary = "npm";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("npm", ["outdated", "-g", "--json"], {
+        timeoutMs: options?.timeoutMs ?? 25e3
+      });
+      const updates = [];
+      const stdout = execRes.stdout.trim();
+      if (stdout.startsWith("{")) {
+        const parsed = JSON.parse(stdout);
+        for (const [name, info] of Object.entries(parsed)) {
+          updates.push({
+            managerId: this.id,
+            managerName: this.name,
+            name,
+            currentVersion: info.current ?? "unknown",
+            latestVersion: info.latest ?? info.wanted ?? "latest",
+            type: "global-pkg"
+          });
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    let updatedCount = 0;
+    if (items.length === 0) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        success: true,
+        updatedCount: 0,
+        durationMs: Date.now() - startTime,
+        steps: []
+      };
+    }
+    let runIsolatedFallback = true;
+    if (items.length > 1) {
+      const targets = items.map(
+        (i) => i.latestVersion && i.latestVersion !== "unknown" ? `${i.name}@${i.latestVersion}` : `${i.name}@latest`
+      );
+      const batchStep = await this.executeStep(
+        `npm install -g --legacy-peer-deps (${items.length} pkgs)`,
+        "npm",
+        ["install", "-g", "--legacy-peer-deps", "--", ...targets],
+        options
+      );
+      if (batchStep.status === "success") {
+        steps.push(batchStep);
+        updatedCount = items.length;
+        runIsolatedFallback = false;
+      } else {
+        batchStep.status = "skipped";
+        steps.push(batchStep);
+        options.onStepProgress?.(
+          "npm install",
+          "Batch install hit conflicts; falling back to per-package isolated installs..."
+        );
+      }
+    }
+    if (runIsolatedFallback) {
+      for (const item of items) {
+        const pkgTarget = item.latestVersion && item.latestVersion !== "unknown" ? `${item.name}@${item.latestVersion}` : `${item.name}@latest`;
+        const itemStep = await this.executeStep(
+          `npm install -g ${item.name}`,
+          "npm",
+          ["install", "-g", "--legacy-peer-deps", "--", pkgTarget],
+          options
+        );
+        if (itemStep.status === "success") {
+          updatedCount++;
+          steps.push(itemStep);
+        } else {
+          const errLower = (itemStep.error ?? "").toLowerCase();
+          const isScriptIssue = errLower.includes("only-allow") || errLower.includes("sh -c") || errLower.includes("preinstall") || errLower.includes("postinstall") || errLower.includes("install script") || errLower.includes("node-gyp") || errLower.includes("254");
+          if (isScriptIssue) {
+            options.onStepProgress?.(
+              `npm install -g ${item.name}`,
+              `Install script failed; retrying with --ignore-scripts...`
+            );
+            const retryStep = await this.executeStep(
+              `npm install -g ${item.name} (--ignore-scripts)`,
+              "npm",
+              ["install", "-g", "--legacy-peer-deps", "--ignore-scripts", "--", pkgTarget],
+              options
+            );
+            if (retryStep.status === "success") {
+              updatedCount++;
+              steps.push(retryStep);
+            } else {
+              steps.push(retryStep);
+            }
+          } else {
+            steps.push(itemStep);
+          }
+        }
+      }
+    }
+    const failedSteps = steps.filter((s) => s.status === "failed");
+    const success = failedSteps.length === 0;
+    let errorSummary;
+    if (!success) {
+      const failedDetails = failedSteps.map((s) => `${s.name}${s.error ? `: ${s.error}` : ""}`).join("; ");
+      errorSummary = `${failedSteps.length} step(s) failed: ${failedDetails}`;
+    }
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: errorSummary
+    };
+  }
+};
+
+// src/managers/pnpm.ts
+var PnpmManager = class extends BasePackageManager {
+  id = "pnpm";
+  name = "pnpm (global)";
+  icon = "\u26A1";
+  category = "runtime";
+  binary = "pnpm";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("pnpm", ["outdated", "-g", "--format", "json"], {
+        timeoutMs: options?.timeoutMs ?? 25e3
+      });
+      const updates = [];
+      const stdout = execRes.stdout.trim();
+      const jsonStart = stdout.indexOf("{");
+      const jsonEnd = stdout.lastIndexOf("}");
+      if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
+        const jsonStr = stdout.slice(jsonStart, jsonEnd + 1);
+        try {
+          const parsed = JSON.parse(jsonStr);
+          for (const [name, info] of Object.entries(parsed)) {
+            updates.push({
+              managerId: this.id,
+              managerName: this.name,
+              name,
+              currentVersion: info.current ?? "unknown",
+              latestVersion: info.latest ?? info.wanted ?? "latest",
+              type: "global-pkg"
+            });
+          }
+        } catch {
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    const updateStep = await this.executeStep(
+      "pnpm update -g --latest",
+      "pnpm",
+      ["update", "-g", "--latest"],
+      options
+    );
+    steps.push(updateStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/bun.ts
+var BunManager = class extends BasePackageManager {
+  id = "bun";
+  name = "Bun";
+  icon = "\u{1F35E}";
+  category = "runtime";
+  binary = "bun";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("bun", ["outdated", "-g"], {
+        timeoutMs: options?.timeoutMs ?? 25e3
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|") || trimmed.includes("---") || trimmed.includes("Package")) {
+          continue;
+        }
+        const cols = trimmed.split("|").map((c) => c.trim()).filter(Boolean);
+        if (cols.length >= 3) {
+          const pkgName = cols[0];
+          const current = cols[1];
+          const latest = cols[cols.length - 1];
+          if (pkgName && current && latest) {
+            updates.push({
+              managerId: this.id,
+              managerName: this.name,
+              name: pkgName,
+              currentVersion: current,
+              latestVersion: latest,
+              type: "global-pkg"
+            });
+          }
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (items.length > 0) {
+      const pkgsToUpgrade = items.map(
+        (item) => item.latestVersion && item.latestVersion !== "latest" && item.latestVersion !== "unknown" ? `${item.name}@${item.latestVersion}` : `${item.name}@latest`
+      );
+      const addStep = await this.executeStep(
+        `bun add -g ${pkgsToUpgrade.length} package(s)`,
+        "bun",
+        ["add", "-g", ...pkgsToUpgrade],
+        options
+      );
+      steps.push(addStep);
+    }
+    const updateStep = await this.executeStep(
+      "bun update -g",
+      "bun",
+      ["update", "-g"],
+      options
+    );
+    steps.push(updateStep);
+    const whichBun = await safeExec("which", ["bun"], { timeoutMs: 3e3 });
+    const isBrewBun = whichBun.stdout.includes("/opt/homebrew") || whichBun.stdout.includes("/Cellar");
+    if (!isBrewBun) {
+      const upgradeStep = await this.executeStep(
+        "bun upgrade",
+        "bun",
+        ["upgrade"],
+        options
+      );
+      if (upgradeStep.status === "failed" && upgradeStep.error?.includes("Homebrew")) {
+        upgradeStep.status = "skipped";
+      }
+      steps.push(upgradeStep);
+    }
+    const hasFailedStep = steps.some((s) => s.status === "failed");
+    const success = !hasFailedStep;
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/yarn.ts
+var YarnManager = class extends BasePackageManager {
+  id = "yarn";
+  name = "Yarn (global)";
+  icon = "\u{1F9F6}";
+  category = "runtime";
+  binary = "yarn";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("yarn", ["global", "list", "--depth=0"], {
+        timeoutMs: options?.timeoutMs ?? 15e3
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      const installed = [];
+      for (const line of lines) {
+        const match = line.match(/info\s+"((?:@[^/]+\/)?[^@]+)@([^"]+)"/);
+        if (match) {
+          installed.push({ name: match[1], currentVersion: match[2] });
+        }
+      }
+      await Promise.all(
+        installed.map(async ({ name, currentVersion }) => {
+          try {
+            const res = await fetch(
+              `https://registry.npmjs.org/${encodeURIComponent(name).replace("%40", "@")}/latest`,
+              {
+                signal: AbortSignal.timeout(3e3),
+                headers: { Accept: "application/json" }
+              }
+            );
+            if (res.ok) {
+              const data = await res.json();
+              const latest = data.version;
+              if (latest && latest !== currentVersion) {
+                updates.push({
+                  managerId: this.id,
+                  managerName: this.name,
+                  name,
+                  currentVersion,
+                  latestVersion: latest,
+                  type: "global-pkg"
+                });
+              }
+            }
+          } catch {
+          }
+        })
+      );
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (items.length > 0) {
+      const pkgsToUpgrade = items.map(
+        (item) => item.latestVersion && item.latestVersion !== "latest" && item.latestVersion !== "unknown" ? `${item.name}@${item.latestVersion}` : `${item.name}@latest`
+      );
+      const addStep = await this.executeStep(
+        `yarn global add ${pkgsToUpgrade.length} package(s)`,
+        "yarn",
+        ["global", "add", ...pkgsToUpgrade],
+        options
+      );
+      steps.push(addStep);
+    }
+    const upgradeStep = await this.executeStep(
+      "yarn global upgrade",
+      "yarn",
+      ["global", "upgrade"],
+      options
+    );
+    steps.push(upgradeStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/python.ts
+var PythonPipManager = class extends BasePackageManager {
+  id = "pip";
+  name = "Python (pip user)";
+  icon = "\u{1F40D}";
+  category = "language";
+  binary = "pip3";
+  activeBinary = "pip3";
+  async isAvailable() {
+    if (await commandExists("pip3")) {
+      this.activeBinary = "pip3";
+      return true;
+    }
+    if (await commandExists("pip")) {
+      this.activeBinary = "pip";
+      return true;
+    }
+    return false;
+  }
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec(
+        this.activeBinary,
+        ["list", "--user", "--outdated", "--format=json"],
+        { timeoutMs: options?.timeoutMs ?? 15e3 }
+      );
+      const updates = [];
+      const stdout = execRes.stdout.trim();
+      if (stdout.startsWith("[")) {
+        try {
+          const parsed = JSON.parse(stdout);
+          for (const item of parsed) {
+            updates.push({
+              managerId: this.id,
+              managerName: this.name,
+              name: item.name,
+              currentVersion: item.version ?? "unknown",
+              latestVersion: item.latest_version ?? "latest",
+              type: "pip-user"
+            });
+          }
+        } catch {
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (items.length > 0) {
+      const packageNames = items.map((i) => i.name);
+      const step = await this.executeStep(
+        `${this.activeBinary} install --user --upgrade (${items.length} pkgs)`,
+        this.activeBinary,
+        ["install", "--user", "--upgrade", ...packageNames],
+        options
+      );
+      steps.push(step);
+    }
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/pipx.ts
+var PipxManager = class extends BasePackageManager {
+  id = "pipx";
+  name = "pipx (Python CLI tools)";
+  icon = "\u{1F4E6}";
+  category = "language";
+  binary = "pipx";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("pipx", ["list", "--json"], {
+        timeoutMs: options?.timeoutMs ?? 15e3
+      });
+      const updates = [];
+      const stdout = execRes.stdout.trim();
+      if (stdout.startsWith("{")) {
+        try {
+          const parsed = JSON.parse(stdout);
+          if (parsed.venvs) {
+            const entries = Object.entries(parsed.venvs);
+            await Promise.all(
+              entries.map(async ([pkgName, venvData]) => {
+                const current = venvData.metadata?.main_package?.package_version;
+                if (!current) return;
+                try {
+                  const response = await fetch(
+                    `https://pypi.org/pypi/${encodeURIComponent(pkgName)}/json`,
+                    { signal: AbortSignal.timeout(3e3) }
+                  );
+                  if (response.ok) {
+                    const data = await response.json();
+                    const latest = data.info?.version;
+                    if (latest && latest !== current) {
+                      updates.push({
+                        managerId: this.id,
+                        managerName: this.name,
+                        name: pkgName,
+                        currentVersion: current,
+                        latestVersion: latest,
+                        type: "pipx-app"
+                      });
+                    }
+                  }
+                } catch {
+                }
+              })
+            );
+          }
+        } catch {
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    const upgradeStep = await this.executeStep(
+      "pipx upgrade-all",
+      "pipx",
+      ["upgrade-all"],
+      options
+    );
+    steps.push(upgradeStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/cargo.ts
+var CargoManager = class extends BasePackageManager {
+  id = "cargo";
+  name = "Rust (Cargo & Rustup)";
+  icon = "\u{1F980}";
+  category = "language";
+  binary = "cargo";
+  async isAvailable() {
+    return await commandExists("cargo") || await commandExists("rustup");
+  }
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const updates = [];
+      if (await commandExists("rustup")) {
+        const checkRes = await safeExec("rustup", ["check"], {
+          timeoutMs: options?.timeoutMs ?? 15e3
+        });
+        const lines = checkRes.stdout.split("\n");
+        for (const line of lines) {
+          if (line.includes("Update available")) {
+            const parts = line.trim().split(/\s+/);
+            const toolchain = parts[0] ?? "toolchain";
+            updates.push({
+              managerId: this.id,
+              managerName: this.name,
+              name: `rustup (${toolchain})`,
+              currentVersion: "installed",
+              latestVersion: "update-available",
+              type: "toolchain"
+            });
+          }
+        }
+      }
+      if (await commandExists("cargo-install-update")) {
+        const listRes = await safeExec("cargo", ["install-update", "-l"], {
+          timeoutMs: options?.timeoutMs ?? 15e3
+        });
+        const lines = listRes.stdout.split("\n");
+        for (const line of lines) {
+          const match = line.match(/^(\S+)\s+v(\S+)\s+v(\S+)/);
+          if (match) {
+            const [, name, cur, latest] = match;
+            if (cur !== latest) {
+              updates.push({
+                managerId: this.id,
+                managerName: this.name,
+                name,
+                currentVersion: cur,
+                latestVersion: latest,
+                type: "crate"
+              });
+            }
+          }
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (await commandExists("rustup")) {
+      const rustupStep = await this.executeStep(
+        "rustup update",
+        "rustup",
+        ["update"],
+        options
+      );
+      steps.push(rustupStep);
+    }
+    if (await commandExists("cargo-install-update")) {
+      const cargoStep = await this.executeStep(
+        "cargo install-update -a",
+        "cargo",
+        ["install-update", "-a"],
+        options
+      );
+      steps.push(cargoStep);
+    }
+    const hasFailedStep = steps.some((s) => s.status === "failed");
+    const success = !hasFailedStep;
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/gem.ts
+var RubyGemManager = class extends BasePackageManager {
+  id = "gem";
+  name = "Ruby Gem";
+  icon = "\u{1F48E}";
+  category = "language";
+  binary = "gem";
+  async isAvailable() {
+    const hasCmd = await commandExists(this.binary);
+    if (!hasCmd) return false;
+    const whichRes = await safeExec("which", ["gem"], { timeoutMs: 3e3 });
+    const gemPath = whichRes.stdout.trim();
+    if (gemPath === "/usr/bin/gem" || gemPath.startsWith("/System/Library")) {
+      return false;
+    }
+    return true;
+  }
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("gem", ["outdated"], {
+        timeoutMs: options?.timeoutMs ?? 2e4
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        const match = trimmed.match(/^(\S+)\s*\(([^<]+)<\s*([^)]+)\)/);
+        if (match) {
+          const [, name, current, latest] = match;
+          updates.push({
+            managerId: this.id,
+            managerName: this.name,
+            name: name.trim(),
+            currentVersion: current.trim(),
+            latestVersion: latest.trim(),
+            type: "gem"
+          });
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    const updateStep = await this.executeStep(
+      "gem update --user-install",
+      "gem",
+      ["update", "--user-install"],
+      options
+    );
+    steps.push(updateStep);
+    const cleanupStep = await this.executeStep(
+      "gem cleanup",
+      "gem",
+      ["cleanup"],
+      options
+    );
+    steps.push(cleanupStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/macports.ts
+var MacPortsManager = class extends BasePackageManager {
+  id = "macports";
+  name = "MacPorts";
+  icon = "\u2693";
+  category = "system";
+  binary = "port";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("port", ["outdated"], {
+        timeoutMs: options?.timeoutMs ?? 2e4
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("The following") || trimmed.startsWith("--")) {
+          continue;
+        }
+        const match = trimmed.match(/^(\S+)\s+(\S+)\s*<\s*(\S+)/);
+        if (match) {
+          const [, name, current, latest] = match;
+          updates.push({
+            managerId: this.id,
+            managerName: this.name,
+            name,
+            currentVersion: current,
+            latestVersion: latest,
+            type: "port"
+          });
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (!options.dryRun && process.getuid?.() !== 0) {
+      const sudoCheck = await safeExec("sudo", ["-n", "true"], { timeoutMs: 3e3 });
+      if (!sudoCheck.success) {
+        return {
+          managerId: this.id,
+          managerName: this.name,
+          icon: this.icon,
+          success: false,
+          updatedCount: 0,
+          durationMs: Date.now() - startTime,
+          steps: [
+            {
+              name: "sudo privileges",
+              command: "sudo -n true",
+              status: "failed",
+              error: 'MacPorts requires sudo privileges. Run "sudo -v" in your terminal before hmd.'
+            }
+          ],
+          error: 'MacPorts requires sudo privileges. Run "sudo -v" before running hmd.'
+        };
+      }
+    }
+    const selfupdateStep = await this.executeStep(
+      "sudo port selfupdate",
+      "sudo",
+      ["port", "selfupdate"],
+      options
+    );
+    steps.push(selfupdateStep);
+    const upgradeStep = await this.executeStep(
+      "sudo port upgrade outdated",
+      "sudo",
+      ["port", "upgrade", "outdated"],
+      options
+    );
+    steps.push(upgradeStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/mas.ts
+var MacAppStoreManager = class extends BasePackageManager {
+  id = "mas";
+  name = "Mac App Store";
+  icon = "\u{1F34E}";
+  category = "appstore";
+  binary = "mas";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("mas", ["outdated"], {
+        timeoutMs: options?.timeoutMs ?? 2e4
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        const match = trimmed.match(/^\s*(\d+)\s+(.+?)\s*\(([^->]+)->\s*([^)]+)\)/);
+        if (match) {
+          const [, id, appName, current, latest] = match;
+          updates.push({
+            managerId: this.id,
+            managerName: this.name,
+            name: `${appName.trim()} [${id}]`,
+            currentVersion: current.trim(),
+            latestVersion: latest.trim(),
+            type: "mas-app"
+          });
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    const upgradeStep = await this.executeStep(
+      "mas upgrade",
+      "mas",
+      ["upgrade"],
+      options
+    );
+    steps.push(upgradeStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/linux.ts
+var AptManager = class extends BasePackageManager {
+  id = "apt";
+  name = "APT (Debian/Ubuntu)";
+  icon = "\u{1F427}";
+  category = "system";
+  binary = "apt-get";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("apt", ["list", "--upgradable"], {
+        timeoutMs: options?.timeoutMs ?? 2e4
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      for (const line of lines) {
+        if (!line.includes("/") || line.startsWith("Listing")) continue;
+        const match = line.match(/^([^\/\s]+)\/\S+\s+(\S+)\s+\S+\s+\[upgradable from:\s+(\S+)\]/);
+        if (match) {
+          const [, name, latest, current] = match;
+          updates.push({
+            managerId: this.id,
+            managerName: this.name,
+            name,
+            currentVersion: current,
+            latestVersion: latest,
+            type: "deb"
+          });
+        }
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    if (!options.dryRun && process.getuid?.() !== 0) {
+      const sudoCheck = await safeExec("sudo", ["-n", "true"], { timeoutMs: 3e3 });
+      if (!sudoCheck.success) {
+        return {
+          managerId: this.id,
+          managerName: this.name,
+          icon: this.icon,
+          success: false,
+          updatedCount: 0,
+          durationMs: Date.now() - startTime,
+          steps: [
+            {
+              name: "sudo privileges",
+              command: "sudo -n true",
+              status: "failed",
+              error: 'APT requires sudo privileges. Run "sudo -v" in your terminal before hmd.'
+            }
+          ],
+          error: 'APT requires sudo privileges. Run "sudo -v" before running hmd.'
+        };
+      }
+    }
+    const updateStep = await this.executeStep(
+      "sudo apt-get update",
+      "sudo",
+      ["apt-get", "update", "-y"],
+      options
+    );
+    steps.push(updateStep);
+    const upgradeStep = await this.executeStep(
+      "sudo apt-get upgrade",
+      "sudo",
+      ["apt-get", "upgrade", "-y"],
+      options
+    );
+    steps.push(upgradeStep);
+    const cleanupStep = await this.executeStep(
+      "sudo apt-get autoremove",
+      "sudo",
+      ["apt-get", "autoremove", "-y"],
+      options
+    );
+    steps.push(cleanupStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+var FlatpakManager = class extends BasePackageManager {
+  id = "flatpak";
+  name = "Flatpak";
+  icon = "\u{1F4E6}";
+  category = "system";
+  binary = "flatpak";
+  async checkUpdates(options) {
+    const startTime = Date.now();
+    const isAvail = await this.isAvailable();
+    if (!isAvail) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: false,
+        updates: [],
+        durationMs: 0
+      };
+    }
+    try {
+      const execRes = await safeExec("flatpak", ["remote-ls", "--updates"], {
+        timeoutMs: options?.timeoutMs ?? 2e4
+      });
+      const updates = [];
+      const lines = execRes.stdout.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const parts = trimmed.split(/\s+/);
+        updates.push({
+          managerId: this.id,
+          managerName: this.name,
+          name: parts[0],
+          currentVersion: "installed",
+          latestVersion: parts[1] ?? "latest",
+          type: "flatpak"
+        });
+      }
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        managerId: this.id,
+        managerName: this.name,
+        icon: this.icon,
+        category: this.category,
+        available: true,
+        updates: [],
+        durationMs: Date.now() - startTime,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async executeUpdate(items, options) {
+    const startTime = Date.now();
+    const steps = [];
+    const updateStep = await this.executeStep(
+      "flatpak update -y",
+      "flatpak",
+      ["update", "-y", "--noninteractive"],
+      options
+    );
+    steps.push(updateStep);
+    const success = steps.every((s) => s.status === "success");
+    return {
+      managerId: this.id,
+      managerName: this.name,
+      icon: this.icon,
+      success,
+      updatedCount: success ? items.length : 0,
+      durationMs: Date.now() - startTime,
+      steps,
+      error: !success ? steps.find((s) => s.status === "failed")?.error : void 0
+    };
+  }
+};
+
+// src/managers/registry.ts
+function createDefaultManagers() {
+  return [
+    new HomebrewManager(),
+    new NpmManager(),
+    new PnpmManager(),
+    new BunManager(),
+    new YarnManager(),
+    new PythonPipManager(),
+    new PipxManager(),
+    new CargoManager(),
+    new RubyGemManager(),
+    new MacPortsManager(),
+    new MacAppStoreManager(),
+    new AptManager(),
+    new FlatpakManager()
+  ];
+}
+function filterManagers(managers, only, exclude) {
+  let result = [...managers];
+  if (only && only.length > 0) {
+    const onlySet = new Set(only.map((s) => s.toLowerCase().trim()));
+    result = result.filter(
+      (m) => onlySet.has(m.id.toLowerCase()) || onlySet.has(m.name.toLowerCase())
+    );
+  }
+  if (exclude && exclude.length > 0) {
+    const excludeSet = new Set(exclude.map((s) => s.toLowerCase().trim()));
+    result = result.filter(
+      (m) => !excludeSet.has(m.id.toLowerCase()) && !excludeSet.has(m.name.toLowerCase())
+    );
+  }
+  return result;
+}
+
+// src/core/engine.ts
+var UpdaterEngine = class {
+  constructor(managers) {
+    this.managers = managers;
+  }
+  managers;
+  /**
+   * Scans all managers for availability and pending updates.
+   * Runs checks concurrently for high performance, but isolates failures.
+   */
+  async scan(timeoutMs = 25e3, callbacks) {
+    const availabilityChecks = await Promise.all(
+      this.managers.map(async (manager) => {
+        try {
+          const available = await manager.isAvailable();
+          return { manager, available };
+        } catch {
+          return { manager, available: false };
+        }
+      })
+    );
+    const availableManagers = availabilityChecks.filter((c) => c.available).map((c) => c.manager);
+    const unavailableManagers = availabilityChecks.filter((c) => !c.available).map((c) => c.manager);
+    const checkTask = async (manager) => {
+      callbacks?.onManagerStart?.(manager);
+      try {
+        const res = await manager.checkUpdates({ timeoutMs });
+        callbacks?.onManagerComplete?.(manager, res);
+        return res;
+      } catch (err) {
+        const fallbackRes = {
+          managerId: manager.id,
+          managerName: manager.name,
+          icon: manager.icon,
+          category: manager.category,
+          available: true,
+          updates: [],
+          durationMs: 0,
+          error: err instanceof Error ? err.message : String(err)
+        };
+        callbacks?.onManagerComplete?.(manager, fallbackRes);
+        return fallbackRes;
+      }
+    };
+    const checkResults = new Array(availableManagers.length);
+    let taskIndex = 0;
+    const concurrency = Math.min(4, availableManagers.length);
+    const workers = Array.from({ length: concurrency }, async () => {
+      while (taskIndex < availableManagers.length) {
+        const idx = taskIndex++;
+        checkResults[idx] = await checkTask(availableManagers[idx]);
+      }
+    });
+    await Promise.all(workers);
+    const allUpdates = [];
+    for (const res of checkResults) {
+      allUpdates.push(...res.updates);
+    }
+    return {
+      availableResults: checkResults,
+      allUpdates,
+      unavailableManagers
+    };
+  }
+  /**
+   * Executes updates for the specified managers sequentially or with controlled steps.
+   */
+  async execute(selectedManagerIds, itemsByManager, options, onManagerStart, onManagerComplete) {
+    const startTime = Date.now();
+    const results = [];
+    const managersToRun = this.managers.filter(
+      (m) => selectedManagerIds.includes(m.id)
+    );
+    for (const manager of managersToRun) {
+      const items = itemsByManager.get(manager.id) ?? [];
+      onManagerStart?.(manager);
+      try {
+        const result = await manager.executeUpdate(items, options);
+        results.push(result);
+        onManagerComplete?.(manager, result);
+      } catch (err) {
+        const failedResult = {
+          managerId: manager.id,
+          managerName: manager.name,
+          icon: manager.icon,
+          success: false,
+          updatedCount: 0,
+          durationMs: 0,
+          steps: [],
+          error: err instanceof Error ? err.message : String(err)
+        };
+        results.push(failedResult);
+        onManagerComplete?.(manager, failedResult);
+      }
+    }
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    const totalUpdated = results.reduce((acc, r) => acc + r.updatedCount, 0);
+    const totalPending = Array.from(itemsByManager.values()).reduce(
+      (acc, items) => acc + items.length,
+      0
+    );
+    return {
+      scannedManagersCount: this.managers.length,
+      availableManagersCount: managersToRun.length,
+      upToDateManagersCount: results.filter((r) => r.success && r.updatedCount === 0).length,
+      pendingUpdatesCount: totalPending,
+      executedCount: results.length,
+      successCount: successful,
+      failedCount: failed,
+      totalDurationMs: Date.now() - startTime,
+      results
+    };
+  }
+};
+
+// src/utils/formatting.ts
+import pc from "picocolors";
+import Table from "cli-table3";
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = (ms / 1e3).toFixed(1);
+  return `${seconds}s`;
+}
+function renderUpdatesTable(items) {
+  if (items.length === 0) {
+    return pc.dim("  No updates pending.");
+  }
+  const table = new Table({
+    head: [
+      pc.dim("Manager"),
+      pc.dim("Package"),
+      pc.dim("Type"),
+      pc.dim("Version Transition")
+    ],
+    style: {
+      head: [],
+      border: ["dim"]
+    },
+    chars: {
+      top: "\u2500",
+      "top-mid": "\u2500",
+      "top-left": "\u250C",
+      "top-right": "\u2510",
+      bottom: "\u2500",
+      "bottom-mid": "\u2500",
+      "bottom-left": "\u2514",
+      "bottom-right": "\u2518",
+      left: "\u2502",
+      "left-mid": "\u251C",
+      mid: "\u2500",
+      "mid-mid": "\u253C",
+      right: "\u2502",
+      "right-mid": "\u2524",
+      middle: "\u2502"
+    }
+  });
+  for (const item of items) {
+    const typeLabel = item.type ? pc.dim(`[${item.type}]`) : pc.dim("-");
+    const currentVer = pc.yellow(item.currentVersion || "?");
+    const arrow = pc.dim(" \u2192 ");
+    const latestVer = pc.green(pc.bold(item.latestVersion || "?"));
+    table.push([
+      pc.cyan(item.managerName),
+      pc.bold(pc.white(item.name)),
+      typeLabel,
+      `${currentVer}${arrow}${latestVer}`
+    ]);
+  }
+  return table.toString();
+}
+function renderExecutionSummary(results) {
+  const total = results.length;
+  const successful = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  const totalUpdated = results.reduce((acc, r) => acc + r.updatedCount, 0);
+  const lines = [];
+  lines.push("");
+  lines.push(pc.dim("\u2500".repeat(60)));
+  lines.push(`  ${pc.bold(pc.cyan("Heimdall"))} ${pc.dim("\u2022 Execution Summary")}`);
+  lines.push(pc.dim("\u2500".repeat(60)));
+  for (const res of results) {
+    const icon = res.icon || "\u{1F4E6}";
+    const status = res.success ? pc.green("\u2714 SUCCESS") : pc.red("\u2716 FAILED");
+    const time = pc.dim(`(${formatDuration(res.durationMs)})`);
+    const count = res.success ? pc.dim(`\u2022 ${res.updatedCount} updated`) : pc.dim(`\u2022 ${res.updatedCount} updated, ${res.steps.filter((s) => s.status === "failed").length} issue(s)`);
+    lines.push(`  ${icon} ${pc.bold(res.managerName)} ${status} ${count} ${time}`);
+    if (!res.success && res.error) {
+      lines.push(`     ${pc.red("\u21B3 Error:")} ${pc.dim(res.error.trim().split("\n")[0])}`);
+    }
+    if (res.steps.length > 0) {
+      for (const step of res.steps) {
+        if (step.status === "skipped") continue;
+        const stepStatus = step.status === "success" ? pc.green("\u2714") : step.status === "failed" ? pc.red("\u2716") : pc.dim("\u25CB");
+        const stepDuration = step.durationMs ? pc.dim(`[${formatDuration(step.durationMs)}]`) : "";
+        const stepError = step.error && step.status === "failed" ? pc.red(` (${step.error.split("\n")[0]})`) : "";
+        lines.push(`       ${stepStatus} ${pc.dim(step.name)} ${stepDuration}${stepError}`);
+      }
+    }
+  }
+  lines.push(pc.dim("\u2500".repeat(60)));
+  const summaryParts = [
+    pc.green(`${successful}/${total} managers succeeded`),
+    failed > 0 ? pc.red(`${failed} failed`) : null,
+    pc.cyan(`${totalUpdated} package(s) updated`)
+  ].filter(Boolean);
+  lines.push(`  ${summaryParts.join(" \u2022 ")}`);
+  lines.push(pc.dim("\u2500".repeat(60)));
+  return lines.join("\n");
+}
+
+// src/utils/version.ts
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+var FALLBACK_METADATA = {
+  name: "@dahch/heimdall",
+  version: "1.0.0",
+  description: "Heimdall: resilient validator and updater for system and global packages"
+};
+var cachedMetadata = null;
+var customFsAdapter = null;
+function resolvePackageMetadata(options) {
+  const exists = options?.fsAdapter?.existsSync ?? customFsAdapter?.existsSync ?? existsSync;
+  const read = options?.fsAdapter?.readFileSync ?? customFsAdapter?.readFileSync ?? readFileSync;
+  try {
+    let currentDir;
+    if (options?.basePath) {
+      currentDir = options.basePath;
+    } else {
+      try {
+        if (typeof import.meta !== "undefined" && import.meta.url) {
+          currentDir = dirname(fileURLToPath(import.meta.url));
+        }
+      } catch {
+      }
+    }
+    const candidates = [];
+    if (currentDir) {
+      candidates.push(
+        resolve(currentDir, "../package.json"),
+        resolve(currentDir, "../../package.json"),
+        resolve(currentDir, "./package.json")
+      );
+    }
+    for (const candidate of candidates) {
+      try {
+        if (exists(candidate)) {
+          const raw = read(candidate, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === "object") {
+            const name = typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : FALLBACK_METADATA.name;
+            const version = typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : FALLBACK_METADATA.version;
+            const description = typeof parsed.description === "string" && parsed.description.trim().length > 0 ? parsed.description.trim() : FALLBACK_METADATA.description;
+            return { name, version, description };
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return { ...FALLBACK_METADATA };
+}
+function getPackageMetadata(options) {
+  if (!options?.bypassCache && cachedMetadata && !options?.basePath) {
+    return cachedMetadata;
+  }
+  const meta = resolvePackageMetadata(options);
+  if (!options?.basePath) {
+    cachedMetadata = meta;
+  }
+  return meta;
+}
+
+// src/cli.ts
+async function main() {
+  const { version, description } = getPackageMetadata();
+  const program = new Command();
+  program.name("hmd").description(description || "Heimdall: resilient validator and updater for system and global packages").version(version).option("-y, --yes", "Skip confirmation prompt and update all automatically").option("-d, --dry-run", "Inspect outdated packages and simulate update without running changes").option("-o, --only <managers>", "Only check and update specified managers (comma-separated, e.g. brew,npm)").option("-x, --exclude <managers>", "Exclude specified managers (comma-separated, e.g. macports,pip)").option("-t, --timeout <ms>", "Timeout per check in milliseconds", "25000").option("-v, --verbose", "Show detailed output and logs").parse(process.argv);
+  const options = program.opts();
+  if (process.stdout.isTTY && !options.verbose) {
+    console.clear();
+  }
+  p.intro(`${pc2.cyan("\u25CF")} ${pc2.bold("hmd")} ${pc2.dim(`v${version}`)} \u2014 ${pc2.dim("Heimdall System Updater")}`);
+  const rawTimeout = parseInt(options.timeout || "25000", 10);
+  const timeoutMs = Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : 25e3;
+  const onlyList = options.only ? options.only.split(",") : void 0;
+  const excludeList = options.exclude ? options.exclude.split(",") : void 0;
+  const allManagers = createDefaultManagers();
+  const selectedManagers = filterManagers(allManagers, onlyList, excludeList);
+  if (selectedManagers.length === 0) {
+    p.log.error(pc2.red("No package managers matched your filter."));
+    p.outro(pc2.yellow("Exiting without changes."));
+    process.exit(1);
+  }
+  const engine = new UpdaterEngine(selectedManagers);
+  const scanSpinner = p.spinner();
+  scanSpinner.start("Discovering available package managers and checking for updates...");
+  let activeChecks = 0;
+  const { availableResults, allUpdates, unavailableManagers } = await engine.scan(timeoutMs, {
+    onManagerStart: (mgr) => {
+      activeChecks++;
+      scanSpinner.message(`Querying ${mgr.icon} ${mgr.name} (${activeChecks} in progress)...`);
+    },
+    onManagerComplete: (mgr, res) => {
+      activeChecks = Math.max(0, activeChecks - 1);
+      const countStr = res.updates.length > 0 ? pc2.yellow(`${res.updates.length} outdated`) : pc2.green("up to date");
+      scanSpinner.message(`Checked ${mgr.icon} ${mgr.name}: ${countStr}`);
+    }
+  });
+  scanSpinner.stop("Discovery and validation completed");
+  const availableManagers = availableResults.map((r) => `${r.icon} ${pc2.bold(r.managerName)}`);
+  p.log.info(
+    `${pc2.bold("Active package managers:")} ${availableManagers.join(" \u2022 ")}`
+  );
+  if (unavailableManagers.length > 0 && options.verbose) {
+    const unavailStr = unavailableManagers.map((m) => `${m.icon} ${m.name}`).join(", ");
+    p.log.step(pc2.dim(`Inactive/not installed (skipped safely): ${unavailStr}`));
+  }
+  if (allUpdates.length === 0) {
+    p.note(
+      pc2.green("All detected package managers and global packages are completely up to date! \u{1F389}"),
+      "Status: Up to Date"
+    );
+    p.outro(pc2.cyan("No updates needed. Have a great day!"));
+    process.exit(0);
+  }
+  p.log.message(`
+${pc2.bold("Pending updates")} ${pc2.dim(`(${allUpdates.length} total):`)}`);
+  console.log(renderUpdatesTable(allUpdates));
+  console.log("");
+  const itemsByManager = /* @__PURE__ */ new Map();
+  for (const update of allUpdates) {
+    const list = itemsByManager.get(update.managerId) ?? [];
+    list.push(update);
+    itemsByManager.set(update.managerId, list);
+  }
+  let managersToUpdate = [];
+  if (options.dryRun) {
+    managersToUpdate = Array.from(itemsByManager.keys());
+    p.log.info(pc2.yellow(`[DRY RUN] Simulating updates for ${allUpdates.length} package(s)...`));
+  } else if (options.yes) {
+    managersToUpdate = Array.from(itemsByManager.keys());
+    p.log.info(pc2.cyan("Flag -y provided: proceeding with all updates automatically."));
+  } else {
+    const managerOptions = Array.from(itemsByManager.entries()).map(([mgrId, items]) => {
+      const mgrInfo = availableResults.find((r) => r.managerId === mgrId);
+      return {
+        value: mgrId,
+        label: `${mgrInfo?.icon ?? "\u{1F4E6}"} ${mgrInfo?.managerName ?? mgrId} (${items.length} updates)`
+      };
+    });
+    const action = await p.select({
+      message: `How would you like to proceed with the ${allUpdates.length} update(s)?`,
+      options: [
+        {
+          value: "all",
+          label: `\u26A1 Confirm & Update everything (${allUpdates.length} packages across ${itemsByManager.size} managers)`,
+          hint: "Recommended"
+        },
+        {
+          value: "select",
+          label: "\u2699 Select specific package managers to update",
+          hint: "Fine-grained choice"
+        },
+        {
+          value: "cancel",
+          label: "\u2716 Cancel and exit without updating"
+        }
+      ]
+    });
+    if (p.isCancel(action) || action === "cancel") {
+      p.cancel("Update operation cancelled by user.");
+      process.exit(0);
+    }
+    if (action === "all") {
+      managersToUpdate = Array.from(itemsByManager.keys());
+    } else if (action === "select") {
+      const chosen = await p.multiselect({
+        message: "Select the package managers you want to update:",
+        options: managerOptions,
+        initialValues: Array.from(itemsByManager.keys()),
+        required: true
+      });
+      if (p.isCancel(chosen)) {
+        p.cancel("Selection cancelled.");
+        process.exit(0);
+      }
+      managersToUpdate = chosen;
+    }
+  }
+  if (managersToUpdate.length === 0) {
+    p.outro(pc2.yellow("No managers selected for update."));
+    process.exit(0);
+  }
+  const isSimulated = options.dryRun ?? false;
+  p.log.step(
+    pc2.bold(
+      pc2.cyan(
+        `
+${isSimulated ? "[DRY RUN] Simulating" : "Starting"} updates for ${managersToUpdate.length} package manager(s)...`
+      )
+    )
+  );
+  const updateSpinner = p.spinner();
+  let managerIndex = 0;
+  const summary = await engine.execute(
+    managersToUpdate,
+    itemsByManager,
+    {
+      verbose: options.verbose,
+      dryRun: isSimulated,
+      onStepStart: (stepName) => {
+        updateSpinner.message(pc2.dim(`Running: ${stepName}...`));
+      },
+      onStepProgress: (stepName, logLine) => {
+        if (logLine) {
+          const truncated = logLine.length > 55 ? logLine.slice(0, 52) + "..." : logLine;
+          updateSpinner.message(pc2.dim(`${stepName} [${truncated}]`));
+        }
+      },
+      onStepEnd: (stepName, success, error, durationMs) => {
+        const mark = success ? pc2.green("\u2714") : pc2.red("\u2716");
+        const durStr = durationMs !== void 0 ? pc2.dim(` [${formatDuration(durationMs)}]`) : "";
+        const detail = error ? pc2.red(` \u21B3 ${error.split("\n")[0]}`) : "";
+        updateSpinner.stop(`  ${mark} ${pc2.dim(stepName)}${durStr}${detail}`);
+        updateSpinner.start(pc2.dim("Working..."));
+      }
+    },
+    (mgr) => {
+      managerIndex++;
+      console.log(pc2.bold(pc2.cyan(`
+\u25CF [${managerIndex}/${managersToUpdate.length}] ${mgr.icon} ${mgr.name}`)));
+      updateSpinner.start(pc2.dim("Starting update routine..."));
+    },
+    (mgr, res) => {
+      if (res.success) {
+        updateSpinner.stop(pc2.green(`  \u2714 ${mgr.name} completed in ${formatDuration(res.durationMs)}`));
+      } else {
+        updateSpinner.stop(pc2.red(`  \u2716 ${mgr.name} completed with issues in ${formatDuration(res.durationMs)}`));
+      }
+    }
+  );
+  console.log(renderExecutionSummary(summary.results));
+  if (summary.failedCount === 0) {
+    p.outro(
+      pc2.bold(
+        pc2.green(
+          `\u2714 All operations completed successfully: ${summary.pendingUpdatesCount} package(s) updated across ${summary.successCount} manager(s) (${formatDuration(summary.totalDurationMs)})!`
+        )
+      )
+    );
+  } else {
+    process.exitCode = 1;
+    p.outro(
+      pc2.bold(
+        pc2.yellow(
+          `Completed with warnings: ${summary.successCount} succeeded, ${summary.failedCount} failed (${formatDuration(summary.totalDurationMs)}).`
+        )
+      )
+    );
+  }
+}
+main().catch((err) => {
+  p.log.error(pc2.red(`Fatal error: ${err instanceof Error ? err.message : String(err)}`));
+  process.exit(1);
+});