offgrid-ai 0.6.6 → 0.6.7

package/src/commands/benchmark.mjs

@@ -0,0 +1,4 @@
+export async function benchmarkCommand() {
+  const { benchmarkFlow } = await import("../benchmark.mjs");
+  return await benchmarkFlow();
+}

package/src/commands/main.mjs

@@ -0,0 +1,89 @@
+import { findLlamaServer, ensureDirs } from "../config.mjs";
+import { backendFor } from "../backends.mjs";
+import { scanGgufModels } from "../scan.mjs";
+import { loadProfiles } from "../profiles.mjs";
+import { hasPi } from "../harness-pi.mjs";
+import { offerManagedLlamaRuntimeUpdate } from "../runtime.mjs";
+import { hasLmStudioInstalled, hasOllamaInstalled, hasOmlxInstalled, scanManagedModels } from "../managed.mjs";
+import { recommendedModel } from "../recommendations.mjs";
+import { pc, startInteractive, createPrompt } from "../ui.mjs";
+import { onboardFlow } from "./onboard.mjs";
+import { modelCommandCenter } from "./models.mjs";
+import { statusCommand } from "./status.mjs";
+
+export async function mainFlow() {
+  await ensureDirs();
+
+  if (process.stdin.isTTY) {
+    const runtimePrompt = createPrompt();
+    try {
+      await offerManagedLlamaRuntimeUpdate(runtimePrompt);
+    } finally {
+      runtimePrompt.close();
+    }
+  }
+
+  const llamaBinary = await findLlamaServer();
+  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 piInstalled = await hasPi();
+  const needsLlama = ggufModels.length > 0 || profiles.some((profile) => backendFor(profile.backend).type === "local-server");
+  const missingDeps = [];
+  if (needsLlama && !llamaBinary) missingDeps.push("llama-server");
+  if (!piInstalled) missingDeps.push("Pi");
+  if (missingDeps.length > 0) {
+    if (!process.stdin.isTTY) throw new Error(`Missing dependencies: ${missingDeps.join(", ")}. Run offgrid-ai interactively to install.`);
+    console.log(pc.yellow(`Missing: ${missingDeps.join(", ")}`));
+    console.log(pc.dim("offgrid-ai needs these to run. Let's finish setup.\n"));
+    return await onboardFlow();
+  }
+
+  if (!hasAnyBackend && !hasAnyModels && profiles.length === 0) {
+    if (!process.stdin.isTTY) throw new Error("No local LLM backends found. Run offgrid-ai interactively to set up.");
+    return await onboardFlow();
+  }
+
+  if (!hasAnyModels && profiles.length === 0) {
+    if (!process.stdin.isTTY) throw new Error("No models found. Download a model, then run offgrid-ai.");
+    await printNoModelsHelp(llamaBinary);
+    return;
+  }
+
+  if (!process.stdin.isTTY) return await statusCommand();
+
+  startInteractive("offgrid-ai");
+  return await modelCommandCenter({ profiles, ggufModels, managedModels, drafters });
+}
+
+async function printNoModelsHelp(llamaBinary) {
+  console.log(pc.yellow("No models found."));
+  console.log(pc.dim("You need to download a model to use offgrid-ai.\n"));
+
+  const [ollamaInstalled, omlxInstalled] = await Promise.all([hasOllamaInstalled(), hasOmlxInstalled()]);
+  const lmStudioInstalled = hasLmStudioInstalled();
+  const hasBackends = llamaBinary || ollamaInstalled || omlxInstalled || lmStudioInstalled;
+  if (!hasBackends) {
+    console.log(pc.dim("Run offgrid-ai to install a backend and download a model."));
+    return;
+  }
+
+  console.log(pc.bold("Backend status:"));
+  console.log(`  ${lmStudioInstalled ? pc.green("✓") : pc.red("✗")} LM Studio ${lmStudioInstalled ? "— installed" : "— not installed"}`);
+  console.log(`  ${ollamaInstalled ? pc.green("✓") : pc.red("✗")} Ollama ${ollamaInstalled ? "— installed" : "— not installed"}`);
+  console.log(`  ${omlxInstalled ? pc.green("✓") : pc.red("✗")} oMLX ${omlxInstalled ? "— installed" : "— not installed"}`);
+  console.log(`  ${llamaBinary ? pc.green("✓") : pc.red("✗")} llama-server ${llamaBinary ? "— installed" : "— not installed"}`);
+  console.log();
+
+  const model = recommendedModel();
+  console.log(pc.bold("Next step — download a model:"));
+  if (lmStudioInstalled) {
+    console.log("  Open LM Studio → browse models → download");
+    console.log(pc.dim(`  Recommended: ${model.label}`));
+  }
+  if (ollamaInstalled) console.log(pc.bold(`  ollama pull ${model.ollama}`));
+  if (omlxInstalled) console.log(pc.bold("  omlx start"));
+}

