offgrid-ai 0.16.3 → 0.18.0

package/src/commands/onboard.mjs

@@ -1,16 +1,13 @@
-import { ensureDirs, findLlamaServer, ensureHomebrewFor, HF_HUB_DIR } from "../config.mjs";
+import { ensureDirs, findLlamaServer } from "../config.mjs";
 import { BACKENDS } from "../backends.mjs";
 import { scanGgufModels } from "../scan.mjs";
 import { hasPi } from "../harness-pi.mjs";
 import { offerManagedLlamaRuntimeUpdate } from "../runtime.mjs";
 import { ensureOmlxRuntime } from "../omlx-runtime.mjs";
 import { scanManagedModels } from "../managed.mjs";
-import { BACKEND_INSTALL_CHOICES, BACKEND_INSTALLERS } from "../backend-installers.mjs";
-import { recommendedModel, selectFormat, allFittingModels } from "../recommendations.mjs";
-import { hasHuggingfaceHub, resolveHfDownload, downloadToHfCache } from "../huggingface.mjs";
-import { detectHardware, getFreeDiskBytes, installedRamGB } from "../hardware.mjs";
+import { downloadFlow } from "../download.mjs";
 import { runCommand } from "../exec.mjs";
-import { pc, formatBytes, renderRows, renderSection, startInteractive, createPrompt } from "../ui.mjs";
+import { pc, renderRows, renderSection, startInteractive, createPrompt } from "../ui.mjs";
 
 export async function onboardFlow() {
   await ensureDirs();
@@ -37,12 +34,10 @@ export async function onboardFlow() {
     if (hasModels) {
       printFoundModels(ggufModels, managedModels, llamaBinary);
     } else {
-      const canDownload = await hasHuggingfaceHub();
-      if (canDownload) {
-        const downloaded = await offerModelDownload(prompt);
-        if (downloaded) return;
+      const downloaded = await downloadFlow(prompt);
+      if (!downloaded) {
+        console.log(pc.dim("\nRun offgrid-ai again when you've downloaded a model."));
       }
-      await offerBackendInstall(prompt, run);
       return;
     }
 
@@ -109,98 +104,3 @@ function printFoundModels(ggufModels, managedModels, llamaBinary) {
   }
 }
 
-async function offerModelDownload(prompt) {
-  const hardware = detectHardware();
-  const candidates = allFittingModels(hardware)
-    .map((entry) => ({ entry, format: selectFormat(entry, hardware) }))
-    .filter((item) => item.format === "gguf");
-  if (candidates.length === 0) {
-    console.log(pc.yellow("No curated models fit your hardware."));
-    return false;
-  }
-
-  const primary = candidates[0];
-  console.log(renderSection("Download a recommended model", renderRows([
-    ["Model", pc.bold(primary.entry.label)],
-    ["Format", primary.format],
-    ["Minimum RAM", String(primary.entry.minRamGb) + " GB"],
-    ["Your RAM", installedRamGB() + " GB"],
-  ]), { formatBorder: pc.cyan }));
-
-  const shouldDownload = await prompt.yesNo("Download " + primary.entry.label + " (" + primary.format + ")?", true);
-  if (!shouldDownload) return false;
-
-  const hfRef = primary.entry.gguf;
-  try {
-    const plan = await resolveHfDownload(hfRef);
-    console.log(pc.dim("Total size: " + formatBytes(plan.totalSizeBytes)));
-    const freeBytes = getFreeDiskBytes(HF_HUB_DIR);
-    if (plan.totalSizeBytes > 0 && freeBytes < plan.totalSizeBytes * 1.1) {
-      console.log(pc.red(`Not enough disk space in ${HF_HUB_DIR}: need ~${formatBytes(plan.totalSizeBytes)}, only ${formatBytes(freeBytes)} free.`));
-      return false;
-    }
-    await downloadToHfCache(plan, {
-      onProgress({ percentage }) {
-        process.stdout.write(pc.cyan("\r  " + percentage + "% downloaded"));
-      },
-    });
-    process.stdout.write("\n");
-    console.log(pc.green("✓ Download complete. Run offgrid-ai to use the model."));
-    return true;
-  } catch (err) {
-    console.log(pc.red("Download failed: " + err.message));
-    return false;
-  }
-}
-
-async function offerBackendInstall(prompt, run) {
-  console.log(pc.yellow("\nNo models found."));
-  console.log(pc.dim("You need at least one model backend to use offgrid-ai.\n"));
-  const choice = await prompt.choice("Install a model backend?", BACKEND_INSTALL_CHOICES, "lmstudio");
-  const model = recommendedModel();
-
-  if (choice === "skip") {
-    console.log(pc.dim("Run offgrid-ai again when you've set up a model backend."));
-    return;
-  }
-  if (choice === "all") {
-    await installAllBackends(prompt, run, model);
-    return;
-  }
-  await installBackend(prompt, run, choice, model);
-}
-
-async function installBackend(prompt, run, backendId, model) {
-  const installer = BACKEND_INSTALLERS[backendId];
-  if (!(await ensureHomebrewFor(prompt, run, installer.label))) return;
-  console.log(pc.cyan(`Installing ${installer.label} via Homebrew...`));
-  try {
-    await runInstallerCommands(run, installer);
-    installer.success(model);
-  } catch {
-    console.log(pc.red(`✗ ${installer.label} installation failed.`));
-    console.log(pc.dim(installer.failure));
-  }
-}
-
-async function installAllBackends(prompt, run, model) {
-  if (!(await ensureHomebrewFor(prompt, run, "model backends"))) return;
-  const installed = [];
-  for (const installer of Object.values(BACKEND_INSTALLERS)) {
-    console.log(pc.cyan(`Installing ${installer.label} via Homebrew...`));
-    try {
-      await runInstallerCommands(run, installer);
-      installed.push(installer.label);
-    } catch {
-      console.log(pc.yellow(installer.allFailure));
-    }
-  }
-  if (installed.length > 0) {
-    console.log(pc.green(`\n✓ Installed: ${installed.join(", ")}`));
-    console.log(pc.dim(`Recommended for your machine (${installedRamGB()}GB RAM): ${model.label}`));
-  }
-}
-
-async function runInstallerCommands(run, installer) {
-  for (const [cmd, args, label] of installer.commands) await run(cmd, args, label);
-}

package/src/commands/run.mjs

@@ -46,6 +46,7 @@ export async function runProfile(profile, options = {}) {
 
   printMemoryEstimate(profile, isManaged);
   await launchHarness(profile, options, isManaged, withHarness, backend);
+  console.log("");
 }
 
 async function ensureLocalServer(profile, backend, options) {
@@ -113,6 +114,7 @@ async function launchHarness(profile, options, isManaged, withHarness, backend)
   }
 
   if (!(await hasPiModel(profile))) await syncPiConfig(profile);
+
   try {
     await launchPi(profile);
   } finally {
@@ -121,10 +123,6 @@ async function launchHarness(profile, options, isManaged, withHarness, backend)
         const result = await stopProfile(profile);
         console.log(result.stopped ? pc.green(`[stop] ${result.message}`) : pc.dim(`[stop] ${result.message}`));
       } else {
-        // Managed-server backends (oMLX): unload the model from the
-        // server's memory via its HTTP API. The server itself stays running
-        // (offgrid-ai doesn't manage it), but the model is released — same UX
-        // as local-server backends where stopProfile kills the process.
         const result = await unloadModelFromServer(profile);
         if (result.unloaded) {
           console.log(pc.green(`[unload] ${backend.label}: model unloaded`));

package/src/commands/status.mjs

@@ -85,4 +85,5 @@ export async function statusCommand() {
       ["Server", profile.baseUrl],
     ]), { formatBorder: status.ready ? pc.green : pc.yellow }));
   }
