@otto-code/brain 0.7.5 → 0.8.0

package/dist/service/router.js

@@ -1,8 +1,11 @@
 import http from "node:http";
+import { chunkHasContent, chunkHasReasoning, readActivity, ReasoningTracker } from "./activity.js";
 import { Scheduler } from "./scheduler.js";
+import { slots as sampleSlots } from "../sysmon.js";
 import { makeVramFitPredicate, selectCodingModel } from "./model-selector.js";
 import { query as queryGpu } from "../gpu.js";
 import { rankModels } from "../ops/results.js";
+import { errorBody, errorMessage, HOP_BY_HOP, readJsonBody, sendError, sendJson, } from "./http-util.js";
 /**
  * Fronts the supervised llama-server on a stable port.
  *
@@ -18,16 +21,6 @@ import { rankModels } from "../ops/results.js";
  *     catalog (via the injected `getCatalog`), mark the running one 'loaded',
  *     and give each a friendly name plus the context fields clients size against.
  */
-const HOP_BY_HOP = new Set([
-    "connection",
-    "keep-alive",
-    "proxy-authenticate",
-    "proxy-authorization",
-    "te",
-    "trailer",
-    "transfer-encoding",
-    "upgrade",
-]);
 const MAX_ANALYSIS_BYTES = 2 * 1024 * 1024;
 // Completion bodies are buffered so the scheduler can read `model` and replay
 // them after a possible model switch. Long-context prompts are large but bounded.
@@ -53,19 +46,32 @@ export class Telemetry {
         if (this.records.length > this.keep)
             this.records.shift();
     }
