offgrid-ai 0.8.14 → 0.9.0

package/src/cli.mjs

@@ -10,7 +10,7 @@ import { uninstallCommand } from "./commands/uninstall.mjs";
 
 async function offerUpdate(argv) {
   const invocation = detectInvocation();
-  const update = await checkForUpdate({ force: false });
+  const update = await checkForUpdate();
   if (!update) return false;
 
   const plan = updateCommand(invocation, argv);
@@ -56,7 +56,7 @@ async function printVersion() {
   const version = currentPackageVersion();
   console.log(`offgrid-ai v${version}`);
   const invocation = detectInvocation();
-  const update = await checkForUpdate({ force: false });
+  const update = await checkForUpdate();
   if (update) {
     const plan = updateCommand(invocation, ["version"]);
     console.log(pc.yellow(`Update available: v${update.latest}. Run: ${plan.display}`));

package/src/commands/main.mjs

@@ -27,8 +27,8 @@ export async function mainFlow() {
   const { models: ggufModels, drafters } = await scanGgufModels();
   const managedModels = await scanManagedModels();
   const profiles = await loadProfiles();
-  const hasAnyBackend = llamaBinary || managedModels.some((item) => item.models.length > 0);
-  const hasAnyModels = ggufModels.length > 0 || managedModels.some((item) => item.models.length > 0);
+  const hasAnyBackend = llamaBinary || managedModels.some((item) => item.status === "ok" && item.models.length > 0);
+  const hasAnyModels = ggufModels.length > 0 || managedModels.some((item) => item.status === "ok" && item.models.length > 0);
 
   const piInstalled = await hasPi();
   const needsLlama = ggufModels.length > 0 || profiles.some((profile) => backendFor(profile.backend).type === "local-server");

package/src/commands/onboard.mjs

@@ -90,8 +90,12 @@ function printFoundModels(ggufModels, managedModels, llamaBinary) {
     console.log(pc.green(`✓ Found ${ggufModels.length} GGUF model${ggufModels.length === 1 ? "" : "s"}`));
     if (!llamaBinary) console.log(pc.yellow("Install the managed llama.cpp runtime to run these GGUF models."));
   }
-  for (const { backendId, models } of managedModels) {
-    if (models.length > 0) console.log(pc.green(`✓ ${BACKENDS[backendId].label}: ${models.length} model${models.length === 1 ? "" : "s"}`));
+  for (const { backendId, models, status, reason } of managedModels) {
+    if (status === "unavailable") {
+      console.log(pc.yellow(`${BACKENDS[backendId].label}: unavailable${reason ? ` — ${reason}` : ""}`));
+    } else if (models.length > 0) {
+      console.log(pc.green(`✓ ${BACKENDS[backendId].label}: ${models.length} model${models.length === 1 ? "" : "s"}`));
+    }
   }
 }
 

package/src/config.mjs

@@ -46,8 +46,13 @@ export async function loadConfig() {
   try {
     const raw = await readFile(CONFIG_PATH, "utf8");
     return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
-  } catch {
-    return { ...DEFAULT_CONFIG };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { ...DEFAULT_CONFIG };
+    throw new Error(
+      `Failed to read config at ${CONFIG_PATH}: ${error.message}. ` +
+      `Fix or remove the file, then try again.`,
+      { cause: error }
+    );
   }
 }
 
@@ -99,6 +104,7 @@ export async function findLlamaServer() {
     if (existsSync(candidate)) return candidate;
   } catch { /* Homebrew not installed or llama.cpp not brewed */ }
 
+  // No llama-server found — caller must present actionable error or onboarding.
   return null;
 }
 

package/src/harness-pi.mjs

@@ -70,7 +70,7 @@ export async function hasPi() {
 // ── Internals ──────────────────────────────────────────────────────────────
 
 async function activeProviderProfiles(currentProfile) {
-  const allProfiles = await loadProfiles().catch(() => []);
+  const allProfiles = await loadProfiles();
   const byAlias = new Map();
   for (const item of [...allProfiles, currentProfile]) {
     if (item.providerId !== currentProfile.providerId) continue;

package/src/managed.mjs

@@ -10,9 +10,9 @@ export async function scanManagedModels() {
     const backend = BACKENDS[backendId];
     try {
       const models = await backend.scanModels();
-      results.push({ backendId, models });
-    } catch {
-      // Managed backends are optional and may not be running.
+      results.push({ backendId, models, status: "ok" });
+    } catch (error) {
+      results.push({ backendId, models: [], status: "unavailable", reason: error?.message ?? String(error) });
     }
   }
   return results;

package/src/model-catalog.mjs

@@ -18,7 +18,8 @@ export function normalizeCatalog(catalog) {
   const profiledPaths = new Set(profiles.map((profile) => profile.modelPath).filter(Boolean));
   const newModels = ggufModels.filter((model) => !profiledPaths.has(model.path));
   const managedItems = [];
-  for (const { backendId, models } of managedModels) {
+  for (const { backendId, models, status } of managedModels) {
+    if (status === "unavailable") continue;
     const profiledAliases = new Set(
       profiles
         .filter((profile) => profile.backend === backendId)

package/src/process.mjs

@@ -195,47 +195,55 @@ export async function waitForReady(profile, pid, rawLogPath) {
 // ── Internals ──────────────────────────────────────────────────────────────
 
 async function serverModelIds(baseUrl) {
-  const body = await fetchJson(`${baseUrl.replace(/\/$/, "")}/models`);
-  return (Array.isArray(body?.data) ? body.data : [])
+  const result = await fetchJson(`${baseUrl.replace(/\/+$/u, "")}/models`);
+  if (!result.ok) return [];
+  return (Array.isArray(result.data?.data) ? result.data.data : [])
     .map((model) => String(model?.id ?? "").trim())
     .filter(Boolean);
 }
 
 async function ollamaLoadedModelIds(profile) {
-  const body = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/ps`);
-  return (Array.isArray(body?.models) ? body.models : [])
+  const result = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/ps`);
+  if (!result.ok) return [];
+  return (Array.isArray(result.data?.models) ? result.data.models : [])
     .flatMap((model) => [model?.name, model?.model])
     .map((id) => String(id ?? "").trim())
     .filter(Boolean);
 }
 
 async function omlxLoadedModelIds(profile) {
-  const status = await fetchJson(`${profile.baseUrl.replace(/\/$/, "")}/models/status`);
-  const fromStatus = (Array.isArray(status?.models) ? status.models : [])
-    .filter((model) => model?.loaded === true)
-    .flatMap((model) => [model?.id, model?.name, model?.model, model?.alias])
-    .map((id) => String(id ?? "").trim())
-    .filter(Boolean);
-  if (Number(status?.loaded_count) === 0) return fromStatus;
-
-  const summary = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/status`);
-  const fromSummary = (Array.isArray(summary?.loaded_models) ? summary.loaded_models : [])
-    .map((id) => String(id ?? "").trim())
-    .filter(Boolean);
+  const statusResult = await fetchJson(`${profile.baseUrl.replace(/\/+$/u, "")}/models/status`);
+  const fromStatus = statusResult.ok
+    ? (Array.isArray(statusResult.data?.models) ? statusResult.data.models : [])
+        .filter((model) => model?.loaded === true)
+        .flatMap((model) => [model?.id, model?.name, model?.model, model?.alias])
+        .map((id) => String(id ?? "").trim())
+        .filter(Boolean)
+    : [];
+  if (!statusResult.ok || Number(statusResult.data?.loaded_count) === 0) return fromStatus;
+
+  const summaryResult = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/status`);
+  const fromSummary = summaryResult.ok
+    ? (Array.isArray(summaryResult.data?.loaded_models) ? summaryResult.data.loaded_models : [])
+        .map((id) => String(id ?? "").trim())
+        .filter(Boolean)
+    : [];
   return [...fromStatus, ...fromSummary];
 }
 
 async function fetchJson(url) {
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(1000) });
-    if (!response.ok) return null;
-    return await response.json();
-  } catch {
-    return null;
+    if (!response.ok) return { ok: false, reason: "http", status: response.status, data: null };
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (error) {
+    if (error?.name === "AbortError" || error?.name === "TimeoutError") return { ok: false, reason: "timeout", data: null };
+    return { ok: false, reason: "network", data: null };
   }
 }
 
-function apiRootUrl(baseUrl) {
+export function apiRootUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
     url.pathname = url.pathname.replace(/\/v1\/?$/u, "") || "/";

package/src/runtime.mjs

@@ -33,6 +33,12 @@ export async function offerManagedLlamaRuntimeUpdate(prompt, { fetchImpl = globa
   return true;
 }
 
+/**
+ * Check for the latest llama.cpp release on GitHub.
+ * Returns null if the check fails (network error, timeout, etc.).
+ * Callers must treat null as "check failed, skip prompt" — do not
+ * treat null as "no update available."
+ */
 export async function latestLlamaRelease(fetchImpl = globalThis.fetch) {
   try {
     const response = await fetchImpl(RELEASE_API, { signal: AbortSignal.timeout(5000) });
@@ -47,6 +53,11 @@ export async function latestLlamaRelease(fetchImpl = globalThis.fetch) {
   }
 }
 
+/**
+ * Read the installed runtime version from disk.
+ * Returns null if not installed or if the version file is missing/corrupt.
+ * Callers must treat null as "runtime not installed" — not as a hidden default.
+ */
 export async function installedRuntime() {
   try {
     return JSON.parse(await readFile(VERSION_PATH, "utf8"));

package/src/postinstall.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-import { existsSync, readFileSync, appendFileSync } from "node:fs";
-import { mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-if (process.env.CI || process.env.OFFGRID_SKIP_POSTINSTALL) process.exit(0);
-
-// npm v9+ sets npm_config_global="true" for global installs. Some contexts (Hermes,
-// older npm, or wrapped installs) may not set it, so also check the prefix.
-const isGlobalInstall = process.env.npm_config_global === "true" || isLikelyGlobalPrefix(process.env.npm_config_prefix, process.env.HOME);
-if (!isGlobalInstall) process.exit(0);
-
-const prefix = process.env.npm_config_prefix;
-if (!prefix) {
-  console.log("offgrid-ai postinstall: npm global prefix not detected; skipping PATH update.");
-  process.exit(0);
-}
-
-const npmBin = join(prefix, "bin");
-const marker = "# Added by offgrid-ai installer";
-const pathLine = `export PATH="${npmBin}:$PATH"`;
-
-const home = process.env.HOME;
-if (!home) {
-  console.log("offgrid-ai postinstall: HOME not set; cannot update shell PATH.");
-  process.exit(0);
-}
-
-// Detect target shell config file. Prefer the file matching the user's shell.
-const shell = process.env.SHELL ?? "";
-const isZsh = /\bzsh$/u.test(shell);
-const isBash = /\bbash$/u.test(shell);
-
-let rcCandidates;
-if (isZsh) {
-  rcCandidates = [".zshrc", ".zprofile", ".profile"];
-} else if (isBash) {
-  rcCandidates = [".bashrc", ".bash_profile", ".profile"];
-} else {
-  // Fallback: try common files, prefer existing ones
-  rcCandidates = [".bashrc", ".bash_profile", ".zshrc", ".zprofile", ".profile"];
-}
-
-const rcPaths = rcCandidates.map((name) => join(home, name));
-let rcFile = rcPaths.find((file) => existsSync(file));
-if (!rcFile) {
-  // No existing rc file: create the one matching the user's shell.
-  const defaultName = isZsh ? ".zshrc" : isBash ? ".bashrc" : ".bashrc";
-  rcFile = join(home, defaultName);
-}
-
-let content = "";
-try {
-  content = existsSync(rcFile) ? readFileSync(rcFile, "utf8") : "";
-} catch (err) {
-  console.log(`offgrid-ai postinstall: could not read ${rcFile}: ${err.message}`);
-  process.exit(0);
-}
-
-if (!content.includes(npmBin)) {
-  try {
-    mkdirSync(dirname(rcFile), { recursive: true });
-    appendFileSync(rcFile, `${content.endsWith("\n") || content.length === 0 ? "" : "\n"}\n${marker}\n${pathLine}\n`, "utf8");
-    const version = currentPackageVersion();
-    console.log("");
-    console.log(`offgrid-ai v${version} installed and added to PATH`);
-    console.log(`  Config file: ${rcFile}`);
-    console.log(`  Bin path:    ${npmBin}`);
-    console.log("");
-    console.log("To use it right now in this terminal, run:");
-    console.log(`  source ${rcFile}`);
-    console.log("");
-    console.log("Or open a new terminal window/tab.");
-  } catch (err) {
-    console.log(`offgrid-ai postinstall: could not write to ${rcFile}: ${err.message}`);
-  }
-} else {
-  console.log(`offgrid-ai is installed in ${npmBin}`);
-  console.log(`Open a new terminal if the command is not found yet.`);
-}
-
-if (process.getuid?.() === 0) {
-  console.log("Warning: offgrid-ai was installed as root. PATH was added to root's shell config, not the regular user's.");
-  console.log("If you installed with sudo, run the installer as your normal user instead, or manually add the line above to your user's shell config.");
-}
-
-function currentPackageVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"));
-    return pkg.version;
-  } catch {
-    return "";
-  }
-}
-
-function isLikelyGlobalPrefix(prefix, home) {
-  if (!prefix || !home) return false;
-  const normalized = prefix.replace(/\\/gu, "/");
-  const homeNormalized = home.replace(/\\/gu, "/");
-  // Common global prefixes: /usr/local, /opt/homebrew, nvm paths, ~/.npm-global, ~/.local
-  return normalized.startsWith("/usr/") ||
-    normalized.startsWith("/opt/") ||
-    normalized.startsWith(homeNormalized) ||
-    /\/versions\/node\/v?\d/u.test(normalized);
-}