offgrid-ai 0.8.15 → 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"));