-    /** Advice derived from observed behaviour, not guesswork. */
+    /**
+     * Advice derived from the recent window (`records`), not lifetime `totals`.
+     * A ratio over the lifetime total barely moves once a service has served any
+     * real volume, so a handful of clean responses after a bad patch could never
+     * clear it. The sliding window lets a few good requests visibly clear the
+     * advice, and `reset()` gives a restarted model a clean slate instead of
+     * carrying blame from before the fix was applied.
+     */
     get warning() {
-        const { requests, reasoningOnly, truncated } = this.totals;
-        if (requests < 3)
+        const total = this.records.length;
+        if (total < 3)
             return null;
-        if (reasoningOnly / requests > 0.3) {
-            return `${reasoningOnly}/${requests} responses spent all tokens on reasoning and returned no content - lower the reasoning budget`;
+        const reasoningOnly = this.records.filter((r) => r.verdict === "reasoning-only").length;
+        if (reasoningOnly / total > 0.3) {
+            return `${reasoningOnly}/${total} recent responses spent all tokens on reasoning and returned no content - lower the reasoning budget`;
         }
-        if (truncated / requests > 0.3) {
-            return `${truncated}/${requests} responses hit the token limit - raise the client's max_tokens`;
+        const truncated = this.records.filter((r) => r.verdict === "truncated").length;
+        if (truncated / total > 0.3) {
+            return `${truncated}/${total} recent responses hit the token limit - raise the client's max_tokens`;
         }
         return null;
     }
+    /** Clear the recent window so the warning starts fresh - called when the model (re)starts. */
+    reset() {
+        this.records = [];
+    }
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null;
@@ -82,9 +88,6 @@ function readTokens(usage, key) {
     const value = usage[key];
     return typeof value === "number" ? value : null;
 }
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 /** Classify a completion body (Anthropic or OpenAI shaped). */
 export function analyse(bodyText) {
     let parsed;
@@ -135,19 +138,13 @@ export function analyse(bodyText) {
         verdict = "truncated";
     return { finishReason, contentChars, reasoningChars, outputTokens, toolCalls, verdict };
 }
-function errorBody(status, message) {
-    return JSON.stringify({
-        type: "error",
-        error: { type: status === 503 ? "overloaded_error" : "api_error", message },
-    });
-}
 export function describeModel(model, options = {}) {
     if (!model)
         return null;
     const { state = "not-loaded", profile = null, createdAt = null } = options;
     const md = model.metadata || {};
     const entry = {
-        // Standard OpenAI fields — id is the friendly name, never the file path.
+        // Standard OpenAI fields - id is the friendly name, never the file path.
         id: model.displayName,
         object: "model",
         created: Math.floor((createdAt ? createdAt.getTime() : Date.now()) / 1000),
@@ -241,32 +238,38 @@ function handleModelsRoute(req, res, supervisor, getCatalog) {
     res.end(body);
     return true;
 }
-function sendError(res, status, message) {
-    if (res.headersSent) {
-        if (!res.writableEnded)
-            res.destroy();
-        return;
-    }
-    const body = errorBody(status, message);
-    const headers = {
-        "content-type": "application/json",
-        "content-length": Buffer.byteLength(body),
-    };
-    if (status === 503)
-        headers["retry-after"] = "5";
-    res.writeHead(status, headers);
-    res.end(body);
+/**
+ * Correlates the chunks of one proxied stream for the reasoning tracker. A
+ * counter rather than a uuid: it never leaves the process and only has to be
+ * unique among the handful of streams in flight at once.
+ */
+let streamCounter = 0;
+function nextStreamId() {
+    streamCounter += 1;
+    return `s${streamCounter}`;
 }
+/**
+ * The reasoning tracker is module-scoped rather than per-router because both
+ * proxy paths need it and `proxyBuffered` is a free function. One service
+ * process hosts exactly one router, so there is nothing to collide with; the
+ * bench command builds its own throwaway router and simply never reads it.
+ */
+const reasoningTracker = new ReasoningTracker();
 /**
  * Forward a buffered completion body to the resident llama-server and stream the
  * reply back, teeing non-streaming bodies for classification. Resolves once the
  * client response is fully concluded (it owns the response in every outcome,
  * including upstream errors), so the scheduler can move to the next turn.
  */
-function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, }) {
+function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, reasoning = null, }) {
     return new Promise((resolve) => {
         let settled = false;
+        const streamId = nextStreamId();
         const done = () => {
+            // Always release the reasoning flag, including on the error and abort
+            // paths: a stream that dies mid-thought would otherwise pin the rail on
+            // "thinking" until the service restarts.
+            reasoning?.end(streamId);
             if (!settled) {
                 settled = true;
                 resolve();
@@ -300,9 +303,10 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, }
                 let sawReasoning = false;
                 upstreamRes.on("data", (chunk) => {
                     const text = String(chunk);
-                    if (text.includes('"text_delta"') || /"content"\s*:\s*"[^"]/.test(text))
+                    reasoning?.observe(streamId, text);
+                    if (chunkHasContent(text))
                         sawContent = true;
-                    if (text.includes("thinking") || text.includes("reasoning"))
+                    if (chunkHasReasoning(text))
                         sawReasoning = true;
                 });
                 upstreamRes.on("end", () => {
@@ -400,33 +404,6 @@ export function decideModelGate(params) {
     }
     return { ok: true, model: resolved };
 }
-/** Buffer a bounded JSON request body (for POST /__host/config). */
-function readJsonBody(req, limit, cb) {
-    const chunks = [];
-    let size = 0;
-    let tooBig = false;
-    req.on("data", (chunk) => {
-        size += chunk.length;
-        if (size > limit)
-            tooBig = true;
-        else
-            chunks.push(chunk);
-    });
-    req.on("error", () => cb({ ok: false, error: "request stream error" }));
-    req.on("end", () => {
-        if (tooBig) {
-            cb({ ok: false, error: "request body too large" });
-            return;
-        }
-        try {
-            const text = Buffer.concat(chunks).toString("utf8") || "{}";
-            cb({ ok: true, body: JSON.parse(text) });
-        }
-        catch {
-            cb({ ok: false, error: "invalid JSON body" });
-        }
-    });
-}
 /** Buffer a completion request, resolve its target model, and queue it. */
 function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, scheduler, modelGate, }) {
     const chunks = [];
@@ -463,23 +440,41 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
         }
         const model = gate.model;
         scheduler
-            .submit(model, () => proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body }))
+            .submit(model, () => proxyBuffered({
+            agent,
+            supervisor,
+            telemetry,
+            logger,
+            req,
+            res,
+            body,
+            reasoning: reasoningTracker,
+        }))
             .catch((error) => sendError(res, 502, `could not serve ${model.displayName}: ${errorMessage(error)}`));
     });
 }
 // The bench ranking is read from disk (one JSON per run). A completion request
 // must not pay that IO, and rankings only change when a bench run finishes
 // (rare), so the router caches the ranking and re-reads it at most once per