package/src/commands/models.mjs

@@ -0,0 +1,170 @@
+import { ensureDirs } from "../config.mjs";
+import { backendFor, BACKENDS } from "../backends.mjs";
+import { createProfileFromModel, readProfile, saveProfile, deleteProfile } from "../profiles.mjs";
+import { isProfileRunning, stopProfile } from "../process.mjs";
+import { syncPiConfig, removeFromPiConfig } from "../harness-pi.mjs";
+import { configureLocalProfile } from "../profile-setup.mjs";
+import { pc, renderRows, renderCard, startInteractive, createPrompt } from "../ui.mjs";
+import { buildCatalogItems, createManagedProfile, itemKey, loadModelCatalog, normalizeCatalog } from "../model-catalog.mjs";
+import { isProfileFileMissing } from "../model-summary.mjs";
+import { modelSelectOption, printGgufModelDetails, printManagedModelDetails, printModelCards, printProfileDetails } from "../model-presenters.mjs";
+import { runProfile } from "./run.mjs";
+
+export async function modelsCommand(argv) {
+  await ensureDirs();
+  const catalog = await loadModelCatalog();
+
+  if (argv[0]) {
+    await printProfileDetails(await readProfile(argv[0]));
+    return;
+  }
+
+  if (process.stdin.isTTY) startInteractive("offgrid-ai");
+  return await modelCommandCenter(catalog);
+}
+
+export async function modelCommandCenter(initialCatalog) {
+  if (!process.stdin.isTTY) {
+    const allItems = buildCatalogItems(normalizeCatalog(initialCatalog));
+    for (const item of allItems) console.log(item.label);
+    return;
+  }
+
+  const catalog = initialCatalog.newModels ? initialCatalog : await loadModelCatalog();
+  const normalized = normalizeCatalog(catalog);
+  const allItems = buildCatalogItems(normalized);
+  if (allItems.length === 0) {
+    console.log(pc.dim("No models found."));
+    return;
+  }
+
+  const runningProfilesNow = [];
+  for (const profile of normalized.profiles) {
+    if (await isProfileRunning(profile)) runningProfilesNow.push(profile);
+  }
+  printWorkspaceSummary(normalized, runningProfilesNow);
+  printModelCards(allItems, { runningProfilesNow, drafters: normalized.drafters });
+
+  const prompt = createPrompt();
+  try {
+    const selected = await prompt.choice("Select a model", allItems.map((item) => modelSelectOption(item, { runningProfilesNow, drafters: normalized.drafters })));
+    if (!selected) return;
+    const item = allItems.find((candidate) => itemKey(candidate) === selected);
+    if (!item) return;
+
+    const actions = actionsForItem(item);
+    const action = await prompt.choice(item.label, actions, actions[0].value);
+    if (!action) return;
+    await performAction(prompt, action, item);
+  } finally {
+    prompt.close();
+  }
+}
+
+function printWorkspaceSummary(normalized, runningProfilesNow) {
+  const fileMissingCount = normalized.profiles.filter((profile) => isProfileFileMissing(profile)).length;
+  const summaryBorder = fileMissingCount > 0 ? pc.red : normalized.newModels.length > 0 ? pc.yellow : pc.dim;
+  console.log("\n" + renderCard("Your local AI workspace", renderRows([
+    ["Setups", `${normalized.profiles.length} saved`],
+    ["Need setup", normalized.newModels.length > 0 ? pc.yellow(`${normalized.newModels.length} model${normalized.newModels.length === 1 ? "" : "s"}`) : pc.dim("none")],
+    ["Running", runningProfilesNow.length > 0 ? pc.green(String(runningProfilesNow.length)) : pc.dim("none")],
+    ["File missing", fileMissingCount > 0 ? pc.red(`${fileMissingCount} setup${fileMissingCount === 1 ? "" : "s"}`) : pc.dim("none")],
+  ]), { formatBorder: summaryBorder }));
+}
+
+function actionsForItem(item) {
+  if (item.type === "profile") {
+    const actions = [
+      { value: "run", label: "Start chatting", hint: "Launch and open Pi" },
+      { value: "reconfigure", label: "Reconfigure", hint: "Change context, MTP, settings" },
+      { value: "inspect", label: "Details", hint: "Paths, ports, flags" },
+    ];
+    const backend = backendFor(item.profile.backend);
+    if (backend.type === "local-server" || backend.type === "managed-server") actions.push({ value: "benchmark", label: "Benchmark", hint: "Prepare a benchmark run" });
+    if (!item.fileMissing) actions.push({ value: "remove", label: "Remove", hint: "Delete this setup" });
+    return actions;
+  }
+  if (item.type === "new") {
+    return [
+      { value: "setup", label: "Set up", hint: "Configure and save" },
+      { value: "inspect", label: "Details", hint: "Model info" },
+    ];
+  }
+  return [
+    { value: "setup", label: "Set up", hint: `Connect via ${BACKENDS[item.backendId].label}` },
+    { value: "inspect", label: "Details", hint: "Model info" },
+  ];
+}
+
+async function performAction(prompt, action, item) {
+  if (action === "inspect") {
+    if (item.type === "profile") return await printProfileDetails(await readProfile(item.profile.id));
+    if (item.type === "managed") return printManagedModelDetails(item.model, BACKENDS[item.backendId]);
+    return printGgufModelDetails(item.model, item.drafter);
+  }
+  if (action === "benchmark") {
+    if (item.type === "profile") {
+      const { benchmarkForProfile } = await import("../benchmark.mjs");
+      return await benchmarkForProfile(await readProfile(item.profile.id));
+    }
+    const { benchmarkFlow } = await import("../benchmark.mjs");
+    return await benchmarkFlow();
+  }
+  if (action === "run") return await runItem(prompt, item);
+  if (action === "reconfigure" || action === "setup") return await setupItem(prompt, item, action);
+  if (action === "remove" && item.type === "profile") return await removeProfileInteractive(item.profile.id);
+}
+
+async function runItem(prompt, item) {
+  if (item.type === "profile") return await runProfile(await readProfile(item.profile.id));
+  const profile = await createProfileFromModel(item.model, null, item.drafter?.path);
+  const configured = await configureLocalProfile(prompt, profile);
+  if (!configured) return;
+  await saveProfile(configured);
+  await syncPiConfig(configured);
+  return await runProfile(configured);
+}
+
+async function setupItem(prompt, item, action) {
+  if (item.type === "profile") {
+    const configured = await configureLocalProfile(prompt, await readProfile(item.profile.id));
+    if (!configured) return;
+    await saveProfile(configured, { writeCommand: true });
+    return await syncPiConfig(configured);
+  }
+  if (item.type === "managed") {
+    const profile = createManagedProfile(item.model, item.backendId);
+    await saveProfile(profile);
+    return await syncPiConfig(profile);
+  }
+  const profile = await createProfileFromModel(item.model, null, item.drafter?.path);
+  const configured = await configureLocalProfile(prompt, profile);
+  if (!configured) return;
+  await saveProfile(configured, { writeCommand: action === "reconfigure" });
+  return await syncPiConfig(configured);
+}
+
+async function removeProfileInteractive(id) {
+  const profile = await readProfile(id);
+  if (!process.stdin.isTTY) {
+    console.log(pc.red(`Use --force to remove ${id} non-interactively.`));
+    return;
+  }
+  const prompt = createPrompt();
+  try {
+    const confirmed = await prompt.yesNo(`Remove ${profile.label} (${profile.id})?`, false);
+    if (!confirmed) {
+      console.log(pc.dim("Cancelled."));
+      return;
+    }
+  } finally {
+    prompt.close();
+  }
+  if (await isProfileRunning(profile)) {
+    console.log(pc.yellow("Stopping running server..."));
+    await stopProfile(profile);
+  }
+  await removeFromPiConfig(profile);
+  await deleteProfile(id);
+  console.log(pc.green(`Removed ${profile.label} (${profile.id})`));
+}

