@otto-code/brain 0.7.5

package/dist/commands/search.js

@@ -0,0 +1,135 @@
+import { loadBrainConfig } from "../config/index.js";
+import { downloadRepoFiles, listRepoQuants, managedModelsDir, repoOfModel, resolveHfToken, scanModels, searchModels, } from "../models/index.js";
+import { formatBytes } from "../models/scan.js";
+import { CommandError } from "../output/types.js";
+/** What is already on disk, so search + quant listings can mark installed rows. */
+function installedIndex(config) {
+    const repos = new Set();
+    const quants = new Set();
+    for (const model of scanModels(config)) {
+        const repo = repoOfModel(model);
+        if (!repo)
+            continue;
+        repos.add(repo.toLowerCase());
+        if (model.quant)
+            quants.add(`${repo.toLowerCase()} ${model.quant.toUpperCase()}`);
+    }
+    return { repos, quants };
+}
+const searchSchema = {
+    idField: "repo",
+    columns: [
+        { header: "REPO", field: "repo", width: 48 },
+        { header: "DOWNLOADS", field: "downloads", width: 11, align: "right" },
+        { header: "LIKES", field: "likes", width: 6, align: "right" },
+        { header: "GATED", field: "gated", width: 6 },
+        { header: "HAVE", field: (r) => (r.installed ? "yes" : ""), width: 5 },
+    ],
+};
+export function addSearchOptions(cmd) {
+    return cmd
+        .description("Search Hugging Face for GGUF models")
+        .argument("<query>", "search text")
+        .option("--limit <n>", "maximum results", "25");
+}
+export async function runSearchCommand(query, options, _command) {
+    const config = loadBrainConfig();
+    const token = resolveHfToken(config);
+    const limit = Math.max(1, Math.min(100, Number(options.limit) || 25));
+    const results = await searchModels(query, { limit, token });
+    const { repos } = installedIndex(config);
+    return {
+        type: "list",
+        data: results.map((r) => ({
+            repo: r.repo,
+            downloads: r.downloads,
+            likes: r.likes,
+            gated: r.gated ? "yes" : "",
+            installed: repos.has(r.repo.toLowerCase()),
+        })),
+        schema: searchSchema,
+    };
+}
+const addSchema = {
+    idField: "repo",
+    columns: [
+        { header: "REPO", field: "repo", width: 40 },
+        { header: "QUANT", field: "quant", width: 12 },
+        { header: "PATH", field: "path", width: 40 },
+        { header: "SIZE", field: "size", width: 10, align: "right" },
+    ],
+};
+const addQuantSchema = {
+    idField: "quant",
+    columns: [
+        { header: "QUANT", field: "quant", width: 12 },
+        { header: "SIZE", field: "size", width: 10, align: "right" },
+        { header: "FILES", field: "files", width: 6, align: "right" },
+        { header: "HAVE", field: (r) => (r.installed ? "yes" : ""), width: 5 },
+    ],
+};
+export function addAddOptions(cmd) {
+    return cmd
+        .description("Download a model from an arbitrary Hugging Face repo")
+        .argument("<repo>", "owner/repo on Hugging Face")
+        .option("--quant <label>", "quantization to download (e.g. Q5_K_M)")
+        .option("--list-quants", "list the quantizations the repo offers and exit");
+}
+export async function runAddCommand(repo, options, _command) {
+    const config = loadBrainConfig();
+    const token = resolveHfToken(config);
+    const { quants, mmproj } = await listRepoQuants(repo, token);
+    if (options.listQuants || !options.quant) {
+        const { quants: installedQuants } = installedIndex(config);
+        const listing = {
+            type: "list",
+            data: quants.map((q) => ({
+                quant: q.quant,
+                size: formatBytes(q.sizeBytes),
+                sizeBytes: q.sizeBytes,
+                files: q.files.length,
+                installed: installedQuants.has(`${repo.toLowerCase()} ${q.quant.toUpperCase()}`),
+            })),
+            schema: addQuantSchema,
+        };
+        // withOutput infers one row type; the renderer is schema-driven, so a
+        // differently-shaped result renders correctly at runtime.
+        return listing;
+    }
+    const wanted = options.quant.toLowerCase();
+    const choice = quants.find((q) => q.quant.toLowerCase() === wanted);
+    if (!choice) {
+        throw new CommandError({
+            code: "NO_QUANT",
+            message: `${repo} has no ${options.quant} - available: ${quants.map((q) => q.quant).join(", ") || "none"}`,
+        });
+    }
+    const files = [...choice.files, ...(mmproj ? mmproj.files : [])];
+    const total = choice.sizeBytes + (mmproj?.sizeBytes ?? 0);
+    let lastPct = -1;
+    const written = await downloadRepoFiles({
+        repo,
+        files,
+        destRoot: managedModelsDir(config),
+        token,
+        onProgress: (p) => {
+            const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
+            if (pct !== lastPct && pct % 5 === 0) {
+                lastPct = pct;
+                process.stderr.write(`  ${repo} ${choice.quant}: ${pct}%\r`);
+            }
+        },
+    });
+    process.stderr.write("\n");
+    return {
+        type: "single",
+        data: {
+            repo,
+            quant: choice.quant,
+            path: written[0] ?? "(already present)",
+            size: formatBytes(total),
+        },
+        schema: addSchema,
+    };
+}
+//# sourceMappingURL=search.js.map

