offgrid-ai 0.8.11 → 0.8.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.8.11",
+  "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

@@ -1,7 +1,7 @@
 import { ensureDirs } from "../config.mjs";
 import { backendFor, BACKENDS } from "../backends.mjs";
 import { createProfileFromModel, readProfile, saveProfile, deleteProfile, profileJsonPath } from "../profiles.mjs";
-import { isProfileRunning, stopProfile } from "../process.mjs";
+import { isProfileRunning, isProfileServerUp, stopProfile } from "../process.mjs";
 import { syncPiConfig, removeFromPiConfig } from "../harness-pi.mjs";
 import { configureLocalProfile } from "../profile-setup.mjs";
 import { pc, startInteractive, createPrompt } from "../ui.mjs";
@@ -40,17 +40,46 @@ export async function modelCommandCenter(initialCatalog) {
   }
 
   const runningProfilesNow = [];
+  const serverUpIds = new Set();
   for (const profile of normalized.profiles) {
-    if (await isProfileRunning(profile)) runningProfilesNow.push(profile);
+    if (await isProfileRunning(profile)) {
+      runningProfilesNow.push(profile);
+      continue;
+    }
+    if (backendFor(profile.backend).type === "managed-server" && await isProfileServerUp(profile)) serverUpIds.add(profile.id);
   }
-  printWorkspaceHeader(normalized, runningProfilesNow);
+  printWorkspaceHeader(normalized, runningProfilesNow, serverUpIds);
   await printBenchmarkLine();
 
   const nameWidth = modelNameWidth(allItems);
 