package/src/commands/onboard.mjs

@@ -0,0 +1,177 @@
+import { existsSync } from "node:fs";
+import { ensureDirs, findLlamaServer, hasHomebrew } from "../config.mjs";
+import { BACKENDS } from "../backends.mjs";
+import { scanGgufModels } from "../scan.mjs";
+import { hasPi } from "../harness-pi.mjs";
+import { offerManagedLlamaRuntimeUpdate } from "../runtime.mjs";
+import { scanManagedModels } from "../managed.mjs";
+import { BACKEND_INSTALL_CHOICES, BACKEND_INSTALLERS } from "../backend-installers.mjs";
+import { installedRamGB, recommendedModel } from "../recommendations.mjs";
+import { runCommand } from "../exec.mjs";
+import { pc, renderRows, renderSection, startInteractive, createPrompt } from "../ui.mjs";
+
+export async function onboardFlow() {
+  await ensureDirs();
+  startInteractive("offgrid-ai setup");
+  const prompt = createPrompt();
+  const verbose = process.argv.includes("--verbose");
+  const run = (cmd, args, label) => runCommand(cmd, args, { label, verbose });
+
+  try {
+    console.log(pc.bold("Welcome to offgrid-ai!"));
+    console.log(pc.dim("Let's make sure you have everything you need to run local models.\n"));
+
+    const llamaBinary = await ensureLlamaRuntime(prompt);
+    if (!(await ensurePi(prompt, run))) return;
+
+    const { models: ggufModels } = await scanGgufModels();
+    const managedModels = await scanManagedModels();
+    const totalManaged = managedModels.reduce((sum, item) => sum + item.models.length, 0);
+    const hasModels = ggufModels.length > 0 || totalManaged > 0;
+
+    if (hasModels) {
+      printFoundModels(ggufModels, managedModels, llamaBinary);
+    } else {
+      await offerBackendInstall(prompt, run);
+      return;
+    }
+
+    console.log(pc.green("\n✓ Setup complete! Run offgrid-ai to pick and run a model."));
+  } finally {
+    prompt.close();
+  }
+}
+
+async function ensureLlamaRuntime(prompt) {
+  let llamaBinary = await findLlamaServer();
+  if (!llamaBinary) {
+    console.log(renderSection("llama.cpp runtime", renderRows([
+      ["Status", pc.yellow("not installed")],
+      ["Used for", "local GGUF models"],
+      ["Install", "managed by offgrid-ai under ~/.offgrid-ai/runtime"],
+    ]), { formatBorder: pc.cyan }));
+    await offerManagedLlamaRuntimeUpdate(prompt);
+    llamaBinary = await findLlamaServer();
+    if (!llamaBinary) console.log(pc.yellow("Skipping llama.cpp for now. You can still use Ollama/oMLX, or run offgrid-ai again to install the managed runtime."));
+  }
+  if (llamaBinary) console.log(pc.green(`✓ llama-server: ${llamaBinary}`));
+  return llamaBinary;
+}
+
+async function ensurePi(prompt, run) {
+  if (await hasPi()) {
+    console.log(pc.green("✓ Pi found"));
+    return true;
+  }
+  const install = await prompt.yesNo("Pi coding agent is required to chat with models. Install via npm?", true);
+  if (!install) {
+    console.log(pc.red("offgrid-ai needs Pi to run models."));
+    console.log(pc.dim("Install it manually: npm install -g --ignore-scripts @earendil-works/pi-coding-agent"));
+    return false;
+  }
+  console.log(pc.cyan("Installing Pi..."));
+  try {
+    await run("npm", ["install", "-g", "--ignore-scripts", "@earendil-works/pi-coding-agent"], "Pi");
+  } catch {
+    console.log(pc.red("✗ Failed to install Pi."));
+    console.log(pc.dim("Install it manually: npm install -g --ignore-scripts @earendil-works/pi-coding-agent"));
+    return false;
+  }
+  if (!(await hasPi())) {
+    console.log(pc.yellow("Pi was installed but not found on PATH. Restart your terminal and run offgrid-ai again."));
+    return false;
+  }
+  console.log(pc.green("✓ Pi found"));
+  return true;
+}
+
+function printFoundModels(ggufModels, managedModels, llamaBinary) {
+  if (ggufModels.length > 0) {
+    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"}`));
+  }
+}
+
+async function offerBackendInstall(prompt, run) {
+  console.log(pc.yellow("\nNo models found."));
+  console.log(pc.dim("You need at least one model backend to use offgrid-ai.\n"));
+  const choice = await prompt.choice("Install a model backend?", BACKEND_INSTALL_CHOICES, "lmstudio");
+  const model = recommendedModel();
+
+  if (choice === "skip") {
+    console.log(pc.dim("Run offgrid-ai again when you've set up a model backend."));
+    return;
+  }
+  if (choice === "all") {
+    await installAllBackends(prompt, run, model);
+    return;
+  }
+  await installBackend(prompt, run, choice, model);
+}
+
+async function ensureHomebrewFor(prompt, run, label) {
+  if (await hasHomebrew()) return true;
+  const install = await prompt.yesNo(`Homebrew is needed to install ${label}. Install Homebrew now?`, true);
+  if (!install) {
+    console.log(pc.dim(`Install ${label} manually, or install Homebrew from https://brew.sh and run offgrid-ai again.`));
+    return false;
+  }
+  console.log(pc.cyan("Installing Homebrew..."));
+  try {
+    await run("/bin/bash", ["-c", "NONINTERACTIVE=1 /bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\""], "Homebrew");
+    for (const path of ["/opt/homebrew/bin", "/usr/local/bin"]) {
+      if (existsSync(path)) {
+        process.env.PATH = `${path}:${process.env.PATH}`;
+        break;
+      }
+    }
+  } catch {
+    console.log(pc.red("✗ Homebrew installation failed."));
+    console.log(pc.dim("Install it manually from https://brew.sh, then run offgrid-ai again."));
+    return false;
+  }
+  if (!(await hasHomebrew())) {
+    console.log(pc.red("Homebrew was installed but not found on PATH. Restart your terminal and run offgrid-ai again."));
+    return false;
+  }
+  console.log(pc.green("✓ Homebrew found"));
+  return true;
+}
+
+async function installBackend(prompt, run, backendId, model) {
+  const installer = BACKEND_INSTALLERS[backendId];
+  if (!(await ensureHomebrewFor(prompt, run, installer.label))) return;
+  console.log(pc.cyan(`Installing ${installer.label} via Homebrew...`));
+  try {
+    await runInstallerCommands(run, installer);
+    installer.success(model);
+  } catch {
+    console.log(pc.red(`✗ ${installer.label} installation failed.`));
+    console.log(pc.dim(installer.failure));
+  }
+}
+
+async function installAllBackends(prompt, run, model) {
+  if (!(await ensureHomebrewFor(prompt, run, "model backends"))) return;
+  const installed = [];
+  for (const installer of Object.values(BACKEND_INSTALLERS)) {
+    console.log(pc.cyan(`Installing ${installer.label} via Homebrew...`));
+    try {
+      await runInstallerCommands(run, installer);
+      installed.push(installer.label);
+    } catch {
+      console.log(pc.yellow(installer.allFailure));
+    }
+  }
+  if (installed.length > 0) {
+    console.log(pc.green(`\n✓ Installed: ${installed.join(", ")}`));
+    console.log(pc.dim(`Recommended for your machine (${installedRamGB()}GB RAM): ${model.label}`));
+  }
+}
+
+async function runInstallerCommands(run, installer) {
+  for (const [cmd, args, label] of installer.commands) await run(cmd, args, label);
+}

