ollanet 0.4.1 → 0.6.0

package/dist/ollama-chat.d.ts

@@ -50,9 +50,26 @@ export interface OllamaModelInfo {
     };
 }
 export declare function ollamaTags(baseUrl: string, timeoutMs: number): Promise<OllamaModelInfo[]>;
-export declare function ollamaShow(baseUrl: string, model: string, timeoutMs: number): Promise<{
+export interface OllamaShowInfo {
     capabilities?: string[];
-}>;
+    modelfile?: string;
+    parameters?: string;
+    template?: string;
+    system?: string;
+    details?: {
+        parent_model?: string;
+        format?: string;
+        family?: string;
+        families?: string[];
+        parameter_size?: string;
+        quantization_level?: string;
+    };
+    model_info?: Record<string, unknown>;
+    modified_at?: string;
+}
+export declare function ollamaShow(baseUrl: string, model: string, timeoutMs: number): Promise<OllamaShowInfo>;
+/** POST /api/delete — removes the named model from that host's disk. */
+export declare function ollamaDelete(baseUrl: string, model: string, timeoutMs: number): Promise<void>;
 export declare function ollamaVersion(baseUrl: string, timeoutMs: number): Promise<string | undefined>;
 export interface PsModel {
     name?: string;
@@ -61,7 +78,34 @@ export interface PsModel {
     context_length?: number;
     digest?: string;
 }
+export interface PullChunk {
+    status?: string;
+    digest?: string;
+    total?: number;
+    completed?: number;
+    error?: string;
+}
+export interface OllamaPullOptions {
+    baseUrl: string;
+    model: string;
+    /** Allow HTTP / self-signed registries (Ollama `insecure`). */
+    insecure?: boolean;
+    stream: boolean;
+    timeoutMs: number;
+    onProgress?: (chunk: PullChunk) => void;
+}
+export interface OllamaPullResult {
+    status: string;
+    chunks: PullChunk[];
+}
+/**
+ * POST /api/pull — the *server* downloads the model. The client only sends the
+ * request. Default timeout 0 (none): large pulls can take hours.
+ */
+export declare function ollamaPull(opts: OllamaPullOptions): Promise<OllamaPullResult>;
 export declare function ollamaPs(baseUrl: string, timeoutMs: number): Promise<PsModel[]>;
+/** Like ollamaPs, but unreachable hosts throw instead of looking empty. */
+export declare function ollamaPsRequired(baseUrl: string, timeoutMs: number): Promise<PsModel[]>;
 export declare function psHasModel(models: PsModel[], name: string): boolean;
 export declare function vramForModel(models: PsModel[], name: string): number | undefined;
 export declare function contextLengthForModel(models: PsModel[], name: string): number | undefined;

package/dist/ollama-chat.js

@@ -164,6 +164,10 @@ export async function ollamaShow(baseUrl, model, timeoutMs) {
     const url = `${baseUrl}/api/show`;
     return ollamaPostJson(url, { model }, timeoutMs);
 }
+/** POST /api/delete — removes the named model from that host's disk. */
+export async function ollamaDelete(baseUrl, model, timeoutMs) {
+    await ollamaPostJson(`${baseUrl}/api/delete`, { model }, timeoutMs);
+}
 export async function ollamaVersion(baseUrl, timeoutMs) {
     try {
         const body = await ollamaGetJson(`${baseUrl}/api/version`, timeoutMs);
@@ -173,15 +177,128 @@ export async function ollamaVersion(baseUrl, timeoutMs) {
         return undefined;
     }
 }
+function parsePullChunk(url, raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${raw.slice(0, 120)}`);
+    }
+}
+/**
+ * POST /api/pull — the *server* downloads the model. The client only sends the
+ * request. Default timeout 0 (none): large pulls can take hours.
+ */
+export async function ollamaPull(opts) {
+    const url = `${opts.baseUrl}/api/pull`;
+    const body = {
+        model: opts.model,
+        stream: opts.stream,
+    };
+    if (opts.insecure)
+        body.insecure = true;
+    const controller = new AbortController();
+    const timer = opts.timeoutMs > 0 ? setTimeout(() => controller.abort(), opts.timeoutMs) : undefined;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (timer)
+            clearTimeout(timer);
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Pull timed out after ${opts.timeoutMs}ms (${url})`);
+        }
+        throw err;
+    }
+    if (!res.ok) {
+        if (timer)
+            clearTimeout(timer);
+        const text = await res.text().catch(() => "");
+        let detail = text;
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed.error)
+                detail = parsed.error;
+        }
+        catch {
+            // keep raw text
+        }
+        throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${detail ? `: ${detail}` : ""}`);
+    }
+    const chunks = [];
+    const take = (chunk) => {
+        if (chunk.error)
+            throw new Error(chunk.error);
+        chunks.push(chunk);
+        opts.onProgress?.(chunk);
+    };
+    try {
+        if (!opts.stream) {
+            take(parsePullChunk(url, await res.text()));
+        }
+        else {
+            if (!res.body)
+                throw new Error("No response body from Ollama");
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    take(parsePullChunk(url, trimmed));
+                }
+            }
+            const trailing = buffer.trim();
+            if (trailing)
+                take(parsePullChunk(url, trailing));
+        }
+    }
+    catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Pull timed out after ${opts.timeoutMs}ms (${url})`);
+        }
+        throw err;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    const last = chunks.at(-1);
+    const status = last?.status ?? "";
+    if (status !== "success") {
+        throw new Error(status ? `Pull ended: ${status}` : "Pull failed (no success status)");
+    }
+    return { status, chunks };
+}
 export async function ollamaPs(baseUrl, timeoutMs) {
     try {
-        const body = await ollamaGetJson(`${baseUrl}/api/ps`, timeoutMs);
-        return body.models ?? [];
+        return await ollamaPsRequired(baseUrl, timeoutMs);
     }
     catch {
         return [];
     }
 }