+  const statusFor = (item) => {
+    if (item.type === "profile") {
+      if (item.fileMissing) return "missing";
+      if (runningProfilesNow.some((profile) => profile.id === item.profile.id)) return "running";
+      if (serverUpIds.has(item.profile.id)) return "serverup";
+      return "ready";
+    }
+    return "setup";
+  };
+
+  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 choices = [];
+  for (const group of groupOrder) {
+    const bucket = grouped.get(group);
+    if (!bucket || bucket.length === 0) continue;
+    for (const item of bucket) {
+      const opt = modelSelectOption(item, { runningProfilesNow, serverUpIds, nameWidth });
+      choices.push({ value: opt.value, label: opt.label });
+    }
+  }
+
   const prompt = createPrompt();
   try {
-    const selected = await prompt.choice("Select a model", allItems.map((item) => modelSelectOption(item, { runningProfilesNow, nameWidth })));
+    const selected = await prompt.choice("Select a model", choices);
     if (!selected) return;
     const item = allItems.find((candidate) => itemKey(candidate) === selected);
     if (!item) return;

package/src/model-catalog.mjs

@@ -37,10 +37,24 @@ export function itemKey(item) {
   return `managed:${item.backendId}:${item.model.id}`;
 }
 
+function profileRecency(item) {
+  const updated = item.profile?.updatedAt ?? item.profile?.createdAt;
+  const ts = updated ? Date.parse(updated) : NaN;
+  return Number.isFinite(ts) ? ts : 0;
+}
+
+function compareRecency(a, b) {
+  const diff = profileRecency(b) - profileRecency(a);
+  if (diff !== 0) return diff;
+  return String(a.label ?? "").localeCompare(String(b.label ?? ""));
+}
+
 export function buildCatalogItems(normalized) {
   const { profiles, newModels, managedItems, drafters } = normalized;
+  const profileItems = profiles.map((profile) => ({ type: "profile", profile, label: profile.label, fileMissing: isProfileFileMissing(profile) }));
+  profileItems.sort(compareRecency);
   return [
-    ...profiles.map((profile) => ({ type: "profile", profile, label: profile.label, fileMissing: isProfileFileMissing(profile) })),
+    ...profileItems,
     ...newModels.map((model) => ({ type: "new", model, label: model.label, drafter: matchDrafter(model.path, drafters) })),
     ...managedItems.map(({ model, backendId }) => ({ type: "managed", model, backendId, label: model.label })),
   ];

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";
@@ -25,6 +25,7 @@ function optionPad(text, color, width) {
 function optionStatusTag(kind) {
   const statuses = {
     running: ["RUNNING", pc.green],
+    serverup: ["SERVER UP", pc.yellow],
     ready: ["READY", pc.blue],
     missing: ["MISSING", pc.red],
     setup: ["SETUP", pc.yellow],
@@ -79,14 +80,16 @@ function optionLabel({ status, source, name, ctx, size, nameWidth }) {
   return [status, source, pc.bold(optionPad(name, null, nameWidth)), ctx, pc.dim(size)].join(OPTION_SEPARATOR);
 }
 
-export function modelSelectOption(item, { runningProfilesNow, nameWidth }) {
+export function modelSelectOption(item, { runningProfilesNow, serverUpIds, nameWidth }) {
   if (item.type === "profile") {
     const backend = backendFor(item.profile.backend);
     const running = runningProfilesNow.some((profile) => profile.id === item.profile.id);
+    const serverUp = !running && !item.fileMissing && serverUpIds?.has(item.profile.id);
+    const status = item.fileMissing ? "missing" : running ? "running" : serverUp ? "serverup" : "ready";
     return {
       value: itemKey(item),
       label: optionLabel({
-        status: optionStatusTag(item.fileMissing ? "missing" : running ? "running" : "ready"),
+        status: optionStatusTag(status),
         source: optionSourceTag(item.profile.backend, backend.label),
         name: item.profile.label,
         nameWidth,
@@ -122,15 +125,19 @@ export function modelSelectOption(item, { runningProfilesNow, nameWidth }) {
   };
 }
 
-export function printWorkspaceHeader(normalized, runningProfilesNow) {
+export function printWorkspaceHeader(normalized, runningProfilesNow, serverUpIds = new Set()) {
   const profiles = normalized.profiles;
-  const readyCount = profiles.filter((p) => !isProfileFileMissing(p) && !runningProfilesNow.some((r) => r.id === p.id)).length;
+  const isRunning = (p) => runningProfilesNow.some((r) => r.id === p.id);
+  const isMissing = (p) => isProfileFileMissing(p);
+  const readyCount = profiles.filter((p) => !isMissing(p) && !isRunning(p) && !serverUpIds.has(p.id)).length;
   const runningCount = runningProfilesNow.length;
-  const missingCount = profiles.filter((p) => isProfileFileMissing(p)).length;
+  const serverUpCount = profiles.filter((p) => !isMissing(p) && serverUpIds.has(p.id) && !isRunning(p)).length;
+  const missingCount = profiles.filter(isMissing).length;
   const setupCount = normalized.newModels.length + normalized.managedItems.length;
 
   const countParts = [];
   if (runningCount > 0) countParts.push(pc.green(`${runningCount} running`));
+  if (serverUpCount > 0) countParts.push(pc.yellow(`${serverUpCount} server up, model not loaded`));
   if (readyCount > 0) countParts.push(pc.blue(`${readyCount} model${readyCount === 1 ? "" : "s"} ready`));
   if (missingCount > 0) countParts.push(pc.red(`${missingCount} model${missingCount === 1 ? "" : "s"} missing`));
   if (setupCount > 0) countParts.push(pc.yellow(`${setupCount} model${setupCount === 1 ? "" : "s"} need${setupCount === 1 ? "s" : ""} setup`));
@@ -153,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

@@ -113,16 +113,31 @@ export async function stopProfile(profile) {
 
 export async function isProfileRunning(profile) {
   const backend = backendFor(profile.backend);
-  if (backend.type === "managed-server") return await serverReady(profile.baseUrl);
+  if (backend.type === "managed-server") {
+    return await serverReady(profile.baseUrl) && (await modelLoadedOnServer(profile));
+  }
   const state = await readState(profile.id);
   return Boolean(state?.pid && pidAlive(state.pid));
 }
 
+export async function isProfileServerUp(profile) {
+  return await serverReady(profile.baseUrl);
+}
+
+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;
+}
+
 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));
@@ -180,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() {},