offgrid-ai 0.8.11 → 0.8.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.8.11",
+  "version": "0.8.12",
   "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,18 +40,55 @@ 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 (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 = [
+    { 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, []]));
+  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);
+    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 });
+    }
+  }
+
   const prompt = createPrompt();
   try {
-    const selected = await prompt.choice("Select a model", allItems.map((item) => modelSelectOption(item, { runningProfilesNow, nameWidth })));
-    if (!selected) return;
+    const selected = await prompt.choice("Select a model", choices);
+    if (!selected || selected.startsWith(`${sectionSentinel}:`)) 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

@@ -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`));

package/src/process.mjs

@@ -113,11 +113,22 @@ 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 { matches } = await serverMatchesProfile(profile);
+  return matches;
+}
+
 export async function profileRuntimeStatus(profile) {
   const backend = backendFor(profile.backend);
   if (backend.type === "managed-server") {