ollanet 0.1.0 → 0.2.0

package/dist/prompt.js

@@ -3,7 +3,7 @@
  * 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 localhost "What is Tailscale?"
  *   ollanet prompt 192.168.1.50 "Hello"
  *
  * Continue:
@@ -15,7 +15,10 @@
 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";
+import { discoverHosts, envInt, findDiscoveredHost, ollamaBaseUrl, resolveHost, shortName, } from "./hosts.js";
+import { ollamaChat } from "./ollama-chat.js";
+/** Prompt/chat HTTP timeout (ms). 0 = no timeout. Separate from scan's OLLAMA_TIMEOUT_MS. */
+const PROMPT_TIMEOUT_MS = envInt("OLLAMA_PROMPT_TIMEOUT_MS", 600_000);
 function usage() {
     console.error(`Usage:
   ollanet prompt <machine> [model] <prompt...>
@@ -23,9 +26,9 @@ function usage() {
   ollanet prompt <machine> --chat <hash> <prompt...>
 
 Examples:
-  ollanet prompt mycroftone "Explain MagicDNS"
+  ollanet prompt localhost "Explain MagicDNS"
   ollanet prompt --chat a1b2c3d4e5f6 "Give an example"
-  ollanet prompt mycroftone --temperature 0.2 --num-predict 64 "2+2?"
+  ollanet prompt localhost --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
@@ -45,12 +48,72 @@ Options:
   --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
+  --think                Enable model thinking (qwen3 etc.); streams to stderr
+  --no-think             Disable thinking (default) so tokens go to the reply
   --no-stream            Wait for the full response
   --json                 Emit final response JSON (implies --no-stream)`);
     process.exit(1);
 }