package/dist/commands/share.d.ts

@@ -0,0 +1,26 @@
+import type { Command } from "commander";
+import type { AnyCommandResult } from "../output/index.js";
+interface ShareStatus {
+    shared: boolean;
+    bind: string;
+    access: "open" | "key" | "none";
+    hasKey: boolean;
+    /** The access key, only when it was just generated (so it is shown once). */
+    key: string | null;
+    https: string;
+    allowRemoteConfig: boolean;
+}
+export interface ShareOptions {
+    on?: boolean;
+    off?: boolean;
+    bind?: string;
+    access?: string;
+    key?: string;
+    generate?: boolean;
+    allowConfig?: boolean;
+    https?: string;
+}
+export declare function addShareOptions(cmd: Command): Command;
+export declare function runShareCommand(options: ShareOptions, _command: Command): Promise<AnyCommandResult<ShareStatus>>;
+export {};
+//# sourceMappingURL=share.d.ts.map

package/dist/commands/share.js

@@ -0,0 +1,148 @@
+/**
+ * `otto brain share` — opt a brain into being reachable (and optionally
+ * configurable) by other Otto hosts. Off by default: a brain binds loopback and
+ * is invisible to the network until its owner runs this. Sets the bind, the
+ * access level (open on a trusted network, or a bearer key), HTTPS, and whether
+ * key holders may reconfigure it. Writes $OTTO_HOME/otto-brain/config.json — the
+ * same fields the Otto app's Sharing UI sets, so the two stay in sync.
+ */
+import { randomBytes } from "node:crypto";
+import { loadPersistedConfig, saveBrainConfig } from "../config/index.js";
+import { CommandError } from "../output/types.js";
+import * as tailscale from "../service/tailscale.js";
+function isLoopback(host) {
+    return host === "127.0.0.1" || host === "::1" || host === "localhost" || host === "";
+}
+function toStatus(config, generatedKey) {
+    const shared = !isLoopback(config.listen.host);
+    const access = config.auth.mode === "token" ? "key" : shared ? "open" : "none";
+    return {
+        shared,
+        bind: config.listen.host,
+        access,
+        hasKey: Boolean(config.auth.token),
+        key: generatedKey,
+        https: config.tls.mode,
+        allowRemoteConfig: config.allowRemoteConfig,
+    };
+}
+const shareSchema = {
+    idField: () => "share",
+    columns: [{ header: "SHARE", field: () => "share" }],
+    renderHuman: (data) => {
+        const d = Array.isArray(data) ? data[0] : data;
+        if (!d)
+            return "";
+        const lines = [
+            `Sharing:       ${d.shared ? "on" : "off (loopback only)"}`,
+            `Bind:          ${d.bind}`,
+            `Access:        ${d.access}${d.access === "key" && !d.hasKey ? " (no key set!)" : ""}`,
+            `HTTPS:         ${d.https}`,
+            `Remote config: ${d.allowRemoteConfig ? "allowed" : "disabled"}`,
+        ];
+        if (d.key) {
+            lines.push("", "Access key (copy this to the connecting host):", `  ${d.key}`);
+        }
+        return lines.join("\n");
+    },
+    serialize: (d) => d,
+};
+export function addShareOptions(cmd) {
+    return cmd
+        .description("Share this brain with other Otto hosts (off by default)")
+        .option("--on", "turn sharing on")
+        .option("--off", "turn sharing off (bind loopback only)")
+        .option("--bind <where>", "network to bind: tailscale, all, or an explicit IP/host")
+        .option("--access <mode>", "open (trusted network) or key (bearer token)")
+        .option("--key <token>", "use this access key")
+        .option("--generate", "generate a fresh access key")
+        .option("--allow-config", "let key holders change model/lock over the network")
+        .option("--no-allow-config", "forbid remote configuration")
+        .option("--https <mode>", "off, self-signed, or tailscale");
+}
+function resolveBind(bind) {
+    if (bind === "all")
+        return "0.0.0.0";
+    if (bind === "tailscale")
+        return "tailscale";
+    return bind;
+}
+function validateAccess(access) {
+    if (access !== "open" && access !== "key") {
+        throw new CommandError({ code: "BAD_ACCESS", message: `--access must be "open" or "key"` });
+    }
+    return access;
+}
+export async function runShareCommand(options, _command) {
+    const config = loadPersistedConfig();
+    const anyChange = options.on ||
+        options.off ||
+        options.bind !== undefined ||
+        options.access !== undefined ||
+        options.key !== undefined ||
+        options.generate ||
+        options.allowConfig !== undefined ||
+        options.https !== undefined;
+    if (!anyChange) {
+        return { type: "single", data: toStatus(config, null), schema: shareSchema };
+    }
+    if (options.off) {
+        config.listen.host = "127.0.0.1";
+        config.auth.mode = "none";
+        config.allowInsecureBind = false;
+        config.allowRemoteConfig = false;
+        saveBrainConfig(config);
+        return { type: "single", data: toStatus(config, null), schema: shareSchema };
+    }
+    // Bind: explicit wins; otherwise turning on a loopback brain defaults to the
+    // tailnet when Tailscale is present (private + encrypted), else all interfaces.
+    if (options.bind !== undefined) {
+        config.listen.host = resolveBind(options.bind);
+    }
+    else if (options.on && isLoopback(config.listen.host)) {
+        config.listen.host = (await tailscale.isAvailable()) ? "tailscale" : "0.0.0.0";
+    }
+    // Access: key by default when turning on (secure by default). "open" allows an
+    // unauthenticated non-loopback bind for a trusted network.
+    const access = options.access
+        ? validateAccess(options.access)
+        : options.key !== undefined || options.generate
+            ? "key"
+            : options.on
+                ? "key"
+                : config.auth.mode === "token"
+                    ? "key"
+                    : "open";
+    let generatedKey = null;
+    if (access === "open") {
+        config.auth.mode = "none";
+        config.allowInsecureBind = true;
+    }
+    else {
+        config.auth.mode = "token";
+        config.allowInsecureBind = false;
+        if (options.key !== undefined) {
+            config.auth.token = options.key;
+        }
+        else if (options.generate || !config.auth.token) {
+            generatedKey = randomBytes(24).toString("base64url");
+            config.auth.token = generatedKey;
+        }
+    }
+    if (options.https !== undefined) {
+        const mode = options.https;
+        if (mode !== "off" && mode !== "self-signed" && mode !== "tailscale" && mode !== "files") {
+            throw new CommandError({
+                code: "BAD_HTTPS",
+                message: `--https must be off, self-signed, tailscale, or files`,
+            });
+        }
+        config.tls.mode = mode;
+    }
+    if (options.allowConfig !== undefined) {
+        config.allowRemoteConfig = options.allowConfig;
+    }
+    saveBrainConfig(config);
+    return { type: "single", data: toStatus(config, generatedKey), schema: shareSchema };
+}
+//# sourceMappingURL=share.js.map

