@otto-code/brain 0.8.7 → 0.8.9

package/dist/runtime/index.js

@@ -16,7 +16,7 @@ import { listRuntimes as listLmStudioRuntimes, resolveOverride } from "./lmstudi
 import { defaultRuntimeSpec, installManagedRuntime, listManagedRuntimes, } from "./managed.js";
 export { BACKENDS_DIR, LMSTUDIO_ROOT, listRuntimes as listLmStudioRuntimes } from "./lmstudio.js";
 export { buildArgs, buildEnv, formatCommand } from "./args.js";
-export { installManagedRuntime, listManagedRuntimes, listRuntimeDevices, verifyRuntimeExecutable, defaultRuntimeSpec, extractArchive, resolveRuntimeVariant, serverExeName, supportedVariants, DEFAULT_LLAMA_BUILD, } from "./managed.js";
+export { installManagedRuntime, removeManagedRuntime, listManagedRuntimes, listRuntimeDevices, verifyRuntimeExecutable, defaultRuntimeSpec, extractArchive, resolveRuntimeVariant, serverExeName, supportedVariants, DEFAULT_LLAMA_BUILD, listRuntimeReleases, latestRuntimeBuild, resolveLatestBuildOrPin, MissingAssetError, } from "./managed.js";
 /** Every runtime available on this machine, managed first then LM Studio. */
 export function listAllRuntimes(env = process.env) {
     const paths = resolveBrainPaths(env);
@@ -44,6 +44,16 @@ export function resolveRuntime(config, env = process.env) {
         return lmstudio[0] ?? null;
     return managed[0] ?? lmstudio[0] ?? null; // auto
 }
+/**
+ * The numeric llama.cpp build carried by a resolved runtime, when its source
+ * identifies one. LM Studio and explicit overrides need not expose their
+ * upstream build, so callers must treat null as incompatible with a component
+ * that declares a minimum build rather than guessing compatibility.
+ */
+export function runtimeBuild(runtime) {
+    const match = /^b(\d+)$/iu.exec(runtime?.version ?? "");
+    return match ? Number(match[1]) : null;
+}
 /** Ensure a runtime exists, downloading the default managed build if none does. */
 export async function ensureRuntime(config, env = process.env, onProgress, target = {}) {
     const existing = resolveRuntime(config, env);

package/dist/runtime/managed.d.ts

@@ -30,6 +30,33 @@ export interface InstallProgress {
  * names (see the module header) - the naming scheme is not stable across tags.
  */
 export declare const DEFAULT_LLAMA_BUILD = "b10265";
+export interface RuntimeRelease {
+    build: string;
+    publishedAt: string | null;
+}
+/** Official llama.cpp builds, newest first. Only numbered build releases are actionable. */
+export declare function listRuntimeReleases(limit?: number): Promise<RuntimeRelease[]>;
+/** Resolve the latest official build at the last responsible moment. */
+export declare function latestRuntimeBuild(): Promise<string>;
+export interface ResolvedBuild {
+    build: string;
+    /** A single line explaining a fallback, or null when "latest" resolved. */
+    warning: string | null;
+}
+/**
+ * The build to install for a "latest" request, with the pin as the safety net.
+ *
+ * Asking upstream is a best effort, never a precondition. `listRuntimeReleases`
+ * hits api.github.com unauthenticated, which is rate limited to 60 requests per
+ * hour per IP: behind NAT, on a corporate egress or on a CI runner that is a 403
+ * on an address that has spent its budget on something else entirely. An install
+ * the pinned build can serve must not fail because a version lookup did.
+ *
+ * The warning is deliberately one line. The daemon's BrainOpsManager keeps the
+ * *last* stderr line as the job's message, so a wrapped warning would surface in
+ * the GUI as a dangling fragment.
+ */
+export declare function resolveLatestBuildOrPin(): Promise<ResolvedBuild>;
 /** The binary name llama.cpp ships for a platform. */
 export declare function serverExeName(platform?: NodeJS.Platform): string;
 /**
@@ -49,6 +76,17 @@ export declare function supportedVariants(platform?: NodeJS.Platform, arch?: str
  * best accelerator first and newest build first within an accelerator.
  */
 export declare function listManagedRuntimes(runtimesDir: string, platform?: NodeJS.Platform): Runtime[];
+/**
+ * An asset upstream does not serve at all, which is what a renamed asset or a
+ * tag without the expected build looks like from here. Distinguished from every
+ * other download failure because it is the one a caller can answer by retrying
+ * a build whose asset names are pinned and tested, rather than by retrying the
+ * same URL later.
+ */
+export declare class MissingAssetError extends Error {
+    readonly url: string;
+    constructor(url: string);
+}
 /**
  * The actionable message for a dynamic-loader failure, or null when the output
  * is not one. Pure, so the classification is testable without spawning.
@@ -87,4 +125,6 @@ export declare function listRuntimeDevices(runtime: Runtime, platform?: NodeJS.P
 export declare function extractArchive(archivePath: string, destDir: string, platform?: NodeJS.Platform): Promise<void>;
 /** Download + extract a runtime spec into runtimesDir and return the Runtime. */
 export declare function installManagedRuntime(spec: RuntimeSpec, runtimesDir: string, onProgress?: (progress: InstallProgress) => void): Promise<Runtime>;
+/** Remove one Otto-managed runtime. LM Studio files are outside this root. */
+export declare function removeManagedRuntime(runtimesDir: string, name: string): void;
 //# sourceMappingURL=managed.d.ts.map

package/dist/runtime/managed.js

@@ -63,8 +63,75 @@ import { buildEnv } from "./args.js";
  */
 export const DEFAULT_LLAMA_BUILD = "b10265";
 const LLAMA_RELEASE_BASE = "https://github.com/ggml-org/llama.cpp/releases/download";
+const LLAMA_RELEASE_API = "https://api.github.com/repos/ggml-org/llama.cpp/releases";
+/**
+ * How many releases to read when resolving "latest".
+ *
+ * Not 1: the newest release is not necessarily a numbered build (upstream also
+ * publishes differently tagged and pre-release entries), and a single
+ * non-matching entry would otherwise read as "llama.cpp published no release
+ * builds" while the very next one qualified.
+ */
+const LATEST_BUILD_SCAN_PAGE = 30;
+/** Official llama.cpp builds, newest first. Only numbered build releases are actionable. */
+export async function listRuntimeReleases(limit = 100) {
+    const response = await fetch(`${LLAMA_RELEASE_API}?per_page=${Math.min(Math.max(limit, 1), 100)}`, {
+        headers: { Accept: "application/vnd.github+json" },
+    });
+    if (!response.ok)
+        throw new Error(`could not fetch llama.cpp releases (${response.status})`);
+    const releases = await response.json();
+    if (!Array.isArray(releases))
+        throw new Error("llama.cpp releases response was invalid");
+    return releases.flatMap((release) => {
+        if (!release || typeof release !== "object")
+            return [];
+        const value = release;
+        const build = typeof value.tag_name === "string" ? value.tag_name : "";
+        return /^b\d+$/.test(build)
+            ? [{ build, publishedAt: typeof value.published_at === "string" ? value.published_at : null }]
+            : [];
+    });
+}
+/** Resolve the latest official build at the last responsible moment. */
+export async function latestRuntimeBuild() {
+    const [latest] = await listRuntimeReleases(LATEST_BUILD_SCAN_PAGE);
+    if (!latest)
+        throw new Error("llama.cpp published no release builds");
+    return latest.build;
+}
+/**
+ * The build to install for a "latest" request, with the pin as the safety net.
+ *
+ * Asking upstream is a best effort, never a precondition. `listRuntimeReleases`
+ * hits api.github.com unauthenticated, which is rate limited to 60 requests per
+ * hour per IP: behind NAT, on a corporate egress or on a CI runner that is a 403
+ * on an address that has spent its budget on something else entirely. An install
+ * the pinned build can serve must not fail because a version lookup did.
+ *
+ * The warning is deliberately one line. The daemon's BrainOpsManager keeps the
+ * *last* stderr line as the job's message, so a wrapped warning would surface in
+ * the GUI as a dangling fragment.
+ */
+export async function resolveLatestBuildOrPin() {
+    try {
+        return { build: await latestRuntimeBuild(), warning: null };
+    }
+    catch (error) {
+        return {
+            build: DEFAULT_LLAMA_BUILD,
+            warning: `could not look up the latest llama.cpp build (${oneLine(error)}), so Otto installed` +
+                ` the pinned build ${DEFAULT_LLAMA_BUILD} instead.`,
+        };
+    }
+}
+/** Flatten a message to one line, so a warning survives the last-line rule. */
+function oneLine(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/\s+/gu, " ").trim();
+}
 /** The CUDA toolkit version whose Windows assets we pin. */
 const WINDOWS_CUDA = "12.4";
+const MANAGED_RUNTIME_METADATA_FILE = ".otto-runtime.json";
 /** The binary name llama.cpp ships for a platform. */
 export function serverExeName(platform = process.platform) {
     return platform === "win32" ? "llama-server.exe" : "llama-server";
@@ -181,6 +248,34 @@ function slug(spec) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/(^-|-$)/g, "");
 }
+function displayNameForManagedRuntime(label, version) {
+    return `${label.replace(/\s*\(managed\)$/iu, "")} · ${version} (Otto managed)`;
+}
+function legacyManagedDisplayName(dirName, version) {
+    const cuda = /^cuda-(\d+)-(\d+)-managed(?:-|$)/iu.exec(dirName);
+    if (cuda)
+        return `CUDA ${cuda[1]}.${cuda[2]} · ${version} (Otto managed)`;
+    if (/^vulkan-managed(?:-|$)/iu.test(dirName))
+        return `Vulkan · ${version} (Otto managed)`;
+    if (/^metal-managed(?:-|$)/iu.test(dirName))
+        return `Metal · ${version} (Otto managed)`;
+    if (/^cpu-managed(?:-|$)/iu.test(dirName))
+        return `CPU · ${version} (Otto managed)`;
+    return `${version} (Otto managed)`;
+}
+function readManagedRuntimeDisplayName(root, dirName, version) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(root, MANAGED_RUNTIME_METADATA_FILE), "utf8"));
+        if (typeof parsed.displayName === "string" && parsed.displayName.trim()) {
+            return parsed.displayName;
+        }
+    }
+    catch {
+        // Existing installations predate metadata; their directory name remains a
+        // backend-only migration source, never a UI presentation contract.
+    }
+    return legacyManagedDisplayName(dirName, version);
+}
 /** Recursively find the first file named `name` under `dir`. */
 function findFile(dir, name) {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -230,9 +325,11 @@ export function listManagedRuntimes(runtimesDir, platform = process.platform) {
         const exe = findFile(root, exeName);
         if (!exe)
             continue;
+        const version = entry.name.replace(/^.*-/, "");
         found.push({
             label: entry.name,
-            version: entry.name.replace(/^.*-/, ""),
+            displayName: readManagedRuntimeDisplayName(root, entry.name, version),
+            version,
             dir: path.dirname(exe),
             exe,
             vendorDir: null,
@@ -242,8 +339,24 @@ export function listManagedRuntimes(runtimesDir, platform = process.platform) {
     return found.sort((a, b) => managedVariantRank(a.label) - managedVariantRank(b.label) ||
         buildNumber(b.version) - buildNumber(a.version));
 }
+/**
+ * An asset upstream does not serve at all, which is what a renamed asset or a
+ * tag without the expected build looks like from here. Distinguished from every
+ * other download failure because it is the one a caller can answer by retrying
+ * a build whose asset names are pinned and tested, rather than by retrying the
+ * same URL later.
+ */
+export class MissingAssetError extends Error {
+    constructor(url) {
+        super(`download failed (404) for ${url}`);
+        this.url = url;
+        this.name = "MissingAssetError";
+    }
+}
 async function downloadFile(url, dest, onProgress) {
     const response = await fetch(url);
+    if (response.status === 404)
+        throw new MissingAssetError(url);
     if (!response.ok || !response.body) {
         throw new Error(`download failed (${response.status}) for ${url}`);
     }
@@ -480,13 +593,26 @@ export async function extractArchive(archivePath, destDir, platform = process.pl
 export async function installManagedRuntime(spec, runtimesDir, onProgress) {
     const platform = spec.platform ?? process.platform;
     const targetDir = path.join(runtimesDir, slug(spec));
+    const preexisting = fs.existsSync(targetDir);
     fs.mkdirSync(targetDir, { recursive: true });
-    for (const url of spec.assets) {
-        const archivePath = path.join(targetDir, path.basename(new URL(url).pathname));
-        await downloadFile(url, archivePath, onProgress);
-        onProgress?.({ phase: "extracting", asset: url });
-        await extractArchive(archivePath, targetDir, platform);
-        fs.rmSync(archivePath, { force: true });
+    try {
+        for (const url of spec.assets) {
+            const archivePath = path.join(targetDir, path.basename(new URL(url).pathname));
+            await downloadFile(url, archivePath, onProgress);
+            onProgress?.({ phase: "extracting", asset: url });
+            await extractArchive(archivePath, targetDir, platform);
+            fs.rmSync(archivePath, { force: true });
+        }
+    }
+    catch (error) {
+        // A half-installed directory is worse than no directory: Windows CUDA needs
+        // two archives, so a 404 on the companion leaves a llama-server with no CUDA
+        // runtime beside it, and `listManagedRuntimes` ranks by build number - that
+        // newer, broken build would then outrank the working runtime it replaced.
+        // Only a directory this call created is removed; an existing install stands.
+        if (!preexisting)
+            fs.rmSync(targetDir, { recursive: true, force: true });
+        throw error;
     }
     const exeName = serverExeName(platform);
     const exe = findFile(targetDir, exeName);
@@ -499,6 +625,7 @@ export async function installManagedRuntime(spec, runtimesDir, onProgress) {
     }
     const runtime = {
         label: spec.label,
+        displayName: displayNameForManagedRuntime(spec.label, spec.version),
         version: spec.version,
         dir: path.dirname(exe),
         exe,
@@ -508,7 +635,19 @@ export async function installManagedRuntime(spec, runtimesDir, onProgress) {
     // Before reporting success. An install that cannot exec is not an install, and
     // the loader error names the cause far better than the later spawn failure does.
     await verifyRuntimeExecutable(runtime, platform);
+    fs.writeFileSync(path.join(targetDir, MANAGED_RUNTIME_METADATA_FILE), `${JSON.stringify({ displayName: runtime.displayName })}\n`);
     onProgress?.({ phase: "done" });
     return runtime;
 }
+/** Remove one Otto-managed runtime. LM Studio files are outside this root. */
+export function removeManagedRuntime(runtimesDir, name) {
+    if (!/^[a-z0-9][a-z0-9-]*$/i.test(name))
+        throw new Error("invalid runtime name");
+    const root = path.resolve(runtimesDir);
+    const target = path.resolve(root, name);
+    if (path.dirname(target) !== root || !fs.existsSync(target)) {
+        throw new Error(`managed runtime not found: ${name}`);
+    }
+    fs.rmSync(target, { recursive: true, force: false });
+}
 //# sourceMappingURL=managed.js.map

package/dist/service/host-api.d.ts

@@ -20,7 +20,7 @@
  */
 import type http from "node:http";
 import { calibrationInfo, profileWarnings } from "../config/profile-edit.js";
-import type { Profile, ProfileDefaults, ProfilesStore } from "../config/schema.js";
+import { type Profile, type ProfileDefaults, type ProfilesStore } from "../config/schema.js";
 import { planDelete } from "../models/manage.js";
 import type { RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
@@ -82,11 +82,11 @@ export interface HostCapabilities {
 /** A long-running operation owned by this brain host, not its caller. */
 export interface HostJob {
     id: string;
-    kind: "pull" | "runtime-install" | "calibrate" | "sweep" | "bench";
+    kind: "pull" | "runtime-install" | "runtime-remove" | "calibrate" | "sweep" | "bench";
     label: string;
     target: string | null;
     status: "running" | "succeeded" | "failed" | "canceled";
-    percent: null;
+    percent: number | null;
     message: string | null;
     error: string | null;
     startedAt: string;
@@ -130,6 +130,8 @@ export interface HostApiDeps {
 export interface InventoryRow {
     id: string;
     displayName: string;
+    /** Curated model-family identity for the Otto Brain client glyph. */
+    family: string | null;
     publisher: string | null;
     quant: string | null;
     sizeBytes: number;
@@ -153,7 +155,21 @@ export interface InventoryRow {
     score: RankedModel | null;
     state: "loaded" | "loading" | "not-loaded";
     warnings: ReturnType<typeof profileWarnings>;
+    components: NonNullable<Model["components"]> | null;
 }
+/**
+ * Apply the hosting-profile half of a profile patch, mutating both `profile`
+ * (this model's selection) and `store` (the shared library and family default).
+ *
+ * Separate from `sanitizeProfilePatch` because these keys are not profile
+ * fields: three of the five write to the store rather than the profile.
+ * Exported for testing - the ordering and the cross-profile cleanup are the
+ * parts worth pinning down, and they are unreachable through the HTTP surface
+ * without standing up a service.
+ *
+ * Throws on any invalid input; the caller turns that into a 400.
+ */
+export declare function applyHostingProfilePatch(store: ProfilesStore, model: Model, profile: Profile, patch: Record<string, unknown>, onDelete?: ((id: string) => void) | undefined): void;
 /**
  * Join one model's scan row, GGUF metadata, saved profile, calibration, VRAM
  * budget and benchmark score into the single shape the Models tab renders.
@@ -168,6 +184,7 @@ export declare function buildInventoryRow(params: {
     gpu: GpuInfo | null;
     ranking: RankedModel[];
     supervisor: Supervisor;
+    runtimeBuild?: number | null;
 }): InventoryRow;
 export interface HostApi {
     /** Returns true when it answered the request, false to fall through. */