+  console.log("");
 }

package/src/commands/stop.mjs

@@ -34,6 +34,7 @@ export async function stopCommand(argv) {
 
     const targets = selected === "__all" ? running : running.filter((item) => item.profile.id === selected);
     for (const { profile } of targets) await printStopResult(profile);
+    console.log("");
   } finally {
     prompt.close();
   }

package/src/config.mjs

@@ -26,6 +26,7 @@ export const HF_HUB_DIR = process.env.HF_HUB_CACHE
 
 export const DEFAULT_MODEL_DIRS = [
   join(homedir(), ".lmstudio", "models"),
+  join(homedir(), ".omlx", "models"),
   HF_HUB_DIR,
 ];
 
@@ -47,7 +48,6 @@ const CONFIG_PATH = join(DATA_DIR, "config.json");
 
 const DEFAULT_CONFIG = {
   modelScanDirs: [],
-  benchmarkRepoPath: null,
   binaryOverrides: {},
 };
 
@@ -78,6 +78,21 @@ export async function getModelScanDirs() {
   return [...DEFAULT_MODEL_DIRS, ...config.modelScanDirs].filter((dir, i, arr) => arr.indexOf(dir) === i);
 }
 
+export async function addModelScanDir(dir) {
+  const config = await loadConfig();
+  config.modelScanDirs ??= [];
+  if (!config.modelScanDirs.includes(dir)) {
+    config.modelScanDirs.push(dir);
+    await saveConfig(config);
+  }
+}
+
+export async function removeModelScanDir(dir) {
+  const config = await loadConfig();
+  config.modelScanDirs = (config.modelScanDirs ?? []).filter((d) => d !== dir);
+  await saveConfig(config);
+}
+
 // ── Binary discovery ──────────────────────────────────────────────────────
 
 import { execFile } from "node:child_process";