package/dist/commands/sweep.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `otto brain sweep` — find the reasoning budget that yields the best output, and
+ * save it to the model's profile. Guards against the thinking-model failure where
+ * an unrestricted budget returns pure reasoning and no content.
+ */
+import type { Command } from "commander";
+import type { AnyCommandResult } from "../output/index.js";
+export interface SweepRow {
+    budget: number | string;
+    content: string;
+    files: string;
+    tokensPerSec: string;
+    seconds: string;
+    best: string;
+}
+export declare function addSweepOptions(cmd: Command): Command;
+export declare function runSweepCommand(options: {
+    model?: string;
+    budgets?: string;
+}, _command: Command): Promise<AnyCommandResult<SweepRow>>;
+//# sourceMappingURL=sweep.d.ts.map

package/dist/commands/sweep.js

@@ -0,0 +1,69 @@
+import { forModel, loadBrainConfig, loadProfilesStore, put, saveProfilesStore, } from "../config/index.js";
+import { pickModel, scanModels } from "../models/index.js";
+import { CommandError } from "../output/types.js";
+import { sweep } from "../ops/sweep.js";
+import { resolveRuntime } from "../runtime/index.js";
+const sweepSchema = {
+    idField: "budget",
+    columns: [
+        { header: "BUDGET", field: "budget", width: 8, align: "right" },
+        { header: "CONTENT", field: "content", width: 9, align: "right" },
+        { header: "FILES", field: "files", width: 6, align: "right" },
+        { header: "TOK/S", field: "tokensPerSec", width: 7, align: "right" },
+        { header: "TIME", field: "seconds", width: 6, align: "right" },
+        { header: "", field: "best", width: 8, color: () => "green" },
+    ],
+};
+export function addSweepOptions(cmd) {
+    return cmd
+        .description("Find and save the best reasoning budget")
+        .option("--model <fragment>", "model name fragment or catalog id")
+        .option("--budgets <a,b,c>", "reasoning budgets to sweep");
+}
+export async function runSweepCommand(options, _command) {
+    const config = loadBrainConfig();
+    const runtime = resolveRuntime(config);
+    if (!runtime) {
+        throw new CommandError({
+            code: "NO_RUNTIME",
+            message: "no llama.cpp runtime available",
+            details: "run `otto brain runtime install`",
+        });
+    }
+    const store = loadProfilesStore();
+    const catalog = scanModels(config);
+    const model = pickModel(catalog, options.model ?? store.lastModelId ?? undefined);
+    const profile = forModel(store, model, config.defaults);
+    const budgets = options.budgets
+        ? options.budgets.split(",").map((s) => Number(s.trim()))
+        : undefined;
+    const report = await sweep({
+        runtime,
+        model,
+        profile,
+        budgets,
+        onProgress: (p) => {
+            if (p.phase === "loading")
+                process.stderr.write(`  budget ${String(p.budget).padStart(5)}: loading…\n`);
+            if (p.phase === "done")
+                process.stderr.write(`  budget ${String(p.budget).padStart(5)}: done\n`);
+            if (p.phase === "failed")
+                process.stderr.write(`  budget ${String(p.budget).padStart(5)}: failed ${p.error}\n`);
+        },
+    });
+    if (report.recommended !== null && report.recommended !== undefined) {
+        profile.reasoningBudget = report.recommended;
+        put(store, model, profile);
+        saveProfilesStore(store);
+    }
+    const rows = report.results.map((r) => ({
+        budget: r.budget,
+        content: r.error ? "error" : `${(r.contentChars / 1024).toFixed(1)}KB`,
+        files: r.error ? "-" : `${r.filesDelivered}/4`,
+        tokensPerSec: (r.tokensPerSecond ?? 0).toFixed(1),
+        seconds: `${(r.elapsedSeconds ?? 0).toFixed(0)}s`,
+        best: r.budget === report.recommended ? "<- best" : "",
+    }));
+    return { type: "list", data: rows, schema: sweepSchema };
+}
+//# sourceMappingURL=sweep.js.map