-// window — the cheap time-based trigger.
+// window - the cheap time-based trigger.
 const RANKING_TTL_MS = 60000;
-export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, }) {
+export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, }) {
     const agent = new http.Agent({ keepAlive: true, maxSockets: 32 });
     const scheduler = loadModel
         ? new Scheduler({ supervisor, loadModel, logger: (m) => logger?.warn?.(m) })
         : null;
+    // A (re)start means whatever produced the current warning no longer applies -
+    // either a different model is now resident, or the same one just picked up an
+    // edited profile (e.g. a lowered reasoning budget). Either way the recent
+    // window is stale, so start it clean rather than let old records blame a
+    // config that is no longer running.
+    supervisor.on("state", ({ state }) => {
+        if (state === "starting")
+            telemetry.reset();
+    });
     // GPU total VRAM is static hardware, so it is queried once at startup and
     // cached. Absent (no nvidia-smi) or not-yet-resolved leaves the fit predicate
-    // undefined, and the selector skips the VRAM filter — mirroring serve.ts.
+    // undefined, and the selector skips the VRAM filter - mirroring serve.ts.
     let fitPredicate;
     void (async () => {
         try {
@@ -552,32 +547,57 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
             resolved: lock ? null : resolveModel(name),
         });
     };
-    const sendJson = (res, payload) => {
-        const body = JSON.stringify(payload, null, 2);
-        res.writeHead(200, {
-            "content-type": "application/json",
-            "content-length": Buffer.byteLength(body),
-        });
-        res.end(body);
-    };
     return function handler(req, res) {
         // Host-management read surface (`/__host/*`): the single API both the TUI and
         // Otto's GUI consume, so the two never drift. Status is live; config and
         // evals are point-in-time reads the daemon proxies to its settings UI.
-        if (req.url === "/__host/status") {
-            sendJson(res, {
+        const path = (req.url || "").split("?")[0];
+        if (path === "/__host/status") {
+            const schedulerStats = scheduler ? scheduler.stats() : null;
+            const base = {
                 version,
                 ...supervisor.status(),
                 telemetry: { ...telemetry.totals, warning: telemetry.warning },
-                scheduler: scheduler ? scheduler.stats() : null,
+                scheduler: schedulerStats,
                 recent: telemetry.records.slice(-10),
-            });
+                logLineCount: supervisor.logLines.length,
+                // Carried inline rather than fetched from /__host/capabilities: the
+                // daemon polls status constantly, and a separately cached copy would go
+                // stale the moment the owner toggles allowRemoteConfig.
+                capabilities: hostApi ? hostApi.capabilities() : null,
+                // The three signals the Brain rail's icon is derived from. All are cheap
+                // enough for the liveness poll: `activity` is one stat of a file that is
+                // usually absent, `reasoning` is in-process state, and `queued` is
+                // already computed above. Slot phases are the one that costs a round
+                // trip, and are fetched below.
+                activity: readActivity(),
+                reasoning: reasoningTracker.active,
+                queued: schedulerStats ? schedulerStats.queued : 0,
+            };
+            // Slots come from a loopback GET on the resident llama-server. That is
+            // cheap enough to pay on every poll - unlike the GPU sampling below, which
+            // spawns `nvidia-smi` and stays opt-in. Skipped entirely unless a model is
+            // resident, since there is nothing listening otherwise.
+            const slotsPromise = supervisor.state === "ready"
+                ? sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
+                : Promise.resolve(null);
+            // Resources cost an `nvidia-smi` spawn, so they are opt-in: the daemon's
+            // liveness probe polls this route far more often than any UI does, and
+            // must not pay for a panel it is not rendering.
+            const wantsResources = /[?&]resources=1(&|$)/.test(req.url || "");
+            if (!wantsResources || !getResources) {
+                void slotsPromise.then((slots) => sendJson(res, { ...base, slots }));
+                return;
+            }
+            Promise.all([slotsPromise, getResources().catch(() => null)])
+                .then(([slots, resources]) => sendJson(res, { ...base, slots, resources }))
+                .catch(() => sendJson(res, { ...base, slots: null, resources: null }));
             return;
         }
         // Config write: apply an editable patch (model/lock live, the rest persisted).
         // Must precede the GET read below, which matches the same URL for any method.
         // Refused unless the owner opted into remote configuration.
-        if (req.method === "POST" && req.url === "/__host/config") {
+        if (req.method === "POST" && path === "/__host/config") {
             if (!applyConfigPatch || !getAllowConfigWrite()) {
                 sendError(res, 403, "remote configuration is disabled on this brain");
                 return;
@@ -593,20 +613,26 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
             });
             return;
         }
-        if (req.url === "/__host/config" && getConfig) {
+        if (path === "/__host/config" && getConfig) {
             sendJson(res, getConfig());
             return;
         }
-        if (req.url === "/__host/evals" && getEvals) {
+        if (path === "/__host/evals" && getEvals) {
             sendJson(res, getEvals());
             return;
         }
+        // The management API: inventory, profiles, budget, load/unload, delete, logs.
+        // It claims only the routes it implements and returns false otherwise, so an
+        // unknown /__host/* path still falls through to the 503/proxy path below
+        // rather than being swallowed here.
+        if (hostApi && hostApi.handle(req, res))
+            return;
         // Answer model discovery ourselves so ids are real names (not paths), the
         // whole catalog is listed, and each carries LM Studio's context fields.
         if (handleModelsRoute(req, res, supervisor, getCatalog))
             return;
         // With a scheduler wired in, completion requests are queued and served in
-        // turns — including loading/switching to the model they ask for — instead
+        // turns - including loading/switching to the model they ask for - instead
         // of failing when it is not the resident one.
         if (scheduler && COMPLETION_RE.test(req.url || "")) {
             scheduleCompletion({
@@ -663,14 +689,22 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
                 let sawContent = false;
                 let sawReasoning = false;
                 if (isCompletion) {
+                    const streamId = nextStreamId();
+                    // Released on close, not just on end: an aborted stream would
+                    // otherwise pin `/__host/status` on "thinking" forever.
+                    const releaseReasoning = () => reasoningTracker.end(streamId);
                     upstreamRes.on("data", (chunk) => {
                         const text = String(chunk);
-                        if (text.includes('"text_delta"') || /"content"\s*:\s*"[^"]/.test(text))
+                        reasoningTracker.observe(streamId, text);
+                        if (chunkHasContent(text))
                             sawContent = true;
-                        if (text.includes("thinking") || text.includes("reasoning"))
+                        if (chunkHasReasoning(text))
                             sawReasoning = true;
                     });
+                    upstreamRes.on("close", releaseReasoning);
+                    upstreamRes.on("error", releaseReasoning);
                     upstreamRes.on("end", () => {
+                        releaseReasoning();
                         telemetry.record({
                             at: new Date().toISOString(),
                             path: req.url,

package/dist/service/scheduler.d.ts

@@ -6,11 +6,11 @@
  *
  *  - Requests for the resident model run concurrently, up to that model's
  *    `parallelSlots` (the same number of sequence slots llama-server was
- *    launched with — sending more would only queue inside llama-server). Extra
+ *    launched with - sending more would only queue inside llama-server). Extra
  *    same-model requests wait for a free slot; they never trigger a load.
  *  - Requests for a *different* model wait for a model switch. When the resident
  *    model's current batch drains, the scheduler switches and serves the other
- *    model's batch — so two clients wanting different models share the GPU by
+ *    model's batch - so two clients wanting different models share the GPU by
  *    taking turns.
  *
  * Fairness: after a model finishes a turn, the next turn prefers a *different*

package/dist/service/scheduler.js

@@ -54,7 +54,7 @@ export class Scheduler {
                         await this.loadModel(pick.model);
                     }
                     catch (error) {
-                        // The model would not load — fail exactly its queued jobs and move on.
+                        // The model would not load - fail exactly its queued jobs and move on.
                         for (const job of __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, (j) => j.modelId === turnId))
                             job.reject(error);
                         continue;

package/dist/service/serve.d.ts

@@ -2,7 +2,7 @@
  * The headless brain service: the router + supervisor bound to a port, with the
  * VRAM fit, on-demand model switching, remote auth, built-in TLS, and pid-file
  * lifecycle. Used both by `otto brain serve` (foreground) and by a detached
- * `otto brain start`. It stays provider-neutral about the runtime source — it
+ * `otto brain start`. It stays provider-neutral about the runtime source - it
  * takes whatever resolveRuntime picks (managed or LM Studio).
  *
  * TLS is served in-process (config.tls): HTTPS with a files / self-signed /
@@ -19,6 +19,13 @@ import { Supervisor } from "./supervisor.js";
  * what the relay accepted), or the brain's own `x-otto-brain-token`.
  */
 export declare function extractToken(req: http.IncomingMessage): string | null;
+/**
+ * The one derivation of the effective auth token. `mode: "token"` with a null or
+ * empty token is NO auth - the bind guard and withAuth both read this, so they
+ * cannot disagree (a mode-only guard once let mode=token + token=null bind
+ * non-loopback and then serve every route ungated).
+ */
+export declare function effectiveAuthToken(config: BrainConfig): string | null;
 export interface StartServiceOptions {
     config: BrainConfig;
     modelNeedle?: string;

package/dist/service/serve.js

@@ -2,7 +2,7 @@
  * The headless brain service: the router + supervisor bound to a port, with the
  * VRAM fit, on-demand model switching, remote auth, built-in TLS, and pid-file
  * lifecycle. Used both by `otto brain serve` (foreground) and by a detached
- * `otto brain start`. It stays provider-neutral about the runtime source — it
+ * `otto brain start`. It stays provider-neutral about the runtime source - it
  * takes whatever resolveRuntime picks (managed or LM Studio).
  *
  * TLS is served in-process (config.tls): HTTPS with a files / self-signed /
@@ -14,12 +14,14 @@ import https from "node:https";
 import { getCalibration, forModel, loadPersistedConfig, loadProfilesStore, saveBrainConfig, saveProfilesStore, } from "../config/index.js";
 import { resolveBrainPaths } from "../config/paths.js";
 import { query as queryGpu } from "../gpu.js";
-import { pickModel, scanModels } from "../models/index.js";
+import { managedModelsDir, pickAutoModel, pickModel, scanModels } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { resolveRuntime } from "../runtime/index.js";
 import * as vram from "../vram.js";
 import { resolveVersion } from "../version.js";
 import * as results from "../ops/results.js";
+import { createCpuSampler, sample as sampleSystem } from "../sysmon.js";
+import { createHostApi } from "./host-api.js";
 import { createRouter, Telemetry } from "./router.js";
 import { Supervisor } from "./supervisor.js";
 import * as tailscale from "./tailscale.js";
@@ -30,7 +32,7 @@ function redactConfig(config) {
     return {
         ...config,
         auth: { ...config.auth, token: config.auth.token ? "********" : null },
-        // The Hugging Face token is the owner's account credential — never echo it to
+        // The Hugging Face token is the owner's account credential - never echo it to
         // a caller of /__host/config (read is allowed by default on a shared brain).
         ...(config.hfToken ? { hfToken: "********" } : {}),
     };
@@ -68,9 +70,17 @@ export function extractToken(req) {
     const header = req.headers["x-otto-brain-token"];
     return typeof header === "string" ? header : null;
 }
+/**
+ * The one derivation of the effective auth token. `mode: "token"` with a null or
+ * empty token is NO auth - the bind guard and withAuth both read this, so they
+ * cannot disagree (a mode-only guard once let mode=token + token=null bind
+ * non-loopback and then serve every route ungated).
+ */
+export function effectiveAuthToken(config) {
+    return config.auth.mode === "token" && config.auth.token ? config.auth.token : null;
+}
 /** Gate the router with a bearer token when configured; /health stays open. */
-function withAuth(inner, config) {
-    const token = config.auth.mode === "token" ? config.auth.token : null;
+function withAuth(inner, token) {
     if (!token)
         return inner;
     return (req, res) => {
@@ -102,22 +112,33 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         : config.listen.host;
     const displayHost = tlsOptions?.hostname ?? bindHost;
     // Auth is orthogonal to transport: TLS encrypts the pipe, a token authorizes the
-    // caller. A non-loopback bind still needs a token even over HTTPS.
+    // caller. A non-loopback bind still needs an actual token even over HTTPS -
+    // gate on the token itself, not auth.mode, or mode=token with no token binds open.
+    const authToken = effectiveAuthToken(config);
     if (!isLoopback(bindHost) &&
-        config.auth.mode !== "token" &&
+        !authToken &&
         !config.allowInsecureBind &&
         env.OTTO_BRAIN_ALLOW_INSECURE !== "1") {
         throw new CommandError({
             code: "INSECURE_BIND",
             message: `refusing to bind ${bindHost} without auth`,
-            details: "set auth.mode=token, or allowInsecureBind=true for an open trusted-network share " +
-                "(or OTTO_BRAIN_ALLOW_INSECURE=1 to override)",
+            details: "set auth.mode=token with a non-empty auth.token, or allowInsecureBind=true for an " +
+                "open trusted-network share (or OTTO_BRAIN_ALLOW_INSECURE=1 to override)",
         });
     }
-    const store = loadProfilesStore();
-    const catalog = scanModels(config, env);
+    // `allowRemoteConfig` exists to gate NETWORK control (see its schema comment:
+    // "a brain is not remotely controllable until its owner opts in") - it is not
+    // meant to lock out the only caller that can ever reach a loopback-bound
+    // brain, which is the local daemon that spawned it. When nothing off-machine
+    // could possibly be a caller, config writes are always allowed; the flag only
+    // starts to matter once the bind is actually reachable from elsewhere.
+    const allowWrite = () => isLoopback(bindHost) || config.allowRemoteConfig;
+    const store = loadProfilesStore(paths);
+    // Not const: deleting a model through the management API re-scans and replaces
+    // this, and every reader goes through a getter so nobody holds a stale array.
+    let catalog = scanModels(config, env);
     const needle = modelNeedle ?? config.defaultModel ?? store.lastModelId ?? undefined;
-    const model = pickModel(catalog, needle);
+    const model = needle ? pickModel(catalog, needle) : pickAutoModel(catalog);
     let profile = forModel(store, model, config.defaults);
     const gpu = await queryGpu();
     if (gpu) {
@@ -165,7 +186,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         }
         await supervisor.start(target, fitProfile);
         store.lastModelId = target.id;
-        saveProfilesStore(store);
+        saveProfilesStore(store, paths);
     };
     const loadModel = (target) => {
         const run = modelSwitchChain.then(() => loadModelUnsafe(target));
@@ -208,6 +229,36 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         }
         return redactConfig(config);
     };
+    // One CPU sampler for the lifetime of the service: it reports a busy fraction
+    // between successive calls, so a fresh one per request would always return null.
+    const cpuSampler = createCpuSampler();
+    const hostApi = createHostApi({
+        supervisor,
+        getCatalog: () => catalog,
+        rescan: () => {
+            catalog = scanModels(config, env);
+            return catalog;
+        },
+        getProfilesStore: () => store,
+        saveProfiles: (next) => saveProfilesStore(next, paths),
+        getProfileDefaults: () => config.defaults,
+        queryGpuInfo: queryGpu,
+        getRanking: () => {
+            try {
+                return results.rankModels(results.loadAll());
+            }
+            catch {
+                return [];
+            }
+        },
+        loadModel,
+        // The same gate as POST /__host/config. Deleting someone's model files over
+        // the network is strictly more dangerous than changing their default model,
+        // so it does not get a weaker one.
+        getAllowWrite: allowWrite,
+        getModelsDir: () => managedModelsDir(config, env),
+        sampleResources: () => sampleSystem(cpuSampler, { host: supervisor.host, port: supervisor.internalPort }),
+    });
     const handler = withAuth(createRouter({
         supervisor,
         telemetry,
@@ -220,8 +271,10 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         getLockModel: () => config.lockModel,
         getDefaultModel: () => config.defaultModel,
         applyConfigPatch,
-        getAllowConfigWrite: () => config.allowRemoteConfig,
-    }), config);
+        getAllowConfigWrite: allowWrite,
+        hostApi,
+        getResources: () => sampleSystem(cpuSampler, { host: supervisor.host, port: supervisor.internalPort }),
+    }), authToken);
     // TLS terminates in-process when configured; otherwise plain HTTP. The cert
     // manager issues/generates the first keypair before we listen, and hot-swaps
     // the secure context on renewal without dropping connections.
@@ -249,7 +302,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     certManager?.start();
     await supervisor.start(model, profile);
     store.lastModelId = model.id;
-    saveProfilesStore(store);
+    saveProfilesStore(store, paths);
     writePidFile({
         pid: process.pid,
         host: bindHost,

package/dist/service/supervisor.d.ts

@@ -55,6 +55,12 @@ export declare class Supervisor extends EventEmitter {
     vramAtReadyBytes: number | null;
     vramBaselineBytes: number | null;
     command: string | null;
+    /**
+     * The argv of the running child, beside the formatted `command`. Kept as the
+     * array as well because a benchmark stores it (`ops/results.ts`) and a quoted
+     * shell line is for reading, not for re-parsing.
+     */
+    args: string[] | null;
     constructor({ runtime, internalPort, host, readyTimeoutMs, }: SupervisorOptions);
     get upstreamBase(): string;
     /** Start (or restart) the server for a model + profile. */

package/dist/service/supervisor.js

@@ -46,6 +46,7 @@ export class Supervisor extends EventEmitter {
         this.vramAtReadyBytes = null;
         this.vramBaselineBytes = null;
         this.command = null;
+        this.args = null;
     }
     get upstreamBase() {
         return `http://${this.host}:${this.internalPort}`;
@@ -60,6 +61,7 @@ export class Supervisor extends EventEmitter {
         this.vramBaselineBytes = await usedBytes();
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "starting");
         const args = buildArgs({ ...profile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port: this.internalPort, host: this.host });
+        this.args = args;
         this.command = formatCommand(this.runtime, args);
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, `launching: ${this.command}`);
         const started = Date.now();

package/dist/service/tailscale.js

@@ -1,5 +1,5 @@
 /**
- * A thin promisified wrapper over the `tailscale` CLI — the OS boundary for the
+ * A thin promisified wrapper over the `tailscale` CLI - the OS boundary for the
  * `tailscale` TLS mode and the `listen.host: "tailscale"` bind. All Tailscale
  * interaction goes through here. Ported from otto-brain-relay's `tailscale.js`.
  *

package/dist/service/tls.d.ts

@@ -4,11 +4,11 @@
  * generalized from otto-brain-relay's `cert.js`.
  *
  * Modes (resolved from `config.tls`):
- *  - `files`       — read the cert/key paths you provide; no renewal.
- *  - `self-signed` — generate a local keypair on first run, cached under
+ *  - `files`       - read the cert/key paths you provide; no renewal.
+ *  - `self-signed` - generate a local keypair on first run, cached under
  *                    `certDir`; regenerated when it nears expiry. Clients must
  *                    trust it (or pass `-k`); there is no chain of trust.
- *  - `tailscale`   — issue/renew a real Let's Encrypt cert for this machine's
+ *  - `tailscale`   - issue/renew a real Let's Encrypt cert for this machine's
  *                    MagicDNS name via `tailscaled`, so tailnet clients see no
  *                    warnings. Renewal is hot: `renewed` fires with the new
  *                    { cert, key } and the server swaps its secure context
@@ -34,7 +34,7 @@ export interface TlsLogger {
     info?(message: string): void;
     warn?(message: string): void;
 }
-/** Concrete, fully-resolved options — no nulls, no auto-detection left to do. */
+/** Concrete, fully-resolved options - no nulls, no auto-detection left to do. */
 export interface CertManagerOptions {
     mode: "files" | "self-signed" | "tailscale";
     certFile: string;