ollanet 0.4.1 → 0.6.0

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-store.d.ts

@@ -0,0 +1,15 @@
+import type { ScanPayload } from "./scan.js";
+export interface StoredScan extends ScanPayload {
+    scanned_at: string;
+    lan: boolean;
+    include_offline: boolean;
+}
+/** Path for the last-scan snapshot. Read at call time so import stays safe. */
+export declare function lastScanPath(): string;
+export declare function saveLastScan(payload: ScanPayload, meta: {
+    lan: boolean;
+    includeOffline: boolean;
+}): Promise<string>;
+export declare function loadLastScan(): Promise<StoredScan | null>;
+/** Last saved scan, or null if none. Does not probe the network. */
+export declare function lastScan(): Promise<StoredScan | null>;

package/dist/scan-store.js

@@ -0,0 +1,41 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultLastScanPath } from "./paths.js";
+/** Path for the last-scan snapshot. Read at call time so import stays safe. */
+export function lastScanPath() {
+    return process.env.OLLANET_LAST_SCAN ?? defaultLastScanPath();
+}
+export async function saveLastScan(payload, meta) {
+    const stored = {
+        ...payload,
+        scanned_at: new Date().toISOString(),
+        lan: meta.lan,
+        include_offline: meta.includeOffline,
+    };
+    const file = lastScanPath();
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, `${JSON.stringify(stored, null, 2)}\n`, "utf8");
+    return file;
+}
+export async function loadLastScan() {
+    const file = lastScanPath();
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err ? err.code : "";
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const parsed = JSON.parse(text);
+    if (!parsed || !Array.isArray(parsed.servers)) {
+        throw new Error(`Invalid last-scan file: ${file}`);
+    }
+    return parsed;
+}
+/** Last saved scan, or null if none. Does not probe the network. */
+export async function lastScan() {
+    return loadLastScan();
+}

package/dist/scan.d.ts

@@ -1,7 +1,7 @@
 /**
  * Scan reachable networks for Ollama servers and list available models.
  *
- * Usage: ollanet scan [--lan] [--json] [--all]
+ * Usage: ollanet scan [--lan] [--json] [--all] [--last]
  */
 import { type AppConfig } from "./config.js";
 export interface ScanOptions {
@@ -13,6 +13,11 @@ export interface ScanOptions {
      * is not read. Omit to keep CLI/MCP file behavior.
      */
     config?: Partial<AppConfig>;
+    /**
+     * Persist this result as the last scan. Default true when `config` is omitted
+     * (CLI / MCP). Default false when `config` is passed (hermetic apps/tests).
+     */
+    save?: boolean;
 }
 export interface ScannedServer {
     hostname: string;
@@ -30,14 +35,22 @@ export interface ScannedServer {
         parameter_size?: string;
         quantization_level?: string;
         family?: string;
+        /** Name looks like a Finetuna-style host-side tune. */
+        tuned: boolean;
     }>;
 }
+export interface ScanFailure {
+    name: string;
+    ip: string;
+    error: string;
+}
 export interface ScanPayload {
     network: string;
     sources: string[];
     port: number;
     scanned: number;
     servers: ScannedServer[];
+    failures?: ScanFailure[];
 }
 /** Programmatic scan used by CLI `--json`, MCP, and `import { scanNetwork } from "ollanet"`. */
 export declare function scanNetwork(options?: ScanOptions): Promise<ScanPayload>;

package/dist/scan.js

@@ -1,10 +1,12 @@
 /**
  * Scan reachable networks for Ollama servers and list available models.
  *
- * Usage: ollanet scan [--lan] [--json] [--all]
+ * Usage: ollanet scan [--lan] [--json] [--all] [--last]
  */
 import { configFromPartial, loadConfig } from "./config.js";
 import { discoverHosts, envInt, ollamaPort, shortName, } from "./hosts.js";
+import { lastScanPath, loadLastScan, saveLastScan } from "./scan-store.js";
+import { looksTuned } from "./tuned.js";
 function scanTimeoutMs() {
     return envInt("OLLAMA_TIMEOUT_MS", 2500);
 }
@@ -75,47 +77,53 @@ async function scanHost(host) {
         return { host, ok: false, models: [], error, url };
     }
 }