package/src/commands/run.mjs

@@ -0,0 +1,146 @@
+import { existsSync } from "node:fs";
+import { ensureDirs } from "../config.mjs";
+import { backendFor } from "../backends.mjs";
+import { normalizeProfile, readProfile, saveProfile } from "../profiles.mjs";
+import { startServer, stopProfile, waitForReady, serverReady, serverMatchesProfile } from "../process.mjs";
+import { syncPiConfig, hasPiModel, launchPi, hasPi } from "../harness-pi.mjs";
+import { tailFriendly } from "../logs.mjs";
+import { estimateMemory } from "../estimate.mjs";
+import { pc, formatBytes, renderRows, renderSection, parseOptions } from "../ui.mjs";
+
+export async function runCommand(argv) {
+  await ensureDirs();
+  const { positional, options } = parseOptions(argv);
+  if (!positional[0]) {
+    const { mainFlow } = await import("./main.mjs");
+    return await mainFlow();
+  }
+  return await runProfile(await readProfile(positional[0]), options);
+}
+
+export async function runProfile(profile, options = {}) {
+  const backend = backendFor(profile.backend);
+  const withHarness = options.with ?? "pi";
+
+  if (withHarness === "pi" && !(await hasPi())) {
+    console.log(pc.yellow("Pi is not installed. Run with --with server, or install Pi from https://pi.app"));
+    console.log(pc.dim("Starting server only..."));
+    return await runProfile(profile, { ...options, with: "server" });
+  }
+
+  const isManaged = backend.type === "managed-server";
+  if (isManaged) {
+    if (!(await serverReady(profile.baseUrl))) {
+      throw new Error(`${backend.label} is not running at ${profile.baseUrl}. Start it and try again.`);
+    }
+    console.log(pc.green(`[ready] ${backend.label} at ${profile.baseUrl}`));
+  } else {
+    const startup = await ensureLocalServer(profile, backend, options);
+    if (startup?.handled) return startup.result;
+  }
+
+  printMemoryEstimate(profile, isManaged);
+  await launchHarness(profile, options, isManaged, withHarness, backend);
+}
+
+async function ensureLocalServer(profile, backend, options) {
+  if (await serverReady(profile.baseUrl)) {
+    const match = await serverMatchesProfile(profile);
+    if (!match.matches) {
+      throw new Error(`A different server is already responding at ${profile.baseUrl}. ${match.reason}. Stop it with offgrid-ai stop --all, or choose a different port.`);
+    }
+    console.log(pc.green(`[ready] Reusing server at ${profile.baseUrl}`));
+    return;
+  }
+
+  console.log(pc.dim(`Starting ${backend.label} for ${profile.label}...`));
+  let state;
+  try {
+    state = await startServer(profile);
+    const tail = state?.rawLogPath ? tailFriendly(state.rawLogPath, state.friendlyLogPath) : { stop() {} };
+    try {
+      await waitForReady(profile, state?.pid, state?.rawLogPath);
+      console.log(pc.green(`[ready] ${profile.baseUrl}/models`));
+    } finally {
+      tail.stop();
+    }
+  } catch (err) {
+    if (state?.pid) {
+      try { await stopProfile(profile); } catch { /* best effort */ }
+    }
+    if (!options.textOnlyRetry && isUnsupportedMmprojError(err, profile)) {
+      console.log(pc.yellow("Vision projector is not supported by this llama.cpp build. Retrying text-only."));
+      console.log(pc.dim("Update llama.cpp later to re-enable vision for this model."));
+      const textOnly = textOnlyProfile(profile);
+      await saveProfile(textOnly, { writeCommand: true });
+      return { handled: true, result: await runProfile(textOnly, { ...options, textOnlyRetry: true }) };
+    }
+    throw err;
+  }
+}
+
+function printMemoryEstimate(profile, isManaged) {
+  if (isManaged || !profile.modelPath || !existsSync(profile.modelPath)) return;
+  try {
+    const est = estimateMemory(profile.modelPath, profile.mmprojPath, profile.drafterPath, profile.flags);
+    const rows = [
+      ["Estimated total", pc.bold(`~${formatBytes(est.totalBytes)}`)],
+      ["Model file", formatBytes(est.modelBytes)],
+    ];
+    if (est.draftBytes) rows.push(["Drafter", formatBytes(est.draftBytes)]);
+    if (est.mmprojBytes) rows.push(["Vision projector", formatBytes(est.mmprojBytes)]);
+    rows.push(["Conversation memory", est.kvBytes ? `~${formatBytes(est.kvBytes)}` : "unknown"]);
+    console.log(renderSection("Memory estimate", renderRows(rows)));
+  } catch {
+    // Memory estimates are informational only.
+  }
+}
+
+async function launchHarness(profile, options, isManaged, withHarness, backend) {
+  if (withHarness !== "pi") {
+    if (!isManaged) {
+      console.log(pc.dim(`Server running at ${profile.baseUrl}`));
+      console.log(pc.dim(`Stop with: offgrid-ai stop ${profile.id}`));
+    } else {
+      console.log(pc.dim(`${backend.label} is a managed service — offgrid-ai does not stop it.`));
+    }
+    return;
+  }
+
+  if (!(await hasPiModel(profile))) await syncPiConfig(profile);
+  try {
+    await launchPi(profile);
+  } finally {
+    if (!isManaged && !options["keep-server"]) {
+      const result = await stopProfile(profile);
+      console.log(result.stopped ? pc.green(`[stop] ${result.message}`) : pc.dim(`[stop] ${result.message}`));
+    }
+  }
+}
+
+function isUnsupportedMmprojError(err, profile) {
+  const message = String(err?.message ?? "");
+  return Boolean(profile.mmprojPath && /unknown projector type|failed to load multimodal model|failed to load CLIP model/i.test(message));
+}
+
+function textOnlyProfile(profile) {
+  return normalizeProfile({
+    ...profile,
+    mmprojPath: null,
+    disabledMmprojPath: profile.disabledMmprojPath ?? profile.mmprojPath,
+    capabilities: { ...(profile.capabilities ?? {}), vision: false, visionDisabledReason: "unsupported-mmproj" },
+    commandArgv: removeCommandOption(profile.commandArgv ?? [], "--mmproj"),
+  });
+}
+
+function removeCommandOption(argv, flag) {
+  const next = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === flag) {
+      if (argv[i + 1] && !argv[i + 1].startsWith("--")) i += 1;
+      continue;
+    }
+    next.push(argv[i]);
+  }
+  return next;
+}