package/dist/commands/ui.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `otto brain ui` (and the bare `otto brain`) — the full-screen interactive TUI,
+ * the tool's signature experience. Gated on a TTY; falls back with guidance when
+ * piped. Bypasses the output layer since it owns the whole screen.
+ */
+import type { Command } from "commander";
+export declare function addUiOptions(cmd: Command): Command;
+export declare function runUiCommand(_options: unknown, _command: Command): Promise<void>;
+//# sourceMappingURL=ui.d.ts.map

package/dist/commands/ui.js

@@ -0,0 +1,28 @@
+import { loadBrainConfig } from "../config/index.js";
+import { CommandError } from "../output/types.js";
+import { resolveRuntime } from "../runtime/index.js";
+export function addUiOptions(cmd) {
+    return cmd.description("Launch the interactive full-screen UI");
+}
+export async function runUiCommand(_options, _command) {
+    if (!process.stdout.isTTY) {
+        throw new CommandError({
+            code: "NO_TTY",
+            message: "the interactive UI needs a TTY",
+            details: "use `scan`, `serve`, `calibrate`, or `sweep` instead",
+        });
+    }
+    const config = loadBrainConfig();
+    const runtime = resolveRuntime(config);
+    if (!runtime) {
+        throw new CommandError({
+            code: "NO_RUNTIME",
+            message: "no llama.cpp runtime available",
+            details: "run `otto brain runtime install`",
+        });
+    }
+    const { App } = await import("../tui/app.js");
+    const app = new App({ runtime, listenPort: config.listen.port, listenHost: config.listen.host });
+    await app.run();
+}
+//# sourceMappingURL=ui.js.map

