@otto-code/brain 0.7.5

package/dist/output/render.js

@@ -0,0 +1,96 @@
+/**
+ * Format renderers for the output layer. chalk lives here and nowhere else —
+ * command handlers express color declaratively via ColumnDef.color, and only
+ * these renderers turn a result into text. Table output is ANSI-aware so colored
+ * cells still align.
+ */
+import chalk from "chalk";
+import { stringify as toYaml } from "yaml";
+const ANSI = /\[[0-9;]*m/g;
+function stripAnsi(value) {
+    return value.replace(ANSI, "");
+}
+const COLORS = {
+    red: chalk.red,
+    green: chalk.green,
+    blue: chalk.blue,
+    yellow: chalk.yellow,
+    cyan: chalk.cyan,
+    magenta: chalk.magenta,
+    white: chalk.white,
+    gray: chalk.gray,
+    dim: chalk.dim,
+    bold: chalk.bold,
+};
+function fieldValue(item, column) {
+    return typeof column.field === "function" ? column.field(item) : item[column.field];
+}
+function cellText(value) {
+    if (value === null || value === undefined)
+        return "-";
+    return String(value);
+}
+function padCell(text, width, align) {
+    const visible = stripAnsi(text).length;
+    if (visible >= width)
+        return text;
+    const pad = " ".repeat(width - visible);
+    return align === "right" ? pad + text : text + pad;
+}
+function renderTable(rows, schema, options) {
+    const widths = schema.columns.map((col) => {
+        const cells = rows.map((r) => stripAnsi(cellText(fieldValue(r, col))).length);
+        return Math.max(col.width ?? 0, col.header.length, ...cells, 0);
+    });
+    const lines = [];
+    if (!options.noHeaders) {
+        const header = schema.columns
+            .map((col, i) => padCell(options.noColor ? col.header : chalk.bold(col.header), widths[i], col.align ?? "left"))
+            .join("  ");
+        lines.push(header);
+    }
+    for (const row of rows) {
+        const cells = schema.columns.map((col, i) => {
+            const raw = fieldValue(row, col);
+            let text = cellText(raw);
+            if (!options.noColor && col.color) {
+                const name = col.color(raw, row);
+                if (name)
+                    text = COLORS[name](text);
+            }
+            return padCell(text, widths[i], col.align ?? "left");
+        });
+        lines.push(cells.join("  "));
+    }
+    return lines.join("\n");
+}
+export function renderResult(result, options) {
+    const rows = result.type === "list" ? result.data : [result.data];
+    if (options.quiet) {
+        const { idField } = result.schema;
+        return rows
+            .map((r) => (typeof idField === "function" ? idField(r) : String(r[idField])))
+            .join("\n");
+    }
+    if (options.format === "json") {
+        const data = result.schema.serialize ? result.schema.serialize(result.data) : result.data;
+        return JSON.stringify(data, null, 2);
+    }
+    if (options.format === "yaml") {
+        const data = result.schema.serialize ? result.schema.serialize(result.data) : result.data;
+        return toYaml(data).trimEnd();
+    }
+    if (result.schema.renderHuman)
+        return result.schema.renderHuman(result.data, options);
+    return renderTable(rows, result.schema, options);
+}
+export function renderError(error, options) {
+    if (options.format === "json")
+        return JSON.stringify({ error }, null, 2);
+    if (options.format === "yaml")
+        return toYaml({ error }).trimEnd();
+    const prefix = options.noColor ? "Error: " : chalk.red("Error: ");
+    const details = error.details ? `\n  ${String(error.details)}` : "";
+    return `${prefix}${error.message}${details}`;
+}
+//# sourceMappingURL=render.js.map

package/dist/output/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The output contract, mirroring @otto-code/cli's output layer: command handlers
+ * do not print — they return a typed result plus a schema, and a wrapper renders
+ * it in the user-selected format (table / json / yaml / quiet). This is what lets
+ * every `otto brain` command support `--format`, `--json`, and `--quiet` uniformly.
+ */
+export type OutputFormat = "table" | "json" | "yaml";
+export interface OutputOptions {
+    format: OutputFormat;
+    quiet: boolean;
+    noHeaders: boolean;
+    noColor: boolean;
+}
+export type ColorName = "red" | "green" | "blue" | "yellow" | "cyan" | "magenta" | "white" | "gray" | "dim" | "bold";
+export interface ColumnDef<T> {
+    header: string;
+    field: keyof T | ((item: T) => unknown);
+    width?: number;
+    align?: "left" | "right";
+    color?: (value: unknown, item: T) => ColorName | undefined;
+}
+export interface OutputSchema<T> {
+    idField: keyof T | ((item: T) => string);
+    columns: ColumnDef<T>[];
+    /** Optional custom human renderer, used for the table format only. */
+    renderHuman?: (data: T | T[], options: OutputOptions) => string;
+    /** Optional serializer for json/yaml (defaults to the value itself). */
+    serialize?: (data: T | T[]) => unknown;
+}
+export interface SingleResult<T> {
+    type: "single";
+    data: T;
+    schema: OutputSchema<T>;
+}
+export interface ListResult<T> {
+    type: "list";
+    data: T[];
+    schema: OutputSchema<T>;
+}
+export type AnyCommandResult<T> = SingleResult<T> | ListResult<T>;
+/** A structured, user-facing error. Thrown by handlers; rendered by withOutput. */
+export interface CommandErrorShape {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export declare class CommandError extends Error implements CommandErrorShape {
+    code: string;
+    details?: unknown;
+    constructor(shape: CommandErrorShape);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/output/types.js

@@ -0,0 +1,9 @@
+export class CommandError extends Error {
+    constructor(shape) {
+        super(shape.message);
+        this.name = "CommandError";
+        this.code = shape.code;
+        this.details = shape.details;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/output/with-output.d.ts

@@ -0,0 +1,3 @@
+import { type AnyCommandResult } from "./types.js";
+export declare function withOutput<A extends unknown[], T>(handler: (...args: A) => Promise<AnyCommandResult<T>>): (...args: A) => Promise<void>;
+//# sourceMappingURL=with-output.d.ts.map

package/dist/output/with-output.js

@@ -0,0 +1,42 @@
+import { renderError, renderResult } from "./render.js";
+import { CommandError, } from "./types.js";
+const FORMATS = new Set(["table", "json", "yaml"]);
+function optionsFromCommand(command) {
+    const opts = command.optsWithGlobals();
+    let format = typeof opts.format === "string" ? opts.format : "table";
+    if (opts.json === true)
+        format = "json";
+    if (format === "cli")
+        format = "table";
+    if (!FORMATS.has(format)) {
+        throw new CommandError({
+            code: "INVALID_FORMAT",
+            message: `unknown format "${format}"`,
+            details: "Supported formats: table, json, yaml",
+        });
+    }
+    return {
+        format: format,
+        quiet: opts.quiet === true,
+        noHeaders: opts.headers === false,
+        noColor: opts.color === false,
+    };
+}
+export function withOutput(handler) {
+    return async (...args) => {
+        const command = args[args.length - 1];
+        const options = optionsFromCommand(command);
+        try {
+            const result = await handler(...args);
+            process.stdout.write(`${renderResult(result, options)}\n`);
+        }
+        catch (error) {
+            const shape = error instanceof CommandError
+                ? { code: error.code, message: error.message, details: error.details }
+                : { code: "ERROR", message: error instanceof Error ? error.message : String(error) };
+            process.stderr.write(`${renderError(shape, options)}\n`);
+            process.exitCode = 1;
+        }
+    };
+}
+//# sourceMappingURL=with-output.js.map

package/dist/run.d.ts

@@ -0,0 +1,5 @@
+export interface RunOptions {
+    from?: "user" | "node";
+}
+export declare function runBrainCli(argv: string[], options?: RunOptions): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.js

@@ -0,0 +1,19 @@
+/**
+ * Standalone CLI runner for `bin/otto-brain`. Builds a root program named
+ * `otto-brain`, mounts the brain verbs directly on it (so `otto-brain serve`, not
+ * `otto-brain brain serve`), and sets process.exitCode rather than exiting, so
+ * the same code path is testable.
+ */
+import { Command } from "commander";
+import { registerBrainCommands } from "./cli.js";
+import { resolveVersion } from "./version.js";
+export async function runBrainCli(argv, options = {}) {
+    const program = new Command()
+        .name("otto-brain")
+        .description("Otto Brain - host local GGUF models with measured VRAM budgeting")
+        .version(resolveVersion(), "-v, --version", "output the version number");
+    registerBrainCommands(program);
+    await program.parseAsync(argv, { from: options.from ?? "user" });
+    return typeof process.exitCode === "number" ? process.exitCode : 0;
+}
+//# sourceMappingURL=run.js.map

package/dist/runtime/args.d.ts

@@ -0,0 +1,21 @@
+import type { Profile } from "../config/schema.js";
+import type { Runtime } from "../types.js";
+export interface ServeTarget {
+    port: number;
+    host?: string;
+}
+/**
+ * PATH value the child process needs so the stub can resolve its DLLs. Both the
+ * runtime dir and its vendor dir go first, ahead of the inherited PATH.
+ */
+export declare function buildEnv(runtime: Runtime, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * Translate a profile into llama-server arguments.
+ *
+ * Only settings that demonstrably matter for stable local inference are emitted —
+ * no experimental sampler knobs.
+ */
+export declare function buildArgs(profile: Profile, { port, host }: ServeTarget): string[];
+/** The same command as a copy-pasteable shell line, for the TUI to display. */
+export declare function formatCommand(runtime: Runtime, args: string[]): string;
+//# sourceMappingURL=args.d.ts.map

package/dist/runtime/args.js

@@ -0,0 +1,71 @@
+/**
+ * Translates a profile into llama-server arguments and builds the PATH the child
+ * needs. Runtime-source agnostic: works the same for an LM Studio runtime or a
+ * managed one, since both resolve to a `Runtime` (exe + optional vendorDir).
+ */
+import path from "node:path";
+/**
+ * PATH value the child process needs so the stub can resolve its DLLs. Both the
+ * runtime dir and its vendor dir go first, ahead of the inherited PATH.
+ */
+export function buildEnv(runtime, baseEnv = process.env) {
+    const parts = [runtime.dir];
+    if (runtime.vendorDir)
+        parts.push(runtime.vendorDir);
+    return {
+        ...baseEnv,
+        PATH: `${parts.join(path.delimiter)}${path.delimiter}${baseEnv.PATH || ""}`,
+    };
+}
+/**
+ * Translate a profile into llama-server arguments.
+ *
+ * Only settings that demonstrably matter for stable local inference are emitted —
+ * no experimental sampler knobs.
+ */
+export function buildArgs(profile, { port, host = "127.0.0.1" }) {
+    const args = [
+        "-m",
+        profile.modelPath ?? "",
+        "-c",
+        String(profile.contextSize),
+        "-ctk",
+        profile.cacheTypeK,
+        "-ctv",
+        profile.cacheTypeV,
+        "-fa",
+        profile.flashAttention ? "on" : "off",
+        "-ngl",
+        String(profile.gpuLayers),
+        "--host",
+        host,
+        "--port",
+        String(port),
+        "--no-webui",
+    ];
+    if (profile.vision && profile.mmprojPath) {
+        args.push("--mmproj", profile.mmprojPath);
+    }
+    // The setting that was actually breaking long agentic runs.
+    if (profile.reasoningBudget !== null && profile.reasoningBudget !== undefined) {
+        args.push("--reasoning-budget", String(profile.reasoningBudget));
+        if (profile.reasoningBudgetMessage) {
+            args.push("--reasoning-budget-message", profile.reasoningBudgetMessage);
+        }
+    }
+    if (profile.parallelSlots)
+        args.push("--parallel", String(profile.parallelSlots));
+    if (profile.batchSize)
+        args.push("-b", String(profile.batchSize));
+    if (profile.ubatchSize)
+        args.push("-ub", String(profile.ubatchSize));
+    if (profile.extraArgs && profile.extraArgs.length)
+        args.push(...profile.extraArgs);
+    return args;
+}
+/** The same command as a copy-pasteable shell line, for the TUI to display. */
+export function formatCommand(runtime, args) {
+    const quote = (s) => (/\s/.test(s) ? `"${s}"` : s);
+    return `${quote(runtime.exe)} ${args.map(quote).join(" ")}`;
+}
+//# sourceMappingURL=args.js.map

package/dist/runtime/index.d.ts

@@ -0,0 +1,13 @@
+import type { BrainConfig } from "../config/schema.js";
+import type { Runtime } from "../types.js";
+import { type InstallProgress } from "./managed.js";
+export { BACKENDS_DIR, LMSTUDIO_ROOT, listRuntimes as listLmStudioRuntimes } from "./lmstudio.js";
+export { buildArgs, buildEnv, formatCommand, type ServeTarget } from "./args.js";
+export { installManagedRuntime, listManagedRuntimes, defaultRuntimeSpec, DEFAULT_LLAMA_BUILD, type RuntimeSpec, type InstallProgress, } from "./managed.js";
+/** Every runtime available on this machine, managed first then LM Studio. */
+export declare function listAllRuntimes(env?: NodeJS.ProcessEnv): Runtime[];
+/** The runtime to use given config, or null when none is available. */
+export declare function resolveRuntime(config: BrainConfig, env?: NodeJS.ProcessEnv): Runtime | null;
+/** Ensure a runtime exists, downloading the default managed build if none does. */
+export declare function ensureRuntime(config: BrainConfig, env?: NodeJS.ProcessEnv, onProgress?: (progress: InstallProgress) => void): Promise<Runtime>;
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -0,0 +1,41 @@
+/**
+ * Runtime resolution across sources. Two providers implement "where does
+ * llama-server come from": `managed` (downloaded by otto-brain, the self-contained
+ * path) and `lmstudio` (discovered from an existing LM Studio install, a
+ * zero-download fast path). Selection follows config: an explicit path override
+ * wins; otherwise `auto` prefers a managed runtime and falls back to LM Studio.
+ */
+import { resolveBrainPaths } from "../config/paths.js";
+import { listRuntimes as listLmStudioRuntimes, resolveOverride } from "./lmstudio.js";
+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, defaultRuntimeSpec, DEFAULT_LLAMA_BUILD, } from "./managed.js";
+/** Every runtime available on this machine, managed first then LM Studio. */
+export function listAllRuntimes(env = process.env) {
+    const paths = resolveBrainPaths(env);
+    return [...listManagedRuntimes(paths.runtimesDir), ...listLmStudioRuntimes()];
+}
+/** The runtime to use given config, or null when none is available. */
+export function resolveRuntime(config, env = process.env) {
+    const rc = config.runtime;
+    if (rc.path)
+        return resolveOverride(rc.path);
+    const paths = resolveBrainPaths(env);
+    const managed = listManagedRuntimes(paths.runtimesDir);
+    const lmstudio = listLmStudioRuntimes();
+    if (rc.source === "managed")
+        return managed[0] ?? null;
+    if (rc.source === "lmstudio")
+        return lmstudio[0] ?? null;
+    return managed[0] ?? lmstudio[0] ?? null; // auto
+}
+/** Ensure a runtime exists, downloading the default managed build if none does. */
+export async function ensureRuntime(config, env = process.env, onProgress) {
+    const existing = resolveRuntime(config, env);
+    if (existing)
+        return existing;
+    const paths = resolveBrainPaths(env);
+    return installManagedRuntime(defaultRuntimeSpec(), paths.runtimesDir, onProgress);
+}
+//# sourceMappingURL=index.js.map

package/dist/runtime/lmstudio.d.ts

@@ -0,0 +1,10 @@
+import type { Runtime } from "../types.js";
+export declare const LMSTUDIO_ROOT: string;
+export declare const BACKENDS_DIR: string;
+export declare function extractVersion(dirName: string): string;
+/** Compare dotted version strings numerically, descending. */
+export declare function compareVersionsDesc(a: string, b: string): number;
+export declare function listRuntimes(backendsDir?: string): Runtime[];
+/** Resolve an explicit runtime directory or exe override into a Runtime. */
+export declare function resolveOverride(override: string): Runtime;
+//# sourceMappingURL=lmstudio.d.ts.map

package/dist/runtime/lmstudio.js

@@ -0,0 +1,88 @@
+/**
+ * Locates the llama-server binary shipped inside LM Studio.
+ *
+ * Important gotcha: that executable is a ~20KB stub. Launching it without the
+ * matching `backends/vendor/...` directory on PATH fails with
+ * STATUS_DLL_NOT_FOUND (0xC0000135) and prints absolutely nothing, so we always
+ * pair a runtime with its vendor directory. This is one of two runtime sources
+ * (the other being the self-contained `managed` runtime); it stays as a
+ * zero-download fast path when LM Studio is already installed.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const LMSTUDIO_ROOT = path.join(os.homedir(), ".lmstudio");
+export const BACKENDS_DIR = path.join(LMSTUDIO_ROOT, "extensions", "backends");
+// Most preferred first. Each entry maps a runtime prefix to its vendor dir.
+const RUNTIME_PREFERENCE = [
+    {
+        prefix: "llama.cpp-win-x86_64-nvidia-cuda12-",
+        vendor: "win-llama-cuda12-vendor-v2",
+        label: "CUDA 12",
+    },
+    {
+        prefix: "llama.cpp-win-x86_64-nvidia-cuda-",
+        vendor: "win-llama-cuda-vendor-v2",
+        label: "CUDA 11",
+    },
+    { prefix: "llama.cpp-win-x86_64-vulkan-", vendor: "win-llama-vulkan-vendor-v2", label: "Vulkan" },
+    { prefix: "llama.cpp-win-x86_64-avx2-", vendor: null, label: "CPU (AVX2)" },
+];
+// Directory names carry an instruction-set segment before the version
+// (…-cuda12-avx2-2.24.0), so take the trailing dotted number, not the remainder.
+const VERSION_SUFFIX = /(\d+(?:\.\d+)+)$/;
+export function extractVersion(dirName) {
+    const match = dirName.match(VERSION_SUFFIX);
+    return match ? match[1] : "0";
+}
+/** Compare dotted version strings numerically, descending. */
+export function compareVersionsDesc(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+        const diff = (pb[i] || 0) - (pa[i] || 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+export function listRuntimes(backendsDir = BACKENDS_DIR) {
+    if (!fs.existsSync(backendsDir))
+        return [];
+    const entries = fs
+        .readdirSync(backendsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+    const found = [];
+    for (const pref of RUNTIME_PREFERENCE) {
+        const matches = entries
+            .filter((name) => name.startsWith(pref.prefix))
+            .map((name) => ({ name, version: extractVersion(name) }))
+            .filter(({ name }) => fs.existsSync(path.join(backendsDir, name, "llama-server.exe")))
+            .sort((a, b) => compareVersionsDesc(a.version, b.version));
+        for (const match of matches) {
+            const vendorDir = pref.vendor ? path.join(backendsDir, "vendor", pref.vendor) : null;
+            // A runtime whose vendor DLLs are missing cannot launch; skip it.
+            if (vendorDir && !fs.existsSync(vendorDir))
+                continue;
+            found.push({
+                label: pref.label,
+                version: match.version,
+                dir: path.join(backendsDir, match.name),
+                exe: path.join(backendsDir, match.name, "llama-server.exe"),
+                vendorDir,
+                source: "lmstudio",
+            });
+        }
+    }
+    return found;
+}
+/** Resolve an explicit runtime directory or exe override into a Runtime. */
+export function resolveOverride(override) {
+    const exe = override.endsWith(".exe") ? override : path.join(override, "llama-server.exe");
+    if (!fs.existsSync(exe))
+        throw new Error(`llama-server not found at ${exe}`);
+    const dir = path.dirname(exe);
+    return { label: "override", version: "unknown", dir, exe, vendorDir: null, source: "lmstudio" };
+}
+//# sourceMappingURL=lmstudio.js.map

package/dist/runtime/managed.d.ts

@@ -0,0 +1,26 @@
+import type { Runtime } from "../types.js";
+export interface RuntimeSpec {
+    label: string;
+    version: string;
+    /** One or more archive URLs, extracted in order into the same target dir. */
+    assets: string[];
+}
+export interface InstallProgress {
+    phase: "downloading" | "extracting" | "done";
+    asset?: string;
+    receivedBytes?: number;
+    totalBytes?: number;
+}
+/**
+ * The default runtime build. The llama.cpp release tag and CUDA asset names must
+ * be pinned per platform; verify the URLs against the current release before
+ * shipping. Overridable via config (`runtime.path`) or an explicit spec.
+ */
+export declare const DEFAULT_LLAMA_BUILD = "b4600";
+/** Build the default Windows CUDA 12 spec for a given llama.cpp build tag. */
+export declare function defaultRuntimeSpec(build?: string): RuntimeSpec;
+/** A managed runtime is any dir under runtimesDir that contains llama-server.exe. */
+export declare function listManagedRuntimes(runtimesDir: string): Runtime[];
+/** 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>;
+//# sourceMappingURL=managed.d.ts.map

package/dist/runtime/managed.js

@@ -0,0 +1,148 @@
+/**
+ * The self-contained runtime source: otto-brain downloads a pinned llama.cpp
+ * build into `$OTTO_HOME/otto-brain/runtimes/` and runs it directly, so the tool
+ * needs no other software installed. Downloaded runtimes keep their DLLs in the
+ * same directory as the exe (so `vendorDir` is null — buildEnv already puts the
+ * runtime dir on PATH, which is what the DLL-stub trap requires).
+ *
+ * Extraction uses only OS built-ins — PowerShell's Expand-Archive for .zip and
+ * the bundled `tar` for tarballs — to keep the "nothing else to install" promise.
+ */
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+/**
+ * The default runtime build. The llama.cpp release tag and CUDA asset names must
+ * be pinned per platform; verify the URLs against the current release before
+ * shipping. Overridable via config (`runtime.path`) or an explicit spec.
+ */
+export const DEFAULT_LLAMA_BUILD = "b4600";
+const LLAMA_RELEASE_BASE = "https://github.com/ggml-org/llama.cpp/releases/download";
+/** Build the default Windows CUDA 12 spec for a given llama.cpp build tag. */
+export function defaultRuntimeSpec(build = DEFAULT_LLAMA_BUILD) {
+    return {
+        label: "CUDA 12 (managed)",
+        version: build,
+        assets: [
+            `${LLAMA_RELEASE_BASE}/${build}/llama-${build}-bin-win-cuda-12.4-x64.zip`,
+            `${LLAMA_RELEASE_BASE}/${build}/cudart-llama-bin-win-cuda-12.4-x64.zip`,
+        ],
+    };
+}
+function slug(spec) {
+    return `${spec.label}-${spec.version}`
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "");
+}
+/** Recursively find the first file named `name` under `dir`. */
+function findFile(dir, name) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = findFile(full, name);
+            if (nested)
+                return nested;
+        }
+        else if (entry.name.toLowerCase() === name.toLowerCase()) {
+            return full;
+        }
+    }
+    return null;
+}
+/** A managed runtime is any dir under runtimesDir that contains llama-server.exe. */
+export function listManagedRuntimes(runtimesDir) {
+    if (!fs.existsSync(runtimesDir))
+        return [];
+    const found = [];
+    for (const entry of fs.readdirSync(runtimesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const root = path.join(runtimesDir, entry.name);
+        const exe = findFile(root, "llama-server.exe");
+        if (!exe)
+            continue;
+        found.push({
+            label: entry.name,
+            version: entry.name.replace(/^.*-/, ""),
+            dir: path.dirname(exe),
+            exe,
+            vendorDir: null,
+            source: "managed",
+        });
+    }
+    return found;
+}
+async function downloadFile(url, dest, onProgress) {
+    const response = await fetch(url);
+    if (!response.ok || !response.body) {
+        throw new Error(`download failed (${response.status}) for ${url}`);
+    }
+    const totalBytes = Number(response.headers.get("content-length")) || undefined;
+    let receivedBytes = 0;
+    const body = Readable.fromWeb(response.body);
+    body.on("data", (chunk) => {
+        receivedBytes += chunk.length;
+        onProgress?.({ phase: "downloading", asset: url, receivedBytes, totalBytes });
+    });
+    await pipeline(body, createWriteStream(dest));
+}
+function run(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { windowsHide: true });
+        let stderr = "";
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", reject);
+        child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${command} exited ${code}: ${stderr.trim()}`)));
+    });
+}
+async function extractArchive(archivePath, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    if (/\.zip$/i.test(archivePath)) {
+        // PowerShell ships with Windows; -Force overwrites an interrupted extract.
+        // Paths are rooted at $OTTO_HOME (under the user profile), so a username with
+        // an apostrophe would break — or inject into — a raw single-quoted string.
+        // Escape single quotes for PowerShell (a literal ' is written as '').
+        const psQuote = (value) => `'${value.replace(/'/g, "''")}'`;
+        await run("powershell", [
+            "-NoProfile",
+            "-Command",
+            `Expand-Archive -LiteralPath ${psQuote(archivePath)} -DestinationPath ${psQuote(destDir)} -Force`,
+        ]);
+        return;
+    }
+    if (/\.(tar\.gz|tgz|tar)$/i.test(archivePath)) {
+        await run("tar", ["-xf", archivePath, "-C", destDir]);
+        return;
+    }
+    throw new Error(`unknown archive type: ${archivePath}`);
+}
+/** Download + extract a runtime spec into runtimesDir and return the Runtime. */
+export async function installManagedRuntime(spec, runtimesDir, onProgress) {
+    const targetDir = path.join(runtimesDir, slug(spec));
+    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);
+        fs.rmSync(archivePath, { force: true });
+    }
+    const exe = findFile(targetDir, "llama-server.exe");
+    if (!exe)
+        throw new Error(`installed runtime has no llama-server.exe under ${targetDir}`);
+    onProgress?.({ phase: "done" });
+    return {
+        label: spec.label,
+        version: spec.version,
+        dir: path.dirname(exe),
+        exe,
+        vendorDir: null,
+        source: "managed",
+    };
+}
+//# sourceMappingURL=managed.js.map