package/src/commands/status.mjs

@@ -0,0 +1,38 @@
+import { ensureDirs } from "../config.mjs";
+import { backendFor } from "../backends.mjs";
+import { loadProfiles } from "../profiles.mjs";
+import { profileRuntimeStatus } from "../process.mjs";
+import { pc, renderRows, renderCard } from "../ui.mjs";
+
+export async function statusCommand() {
+  await ensureDirs();
+  const profiles = await loadProfiles();
+  const statuses = [];
+  for (const profile of profiles) {
+    statuses.push({ profile, status: await profileRuntimeStatus(profile) });
+  }
+
+  const running = statuses.filter((item) => item.status.running);
+  if (running.length === 0) {
+    console.log(renderCard("Status", renderRows([
+      ["Running now", pc.dim("none")],
+      ["Ready setups", profiles.length > 0 ? String(profiles.length) : pc.dim("none")],
+      ["Next step", profiles.length > 0 ? "Run offgrid-ai to start chatting" : pc.yellow("Run offgrid-ai to set up a model")],
+    ]), { formatBorder: pc.dim }));
+    return;
+  }
+
+  console.log(renderCard("Status", renderRows([
+    ["Running now", pc.green(`${running.length} model${running.length === 1 ? "" : "s"}`)],
+    ["Stop", "offgrid-ai stop"],
+  ]), { formatBorder: pc.green }));
+  for (const { profile, status } of running) {
+    const backend = backendFor(profile.backend);
+    console.log("\n" + renderCard(profile.label, renderRows([
+      ["Status", status.ready ? pc.green("Ready") : pc.yellow("Starting up")],
+      ["Runs with", backend.label],
+      ["Process", `pid ${status.pid}`],
+      ["Server", profile.baseUrl],
+    ]), { formatBorder: status.ready ? pc.green : pc.yellow }));
+  }
+}