package/dist/config/env.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Env-var overrides layered over persisted config, matching Otto's precedence
+ * (CLI → env → file → default). The brain keeps its own `OTTO_BRAIN_*` namespace
+ * (like `OTTO_RELAY_*`), plus it honors `OTTO_HOME` via the path resolver.
+ * Overrides are applied in memory only; they are never written back to the file.
+ */
+import type { BrainConfig } from "./schema.js";
+export declare function parseBooleanEnv(value: string | undefined): boolean | undefined;
+export declare function applyEnvOverrides(config: BrainConfig, env: NodeJS.ProcessEnv): BrainConfig;
+//# sourceMappingURL=env.d.ts.map

package/dist/config/env.js

@@ -0,0 +1,48 @@
+const TRUE = new Set(["1", "true", "yes", "on"]);
+const FALSE = new Set(["0", "false", "no", "off"]);
+export function parseBooleanEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const v = value.trim().toLowerCase();
+    if (TRUE.has(v))
+        return true;
+    if (FALSE.has(v))
+        return false;
+    return undefined;
+}
+export function applyEnvOverrides(config, env) {
+    const next = {
+        ...config,
+        listen: { ...config.listen },
+        auth: { ...config.auth },
+        tls: { ...config.tls },
+        runtime: { ...config.runtime },
+        defaults: { ...config.defaults },
+    };
+    const enabled = parseBooleanEnv(env.OTTO_BRAIN_ENABLED);
+    if (enabled !== undefined)
+        next.enabled = enabled;
+    const autoStart = parseBooleanEnv(env.OTTO_BRAIN_AUTOSTART);
+    if (autoStart !== undefined)
+        next.autoStart = autoStart;
+    if (env.OTTO_BRAIN_LISTEN)
+        next.listen.host = env.OTTO_BRAIN_LISTEN;
+    if (env.OTTO_BRAIN_PORT) {
+        const port = Number(env.OTTO_BRAIN_PORT);
+        if (Number.isFinite(port))
+            next.listen.port = port;
+    }
+    if (env.OTTO_BRAIN_TOKEN) {
+        next.auth = { mode: "token", token: env.OTTO_BRAIN_TOKEN };
+    }
+    // Back-compat: the old runtime override env var points at a runtime directory.
+    if (env.OTTO_BRAIN_LLAMA_SERVER) {
+        next.runtime = { ...next.runtime, path: env.OTTO_BRAIN_LLAMA_SERVER };
+    }
+    if (env.OTTO_BRAIN_MODELS_DIR)
+        next.modelsDir = env.OTTO_BRAIN_MODELS_DIR;
+    if (env.OTTO_BRAIN_MODEL)
+        next.defaultModel = env.OTTO_BRAIN_MODEL;
+    return next;
+}
+//# sourceMappingURL=env.js.map

package/dist/config/index.d.ts

@@ -0,0 +1,9 @@
+/** Barrel for the config subsystem: paths, schemas, stores, and profile logic. */
+export { resolveOttoHome } from "./otto-home.js";
+export { ensurePrivateDirectory, writePrivateFileAtomicSync } from "./private-files.js";
+export { resolveBrainPaths, packageRoot, type BrainPaths } from "./paths.js";
+export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
+export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
+export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, } from "./profiles.js";
+export * from "./schema.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -0,0 +1,9 @@
+/** Barrel for the config subsystem: paths, schemas, stores, and profile logic. */
+export { resolveOttoHome } from "./otto-home.js";
+export { ensurePrivateDirectory, writePrivateFileAtomicSync } from "./private-files.js";
+export { resolveBrainPaths, packageRoot } from "./paths.js";
+export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
+export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
+export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, } from "./profiles.js";
+export * from "./schema.js";
+//# sourceMappingURL=index.js.map

