offgrid-ai 0.3.27 → 0.3.29

package/package.json

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

package/src/cli.mjs

@@ -15,6 +15,7 @@ import { removeInstallerPathEntries } from "./shell-path.mjs";
 import { configureLocalProfile } from "./profile-setup.mjs";
 import { buildPrettyCommand } from "./command.mjs";
 import { detectCapabilities } from "./autodetect.mjs";
+import { offerManagedLlamaRuntimeUpdate } from "./runtime.mjs";
 
 // ── Entry point ────────────────────────────────────────────────────────────
 
@@ -66,6 +67,15 @@ export async function run(argv) {
 export async function mainFlow() {
   await ensureDirs();
 
+  if (process.stdin.isTTY) {
+    const runtimePrompt = createPrompt();
+    try {
+      await offerManagedLlamaRuntimeUpdate(runtimePrompt);
+    } finally {
+      runtimePrompt.close();
+    }
+  }
+
   // 1. Check what backends are available
   const llamaBinary = await findLlamaServer();
   const ggufModels = await scanGgufModels();

package/src/config.mjs

@@ -10,6 +10,8 @@ export const DATA_DIR = process.env.OFFGRID_DIR || join(homedir(), ".offgrid-ai"
 export const PROFILE_DIR = join(DATA_DIR, "profiles");
 export const LOG_DIR = join(DATA_DIR, "logs");
 export const RUN_DIR = join(DATA_DIR, "run");
+export const RUNTIME_DIR = join(DATA_DIR, "runtime");
+export const MANAGED_LLAMA_SERVER = join(RUNTIME_DIR, "bin", "llama-server");
 
 // ── Default scan directories ──────────────────────────────────────────────
 
@@ -74,14 +76,17 @@ export async function findLlamaServer() {
     return process.env.LLAMA_SERVER_BINARY;
   }
 
-  // 2. which/where
+  // 2. offgrid-ai managed runtime
+  if (existsSync(MANAGED_LLAMA_SERVER)) return MANAGED_LLAMA_SERVER;
+
+  // 3. which/where
   try {
     const { stdout } = await execFileAsync("which", ["llama-server"]);
     const path = stdout.trim();
     if (path && existsSync(path)) return path;
   } catch { /* not on PATH */ }
 
-  // 3. Homebrew
+  // 4. Homebrew
   try {
     const { stdout } = await execFileAsync("brew", ["--prefix", "llama.cpp"]);
     const prefix = stdout.trim();

package/src/profile-setup.mjs

@@ -1,6 +1,11 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { estimateMemory } from "./estimate.mjs";
+import { findLlamaServer } from "./config.mjs";
 import { pc, formatBytes, renderRows, renderSection } from "./ui.mjs";
 
+const execFileAsync = promisify(execFile);
+
 const CACHE_CHOICES = [
   { value: "bf16", label: "bf16", hint: "default: stable, good quality" },
   { value: "f16", label: "f16", hint: "stable fallback, similar memory to bf16" },
@@ -57,13 +62,14 @@ export async function configureLocalProfile(prompt, profile) {
   if (caps.vision && profile.mmprojPath) {
     console.log("");
     const gemma4Unified = isGemma4UnifiedProjector(caps.mmprojProjectorType);
+    const supported = !gemma4Unified || await runtimeSupportsGemma4Unified();
     console.log(renderSection("Vision projector detected", renderRows([
       ["Projector", caps.mmprojProjectorType ?? "unknown"],
       ["Flag", `--mmproj ${profile.mmprojPath}`],
-      ...(gemma4Unified ? [["Note", pc.yellow("Gemma 4 unified projectors need newer llama.cpp than current Homebrew stable.")]] : []),
+      ...(gemma4Unified && !supported ? [["Note", pc.yellow("Gemma 4 unified projectors need llama.cpp b9549+.")]] : []),
     ])));
-    const useVision = await prompt.yesNo("Enable vision with --mmproj?", !gemma4Unified);
-    configured = useVision ? applyVisionDefaults(configured) : removeVisionDefaults(configured, gemma4Unified ? "gemma4-unified-unsupported" : "user-disabled");
+    const useVision = await prompt.yesNo("Enable vision with --mmproj?", supported);
+    configured = useVision ? applyVisionDefaults(configured) : removeVisionDefaults(configured, gemma4Unified && !supported ? "gemma4-unified-unsupported" : "user-disabled");
   }
 
   if (caps.thinking) {
@@ -212,6 +218,19 @@ function isGemma4UnifiedProjector(projectorType) {
   return /gemma4u[va]/i.test(String(projectorType ?? ""));
 }
 
+async function runtimeSupportsGemma4Unified() {
+  try {
+    const binary = await findLlamaServer();
+    if (!binary) return false;
+    const { stdout, stderr } = await execFileAsync(binary, ["--version"]);
+    const output = `${stdout}\n${stderr}`;
+    const version = Number(output.match(/version:\s*(\d+)/i)?.[1]);
+    return Number.isFinite(version) && version >= 9549;
+  } catch {
+    return false;
+  }
+}
+
 function detectionSummary(caps) {
   const parts = [];
   if (caps.architecture) parts.push(caps.architecture);

package/src/runtime.mjs

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, mkdtemp, readFile, rm, symlink, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { promisify } from "node:util";
+import { MANAGED_LLAMA_SERVER, RUNTIME_DIR } from "./config.mjs";
+import { compareVersions } from "./updates.mjs";
+import { pc, renderCard, renderRows } from "./ui.mjs";
+
+const execFileAsync = promisify(execFile);
+const RELEASE_API = "https://api.github.com/repos/ggml-org/llama.cpp/releases/latest";
+const VERSION_PATH = join(RUNTIME_DIR, "llama.cpp", "VERSION.json");
+
+export async function offerManagedLlamaRuntimeUpdate(prompt, { fetchImpl = globalThis.fetch } = {}) {
+  const latest = await latestLlamaRelease(fetchImpl);
+  if (!latest) return false;
+
+  const installed = await installedRuntime();
+  if (installed?.tag && compareBuildTags(installed.tag, latest.tag) >= 0 && existsSync(MANAGED_LLAMA_SERVER)) return false;
+
+  console.log("\n" + renderCard("llama.cpp runtime", renderRows([
+    ["Installed", installed?.tag ?? "none"],
+    ["Latest", pc.green(latest.tag)],
+    ["Source", "official GitHub release binary"],
+  ]), { formatBorder: pc.cyan }));
+
+  const shouldInstall = await prompt.yesNo(installed ? "Update llama.cpp runtime?" : "Install llama.cpp runtime?", true);
+  if (!shouldInstall) return false;
+
+  await installLlamaRelease(latest);
+  return true;
+}
+
+export async function latestLlamaRelease(fetchImpl = globalThis.fetch) {
+  try {
+    const response = await fetchImpl(RELEASE_API, { signal: AbortSignal.timeout(5000) });
+    if (!response.ok) return null;
+    const body = await response.json();
+    const tag = typeof body?.tag_name === "string" ? body.tag_name : null;
+    const asset = selectAsset(body?.assets ?? [], process.platform, process.arch);
+    if (!tag || !asset) return null;
+    return { tag, asset };
+  } catch {
+    return null;
+  }
+}
+
+export async function installedRuntime() {
+  try {
+    return JSON.parse(await readFile(VERSION_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export async function installLlamaRelease(release) {
+  const tmp = await mkdtemp(join(tmpdir(), "offgrid-llama-"));
+  const archive = join(tmp, release.asset.name);
+  const releaseDir = join(RUNTIME_DIR, "llama.cpp", "releases", release.tag);
+  const binDir = join(RUNTIME_DIR, "bin");
+
+  try {
+    console.log(pc.dim(`Downloading ${release.asset.name}...`));
+    const response = await fetch(release.asset.url);
+    if (!response.ok) throw new Error(`Download failed: HTTP ${response.status}`);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    verifyDigest(bytes, release.asset.digest);
+    await writeFile(archive, bytes);
+
+    await rm(releaseDir, { recursive: true, force: true });
+    await mkdir(releaseDir, { recursive: true });
+    await execFileAsync("tar", ["-xzf", archive, "--strip-components", "1", "-C", releaseDir]);
+
+    const llamaServer = join(releaseDir, "llama-server");
+    if (!existsSync(llamaServer)) throw new Error("Release archive did not contain llama-server");
+    await chmod(llamaServer, 0o755);
+
+    await mkdir(binDir, { recursive: true });
+    await unlink(MANAGED_LLAMA_SERVER).catch(() => {});
+    await symlink(llamaServer, MANAGED_LLAMA_SERVER);
+
+    await mkdir(join(RUNTIME_DIR, "llama.cpp"), { recursive: true });
+    await writeFile(VERSION_PATH, JSON.stringify({
+      runtime: "llama.cpp",
+      tag: release.tag,
+      asset: release.asset.name,
+      url: release.asset.url,
+      installedAt: new Date().toISOString(),
+      llamaServer,
+    }, null, 2) + "\n", "utf8");
+
+    console.log(pc.green(`✓ Installed llama.cpp ${release.tag}`));
+  } finally {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+function selectAsset(assets, platform, arch) {
+  const suffix = assetSuffix(platform, arch);
+  if (!suffix) return null;
+  const asset = assets.find((item) => item?.name?.endsWith(suffix));
+  if (!asset?.browser_download_url) return null;
+  return {
+    name: asset.name,
+    url: asset.browser_download_url,
+    digest: asset.digest,
+    size: asset.size,
+  };
+}
+
+function assetSuffix(platform, arch) {
+  const cpu = arch === "arm64" ? "arm64" : arch === "x64" ? "x64" : null;
+  if (!cpu) return null;
+  if (platform === "darwin") return `bin-macos-${cpu}.tar.gz`;
+  if (platform === "linux") return `bin-ubuntu-${cpu}.tar.gz`;
+  return null;
+}
+
+function compareBuildTags(a, b) {
+  return compareVersions(String(a).replace(/^b/u, ""), String(b).replace(/^b/u, ""));
+}
+
+function verifyDigest(bytes, digest) {
+  if (!digest?.startsWith("sha256:")) return;
+  const expected = digest.slice("sha256:".length);
+  const actual = createHash("sha256").update(bytes).digest("hex");
+  if (actual !== expected) throw new Error(`${basename("llama.cpp")}: checksum mismatch`);
+}