package/src/discovery-shared.mjs

@@ -1,6 +1,5 @@
-// Shared discovery helpers used by both the GGUF scanner (scan.mjs) and the
-// MLX scanner (mlx-discovery.mjs). Keeping these here avoids a cross-dependency
-// between the two format-specific scanners.
+// Helpers for the GGUF scanner (scan.mjs). Centralizes model-size and embedding-type
+// constants so they're defined once rather than duplicated across scanners.
 
 import { basename, dirname } from "node:path";
 

package/src/download.mjs

@@ -0,0 +1,221 @@
+// Model download flow — HuggingFace downloads with quant picker and RAM fit.
+// Used by onboarding (no models found) and the model picker (↓ Download a model).
+
+import { hasHfCli, parseHfRef, resolveHfDownload, downloadModel, listGgufFiles, getHfModelInfo, isMlxRepo } from "./huggingface.mjs";
+import { detectHardware, installedRamGB, getFreeDiskBytes } from "./hardware.mjs";
+import { allFittingModels } from "./recommendations.mjs";
+import { parseModelName } from "./model-name.mjs";
+import { HF_HUB_DIR } from "./config.mjs";
+import { offerOmlxRestart } from "./omlx-runtime.mjs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pc, formatBytes, renderCard, renderRows } from "./ui.mjs";
+
+const GB = 1024 ** 3;
+
+/**
+ * Interactive model download flow.
+ * @param {object} prompt - createPrompt() instance
+ * @returns {Promise<boolean>} true if a model was downloaded
+ */
+export async function downloadFlow(prompt) {
+  console.log("");
+  const method = await prompt.choice("Download a model", [
+    { value: "manual", label: "Enter a HuggingFace repo ID" },
+    { value: "recommended", label: "Recommended for your machine" },
+  ], "manual");
+
+  if (!method) return false;
+
+  let repo, filename;
+
+  if (method === "recommended") {
+    const hardware = detectHardware();
+    const models = allFittingModels(hardware);
+    if (models.length === 0) {
+      console.log(pc.yellow("No recommended models fit your hardware."));
+      console.log(pc.dim("You can still enter a repo ID manually."));
+      return false;
+    }
+    const choices = models.map((m) => ({
+      value: m,
+      label: `${pc.bold(m.label)}  ${pc.dim(`(${m.minRamGb} GB RAM min)`)}`,
+    }));
+    const selected = await prompt.choice("Select a model", choices, choices[0].value);
+    if (!selected) return false;
+
+    // Determine available formats (ignore empty strings)
+    const hasGguf = Boolean(selected.gguf);
+    const hasMlx = Boolean(selected.mlx && selected.mlx.trim());
+
+    let format;
+    if (hasGguf && hasMlx) {
+      // Both available — let the user choose
+      const formatChoices = [
+        { value: "gguf", label: `GGUF (llama.cpp) — ${selected.gguf.split("/").pop()}` },
+        { value: "mlx", label: `MLX (oMLX) — ${selected.mlx}` },
+      ];
+      // Default to MLX on Apple Silicon, GGUF elsewhere
+      const defaultFormat = (hardware.platform === "darwin" && hardware.arch === "arm64") ? "mlx" : "gguf";
+      format = await prompt.choice("Download format", formatChoices, defaultFormat);
+      if (!format) return false;
+    } else if (hasGguf) {
+      format = "gguf";
+    } else if (hasMlx) {
+      format = "mlx";
+    } else {
+      console.log(pc.yellow("No download path available for this model."));
+      return false;
+    }
+
+    if (format === "gguf") {
+      const ref = parseHfRef(selected.gguf);
+      repo = ref.repo;
+      filename = ref.filename;
+    } else {
+      repo = selected.mlx;
+      filename = undefined;
+    }
+  } else {
+    console.log(pc.dim("  Browse models at huggingface.co/models"));
+    const input = await prompt.text("HuggingFace repo ID (e.g. unsloth/gemma-4-E2B-it-GGUF)", "");
+    if (!input || !input.trim()) return false;
+    const ref = parseHfRef(input.trim());
+    repo = ref.repo;
+    filename = ref.filename;
+  }
+
+  // For GGUF repos without a specific file, show quant picker
+  if (!filename) {
+    let ggufFiles;
+    try {
+      ggufFiles = await listGgufFiles(repo);
+    } catch (err) {
+      console.log(pc.red(`Could not fetch repo info: ${err.message}`));
+      return false;
+    }
+    if (ggufFiles.length > 0) {
+      filename = await pickGgufQuant(prompt, repo, ggufFiles);
+      if (!filename) return false;
+    } else {
+      // No GGUF files — check if it's an MLX repo via HF metadata
+      let modelInfo;
+      try {
+        modelInfo = await getHfModelInfo(repo);
+      } catch {
+        console.log(pc.red(`Could not fetch repo info for ${repo}. Check the repo ID and try again.`));
+        return false;
+      }
+      if (!isMlxRepo(modelInfo)) {
+        console.log(pc.yellow(`This repo is not a GGUF or MLX model (library: ${modelInfo.library_name ?? "unknown"}).`));
+        console.log(pc.dim("For llama.cpp: look for a repo ending in -GGUF (e.g. org/model-name-GGUF)"));
+        console.log(pc.dim("For oMLX: look for a repo in mlx-community/ (e.g. mlx-community/model-name-4bit)"));
+        return false;
+      }
+      // It's MLX — download everything
+    }
+  }
+
+  // Check for huggingface_hub
+  if (!(await hasHfCli())) {
+    console.log(pc.yellow("HuggingFace CLI is required to download models."));
+    console.log(pc.dim("Install it: pip3 install huggingface_hub"));
+    return false;
+  }
+
+  // Resolve download plan
+  const ref = filename ? `${repo}/${filename}` : repo;
+  let plan;
+  try {
+    plan = await resolveHfDownload(ref);
+  } catch (err) {
+    console.log(pc.red(`Could not resolve download: ${err.message}`));
+    return false;
+  }
+
+  // Check disk space
+  const freeBytes = getFreeDiskBytes(HF_HUB_DIR);
+  if (plan.totalSizeBytes > 0 && freeBytes < plan.totalSizeBytes * 1.1) {
+    console.log(pc.red(`Not enough disk space: need ~${formatBytes(plan.totalSizeBytes)}, only ${formatBytes(freeBytes)} free.`));
+    return false;
+  }
+
+  console.log(pc.dim(`\nDownloading ${repo}${filename ? `/${filename}` : ""} (${formatBytes(plan.totalSizeBytes)})`));
+  if (plan.format === "mlx") {
+    const modelParts = repo.split("/").filter(Boolean);
+    const localDir = join(homedir(), ".omlx", "models", ...modelParts);
+    console.log(pc.dim(`Location: ${localDir}\n`));
+  } else {
+    console.log(pc.dim(`Location: HF cache (${HF_HUB_DIR})\n`));
+  }
+
+  try {
+    if (plan.format === "mlx") {
+      // Download directly to ~/.omlx/models/<org>/<model> — oMLX scans this dir
+      const modelParts = repo.split("/").filter(Boolean);
+      const localDir = join(homedir(), ".omlx", "models", ...modelParts);
+      await downloadModel(plan, { localDir });
+      console.log(pc.green("\n✓ Download complete."));
+      await offerOmlxRestart(prompt, "to load the new model");
+    } else {
+      await downloadModel(plan);
+      console.log(pc.green("\n✓ Download complete. Run offgrid-ai again to see the model in the picker."));
+    }
+    return true;
+  } catch (err) {
+    console.log(pc.red("\nDownload failed: " + err.message));
+    return false;
+  }
+}
+
+// ── Quant picker with RAM fit indicators ───────────────────────────────────
+
+async function pickGgufQuant(prompt, repo, ggufFiles) {
+  const hardware = detectHardware();
+  const totalRam = hardware.totalRamBytes;
+  const availableRam = totalRam - 4 * GB; // leave 4GB for OS
+
+  // Sort by size descending (highest quality first)
+  const sorted = [...ggufFiles].sort((a, b) => b.sizeBytes - a.sizeBytes);
+
+  // Find recommended: largest file that fits comfortably
+  const recommended = sorted.find((f) => f.sizeBytes + 2 * GB <= availableRam);
+
+  console.log("");
+  console.log(renderCard("Select quantization", renderRows([
+    ["Your RAM", `${installedRamGB()} GB`],
+    ["Available", `~${formatBytes(availableRam)} (after OS)`],
+    ["Rule", "Lower quant = smaller/faster · Higher = better quality"],
+  ]), { formatBorder: pc.cyan }));
+  console.log("");
+
+  const choices = sorted.map((file) => {
+    const sizeBytes = file.sizeBytes;
+    const parsed = parseModelName(file.path, "huggingface");
+    const quant = parsed.quant ?? file.path.replace(/\.gguf$/i, "");
+
+    let indicator, fitLabel;
+    if (sizeBytes > availableRam) {
+      indicator = pc.red("✗");
+      fitLabel = pc.red("won't fit");
+    } else if (sizeBytes + 2 * GB > availableRam) {
+      indicator = pc.yellow("⚠");
+      fitLabel = pc.yellow("tight");
+    } else {
+      indicator = pc.green("✓");
+      fitLabel = pc.green("fits");
+    }
+
+    const isRecommended = recommended && file.path === recommended.path;
+    const hint = isRecommended ? "recommended" : undefined;
+
+    return {
+      value: file.path,
+      label: `${indicator}  ${quant.padEnd(12)} ${formatBytes(sizeBytes).padEnd(10)} ${fitLabel}`,
+      ...(hint ? { hint } : {}),
+    };
+  });
+
+  const defaultValue = recommended?.path;
+  return await prompt.choice("Quantization", choices, defaultValue);
+}