+/**
+ * Heuristic for an optional positional model token.
+ * Rejects whitespace (so quoted prompts with ":" stay prompts) and URL schemes.
+ * Confirmed against the host's /api/tags before peeling.
+ */
 function looksLikeModel(value) {
-    return value.includes(":") || value.includes("/");
+    const v = value.trim();
+    if (!v || /\s/.test(v))
+        return false;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(v))
+        return false;
+    return /^[a-z0-9][a-z0-9._-]*([/:@][a-z0-9._-]+)+$/i.test(v);
+}
+function modelNameMatches(available, candidate) {
+    const c = candidate.toLowerCase();
+    return available.some((name) => {
+        const n = name.toLowerCase();
+        return n === c || n.startsWith(`${c}:`) || c.startsWith(`${n}:`);
+    });
+}
+async function listModelNames(host) {
+    const url = `${ollamaBaseUrl(host)}/api/tags`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.min(PROMPT_TIMEOUT_MS || 2500, 5000));
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return (body.models ?? []).map((m) => m.name).filter((n) => Boolean(n));
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Peel a leading model token only when it looks like one and exists on the host. */
+async function maybePeelModel(host, promptParts, fromStdin) {
+    if (promptParts.length === 0)
+        return { promptParts };
+    const candidate = promptParts[0];
+    if (!looksLikeModel(candidate))
+        return { promptParts };
+    const names = await listModelNames(host);
+    if (names) {
+        if (modelNameMatches(names, candidate)) {
+            return { model: candidate, promptParts: promptParts.slice(1) };
+        }
+        return { promptParts };
+    }
+    // Tags unavailable: only peel when something remains for the prompt body.
+    if (promptParts.length > 1 || fromStdin) {
+        return { model: candidate, promptParts: promptParts.slice(1) };
+    }
+    return { promptParts };
 }
 function takeValue(args, flag) {
     const value = args.shift();
@@ -97,6 +160,14 @@ function parseArgs(argv) {
             save = false;
             continue;
         }
+        if (arg === "--think") {
+            settings.think = true;
+            continue;
+        }
+        if (arg === "--no-think") {
+            settings.think = false;
+            continue;
+        }
         if (arg === "--chat" || arg.startsWith("--chat=")) {
             chatId = arg.includes("=") ? arg.slice("--chat=".length) : takeValue(args, "--chat");
             continue;
@@ -150,20 +221,16 @@ function parseArgs(argv) {
         positional.push(arg);
     }
     let machine = machineFlag;
-    let model = modelFlag;
+    const model = modelFlag;
     let promptParts = positional;
     if (!chatId) {
-        // New chat: <machine> [model] <prompt...>
+        // New chat: <machine> [model] <prompt...> — model is peeled later against /api/tags.
         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().
@@ -172,115 +239,51 @@ function parseArgs(argv) {
 async function readStdinIfPiped() {
     if (stdinStream.isTTY)
         return "";
+    // Under npm/pnpm/CI, stdin is often a pipe that never gets EOF. Only drain it
+    // when data arrives promptly; otherwise treat as "no stdin prompt".
+    const hasData = await new Promise((resolve) => {
+        if (stdinStream.readableLength > 0 || stdinStream.readableEnded) {
+            resolve(true);
+            return;
+        }
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            stdinStream.off("readable", onReadable);
+            stdinStream.off("end", onEnd);
+            resolve(value);
+        };
+        const onReadable = () => done(true);
+        const onEnd = () => done(true);
+        stdinStream.once("readable", onReadable);
+        stdinStream.once("end", onEnd);
+        const timer = setTimeout(() => done(stdinStream.readableLength > 0), 25);
+    });
+    if (!hasData)
+        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({
+        const { content } = await ollamaChat({
             baseUrl: opts.baseUrl,
             model: opts.model,
             stream: false,
             writeStdout: false,
+            timeoutMs: PROMPT_TIMEOUT_MS,
             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,
+                think: false,
+                // Inherit caller's keep_alive — do not force-unload the model after topic gen.
             }),
             messages: [
                 {
@@ -307,14 +310,9 @@ function formatDuration(ns) {
 }
 export async function main() {
     const parsed = parseArgs(process.argv.slice(2));
-    const { promptParts, stream, json, save } = parsed;
-    const fromArgs = promptParts.join(" ").trim();
+    const { stream, json, save } = parsed;
+    let promptParts = parsed.promptParts;
     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,
@@ -323,19 +321,15 @@ export async function main() {
     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.
+        // Allow `ollanet prompt <host> --chat HASH "follow-up"` only when the
+        // leading token matches an already-discovered host (not direct-address fallback).
         if (!machineQuery && promptParts.length >= 2) {
-            try {
-                resolveHost(targets, promptParts[0]);
+            const hit = findDiscoveredHost(targets, promptParts[0]);
+            if (hit) {
                 machineQuery = promptParts[0];
-                promptText = [...promptParts.slice(1), fromStdin].filter(Boolean).join("\n\n").trim();
-            }
-            catch {
-                // first token is part of the prompt
+                promptParts = promptParts.slice(1);
             }
         }
     }
@@ -344,22 +338,32 @@ export async function main() {
         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.`);
     }
+    let peeledModel;
+    if (!parsed.chatId && !parsed.model) {
+        const peeled = await maybePeelModel(host, promptParts, fromStdin);
+        peeledModel = peeled.model;
+        promptParts = peeled.promptParts;
+    }
+    const promptText = [promptParts.join(" ").trim(), fromStdin].filter(Boolean).join("\n\n").trim();
+    if (!promptText) {
+        console.error("No prompt provided (pass args and/or pipe stdin).");
+        usage();
+    }
     const model = parsed.model ??
+        peeledModel ??
         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);
+    const settings = mergeSettings(
+    // Thinking models otherwise spend the whole num_predict budget on hidden reasoning.
+    { think: false }, config.defaults, machineSettingsForHost(config, host), settingsFromEnv(), chat?.system ? { system: chat.system } : undefined, parsed.settings);
     if (!chat && save) {
         chat = createChat({
             machine: shortName(host),
@@ -393,17 +397,19 @@ export async function main() {
         const chatTag = parsed.chatId ? `  chat=${chat.id}` : "";
         console.error(`→ ${shortName(host)} (${host.ip})  model=${model}  [${src}]${chatTag}${extras ? `  ${extras}` : ""}`);
     }
-    const { content, chunk } = await runChat({
+    const { content, thinking, chunk } = await ollamaChat({
         baseUrl,
         model,
         messages: toApiMessages(chat),
         stream: json ? false : stream,
         writeStdout: !json,
+        timeoutMs: PROMPT_TIMEOUT_MS,
         settings,
     });
     appendMessage(chat, {
         role: "assistant",
         content,
+        ...(thinking ? { thinking } : {}),
         machine: shortName(host),
         model,
         stats: {
@@ -434,6 +440,7 @@ export async function main() {
             chat_id: save ? chat.id : null,
             topic: chat.topic,
             content,
+            thinking: thinking || null,
             ollama: chunk,
         }, null, 2));
         return;

package/dist/scan.js

@@ -5,9 +5,9 @@
  * 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);
+import { OLLAMA_PORT, discoverHosts, envInt, shortName, } from "./hosts.js";
+const TIMEOUT_MS = envInt("OLLAMA_TIMEOUT_MS", 2500);
+const CONCURRENCY = Math.max(1, envInt("OLLAMA_CONCURRENCY", 16));
 function formatBytes(bytes) {
     if (bytes == null || !Number.isFinite(bytes))
         return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ollanet",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Chat with Ollama servers on any reachable network — scan hosts, prompt models, continue chats by hash",
   "type": "module",
   "bin": {
@@ -18,8 +18,11 @@
     "scan": "tsx src/cli.ts scan",
     "prompt": "tsx src/cli.ts prompt",
     "chats": "tsx src/cli.ts chats",
+    "bench": "tsx src/cli.ts bench",
     "start": "tsx src/cli.ts scan",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "tsc -p tsconfig.build.json && node --test test/*.test.mjs",
+    "test:only": "node --test test/*.test.mjs"
   },
   "keywords": [
     "ollama",