offgrid-ai 0.8.12 → 0.8.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.8.12",
+  "version": "0.8.13",
   "description": "Privacy-first CLI for running local LLMs — discover, configure, run, benchmark",
   "author": "Eeshan Srivastava (https://eeshans.com)",
   "type": "module",

package/src/commands/models.mjs

@@ -46,7 +46,7 @@ export async function modelCommandCenter(initialCatalog) {
       runningProfilesNow.push(profile);
       continue;
     }
-    if (await isProfileServerUp(profile)) serverUpIds.add(profile.id);
+    if (backendFor(profile.backend).type === "managed-server" && await isProfileServerUp(profile)) serverUpIds.add(profile.id);
   }
   printWorkspaceHeader(normalized, runningProfilesNow, serverUpIds);
   await printBenchmarkLine();
@@ -63,22 +63,14 @@ export async function modelCommandCenter(initialCatalog) {
     return "setup";
   };
 
-  const groupOrder = [
-    { key: "running", label: pc.green("  Running") },
-    { key: "serverup", label: pc.yellow("  Server up · model not loaded") },
-    { key: "ready", label: pc.blue("  Ready to chat") },
-    { key: "setup", label: pc.yellow("  Need setup") },
-    { key: "missing", label: pc.red("  File missing") },
-  ];
-  const grouped = new Map(groupOrder.map((g) => [g.key, []]));
+  const groupOrder = ["running", "serverup", "ready", "setup", "missing"];
+  const grouped = new Map(groupOrder.map((key) => [key, []]));
   for (const item of allItems) grouped.get(statusFor(item)).push(item);
 
-  const sectionSentinel = "__section__";
   const choices = [];
   for (const group of groupOrder) {
-    const bucket = grouped.get(group.key);
+    const bucket = grouped.get(group);
     if (!bucket || bucket.length === 0) continue;
-    choices.push({ value: `${sectionSentinel}:${group.key}`, label: `── ${group.label} (${bucket.length}) ──`, disabled: true });
     for (const item of bucket) {
       const opt = modelSelectOption(item, { runningProfilesNow, serverUpIds, nameWidth });
       choices.push({ value: opt.value, label: opt.label });
@@ -88,7 +80,7 @@ export async function modelCommandCenter(initialCatalog) {
   const prompt = createPrompt();
   try {
     const selected = await prompt.choice("Select a model", choices);
-    if (!selected || selected.startsWith(`${sectionSentinel}:`)) return;
+    if (!selected) return;
     const item = allItems.find((candidate) => itemKey(candidate) === selected);
     if (!item) return;
 

package/src/model-presenters.mjs

@@ -1,7 +1,7 @@
 import { existsSync, statSync } from "node:fs";
 import { BACKENDS, backendFor } from "./backends.mjs";
 import { readCommandArgv } from "./profiles.mjs";
-import { isProfileRunning } from "./process.mjs";
+import { isProfileRunning, isProfileServerUp } from "./process.mjs";
 import { buildPrettyCommand } from "./command.mjs";
 import { pc, formatBytes, renderRows, renderSection } from "./ui.mjs";
 import { capabilitySummary, ggufDetailParts, isProfileFileMissing, profileDetailParts } from "./model-summary.mjs";
@@ -160,10 +160,11 @@ export async function printProfileDetails(profile) {
   const backend = backendFor(profile.backend);
   const isManaged = backend.type === "managed-server";
   const running = await isProfileRunning(profile);
+  const serverUp = !running && isManaged && await isProfileServerUp(profile);
   const fileMissing = !isManaged && isProfileFileMissing(profile);
   console.log("\n" + renderSection("Model overview", renderRows([
     ["Name", pc.bold(profile.label)],
-    ["Status", fileMissing ? pc.red("File missing") : running ? pc.green("Running now") : pc.blue("Ready")],
+    ["Status", fileMissing ? pc.red("File missing") : running ? pc.green("Running now") : serverUp ? pc.yellow("Server up, model not loaded") : pc.blue("Ready")],
     ["Details", profileDetailParts(profile, { fileMissing }).join(pc.dim(" · "))],
     ["Server", fileMissing ? pc.red(profile.baseUrl) : profile.baseUrl],
   ])));

package/src/process.mjs

@@ -125,6 +125,9 @@ export async function isProfileServerUp(profile) {
 }
 
 export async function modelLoadedOnServer(profile) {
+  const backend = backendFor(profile.backend);
+  if (backend.id === "ollama") return modelIdsMatch(await ollamaLoadedModelIds(profile), expectedModelIds(profile));
+  if (backend.id === "omlx") return modelIdsMatch(await omlxLoadedModelIds(profile), expectedModelIds(profile));
   const { matches } = await serverMatchesProfile(profile);
   return matches;
 }
@@ -133,7 +136,8 @@ export async function profileRuntimeStatus(profile) {
   const backend = backendFor(profile.backend);
   if (backend.type === "managed-server") {
     const ready = await serverReady(profile.baseUrl);
-    return { state: null, pid: null, running: ready, ready, rssBytes: null, startedAt: null };
+    const modelLoaded = ready ? await modelLoadedOnServer(profile) : false;
+    return { state: null, pid: null, running: ready && modelLoaded, ready, serverUp: ready, modelLoaded, rssBytes: null, startedAt: null };
   }
   const state = await readState(profile.id);
   const running = Boolean(state?.pid && pidAlive(state.pid));
@@ -191,18 +195,79 @@ 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 : [])
+    .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 : [])
+    .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);
+  return [...fromStatus, ...fromSummary];
+}
+
+async function fetchJson(url) {
   try {
-    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/models`, { signal: AbortSignal.timeout(1000) });
-    if (!response.ok) return [];
-    const body = await response.json();
-    return (Array.isArray(body?.data) ? body.data : [])
-      .map((model) => String(model?.id ?? "").trim())
-      .filter(Boolean);
+    const response = await fetch(url, { signal: AbortSignal.timeout(1000) });
+    if (!response.ok) return null;
+    return await response.json();
   } catch {
-    return [];
+    return null;
   }
 }
 
+function apiRootUrl(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    url.pathname = url.pathname.replace(/\/v1\/?$/u, "") || "/";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/u, "");
+  } catch {
+    return String(baseUrl).replace(/\/v1\/?$/u, "").replace(/\/$/u, "");
+  }
+}
+
+function modelIdsMatch(actualIds, expectedIds) {
+  const actual = normalizedModelIds(actualIds);
+  const expected = normalizedModelIds(expectedIds);
+  return [...expected].some((id) => actual.has(id));
+}
+
+function normalizedModelIds(ids) {
+  const normalized = new Set();
+  for (const id of ids) {
+    const value = normalizeModelId(id);
+    if (!value) continue;
+    normalized.add(value);
+    if (value.endsWith(":latest")) normalized.add(value.slice(0, -":latest".length));
+  }
+  return normalized;
+}
+
+function normalizeModelId(id) {
+  return String(id ?? "").trim().toLowerCase();
+}
+
 function expectedModelIds(profile) {
   const fileName = profile.modelPath ? basename(profile.modelPath) : null;
   return [

package/src/ui.mjs

@@ -36,7 +36,7 @@ export function createPrompt() {
     async choice(label, choices, defaultValue) {
       return handleCancel(await select({
         message: label, initialValue: defaultValue,
-        options: choices.map((c) => ({ value: c.value, label: c.label ?? c.value, hint: c.hint })),
+        options: choices.map((c) => ({ value: c.value, label: c.label ?? c.value, hint: c.hint, disabled: c.disabled })),
       }));
     },
     close() {},