ollanet 0.4.0 → 0.5.0

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>;

package/dist/pull.js

@@ -0,0 +1,198 @@
+/**
+ * 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 { envInt, ollamaBaseUrl, shortName } from "./hosts.js";
+import { ollamaPull } from "./ollama-chat.js";
+import { resolveTarget } from "./target.js";
+/** Pull HTTP timeout (ms). 0 = none. Large models can take hours. */
+function pullTimeoutMs() {
+    return envInt("OLLAMA_PULL_TIMEOUT_MS", 0);
+}
+function usage() {
+    console.error(`Usage:
+  ollanet pull <machine> <model>
+  ollanet pull --machine <name> --model <name>
+
+Examples:
+  ollanet pull studio gemma3:12b
+  ollanet pull localhost llama3.2:1b
+  ollanet pull 192.168.1.50 gemma3:12b --json
+
+The named machine downloads the model onto its own disk. ollanet does not
+upload weights. Re-pulling the same name updates it when the registry has a
+newer digest.
+
+Options:
+  --machine <name>   Host (discovered name, MagicDNS, hostname, or IP[:port])
+  --model <name>     Model to pull (e.g. gemma3:12b)
+  --insecure         Allow HTTP / self-signed model registries
+  --no-stream        Wait for a single final response (no progress chunks)
+  --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 modelFlag;
+    let insecure = false;
+    let stream = true;
+    let json = false;
+    const positional = [];
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h")
+            usage();
+        if (arg === "--insecure") {
+            insecure = true;
+            continue;
+        }
+        if (arg === "--no-stream") {
+            stream = false;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--machine") {
+            machineFlag = takeValue(args, "--machine");
+            continue;
+        }
+        if (arg === "--model") {
+            modelFlag = takeValue(args, "--model");
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            console.error(`Unknown flag: ${arg}`);
+            usage();
+        }
+        positional.push(arg);
+    }
+    const machine = machineFlag ?? positional[0];
+    const model = modelFlag ?? (machineFlag ? positional[0] : positional[1]);
+    if (positional.length > 2 || (machineFlag && modelFlag && positional.length > 0)) {
+        console.error("Too many arguments.");
+        usage();
+    }
+    return { machine, model, insecure, stream, json };
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 ** 2)
+        return `${(n / 1024).toFixed(1)} KB`;
+    if (n < 1024 ** 3)
+        return `${(n / 1024 ** 2).toFixed(1)} MB`;
+    return `${(n / 1024 ** 3).toFixed(2)} GB`;
+}
+function shortDigest(digest) {
+    const hex = digest.replace(/^sha256:/, "");
+    return hex.slice(0, 12);
+}
+function formatPullLine(chunk) {
+    const status = chunk.status ?? "pulling";
+    if (chunk.total && chunk.total > 0) {
+        const pct = Math.min(100, Math.floor((100 * (chunk.completed ?? 0)) / chunk.total));
+        const digest = chunk.digest ? ` ${shortDigest(chunk.digest)}` : "";
+        return `${status}${digest}  ${pct}%  ${formatBytes(chunk.completed ?? 0)} / ${formatBytes(chunk.total)}`;
+    }
+    return status;
+}
+function emitProgress(chunk, state, tty) {
+    if (chunk.total && chunk.total > 0 && tty) {
+        process.stderr.write(`\r${formatPullLine(chunk).padEnd(80)}`);
+        state.usedCarriage = true;
+        state.lastStatus = chunk.status ?? state.lastStatus;
+        return;
+    }
+    if (chunk.status && chunk.status !== state.lastStatus) {
+        if (state.usedCarriage) {
+            process.stderr.write("\n");
+            state.usedCarriage = false;
+        }
+        process.stderr.write(`${chunk.status}\n`);
+        state.lastStatus = chunk.status;
+    }
+}
+/** Programmatic pull used by the CLI, MCP, and apps. */
+export async function pullModel(opts) {
+    const model = (opts.model ?? "").trim();
+    const machineQuery = (opts.machine ?? "").trim();
+    if (!machineQuery)
+        throw new Error("Machine is required.");
+    if (!model)
+        throw new Error("Model is required.");
+    const host = await resolveTarget(machineQuery, opts.config);
+    const writeProgress = opts.writeStdout !== false;
+    const quiet = opts.quiet === true || !writeProgress;
+    const state = { lastStatus: "", usedCarriage: false };
+    const tty = Boolean(process.stderr.isTTY);
+    if (!quiet) {
+        console.error(`→ ${shortName(host)} (${host.ip})  pulling ${model}`);
+    }
+    const pulled = await ollamaPull({
+        baseUrl: ollamaBaseUrl(host),
+        model,
+        insecure: opts.insecure === true,
+        stream: opts.stream !== false,
+        timeoutMs: opts.timeoutMs ?? pullTimeoutMs(),
+        onProgress: (chunk) => {
+            opts.onProgress?.(chunk);
+            if (!quiet)
+                emitProgress(chunk, state, tty);
+        },
+    });
+    if (!quiet && state.usedCarriage) {
+        process.stderr.write("\n");
+    }
+    const machine = shortName(host);
+    return {
+        machine,
+        model,
+        status: pulled.status,
+        endpoint: ollamaBaseUrl(host),
+        next: {
+            hint: `On ${machine}: finetuna --model ${model}  → then ollanet show ${machine} <tuned-name>`,
+            site: "https://finetuna.net",
+        },
+    };
+}
+export async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (!parsed.machine || !parsed.model) {
+        if (!parsed.machine)
+            console.error("Machine is required.");
+        else
+            console.error("Model is required.");
+        usage();
+    }
+    const result = await pullModel({
+        machine: parsed.machine,
+        model: parsed.model,
+        insecure: parsed.insecure,
+        stream: parsed.stream,
+        writeStdout: true,
+        quiet: false,
+    });
+    if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`pulled ${result.model} on ${result.machine}\n`);
+    process.stderr.write(`${result.next.hint}\n${result.next.site}\n`);
+}

package/dist/rm.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Delete a model from a reachable Ollama host.
+ *
+ *   ollanet rm studio llama3.2:1b --yes
+ */
+import type { AppConfig } from "./config.js";
+export interface RemoveOptions {
+    machine: string;
+    model: string;
+    /** Must be true unless the caller is an interactive TTY confirm. */
+    yes?: boolean;
+    config?: Partial<AppConfig>;
+    timeoutMs?: number;
+}
+export interface RemoveResult {
+    machine: string;
+    model: string;
+    endpoint: string;
+    deleted: true;
+}
+export declare function removeModel(opts: RemoveOptions): Promise<RemoveResult>;
+export declare function main(): Promise<void>;

package/dist/rm.js

@@ -0,0 +1,134 @@
+/**
+ * Delete a model from a reachable Ollama host.
+ *
+ *   ollanet rm studio llama3.2:1b --yes
+ */
+import { createInterface } from "node:readline";
+import { envInt, ollamaBaseUrl, shortName } from "./hosts.js";
+import { ollamaDelete } from "./ollama-chat.js";
+import { resolveTarget } from "./target.js";
+function rmTimeoutMs() {
+    return envInt("OLLAMA_RM_TIMEOUT_MS", 30_000);
+}
+function usage() {
+    console.error(`Usage:
+  ollanet rm <machine> <model> --yes
+  ollanet rm --machine <name> --model <name> --yes
+
+Examples:
+  ollanet rm studio llama3.2:1b --yes
+  ollanet rm localhost old-model:7b --yes --json
+
+Deletes the named model from that host's disk (POST /api/delete).
+Non-interactive use (pipes, MCP, CI) requires --yes / confirm: true.
+
+Options:
+  --machine <name>   Host (discovered name, MagicDNS, hostname, or IP[:port])
+  --model <name>     Model to delete
+  --yes              Required unless stdin is a TTY and you confirm
+  --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 modelFlag;
+    let yes = false;
+    let json = false;
+    const positional = [];
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h")
+            usage();
+        if (arg === "--yes" || arg === "-y") {
+            yes = true;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--machine") {
+            machineFlag = takeValue(args, "--machine");
+            continue;
+        }
+        if (arg === "--model") {
+            modelFlag = takeValue(args, "--model");
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            console.error(`Unknown flag: ${arg}`);
+            usage();
+        }
+        positional.push(arg);
+    }
+    const machine = machineFlag ?? positional[0];
+    const model = modelFlag ?? (machineFlag ? positional[0] : positional[1]);
+    if (positional.length > 2 || (machineFlag && modelFlag && positional.length > 0)) {
+        console.error("Too many arguments.");
+        usage();
+    }
+    return { machine, model, yes, json };
+}
+async function confirmDelete(machine, model, yes) {
+    if (yes)
+        return;
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        throw new Error(`Refusing to delete ${model} on ${machine} without --yes.`);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    const answer = await new Promise((resolve) => {
+        rl.question(`Delete ${model} on ${machine}? [y/N] `, resolve);
+    });
+    rl.close();
+    if (!/^\s*y(es)?\s*$/i.test(answer)) {
+        throw new Error("Aborted.");
+    }
+}
+export async function removeModel(opts) {
+    const model = (opts.model ?? "").trim();
+    const machineQuery = (opts.machine ?? "").trim();
+    if (!machineQuery)
+        throw new Error("Machine is required.");
+    if (!model)
+        throw new Error("Model is required.");
+    await confirmDelete(machineQuery, model, opts.yes === true);
+    const host = await resolveTarget(machineQuery, opts.config);
+    await ollamaDelete(ollamaBaseUrl(host), model, opts.timeoutMs ?? rmTimeoutMs());
+    return {
+        machine: shortName(host),
+        model,
+        endpoint: ollamaBaseUrl(host),
+        deleted: true,
+    };
+}
+export async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (!parsed.machine || !parsed.model) {
+        if (!parsed.machine)
+            console.error("Machine is required.");
+        else
+            console.error("Model is required.");
+        usage();
+    }
+    const result = await removeModel({
+        machine: parsed.machine,
+        model: parsed.model,
+        yes: parsed.yes,
+    });
+    if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`deleted ${result.model} on ${result.machine}\n`);
+}