package/src/harness-pi.mjs

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
 import { PI_CONFIG } from "./config.mjs";
 import { loadProfiles } from "./profiles.mjs";
 import { readJson, writeJson } from "./json.mjs";
@@ -69,8 +70,6 @@ export async function launchPi(profile) {
 
 export async function hasPi() {
   try {
-    const { execFile } = await import("node:child_process");
-    const { promisify } = await import("node:util");
     await promisify(execFile)("which", ["pi"]);
     return true;
   } catch {

package/src/huggingface.mjs

@@ -1,23 +1,19 @@
 // HuggingFace model download helpers.
-// Uses the Python huggingface_hub package (the standard, maintained downloader)
-// to download models into the standard HF cache directory.
-// Downloads go to ~/.cache/huggingface/hub, NOT a custom offgrid-ai folder.
+// Uses the `hf` CLI (from huggingface_hub) for actual downloads.
+// The interactive model/quant selection happens in download.mjs; here we
+// just hand off to the CLI and let it handle progress bars, resumption, etc.
 
-import { execFile } from "node:child_process";
+import { spawn, execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { join, dirname } from "node:path";
 import { mkdir } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
 import { HF_HUB_DIR } from "./config.mjs";
 
 const execFileAsync = promisify(execFile);
 
-const HF_DOWNLOAD_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "resources", "hf-download.py");
-
-/** Check whether python3 + huggingface_hub is available. */
-export async function hasHuggingfaceHub() {
+/** Check whether the `hf` CLI is available. */
+export async function hasHfCli() {
   try {
-    const { stdout } = await execFileAsync("python3", ["-c", "import huggingface_hub; print(huggingface_hub.__version__)"]);
+    const { stdout } = await execFileAsync("hf", ["--version"]);
     return Boolean(stdout.trim());
   } catch {
     return false;
@@ -96,6 +92,33 @@ async function getHfTree(repo, { branch = "main", fetchImpl = globalThis.fetch }
   return await response.json();
 }
 
+/** List all GGUF files in a HuggingFace repo with their sizes. */
+export async function listGgufFiles(repo, { fetchImpl = globalThis.fetch } = {}) {
+  const tree = await getHfTree(repo, { fetchImpl });
+  return tree
+    .filter((f) => f.type === "file" && f.path.endsWith(".gguf"))
+    .map((f) => ({
+      path: f.path,
+      sizeBytes: f.lfs?.size ?? f.size ?? 0,
+    }))
+    .sort((a, b) => a.sizeBytes - b.sizeBytes);
+}
+
+/** Fetch model metadata from the HF API. */
+export async function getHfModelInfo(repo, { fetchImpl = globalThis.fetch } = {}) {
+  const url = `https://huggingface.co/api/models/${repo}`;
+  const response = await fetchImpl(url, { signal: AbortSignal.timeout(10000) });
+  if (!response.ok) throw new Error(`HuggingFace API error: HTTP ${response.status} for ${repo}`);
+  return await response.json();
+}
+
+/** Check if a repo is MLX-formatted based on its HF metadata. */
+export function isMlxRepo(modelInfo) {
+  if (modelInfo.library_name === "mlx") return true;
+  if (Array.isArray(modelInfo.tags) && modelInfo.tags.includes("mlx")) return true;
+  return false;
+}
+
 /** Resolve a user-provided HF reference into a download plan. */
 export async function resolveHfDownload(input, { fetchImpl = globalThis.fetch } = {}) {
   const { repo, filename } = parseHfRef(input);
@@ -136,74 +159,51 @@ export async function resolveHfDownload(input, { fetchImpl = globalThis.fetch }
 }
 
 /**
- * Download a resolved model into the HF hub cache.
+ * Download a resolved model using the `hf` CLI.
+ * GGUF: downloads single file to HF cache (offgrid-ai scanner finds it there).
+ * MLX: downloads full repo to a local directory (oMLX scans ~/.omlx/models).
+ * Progress bars are handled natively by the CLI (stdio inherited).
  * @param {object} model - from resolveHfDownload
- * @param {object} options
- * @param {function} options.onProgress - ({ downloadedBytes, totalBytes, percentage, file }) => void
+ * @param {object} [options]
+ * @param {string} [options.localDir] - for MLX: target directory
  * @returns {Promise<{ localDir: string, format: string }>}
  */
-export async function downloadToHfCache(model, options = {}) {
-  await mkdir(HF_HUB_DIR, { recursive: true });
+export async function downloadModel(model, options = {}) {
+  const args = ["download", model.repo];
+  let localDir;
 
-  const script = HF_DOWNLOAD_SCRIPT;
-  const args = ["--repo", model.repo, "--cache-dir", HF_HUB_DIR];
   if (model.format === "gguf") {
-    args.push("--file", model.files[0].filename);
+    // Single file to HF cache — scanner finds it there
+    await mkdir(HF_HUB_DIR, { recursive: true });
+    args.push(model.files[0].filename, "--cache-dir", HF_HUB_DIR);
+    localDir = HF_HUB_DIR;
+  } else if (options.localDir) {
+    // Full repo to a flat local directory (oMLX)
+    await mkdir(options.localDir, { recursive: true });
+    args.push(
+      "--local-dir", options.localDir,
+      "--exclude", "*.md",
+      "--exclude", ".gitattributes",
+      "--exclude", "LICENSE",
+      "--exclude", ".gitignore",
+    );
+    localDir = options.localDir;
+  } else {
+    // Fallback: full repo to HF cache
+    await mkdir(HF_HUB_DIR, { recursive: true });
+    args.push("--cache-dir", HF_HUB_DIR);
+    localDir = HF_HUB_DIR;
   }
 
-  const onProgress = options.onProgress ?? (() => {});
-
-  return new Promise((resolve, reject) => {
-    const child = execFile("python3", [script, ...args], { env: process.env });
-
-    let stdoutBuf = "";
-    let downloadedBytes = 0;
-    let currentFile = null;
-
-    // huggingface_hub streams NDJSON progress events to stdout, one per line.
-    // Buffer and split on complete newlines so an event split across chunk
-    // boundaries isn't silently dropped.
-    const handleLine = (line) => {
-      if (!line) return;
-      try {
-        const event = JSON.parse(line);
-        if (event.type === "progress") {
-          downloadedBytes = event.downloadedBytes ?? downloadedBytes;
-          currentFile = event.file ?? currentFile;
-          onProgress({
-            downloadedBytes,
-            totalBytes: model.totalSizeBytes,
-            percentage: Math.min(100, Math.round((downloadedBytes / model.totalSizeBytes) * 100)),
-            file: currentFile,
-          });
-        } else if (event.type === "complete") {
-          resolve({ localDir: event.localDir, format: model.format });
-        } else if (event.type === "error") {
-          reject(new Error(event.message));
-        }
-      } catch {
-        // Ignore non-JSON output (progress bars, etc.)
-      }
-    };
-
-    child.stdout?.on("data", (chunk) => {
-      stdoutBuf += String(chunk);
-      let nl;
-      while ((nl = stdoutBuf.indexOf("\n")) !== -1) {
-        handleLine(stdoutBuf.slice(0, nl));
-        stdoutBuf = stdoutBuf.slice(nl + 1);
-      }
-    });
-
-    child.stderr?.on("data", () => {
-      // huggingface_hub prints progress bars to stderr; ignore.
-    });
-
+  const exitCode = await new Promise((resolve, reject) => {
+    const child = spawn("hf", args, { stdio: "inherit", env: process.env });
     child.on("error", reject);
-    child.on("exit", (code) => {
-      // Flush any final line that lacked a trailing newline.
-      if (stdoutBuf.trim()) handleLine(stdoutBuf.trim());
-      if (code !== 0) reject(new Error(`Download failed with exit code ${code}`));
-    });
+    child.on("exit", resolve);
   });
+
+  if (exitCode !== 0) {
+    throw new Error(`hf download exited with code ${exitCode}`);
+  }
+
+  return { localDir, format: model.format };
 }

package/src/managed.mjs

@@ -1,8 +1,7 @@
 import { existsSync } from "node:fs";
 import { BACKENDS } from "./backends.mjs";
-import { hasOmlx } from "./omlx-runtime.mjs";
 
-export const MANAGED_BACKEND_IDS = ["omlx"];
+const MANAGED_BACKEND_IDS = ["omlx"];
 
 export async function scanManagedModels() {
   const results = [];
@@ -21,7 +20,3 @@ export async function scanManagedModels() {
 export function hasLmStudioInstalled() {
   return existsSync("/Applications/LM Studio.app");
 }
-
-export async function hasOmlxInstalled() {
-  return await hasOmlx();
-}

package/src/model-name.mjs

@@ -4,9 +4,9 @@
 // No other function should format, title-case, or dissect a model name.
 //
 // The returned `id` is always the raw identifier (untouched) and is used for
-// API calls, profile IDs, Pi config matching, and benchmark directory slugs.
+// API calls, profile IDs, and Pi config matching.
 // The returned `display` is the human-readable string shown in pickers, details,
-// and benchmark metadata.
+
 
 // ── Known model families ────────────────────────────────────────────────
 //