+/** Like ollamaPs, but unreachable hosts throw instead of looking empty. */
+export async function ollamaPsRequired(baseUrl, timeoutMs) {
+    const body = await ollamaGetJson(`${baseUrl}/api/ps`, timeoutMs);
+    return body.models ?? [];
+}
 function modelKey(name) {
     return name.trim().toLowerCase();
 }
@@ -293,6 +410,8 @@ async function ollamaPostJson(url, body, timeoutMs) {
             throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""} (${url})`);
         }
         const text = await res.text();
+        if (!text.trim())
+            return {};
         try {
             return JSON.parse(text);
         }

package/dist/paths.d.ts

@@ -15,3 +15,7 @@ export declare function defaultConfigPath(): string;
 export declare function defaultResponsesDir(): string;
 /** Default benchmark results dir (mirrors responses layout). */
 export declare function defaultBenchmarksDir(): string;
+/** Last successful scan snapshot (single file). */
+export declare function defaultLastScanPath(): string;
+/** Head-to-head compare records (markdown + JSON). */
+export declare function defaultComparesDir(): string;

package/dist/paths.js

@@ -26,3 +26,11 @@ export function defaultResponsesDir() {
 export function defaultBenchmarksDir() {
     return IS_INSTALLED ? path.join(USER_DIR, "benchmarks") : projectPath("benchmarks");
 }
+/** Last successful scan snapshot (single file). */
+export function defaultLastScanPath() {
+    return IS_INSTALLED ? path.join(USER_DIR, "last-scan.json") : projectPath("last-scan.json");
+}
+/** Head-to-head compare records (markdown + JSON). */
+export function defaultComparesDir() {
+    return IS_INSTALLED ? path.join(USER_DIR, "compares") : projectPath("compares");
+}

package/dist/prompt-input.d.ts

@@ -0,0 +1,7 @@
+export declare function assertPromptFilename(filePath: string): string;
+export declare function readPromptFile(filePath: string): Promise<string>;
+export declare function assemblePrompt(parts: {
+    argv?: string;
+    file?: string;
+    stdin?: string;
+}): string;

package/dist/prompt-input.js

@@ -0,0 +1,36 @@
+/**
+ * Shared prompt assembly: argv, --file (.txt / .md), and piped stdin.
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+const ALLOWED = new Set([".txt", ".md"]);
+const MAX_BYTES = 1_000_000;
+export function assertPromptFilename(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!ALLOWED.has(ext)) {
+        throw new Error(`Prompt file must be .txt or .md (got "${ext || "no extension"}": ${filePath})`);
+    }
+    return path.resolve(filePath);
+}
+export async function readPromptFile(filePath) {
+    const resolved = assertPromptFilename(filePath);
+    const info = await stat(resolved);
+    if (!info.isFile()) {
+        throw new Error(`Prompt path is not a file: ${resolved}`);
+    }
+    if (info.size > MAX_BYTES) {
+        throw new Error(`Prompt file is too large (${info.size} bytes; max ${MAX_BYTES}): ${resolved}`);
+    }
+    const text = (await readFile(resolved, "utf8")).replace(/^\uFEFF/, "");
+    if (!text.trim()) {
+        throw new Error(`Prompt file is empty: ${resolved}`);
+    }
+    return text;
+}
+export function assemblePrompt(parts) {
+    return [parts.argv, parts.file, parts.stdin]
+        .map((s) => (s ?? "").trim())
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+}

package/dist/prompt.js

@@ -16,6 +16,7 @@ import { appendMessage, cleanTopic, createChat, loadChat, saveChat, toApiMessage
 import { configPath, defaultModelForHost, loadConfig, machineSettingsForHost, mergeSettings, parseFormat, settingsFromEnv, settingsSummary, configFromPartial, } from "./config.js";
 import { discoverHosts, envInt, findDiscoveredHost, ollamaBaseUrl, resolveHost, shortName, } from "./hosts.js";
 import { ollamaChat } from "./ollama-chat.js";
+import { assemblePrompt, readPromptFile } from "./prompt-input.js";
 /** Prompt/chat HTTP timeout (ms). 0 = no timeout. Separate from scan's OLLAMA_TIMEOUT_MS. */
 function promptTimeoutMs() {
     return envInt("OLLAMA_PROMPT_TIMEOUT_MS", 600_000);
@@ -30,6 +31,7 @@ Examples:
   ollanet prompt localhost "Explain MagicDNS"
   ollanet prompt --chat a1b2c3d4e5f6 "Give an example"
   ollanet prompt localhost --temperature 0.2 --num-predict 64 "2+2?"
+  ollanet prompt localhost --file ./notes.md
   ollanet chats
 
 Each reply is saved under responses/<hash>.json and the hash is printed so you
@@ -51,6 +53,7 @@ Options:
   --format <json|schema> Force JSON mode or a JSON schema string
   --think                Enable model thinking (qwen3 etc.); streams to stderr
   --no-think             Disable thinking (default) so tokens go to the reply
+  --file <path>          Prompt from a .txt or .md file (joins argv / stdin)
   --no-stream            Wait for the full response
   --json                 Emit final response JSON (implies --no-stream)`);
     process.exit(1);