-function printResults(results, networkLabel, sources) {
-    const found = results.filter((r) => r.ok);
-    const offline = results.filter((r) => r.error === "offline").length;
-    const probed = results.length - offline;
-    console.log(`Network: ${networkLabel}`);
-    console.log(`Discovery: ${sources.join(", ") || "none"}`);
-    console.log(`Probing Ollama on ${results.length} host(s) (${probed} online/reachable candidates)\n`);
-    if (found.length === 0) {
+function printPayload(payload, cached) {
+    if (cached?.scanned_at) {
+        const flags = [
+            cached.lan ? "lan" : null,
+            cached.include_offline ? "all" : null,
+        ].filter(Boolean);
+        console.log(`Cached scan from ${cached.scanned_at}${flags.length ? ` (${flags.join(", ")})` : ""}`);
+        console.log(`File: ${lastScanPath()}\n`);
+    }
+    console.log(`Network: ${payload.network}`);
+    console.log(`Discovery: ${payload.sources.join(", ") || "none"}`);
+    console.log(`Probing Ollama on ${payload.scanned} host(s)\n`);
+    if (payload.servers.length === 0) {
         console.log("No Ollama servers found.");
         console.log("Tip: add hosts to config.json, set OLLANET_HOSTS, pass --lan, or prompt an IP directly.");
-        const interesting = results.filter((r) => r.error && r.error !== "offline");
+        const interesting = (payload.failures ?? []).filter((f) => f.error !== "offline");
         if (interesting.length > 0) {
             console.log("\nNon-timeout failures (first few):");
-            for (const r of interesting.slice(0, 5)) {
-                console.log(`  - ${shortName(r.host)} (${r.host.ip}): ${r.error}`);
+            for (const f of interesting.slice(0, 5)) {
+                console.log(`  - ${f.name} (${f.ip}): ${f.error}`);
             }
         }
         return;
     }
-    for (const result of found) {
-        const label = result.host.dnsName || result.host.hostname;
-        const selfTag = result.host.isSelf ? " [this device]" : "";
+    for (const server of payload.servers) {
+        const label = server.dnsName || server.hostname;
+        const selfTag = server.self ? " [this device]" : "";
         console.log(`${label}${selfTag}`);
-        console.log(`  IP: ${result.host.ip}  source: ${result.host.source}  OS: ${result.host.os}`);
-        console.log(`  Endpoint: http://${result.host.ip}:${result.host.port}`);
-        if (result.models.length === 0) {
+        console.log(`  IP: ${server.ip}  source: ${server.source}  OS: ${server.os}`);
+        console.log(`  Endpoint: ${server.endpoint}`);
+        if (server.models.length === 0) {
             console.log("  Models: (none)");
         }
         else {
-            console.log(`  Models (${result.models.length}):`);
-            for (const model of result.models) {
+            console.log(`  Models (${server.models.length}):`);
+            for (const model of server.models) {
                 const size = formatBytes(model.size);
-                const params = model.details?.parameter_size;
-                const quant = model.details?.quantization_level;
+                const params = model.parameter_size;
+                const quant = model.quantization_level;
                 const meta = [params, quant, size].filter(Boolean).join(" · ");
-                console.log(meta ? `    - ${model.name}  (${meta})` : `    - ${model.name}`);
+                const tag = model.tuned ? " [tuned]" : "";
+                console.log(meta ? `    - ${model.name}  (${meta})${tag}` : `    - ${model.name}${tag}`);
             }
         }
         console.log("");
     }
-    console.log(`Found ${found.length} Ollama server(s) with ${found.reduce((n, r) => n + r.models.length, 0)} model entrie(s).`);
+    console.log(`Found ${payload.servers.length} Ollama server(s) with ${payload.servers.reduce((n, s) => n + s.models.length, 0)} model entrie(s).`);
 }
 function toPayload(results, networkLabel, sources) {
     return {
@@ -141,8 +149,16 @@ 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),
             })),
         })),
+        failures: results
+            .filter((r) => !r.ok)
+            .map((r) => ({
+            name: shortName(r.host),
+            ip: r.host.ip,
+            error: r.error ?? "unknown",
+        })),
     };
 }
 /** Programmatic scan used by CLI `--json`, MCP, and `import { scanNetwork } from "ollanet"`. */
@@ -158,31 +174,49 @@ export async function scanNetwork(options = {}) {
         throw new Error("No hosts to scan. Add config.hosts, set OLLANET_HOSTS, or enable Tailscale/LAN discovery.");
     }
     const results = await mapPool(hosts, scanConcurrency(), scanHost);
-    return toPayload(results, networkLabel, sources);
+    const payload = toPayload(results, networkLabel, sources);
+    const shouldSave = options.save ?? options.config == null;
+    if (shouldSave) {
+        await saveLastScan(payload, {
+            lan: options.lanScan ?? false,
+            includeOffline: options.includeOffline ?? false,
+        });
+    }
+    return payload;
 }
 export async function main() {
     const includeOffline = process.argv.includes("--all");
     const jsonOut = process.argv.includes("--json");
     const lanScan = process.argv.includes("--lan");
-    const config = await loadConfig();
-    const { hosts, sources, networkLabel } = await discoverHosts({
-        hosts: config.hosts,
-        discovery: config.discovery,
-        includeOffline,
-        lanScan,
-    });
-    if (hosts.length === 0) {
-        console.error("No hosts to scan. Add config.hosts, set OLLANET_HOSTS, or enable Tailscale/LAN discovery.");
-        process.exitCode = 1;
+    const cached = process.argv.includes("--last") || process.argv.includes("--cached");
+    if (cached) {
+        const stored = await loadLastScan();
+        if (!stored) {
+            console.error(`No saved scan at ${lastScanPath()}. Run ollanet scan first.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (jsonOut) {
+            console.log(JSON.stringify(stored, null, 2));
+            return;
+        }
+        printPayload(stored, stored);
         return;
     }
-    const results = await mapPool(hosts, scanConcurrency(), scanHost);
-    if (jsonOut) {
-        console.log(JSON.stringify(toPayload(results, networkLabel, sources), null, 2));
-        return;
+    try {
+        const payload = await scanNetwork({ includeOffline, lanScan });
+        if (jsonOut) {
+            console.log(JSON.stringify(payload, null, 2));
+        }
+        else {
+            printPayload(payload);
+        }
+        if (payload.servers.length === 0) {
+            process.exitCode = 2;
+        }
     }
-    printResults(results, networkLabel, sources);
-    if (!results.some((r) => r.ok)) {
-        process.exitCode = 2;
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exitCode = 1;
     }
 }

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