package/dist/scan.d.ts

@@ -6,7 +6,7 @@
 import { type AppConfig } from "./config.js";
 export interface ScanOptions {
     includeOffline?: boolean;
-    /** TCP-scan local /24s. Opt-in; never the default. */
+    /** TCP-scan local /24s for Ollama (port 11434 by default). Off unless set. */
     lanScan?: boolean;
     /**
      * In-memory config. When set, the config file (`~/.ollanet` / `OLLANET_CONFIG`)
@@ -30,6 +30,8 @@ export interface ScannedServer {
         parameter_size?: string;
         quantization_level?: string;
         family?: string;
+        /** Name looks like a Finetuna-style host-side tune. */
+        tuned: boolean;
     }>;
 }
 export interface ScanPayload {

package/dist/scan.js

@@ -5,6 +5,7 @@
  */
 import { configFromPartial, loadConfig } from "./config.js";
 import { discoverHosts, envInt, ollamaPort, shortName, } from "./hosts.js";
+import { looksTuned } from "./tuned.js";
 function scanTimeoutMs() {
     return envInt("OLLAMA_TIMEOUT_MS", 2500);
 }
@@ -110,7 +111,8 @@ function printResults(results, networkLabel, sources) {
                 const params = model.details?.parameter_size;
                 const quant = model.details?.quantization_level;
                 const meta = [params, quant, size].filter(Boolean).join(" · ");
-                console.log(meta ? `    - ${model.name}  (${meta})` : `    - ${model.name}`);
+                const tag = looksTuned(model.name) ? " [tuned]" : "";
+                console.log(meta ? `    - ${model.name}  (${meta})${tag}` : `    - ${model.name}${tag}`);
             }
         }
         console.log("");
@@ -141,6 +143,7 @@ function toPayload(results, networkLabel, sources) {
                 parameter_size: m.details?.parameter_size,
                 quantization_level: m.details?.quantization_level,
                 family: m.details?.family,
+                tuned: looksTuned(m.name),
             })),
         })),
     };

package/dist/show.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Inspect a model on a reachable Ollama host (Modelfile, params, capabilities).
+ *
+ *   ollanet show studio gemma4-ctx32k
+ */
+import { type OllamaShowInfo } from "./ollama-chat.js";
+import type { AppConfig } from "./config.js";
+export interface ShowOptions {
+    machine: string;
+    model: string;
+    config?: Partial<AppConfig>;
+    timeoutMs?: number;
+}
+export interface ShowResult {
+    machine: string;
+    model: string;
+    endpoint: string;
+    tuned: boolean;
+    capabilities?: string[];
+    modelfile?: string;
+    parameters?: string;
+    template?: string;
+    system?: string;
+    details?: OllamaShowInfo["details"];
+    modified_at?: string;
+}
+export declare function showModel(opts: ShowOptions): Promise<ShowResult>;
+export declare function main(): Promise<void>;