@@ -137,6 +140,7 @@ function parseArgs(argv) {
     let machineFlag;
     let modelFlag;
     let chatId;
+    let file;
     let stream = true;
     let json = false;
     let save = true;
@@ -181,6 +185,10 @@ function parseArgs(argv) {
             modelFlag = arg.includes("=") ? arg.slice("--model=".length) : takeValue(args, "--model");
             continue;
         }
+        if (arg === "--file" || arg === "-f" || arg.startsWith("--file=")) {
+            file = arg.includes("=") ? arg.slice("--file=".length) : takeValue(args, "--file");
+            continue;
+        }
         if (arg === "--system" || arg.startsWith("--system=")) {
             settings.system = arg.includes("=")
                 ? arg.slice("--system=".length)
@@ -235,7 +243,7 @@ function parseArgs(argv) {
     }
     // Continue (--chat): all positionals are the prompt. Optional machine override
     // via --machine, or a leading discovered-host name peeled in main().
-    return { machine, model, promptParts, stream, json, save, chatId, settings };
+    return { machine, model, promptParts, file, stream, json, save, chatId, settings };
 }
 async function readStdinIfPiped() {
     if (stdinStream.isTTY)
@@ -261,7 +269,7 @@ async function readStdinIfPiped() {
         const onEnd = () => done(true);
         stdinStream.once("readable", onReadable);
         stdinStream.once("end", onEnd);
-        const timer = setTimeout(() => done(stdinStream.readableLength > 0), 25);
+        const timer = setTimeout(() => done(stdinStream.readableLength > 0), 100);
     });
     if (!hasData)
         return "";
@@ -436,6 +444,17 @@ export async function main() {
     const { stream, json, save } = parsed;
     let promptParts = parsed.promptParts;
     const fromStdin = await readStdinIfPiped();
+    let fromFile = "";
+    if (parsed.file) {
+        try {
+            fromFile = await readPromptFile(parsed.file);
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : err);
+            process.exitCode = 1;
+            return;
+        }
+    }
     const config = await loadConfig();
     const { hosts: targets } = await discoverHosts({
         hosts: config.hosts,
@@ -460,13 +479,17 @@ export async function main() {
             usage();
         }
         const host = resolveHost(targets, machineQuery);
-        const peeled = await maybePeelModel(host, promptParts, fromStdin);
+        const peeled = await maybePeelModel(host, promptParts, fromStdin || fromFile);
         peeledModel = peeled.model;
         promptParts = peeled.promptParts;
     }
-    const promptText = [promptParts.join(" ").trim(), fromStdin].filter(Boolean).join("\n\n").trim();
+    const promptText = assemblePrompt({
+        argv: promptParts.join(" "),
+        file: fromFile,
+        stdin: fromStdin,
+    });
     if (!promptText) {
-        console.error("No prompt provided (pass args and/or pipe stdin).");
+        console.error("No prompt provided (pass args, --file, and/or pipe stdin).");
         usage();
     }
     try {

package/dist/ps.d.ts

@@ -0,0 +1,31 @@
+/**
+ * List models currently loaded in VRAM on reachable Ollama hosts.
+ *
+ *   ollanet ps
+ *   ollanet ps studio
+ */
+import { type AppConfig } from "./config.js";
+export interface LoadedModel {
+    name: string;
+    size_vram?: number;
+    context_length?: number;
+    digest?: string;
+    tuned: boolean;
+}
+export interface LoadedHost {
+    machine: string;
+    endpoint: string;
+    ok: boolean;
+    error?: string;
+    models: LoadedModel[];
+}
+export interface PsOptions {
+    machine?: string;
+    config?: Partial<AppConfig>;
+    timeoutMs?: number;
+}
+export interface PsResult {
+    hosts: LoadedHost[];
+}
+export declare function listLoaded(opts?: PsOptions): Promise<PsResult>;
+export declare function main(): Promise<void>;

package/dist/ps.js

@@ -0,0 +1,165 @@
+/**
+ * List models currently loaded in VRAM on reachable Ollama hosts.
+ *
+ *   ollanet ps
+ *   ollanet ps studio
+ */
+import { configFromPartial, loadConfig } from "./config.js";
+import { discoverHosts, envInt, ollamaBaseUrl, shortName, } from "./hosts.js";
+import { ollamaPs, ollamaPsRequired } from "./ollama-chat.js";
+import { resolveTarget } from "./target.js";
+import { looksTuned } from "./tuned.js";
+function psTimeoutMs() {
+    return envInt("OLLAMA_PS_TIMEOUT_MS", 10_000);
+}
+function usage() {
+    console.error(`Usage:
+  ollanet ps [machine]
+  ollanet ps --machine <name>
+
+Examples:
+  ollanet ps
+  ollanet ps studio
+  ollanet ps studio --json
+
+scan lists models on disk. ps lists what is loaded in VRAM right now.
+
+Options:
+  --machine <name>   One host (default: every discovered host)
+  --json             Emit result JSON on stdout`);
+    process.exit(1);
+}
+function takeValue(args, flag) {
+    const value = args.shift();
+    if (!value) {
+        console.error(`${flag} requires a value`);
+        usage();
+    }
+    return value;
+}
+function parseArgs(argv) {
+    const args = [...argv];
+    let machineFlag;
+    let json = false;
+    const positional = [];
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h")
+            usage();
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--machine") {
+            machineFlag = takeValue(args, "--machine");
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            console.error(`Unknown flag: ${arg}`);
+            usage();
+        }
+        positional.push(arg);
+    }
+    if (positional.length > 1 || (machineFlag && positional.length > 0)) {
+        console.error("Too many arguments.");
+        usage();
+    }
+    return { machine: machineFlag ?? positional[0], json };
+}
+function formatBytes(bytes) {
+    if (bytes == null || !Number.isFinite(bytes))
+        return "";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+function toLoaded(m) {
+    const name = (m.name ?? m.model ?? "").trim();
+    return {
+        name,
+        size_vram: m.size_vram,
+        context_length: m.context_length,
+        digest: m.digest,
+        tuned: looksTuned(name),
+    };
+}
+async function psHost(host, timeoutMs, required) {
+    const endpoint = ollamaBaseUrl(host);
+    try {
+        const models = required
+            ? await ollamaPsRequired(endpoint, timeoutMs)
+            : await ollamaPs(endpoint, timeoutMs);
+        return {
+            machine: shortName(host),
+            endpoint,
+            ok: true,
+            models: models.map(toLoaded).filter((m) => m.name),
+        };
+    }
+    catch (err) {
+        return {
+            machine: shortName(host),
+            endpoint,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            models: [],
+        };
+    }
+}
+export async function listLoaded(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? psTimeoutMs();
+    if (opts.machine?.trim()) {
+        const host = await resolveTarget(opts.machine, opts.config);
+        const row = await psHost(host, timeoutMs, true);
+        if (!row.ok)
+            throw new Error(row.error ?? `ps failed on ${row.machine}`);
+        return { hosts: [row] };
+    }
+    const app = opts.config ? configFromPartial(opts.config) : await loadConfig();
+    const { hosts } = await discoverHosts({
+        hosts: app.hosts,
+        discovery: app.discovery,
+    });
+    const rows = await Promise.all(hosts
+        .filter((h) => h.online || h.isSelf || h.source !== "tailscale")
+        .map((h) => psHost(h, timeoutMs, false)));
+    return { hosts: rows.filter((r) => r.ok) };
+}
+function printPs(result) {
+    if (result.hosts.length === 0) {
+        process.stdout.write("No hosts reported loaded models.\n");
+        return;
+    }
+    for (const host of result.hosts) {
+        process.stdout.write(`${host.machine}  ${host.endpoint}\n`);
+        if (host.models.length === 0) {
+            process.stdout.write("  (nothing loaded)\n");
+        }
+        else {
+            for (const m of host.models) {
+                const vram = formatBytes(m.size_vram);
+                const ctx = m.context_length != null ? `ctx ${m.context_length}` : "";
+                const tag = m.tuned ? " [tuned]" : "";
+                const meta = [vram ? `VRAM ${vram}` : "", ctx].filter(Boolean).join("  ");
+                process.stdout.write(meta ? `  ${m.name}  ${meta}${tag}\n` : `  ${m.name}${tag}\n`);
+            }
+        }
+        process.stdout.write("\n");
+    }
+}
+export async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    const result = await listLoaded({ machine: parsed.machine });
+    if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    printPs(result);
+}

package/dist/pull.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pull a model onto a reachable Ollama host.
+ *
+ *   ollanet pull studio gemma3:12b
+ *
+ * `studio` is the machine (discovered name, MagicDNS, hostname, or IP).
+ * The *server* downloads from the registry; ollanet only sends POST /api/pull.
+ */
+import type { AppConfig } from "./config.js";
+import { type PullChunk } from "./ollama-chat.js";
+export interface PullOptions {
+    machine: string;
+    model: string;
+    insecure?: boolean;
+    stream?: boolean;
+    /** Progress on stderr. Default true for CLI; pass false for MCP / apps. */
+    writeStdout?: boolean;
+    quiet?: boolean;
+    /** In-memory config; skips the config file when set. */
+    config?: Partial<AppConfig>;
+    timeoutMs?: number;
+    onProgress?: (chunk: PullChunk) => void;
+}
+export interface PullResult {
+    machine: string;
+    model: string;
+    status: string;
+    endpoint: string;
+    next: {
+        hint: string;
+        site: string;
+    };
+}
+/** Programmatic pull used by the CLI, MCP, and apps. */
+export declare function pullModel(opts: PullOptions): Promise<PullResult>;
+export declare function main(): Promise<void>;