ollanet 0.4.1 → 0.5.0

package/README.md

@@ -18,7 +18,7 @@ This started as a personal little script. I had Ollama running on a laptop on my
 
 ## Related: Finetuna
 
-**ollanet** is the client-side / network tool. On the machine that *runs* Ollama, use **[Finetuna](https://github.com/Catalyst-Forge-LLC/finetuna)** to turn a stock model into a GPU-tuned, named variant (context, batch, Modelfile, auto-tune).
+**ollanet** is the client-side / network tool. On the machine that *runs* Ollama, use **[Finetuna](https://finetuna.net)** to turn a stock model into a GPU-tuned, named variant (context, batch, Modelfile, auto-tune).
 
 Typical loop:
 
@@ -30,11 +30,13 @@ They share the same Ollama API; Finetuna shapes the models, ollanet finds and ch
 ## Features
 
 - **Discover** Ollama hosts from localhost, `config.hosts`, `OLLANET_HOSTS`, optional Tailscale, and optional LAN scan (`--lan`, off by default)
+- **Pull** a library model onto a named host (`ollanet pull studio gemma3:12b`) — the server downloads; re-pull updates
+- **Show / rm / ps** — inspect a Modelfile, delete a model (`--yes`), see what’s in VRAM. Scan marks Finetuna-style `[tuned]` names
 - **Prompt** any hostname/IP/model with streaming replies
 - **Persist** chats as `responses/<hash>.json` with topic, machine, model, timestamps
 - **Continue** any thread with `--chat <hash>`
 - **Configure** per-machine defaults (model, temperature, context, …)
-- **MCP** — `ollanet mcp` exposes scan/prompt/chats as Model Context Protocol tools for agents
+- **MCP** — `ollanet mcp` exposes scan/prompt/pull/show/rm/ps/chats as Model Context Protocol tools for agents
 - **Library** — `import { scanNetwork } from "ollanet"` for apps (Node 20+, not the browser)
 
 ## Use cases
@@ -44,11 +46,12 @@ The core idea: turn “I have to remember which IP has which models loaded” in
 **For agents and automation** — prefer `ollanet mcp` (stdio MCP). The same flows also work via CLI flags:
 
 - **Live model inventory / routing** — `ollanet_scan` (or `scan --json`) lists reachable hosts and models. Route each sub-task to the best host: the big-VRAM box for reasoning, the laptop for quick lookups.
+- **Put a new model on a box** — `ollanet_pull` (or `pull studio gemma3:12b`) asks that host to download from the registry. Re-pull updates. Then `show` / `ps` / `rm` manage what’s on that disk and in VRAM.
 - **Conversations that survive machines** — chats are stored by short hash with full history. Start a long thread on the GPU box, continue it later with `ollanet_prompt` + `chat_id` (or `--chat <hash>`).
 - **A “talk to any Ollama on my network” tool** — `ollanet_prompt` / `prompt … --json --no-stream`; no hard-coded endpoints.
 - **Embed in an app** — same scan + pick + call as a library. The app does not own the GPUs; it discovers them (FilePress, CLIs, Electron, a local companion for a hosted product).
 - **Fleet health and speed checks** — periodic `ollanet bench <host> --json` builds a record of which model on which machine is currently fastest (or has silently gone offline). Saved results live in `benchmarks/`.
-- **The Finetuna loop** — [Finetuna](https://github.com/Catalyst-Forge-LLC/finetuna) shapes a GPU-tuned named variant on the host; ollanet discovers and uses it from anywhere on the network.
+- **The Finetuna loop** — [Finetuna](https://finetuna.net) shapes a GPU-tuned named variant on the host; ollanet `scan` / `show` / `prompt` it from anywhere on the network. After `pull`, ollanet prints the next step (`finetuna --model …`).
 
 **For humans:**
 
@@ -115,6 +118,11 @@ ollanet scan
 # Also TCP-scan your local /24s for open Ollama ports
 ollanet scan --lan
 
+# Put a library model on a named machine (that host downloads it)
+ollanet pull studio gemma3:12b
+ollanet show studio gemma3:12b
+ollanet ps studio
+
 # Talk to a machine by name, MagicDNS name, or IP
 ollanet prompt localhost "What is MagicDNS?"
 ollanet prompt 192.168.1.50 gemma4:12b "Hello from the LAN"
@@ -162,7 +170,9 @@ await scanNetwork({
 
 `runPrompt({ save: false, writeStdout: false })` is a one-shot call that does not write `~/.ollanet/responses/`.
 
-Requires **ollanet ≥ 0.4.0**. Bundlers (Vite / SvelteKit SSR):
+`pullModel({ machine, model })` asks that host to download (or update) a library model. The bits never transit ollanet. `showModel`, `removeModel({ yes: true })`, and `listLoaded` are the inspect / delete / VRAM trio.
+
+Requires **ollanet ≥ 0.4.0** (library). **Model management (`pull` / `show` / `rm` / `ps`) needs ≥ 0.5.0.** Bundlers (Vite / SvelteKit SSR):
 
 ```ts
 // vite.config.ts
@@ -175,6 +185,10 @@ optimizeDeps: { exclude: ["ollanet"] },
 | Command | Description |
 |---|---|
 | `ollanet scan` | Probe known/discovered hosts for Ollama + list models |
+| `ollanet pull <machine> <model>` | Ask that host to download / update a library model |
+| `ollanet show <machine> <model>` | Inspect Modelfile / params / capabilities (`[tuned]` when it looks like Finetuna) |
+| `ollanet rm <machine> <model> --yes` | Delete a model from that host’s disk |
+| `ollanet ps [machine]` | Models loaded in VRAM (omit machine = every discovered host) |
 | `ollanet prompt …` | Send a prompt / continue a chat |
 | `ollanet chats` | List or inspect saved transcripts |
 | `ollanet bench …` | Benchmark models for tok/s + lightweight quality checks |
@@ -211,6 +225,40 @@ ollanet prompt --chat <hash> <prompt...>
 
 Machine can be a discovered name, hostname, FQDN, or IP (`192.168.1.50`, `host:11434`). Direct addresses work even if they were never scanned.
 
+### `pull` options
+
+```text
+ollanet pull <machine|ip> <model>
+```
+
+The named machine downloads from the Ollama registry onto **its** disk. Re-pulling the same name updates it. This is not a file upload and not a Finetuna runtime tune.
+
+| Flag | Meaning |
+|---|---|
+| `--machine <name>` | Host (same resolution as `prompt`) |
+| `--model <name>` | Model to pull |
+| `--insecure` | Allow HTTP / self-signed registries |
+| `--no-stream` | Single final response (no progress chunks) |
+| `--json` | Result JSON on stdout |
+
+Timeout default is none (large pulls can take hours). Override with `OLLAMA_PULL_TIMEOUT_MS`. After a successful pull, stderr points at [Finetuna](https://finetuna.net) for a host-side named variant.
+
+### `show` / `rm` / `ps`
+
+```text
+ollanet show <machine|ip> <model>
+ollanet rm <machine|ip> <model> --yes
+ollanet ps [machine]
+```
+
+| Flag | Meaning |
+|---|---|
+| `--yes` / `-y` | Required for `rm` unless you confirm on a TTY |
+| `--json` | Result JSON on stdout |
+| `--machine` / `--model` | Same host resolution as `prompt` |
+
+`scan` is on-disk inventory and marks `*-ctx32k` / `*-flash` / `*finetuna*` as `[tuned]`. `ps` is what’s resident. `show` reads the Modelfile so you can see a Finetuna bake from another machine.
+
 ### `chats` options
 
 - `--json` — list summary JSON
@@ -228,6 +276,10 @@ Runs a **stdio MCP server** (no extra npm deps). Cursor / Claude Desktop / any M
 |---|---|
 | `ollanet_scan` | Discover hosts + models (`lan`, `all` optional) |
 | `ollanet_prompt` | Prompt a host or continue with `chat_id` |
+| `ollanet_pull` | Pull / update a model on a host (`machine`, `model`) |
+| `ollanet_show` | Inspect a model (`machine`, `model`) |
+| `ollanet_rm` | Delete a model (`machine`, `model`, `confirm: true`) |
+| `ollanet_ps` | Loaded models (`machine` optional) |
 | `ollanet_list_chats` | Summarize saved transcripts |
 | `ollanet_get_chat` | Load one chat (full history) |
 

package/dist/cli.d.ts

@@ -4,6 +4,10 @@
  *
  *   ollanet scan
  *   ollanet prompt <machine-or-ip> "hello"
+ *   ollanet pull <machine> <model>
+ *   ollanet show <machine> <model>
+ *   ollanet rm <machine> <model> --yes
+ *   ollanet ps [machine]
  *   ollanet chats
  */
 export {};

package/dist/cli.js

@@ -4,6 +4,10 @@
  *
  *   ollanet scan
  *   ollanet prompt <machine-or-ip> "hello"
+ *   ollanet pull <machine> <model>
+ *   ollanet show <machine> <model>
+ *   ollanet rm <machine> <model> --yes
+ *   ollanet ps [machine]
  *   ollanet chats
  */
 const HELP = `ollanet — Ollama over your network
@@ -15,6 +19,10 @@ Usage:
   ollanet scan [--json] [--all] [--lan]
   ollanet prompt <machine|ip> [model] <prompt...>
   ollanet prompt --chat <hash> <prompt...>
+  ollanet pull <machine|ip> <model>
+  ollanet show <machine|ip> <model>
+  ollanet rm <machine|ip> <model> --yes
+  ollanet ps [machine]
   ollanet chats [--json] [--id <hash>]
   ollanet bench <machine|ip> [model...] [--all] [options]
   ollanet mcp
@@ -25,6 +33,10 @@ Examples:
   ollanet prompt localhost "What is MagicDNS?"
   ollanet prompt 192.168.1.50 gemma4:12b "Hello"
   ollanet prompt --chat a1b2c3d4e5f6 "Tell me more"
+  ollanet pull studio gemma3:12b
+  ollanet show studio gemma4-ctx32k
+  ollanet rm studio llama3.2:1b --yes
+  ollanet ps studio
   ollanet chats
   ollanet bench localhost --all
   ollanet bench localhost llama3.2:1b --runs 3
@@ -73,6 +85,30 @@ async function main() {
             await run();
             return;
         }
+        case "pull":
+        case "download": {
+            const { main: run } = await import("./pull.js");
+            await run();
+            return;
+        }
+        case "show":
+        case "inspect": {
+            const { main: run } = await import("./show.js");
+            await run();
+            return;
+        }
+        case "rm":
+        case "delete": {
+            const { main: run } = await import("./rm.js");
+            await run();
+            return;
+        }
+        case "ps":
+        case "loaded": {
+            const { main: run } = await import("./ps.js");
+            await run();
+            return;
+        }
         case "bench":
         case "benchmark": {
             const { main: run } = await import("./bench.js");

package/dist/index.d.ts

@@ -15,4 +15,14 @@ export { loadConfig, defaultModelForHost, mergeSettings, configFromPartial, } fr
 export type { AppConfig, DiscoveryConfig, GenerateSettings } from "./config.js";
 export { runPrompt } from "./prompt.js";
 export type { PromptRunOptions, PromptRunResult } from "./prompt.js";
-export { ollamaChat, ollamaTags, ollamaShow, ollamaPs } from "./ollama-chat.js";
+export { pullModel } from "./pull.js";
+export type { PullOptions, PullResult } from "./pull.js";
+export { showModel } from "./show.js";
+export type { ShowOptions, ShowResult } from "./show.js";
+export { removeModel } from "./rm.js";
+export type { RemoveOptions, RemoveResult } from "./rm.js";
+export { listLoaded } from "./ps.js";
+export type { PsOptions, PsResult, LoadedHost, LoadedModel } from "./ps.js";
+export { looksTuned } from "./tuned.js";
+export { ollamaChat, ollamaTags, ollamaShow, ollamaPs, ollamaPsRequired, ollamaPull, ollamaDelete, } from "./ollama-chat.js";
+export type { PullChunk, OllamaPullOptions, OllamaPullResult, OllamaShowInfo, } from "./ollama-chat.js";

package/dist/index.js

@@ -11,4 +11,9 @@ export { scanNetwork } from "./scan.js";
 export { discoverHosts, resolveHost, ollamaBaseUrl, shortName, ollamaPort, } from "./hosts.js";
 export { loadConfig, defaultModelForHost, mergeSettings, configFromPartial, } from "./config.js";
 export { runPrompt } from "./prompt.js";
-export { ollamaChat, ollamaTags, ollamaShow, ollamaPs } from "./ollama-chat.js";
+export { pullModel } from "./pull.js";
+export { showModel } from "./show.js";
+export { removeModel } from "./rm.js";
+export { listLoaded } from "./ps.js";
+export { looksTuned } from "./tuned.js";
+export { ollamaChat, ollamaTags, ollamaShow, ollamaPs, ollamaPsRequired, ollamaPull, ollamaDelete, } from "./ollama-chat.js";

package/dist/mcp.js

@@ -12,8 +12,12 @@ import { createInterface } from "node:readline";
 import { readFile } from "node:fs/promises";
 import { listChats, loadChat } from "./chat-store.js";
 import { projectPath } from "./paths.js";
+import { listLoaded } from "./ps.js";
+import { pullModel } from "./pull.js";
 import { runPrompt } from "./prompt.js";
+import { removeModel } from "./rm.js";
 import { scanNetwork } from "./scan.js";
+import { showModel } from "./show.js";
 // Pin to the oldest widely-supported MCP revision. Clients may request a newer
 // date; we still answer with this — legal negotiation, max compatibility.
 const PROTOCOL_VERSION = "2024-11-05";
@@ -85,6 +89,78 @@ const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "ollanet_pull",
+        description: "Pull (or update) a model onto a reachable Ollama host. " +
+            "The named machine downloads from the registry onto its own disk — " +
+            "ollanet does not upload weights. Machine is a discovered name, MagicDNS name, hostname, or IP[:port].",
+        inputSchema: {
+            type: "object",
+            properties: {
+                machine: {
+                    type: "string",
+                    description: "Host name/IP that should download the model",
+                },
+                model: {
+                    type: "string",
+                    description: "Model to pull (e.g. gemma3:12b)",
+                },
+                insecure: {
+                    type: "boolean",
+                    description: "Allow HTTP / self-signed model registries (default false)",
+                },
+            },
+            required: ["machine", "model"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_show",
+        description: "Inspect a model on a reachable Ollama host (Modelfile, parameters, capabilities). " +
+            "Marks Finetuna-style tuned names. Machine is a discovered name, MagicDNS name, hostname, or IP[:port].",
+        inputSchema: {
+            type: "object",
+            properties: {
+                machine: { type: "string", description: "Host name/IP" },
+                model: { type: "string", description: "Model to inspect" },
+            },
+            required: ["machine", "model"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_rm",
+        description: "Delete a model from a reachable Ollama host's disk. Destructive. " +
+            "Requires confirm=true. Machine is a discovered name, MagicDNS name, hostname, or IP[:port].",
+        inputSchema: {
+            type: "object",
+            properties: {
+                machine: { type: "string", description: "Host name/IP" },
+                model: { type: "string", description: "Model to delete" },
+                confirm: {
+                    type: "boolean",
+                    description: "Must be true to actually delete (default false)",
+                },
+            },
+            required: ["machine", "model", "confirm"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_ps",
+        description: "List models currently loaded in VRAM. Optional machine; omit to probe every discovered host. " +
+            "scan is on-disk inventory; ps is what is resident right now.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                machine: {
+                    type: "string",
+                    description: "Host name/IP (optional; omit for all discovered hosts)",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
     {
         name: "ollanet_list_chats",
         description: "List saved ollanet chat transcripts (id, topic, machine, model, message count).",
@@ -187,6 +263,47 @@ async function callTool(name, args) {
             });
             return textResult(result);
         }
+        case "ollanet_pull": {
+            const machine = typeof args.machine === "string" ? args.machine : "";
+            const model = typeof args.model === "string" ? args.model : "";
+            if (!machine.trim())
+                return textResult({ error: "machine is required" }, true);
+            if (!model.trim())
+                return textResult({ error: "model is required" }, true);
+            const result = await pullModel({
+                machine,
+                model,
+                insecure: args.insecure === true,
+                writeStdout: false,
+                quiet: true,
+            });
+            return textResult(result);
+        }
+        case "ollanet_show": {
+            const machine = typeof args.machine === "string" ? args.machine : "";
+            const model = typeof args.model === "string" ? args.model : "";
+            if (!machine.trim())
+                return textResult({ error: "machine is required" }, true);
+            if (!model.trim())
+                return textResult({ error: "model is required" }, true);
+            return textResult(await showModel({ machine, model }));
+        }
+        case "ollanet_rm": {
+            const machine = typeof args.machine === "string" ? args.machine : "";
+            const model = typeof args.model === "string" ? args.model : "";
+            if (!machine.trim())
+                return textResult({ error: "machine is required" }, true);
+            if (!model.trim())
+                return textResult({ error: "model is required" }, true);
+            if (args.confirm !== true) {
+                return textResult({ error: "confirm must be true to delete a model" }, true);
+            }
+            return textResult(await removeModel({ machine, model, yes: true }));
+        }
+        case "ollanet_ps": {
+            const machine = typeof args.machine === "string" ? args.machine : undefined;
+            return textResult(await listLoaded({ machine }));
+        }
         case "ollanet_list_chats": {
             const chats = await listChats();
             return textResult(chats.map((c) => ({

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