ollanet 0.1.0

package/dist/prompt.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+/**
+ * Run a prompt / continue a chat against an Ollama server on the network.
+ *
+ * New chat (saved by default):
+ *   ollanet prompt mycroftone "What is Tailscale?"
+ *   ollanet prompt 192.168.1.50 "Hello"
+ *
+ * Continue:
+ *   ollanet prompt --chat a1b2c3d4e5f6 "Tell me more"
+ *
+ * List chats:
+ *   ollanet chats
+ */
+import { stdin as stdinStream } from "node:process";
+import { appendMessage, cleanTopic, createChat, loadChat, saveChat, toApiMessages, topicFromPrompt, } from "./chat-store.js";
+import { configPath, defaultModelForHost, loadConfig, machineSettingsForHost, mergeSettings, parseFormat, settingsFromEnv, settingsSummary, } from "./config.js";
+import { discoverHosts, ollamaBaseUrl, resolveHost, shortName, } from "./hosts.js";
+function usage() {
+    console.error(`Usage:
+  ollanet prompt <machine> [model] <prompt...>
+  ollanet prompt --chat <hash> <prompt...>
+  ollanet prompt <machine> --chat <hash> <prompt...>
+
+Examples:
+  ollanet prompt mycroftone "Explain MagicDNS"
+  ollanet prompt --chat a1b2c3d4e5f6 "Give an example"
+  ollanet prompt mycroftone --temperature 0.2 --num-predict 64 "2+2?"
+  ollanet chats
+
+Each reply is saved under responses/<hash>.json and the hash is printed so you
+can continue later with --chat. Use --no-save to skip persistence.
+
+Config: ${configPath()}
+Precedence: CLI > env > machineDefaults > defaults
+
+Options:
+  --chat <hash>          Continue a saved chat
+  --machine <name>       Machine (new chat positional, or override when using --chat)
+  --no-save              Do not write/update a responses/*.json transcript
+  --model <name>         Model (overrides config / chat default)
+  --system <text>        System prompt (new chats only unless chat has none)
+  --temperature <n>      Sampling temperature
+  --num-predict <n>      Max tokens to generate
+  --num-ctx <n>          Context window size
+  --keep-alive <value>   Keep model loaded (e.g. 5m, 0, -1)
+  --format <json|schema> Force JSON mode or a JSON schema string
+  --no-stream            Wait for the full response
+  --json                 Emit final response JSON (implies --no-stream)`);
+    process.exit(1);
+}
+function looksLikeModel(value) {
+    return value.includes(":") || value.includes("/");
+}
+function takeValue(args, flag) {
+    const value = args.shift();
+    if (!value) {
+        console.error(`${flag} requires a value`);
+        usage();
+    }
+    return value;
+}
+function parseNumberFlag(raw, flag) {
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        console.error(`${flag} must be a number (got "${raw}")`);
+        usage();
+    }
+    return n;
+}
+function parseArgs(argv) {
+    const args = [...argv];
+    let machineFlag;
+    let modelFlag;
+    let chatId;
+    let stream = true;
+    let json = false;
+    let save = true;
+    const settings = {};
+    const positional = [];
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h")
+            usage();
+        if (arg === "--no-stream") {
+            stream = false;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            stream = false;
+            continue;
+        }
+        if (arg === "--no-save") {
+            save = false;
+            continue;
+        }
+        if (arg === "--chat" || arg.startsWith("--chat=")) {
+            chatId = arg.includes("=") ? arg.slice("--chat=".length) : takeValue(args, "--chat");
+            continue;
+        }
+        if (arg === "--machine" || arg.startsWith("--machine=")) {
+            machineFlag = arg.includes("=") ? arg.slice("--machine=".length) : takeValue(args, "--machine");
+            continue;
+        }
+        if (arg === "--model" || arg.startsWith("--model=")) {
+            modelFlag = arg.includes("=") ? arg.slice("--model=".length) : takeValue(args, "--model");
+            continue;
+        }
+        if (arg === "--system" || arg.startsWith("--system=")) {
+            settings.system = arg.includes("=")
+                ? arg.slice("--system=".length)
+                : takeValue(args, "--system");
+            continue;
+        }
+        if (arg === "--temperature" || arg === "-t" || arg.startsWith("--temperature=")) {
+            const raw = arg.includes("=") ? arg.slice("--temperature=".length) : takeValue(args, "--temperature");
+            settings.temperature = parseNumberFlag(raw, "--temperature");
+            continue;
+        }
+        if (arg === "--num-predict" || arg.startsWith("--num-predict=")) {
+            const raw = arg.includes("=") ? arg.slice("--num-predict=".length) : takeValue(args, "--num-predict");
+            settings.num_predict = Math.trunc(parseNumberFlag(raw, "--num-predict"));
+            continue;
+        }
+        if (arg === "--num-ctx" || arg.startsWith("--num-ctx=")) {
+            const raw = arg.includes("=") ? arg.slice("--num-ctx=".length) : takeValue(args, "--num-ctx");
+            settings.num_ctx = Math.trunc(parseNumberFlag(raw, "--num-ctx"));
+            continue;
+        }
+        if (arg === "--keep-alive" || arg.startsWith("--keep-alive=")) {
+            const raw = arg.includes("=") ? arg.slice("--keep-alive=".length) : takeValue(args, "--keep-alive");
+            const asNum = Number(raw);
+            settings.keep_alive = raw.trim() !== "" && Number.isFinite(asNum) && String(asNum) === raw ? asNum : raw;
+            continue;
+        }
+        if (arg === "--format" || arg.startsWith("--format=")) {
+            const raw = arg.includes("=") ? arg.slice("--format=".length) : takeValue(args, "--format");
+            const format = parseFormat(raw);
+            if (format !== undefined)
+                settings.format = format;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            console.error(`Unknown flag: ${arg}`);
+            usage();
+        }
+        positional.push(arg);
+    }
+    let machine = machineFlag;
+    let model = modelFlag;
+    let promptParts = positional;
+    if (!chatId) {
+        // New chat: <machine> [model] <prompt...>
+        if (!machine) {
+            if (positional.length < 1)
+                usage();
+            machine = positional[0];
+            promptParts = positional.slice(1);
+        }
+        if (!model && promptParts.length > 0 && looksLikeModel(promptParts[0])) {
+            model = promptParts[0];
+            promptParts = promptParts.slice(1);
+        }
+    }
+    // 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 };
+}
+async function readStdinIfPiped() {
+    if (stdinStream.isTTY)
+        return "";
+    const chunks = [];
+    for await (const chunk of stdinStream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8").trim();
+}
+function buildOptions(settings) {
+    const options = {};
+    if (settings.temperature != null)
+        options.temperature = settings.temperature;
+    if (settings.num_predict != null)
+        options.num_predict = settings.num_predict;
+    if (settings.num_ctx != null)
+        options.num_ctx = settings.num_ctx;
+    return options;
+}
+async function runChat(opts) {
+    const url = `${opts.baseUrl}/api/chat`;
+    const body = {
+        model: opts.model,
+        messages: opts.messages,
+        stream: opts.stream,
+    };
+    if (opts.settings.keep_alive != null)
+        body.keep_alive = opts.settings.keep_alive;
+    if (opts.settings.format !== undefined)
+        body.format = opts.settings.format;
+    const options = buildOptions(opts.settings);
+    if (Object.keys(options).length > 0)
+        body.options = options;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
+    }
+    if (!opts.stream) {
+        const chunk = (await res.json());
+        if (chunk.error)
+            throw new Error(chunk.error);
+        const content = chunk.message?.content ?? "";
+        if (opts.writeStdout)
+            process.stdout.write(`${content}\n`);
+        return { content, chunk };
+    }
+    if (!res.body)
+        throw new Error("No response body from Ollama");
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let last = {};
+    let content = "";
+    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;
+            const chunk = JSON.parse(trimmed);
+            if (chunk.error)
+                throw new Error(chunk.error);
+            const piece = chunk.message?.content ?? "";
+            if (piece) {
+                content += piece;
+                if (opts.writeStdout)
+                    process.stdout.write(piece);
+            }
+            last = chunk;
+        }
+    }
+    const trailing = buffer.trim();
+    if (trailing) {
+        const chunk = JSON.parse(trailing);
+        if (chunk.error)
+            throw new Error(chunk.error);
+        const piece = chunk.message?.content ?? "";
+        if (piece) {
+            content += piece;
+            if (opts.writeStdout)
+                process.stdout.write(piece);
+        }
+        last = chunk;
+    }
+    if (opts.writeStdout && content.length > 0 && !content.endsWith("\n")) {
+        process.stdout.write("\n");
+    }
+    return { content, chunk: last };
+}
+async function generateTopic(opts) {
+    const fallback = topicFromPrompt(opts.prompt);
+    try {
+        const { content } = await runChat({
+            baseUrl: opts.baseUrl,
+            model: opts.model,
+            stream: false,
+            writeStdout: false,
+            settings: mergeSettings(opts.settings, {
+                temperature: 0.2,
+                num_predict: 24,
+                // keep_alive 0 so topic pass doesn't pin the model longer than needed
+                keep_alive: 0,
+            }),
+            messages: [
+                {
+                    role: "user",
+                    content: "Write a concise 3-8 word topic title for the following user message. " +
+                        "Reply with only the title, no quotes or punctuation wrapping.\n\n" +
+                        opts.prompt,
+                },
+            ],
+        });
+        return cleanTopic(content, fallback);
+    }
+    catch {
+        return fallback;
+    }
+}
+function formatDuration(ns) {
+    if (ns == null)
+        return "";
+    const ms = ns / 1e6;
+    if (ms < 1000)
+        return `${ms.toFixed(0)}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+export async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    const { promptParts, stream, json, save } = parsed;
+    const fromArgs = promptParts.join(" ").trim();
+    const fromStdin = await readStdinIfPiped();
+    const prompt = [fromArgs, fromStdin].filter(Boolean).join("\n\n").trim();
+    if (!prompt) {
+        console.error("No prompt provided (pass args and/or pipe stdin).");
+        usage();
+    }
+    const config = await loadConfig();
+    const { hosts: targets } = await discoverHosts({
+        hosts: config.hosts,
+        discovery: config.discovery,
+    });
+    let chat;
+    let isNewChat = false;
+    let machineQuery = parsed.machine;
+    let promptText = prompt;
+    if (parsed.chatId) {
+        chat = await loadChat(parsed.chatId);
+        // Allow `ollanet prompt mycroftone --chat HASH "follow-up"` by peeling a
+        // leading positional that matches a discovered host.
+        if (!machineQuery && promptParts.length >= 2) {
+            try {
+                resolveHost(targets, promptParts[0]);
+                machineQuery = promptParts[0];
+                promptText = [...promptParts.slice(1), fromStdin].filter(Boolean).join("\n\n").trim();
+            }
+            catch {
+                // first token is part of the prompt
+            }
+        }
+    }
+    machineQuery = machineQuery ?? chat?.machine;
+    if (!machineQuery) {
+        console.error("Machine is required for a new chat (or use --chat <hash>).");
+        usage();
+    }
+    if (!promptText) {
+        console.error("No prompt provided (pass args and/or pipe stdin).");
+        usage();
+    }
+    const host = resolveHost(targets, machineQuery);
+    if (!host.online && !host.isSelf && host.source === "tailscale") {
+        throw new Error(`Machine "${shortName(host)}" appears offline.`);
+    }
+    const model = parsed.model ??
+        chat?.model ??
+        defaultModelForHost(config, host);
+    if (!model) {
+        throw new Error(`No model specified for "${shortName(host)}" and no default in ${configPath()}.\n` +
+            `Pass a model, use --model <name>, or add it under defaultModels.`);
+    }
+    const settings = mergeSettings(config.defaults, machineSettingsForHost(config, host), settingsFromEnv(), chat?.system ? { system: chat.system } : undefined, parsed.settings);
+    if (!chat && save) {
+        chat = createChat({
+            machine: shortName(host),
+            model,
+            system: settings.system,
+            topic: topicFromPrompt(promptText),
+        });
+        isNewChat = true;
+    }
+    else if (!chat) {
+        // --no-save one-shot: ephemeral transcript for the API call only
+        chat = createChat({
+            machine: shortName(host),
+            model,
+            system: settings.system,
+        });
+        isNewChat = true;
+    }
+    else {
+        if (parsed.settings.system && !chat.system) {
+            chat.system = parsed.settings.system;
+        }
+        chat.model = model;
+        chat.machine = shortName(host);
+    }
+    appendMessage(chat, { role: "user", content: promptText });
+    const baseUrl = ollamaBaseUrl(host);
+    if (!json) {
+        const src = parsed.model ? "explicit" : chat && !isNewChat ? "chat" : "default";
+        const extras = settingsSummary(settings);
+        const chatTag = parsed.chatId ? `  chat=${chat.id}` : "";
+        console.error(`→ ${shortName(host)} (${host.ip})  model=${model}  [${src}]${chatTag}${extras ? `  ${extras}` : ""}`);
+    }
+    const { content, chunk } = await runChat({
+        baseUrl,
+        model,
+        messages: toApiMessages(chat),
+        stream: json ? false : stream,
+        writeStdout: !json,
+        settings,
+    });
+    appendMessage(chat, {
+        role: "assistant",
+        content,
+        machine: shortName(host),
+        model,
+        stats: {
+            eval_count: chunk.eval_count,
+            eval_duration: chunk.eval_duration,
+            total_duration: chunk.total_duration,
+            prompt_eval_count: chunk.prompt_eval_count,
+        },
+    });
+    if (isNewChat && save) {
+        chat.topic = await generateTopic({
+            baseUrl,
+            model,
+            prompt: promptText,
+            settings,
+        });
+    }
+    if (save) {
+        const file = await saveChat(chat);
+        if (!json) {
+            console.error(`chat ${chat.id}  topic: ${chat.topic}`);
+            console.error(`saved ${file}`);
+            console.error(`continue: ollanet prompt --chat ${chat.id} "your follow-up"`);
+        }
+    }
+    if (json) {
+        console.log(JSON.stringify({
+            chat_id: save ? chat.id : null,
+            topic: chat.topic,
+            content,
+            ollama: chunk,
+        }, null, 2));
+        return;
+    }
+    const stats = [
+        chunk.eval_count != null ? `${chunk.eval_count} tokens` : "",
+        chunk.eval_duration
+            ? `${((chunk.eval_count ?? 0) / (chunk.eval_duration / 1e9)).toFixed(1)} tok/s`
+            : "",
+        chunk.total_duration ? formatDuration(chunk.total_duration) : "",
+    ].filter(Boolean);
+    if (stats.length > 0) {
+        console.error(`(${stats.join(" · ")})`);
+    }
+}

package/dist/scan.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * Scan reachable networks for Ollama servers and list available models.
+ *
+ * Usage: ollanet scan [--lan] [--json] [--all]
+ */
+import { loadConfig } from "./config.js";
+import { OLLAMA_PORT, discoverHosts, shortName, } from "./hosts.js";
+const TIMEOUT_MS = Number(process.env.OLLAMA_TIMEOUT_MS ?? 2500);
+const CONCURRENCY = Number(process.env.OLLAMA_CONCURRENCY ?? 16);
+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]}`;
+}
+async function fetchModels(host) {
+    const url = `http://${host.ip.includes(":") ? `[${host.ip}]` : host.ip}:${host.port}/api/tags`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        }
+        const body = (await res.json());
+        return { models: body.models ?? [], url };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function mapPool(items, concurrency, worker) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function run() {
+        while (next < items.length) {
+            const index = next;
+            next += 1;
+            results[index] = await worker(items[index]);
+        }
+    }
+    const runners = Array.from({ length: Math.min(concurrency, items.length) }, () => run());
+    await Promise.all(runners);
+    return results;
+}
+async function scanHost(host) {
+    const url = `http://${host.ip}:${host.port}/api/tags`;
+    if (!host.online && !host.isSelf && host.source === "tailscale") {
+        return { host, ok: false, models: [], error: "offline", url };
+    }
+    try {
+        const { models } = await fetchModels(host);
+        return { host, ok: true, models, url };
+    }
+    catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        const message = err instanceof Error ? err.message : String(err);
+        const error = name === "AbortError" || message.toLowerCase().includes("abort")
+            ? `timeout after ${TIMEOUT_MS}ms`
+            : message;
+        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) {
+        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");
+        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}`);
+            }
+        }
+        return;
+    }
+    for (const result of found) {
+        const label = result.host.dnsName || result.host.hostname;
+        const selfTag = result.host.isSelf ? " [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("  Models: (none)");
+        }
+        else {
+            console.log(`  Models (${result.models.length}):`);
+            for (const model of result.models) {
+                const size = formatBytes(model.size);
+                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}`);
+            }
+        }
+        console.log("");
+    }
+    console.log(`Found ${found.length} Ollama server(s) with ${found.reduce((n, r) => n + r.models.length, 0)} model entrie(s).`);
+}
+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;
+        return;
+    }
+    const results = await mapPool(hosts, CONCURRENCY, scanHost);
+    if (jsonOut) {
+        console.log(JSON.stringify({
+            network: networkLabel,
+            sources,
+            port: OLLAMA_PORT,
+            scanned: results.length,
+            servers: results
+                .filter((r) => r.ok)
+                .map((r) => ({
+                hostname: r.host.hostname,
+                dnsName: r.host.dnsName,
+                ip: r.host.ip,
+                port: r.host.port,
+                os: r.host.os,
+                source: r.host.source,
+                self: r.host.isSelf,
+                endpoint: `http://${r.host.ip}:${r.host.port}`,
+                models: r.models.map((m) => ({
+                    name: m.name,
+                    size: m.size,
+                    modified_at: m.modified_at,
+                    parameter_size: m.details?.parameter_size,
+                    quantization_level: m.details?.quantization_level,
+                    family: m.details?.family,
+                })),
+            })),
+        }, null, 2));
+        return;
+    }
+    printResults(results, networkLabel, sources);
+    if (!results.some((r) => r.ok)) {
+        process.exitCode = 2;
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "ollanet",
+  "version": "0.1.0",
+  "description": "Chat with Ollama servers on any reachable network — scan hosts, prompt models, continue chats by hash",
+  "type": "module",
+  "bin": {
+    "ollanet": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "tsc -p tsconfig.build.json",
+    "ollanet": "tsx src/cli.ts",
+    "scan": "tsx src/cli.ts scan",
+    "prompt": "tsx src/cli.ts prompt",
+    "chats": "tsx src/cli.ts chats",
+    "start": "tsx src/cli.ts scan",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "ollama",
+    "cli",
+    "llm",
+    "chat",
+    "lan",
+    "tailscale",
+    "network"
+  ],
+  "author": "Catalyst Forge LLC",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Catalyst-Forge-LLC/ollanet.git"
+  },
+  "homepage": "https://github.com/Catalyst-Forge-LLC/ollanet#readme",
+  "bugs": {
+    "url": "https://github.com/Catalyst-Forge-LLC/ollanet/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@8.14.1",
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "tsx": "^4.23.12",
+    "typescript": "^5.8.3"
+  }
+}