package/dist/config/otto-home.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveOttoHome(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=otto-home.d.ts.map

package/dist/config/otto-home.js

@@ -0,0 +1,24 @@
+/**
+ * Resolves $OTTO_HOME exactly as the Otto daemon does (see
+ * packages/server/src/server/otto-home.ts): env override, else `~/.otto`, tilde
+ * expanded, made private. Sharing this rule is what lets otto-brain's config sit
+ * next to Otto's — and follow it into the dev home whenever the dev scripts export
+ * OTTO_HOME. There is deliberately no dev-path logic here; that lives in shell.
+ */
+import { homedir } from "node:os";
+import path from "node:path";
+import { ensurePrivateDirectory } from "./private-files.js";
+function expandHomeDir(input) {
+    if (input.startsWith("~/"))
+        return path.join(homedir(), input.slice(2));
+    if (input === "~")
+        return homedir();
+    return input;
+}
+export function resolveOttoHome(env = process.env) {
+    const raw = env.OTTO_HOME ?? "~/.otto";
+    const resolved = path.resolve(expandHomeDir(raw));
+    ensurePrivateDirectory(resolved);
+    return resolved;
+}
+//# sourceMappingURL=otto-home.js.map

package/dist/config/paths.d.ts

@@ -0,0 +1,20 @@
+export interface BrainPaths {
+    home: string;
+    root: string;
+    configFile: string;
+    profilesFile: string;
+    catalogFile: string;
+    modelsDir: string;
+    runtimesDir: string;
+    pidFile: string;
+    logFile: string;
+    resultsDir: string;
+}
+export declare function resolveBrainPaths(env?: NodeJS.ProcessEnv): BrainPaths;
+/**
+ * The package root, resolved from this module's location whether running from
+ * `dist/config/` (built) or `src/config/` (tsx). Used only to find the legacy
+ * repo-local `config/` seed data during the one-time migration.
+ */
+export declare function packageRoot(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/config/paths.js

@@ -0,0 +1,33 @@
+/**
+ * The on-disk layout of otto-brain's home, a namespaced subdirectory of $OTTO_HOME
+ * (the dominant per-subsystem convention in Otto: projects/, chat/, loops/, …).
+ * Everything the brain persists lives under `$OTTO_HOME/otto-brain/`.
+ */
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { resolveOttoHome } from "./otto-home.js";
+export function resolveBrainPaths(env = process.env) {
+    const home = resolveOttoHome(env);
+    const root = path.join(home, "otto-brain");
+    return {
+        home,
+        root,
+        configFile: path.join(root, "config.json"),
+        profilesFile: path.join(root, "profiles.json"),
+        catalogFile: path.join(root, "catalog.json"),
+        modelsDir: path.join(root, "models"),
+        runtimesDir: path.join(root, "runtimes"),
+        pidFile: path.join(root, "otto-brain.pid"),
+        logFile: path.join(root, "otto-brain.log"),
+        resultsDir: path.join(root, "results"),
+    };
+}
+/**
+ * The package root, resolved from this module's location whether running from
+ * `dist/config/` (built) or `src/config/` (tsx). Used only to find the legacy
+ * repo-local `config/` seed data during the one-time migration.
+ */
+export function packageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+//# sourceMappingURL=paths.js.map

package/dist/config/private-files.d.ts

@@ -0,0 +1,3 @@
+export declare function ensurePrivateDirectory(dir: string): void;
+export declare function writePrivateFileAtomicSync(filePath: string, contents: string): void;
+//# sourceMappingURL=private-files.d.ts.map

package/dist/config/private-files.js

@@ -0,0 +1,32 @@
+/**
+ * Private-file helpers mirroring the daemon's `private-files.ts`: directories are
+ * created `0700`, files written `0600`, and every write is atomic (temp + rename)
+ * so a crash mid-write never leaves a truncated config on disk. chmod is
+ * best-effort because Windows POSIX-mode support is partial.
+ */
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const DIR_MODE = 0o700;
+const FILE_MODE = 0o600;
+export function ensurePrivateDirectory(dir) {
+    mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+    try {
+        chmodSync(dir, DIR_MODE);
+    }
+    catch {
+        // best effort: Windows filesystems may reject POSIX modes
+    }
+}
+export function writePrivateFileAtomicSync(filePath, contents) {
+    ensurePrivateDirectory(path.dirname(filePath));
+    const tmp = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(tmp, contents, { mode: FILE_MODE });
+    renameSync(tmp, filePath);
+    try {
+        chmodSync(filePath, FILE_MODE);
+    }
+    catch {
+        // best effort
+    }
+}
+//# sourceMappingURL=private-files.js.map