ollanet 0.2.2 → 0.4.0

package/dist/mcp.js

@@ -0,0 +1,287 @@
+/**
+ * ollanet mcp — stdio MCP server (zero deps).
+ *
+ * Speaks the Model Context Protocol over stdin/stdout so agents (Cursor,
+ * Claude Desktop, etc.) can discover hosts, prompt models, and continue chats.
+ *
+ *   ollanet mcp
+ *
+ * stdout is reserved for JSON-RPC; log only to stderr.
+ */
+import { createInterface } from "node:readline";
+import { readFile } from "node:fs/promises";
+import { listChats, loadChat } from "./chat-store.js";
+import { projectPath } from "./paths.js";
+import { runPrompt } from "./prompt.js";
+import { scanNetwork } from "./scan.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";
+const TOOLS = [
+    {
+        name: "ollanet_scan",
+        description: "Discover reachable Ollama hosts and list their models. " +
+            "Use this before routing work to pick a host/model. " +
+            "Optional LAN TCP scan (--lan equivalent) and include offline Tailscale peers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lan: {
+                    type: "boolean",
+                    description: "TCP-scan local LAN CIDRs for open Ollama ports (default false)",
+                },
+                all: {
+                    type: "boolean",
+                    description: "Also probe offline Tailscale peers (default false)",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_prompt",
+        description: "Send a prompt to an Ollama host on the network (or continue a saved chat by id). " +
+            "Returns the assistant reply and chat_id for follow-ups. " +
+            "Machine can be a discovered name, MagicDNS name, hostname, or IP[:port].",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "User message to send",
+                },
+                machine: {
+                    type: "string",
+                    description: "Host name/IP (required for new chats; optional override when continuing)",
+                },
+                model: {
+                    type: "string",
+                    description: "Model name (optional; uses config default or chat model)",
+                },
+                chat_id: {
+                    type: "string",
+                    description: "Continue a saved chat by its hex hash id",
+                },
+                system: {
+                    type: "string",
+                    description: "System prompt (new chats, or if the chat has none yet)",
+                },
+                temperature: { type: "number" },
+                num_predict: { type: "integer" },
+                num_ctx: { type: "integer" },
+                keep_alive: {
+                    description: 'Keep model loaded (e.g. "5m", 0, -1)',
+                },
+                think: {
+                    type: "boolean",
+                    description: "Enable model thinking (default false)",
+                },
+                save: {
+                    type: "boolean",
+                    description: "Persist the transcript (default true)",
+                },
+            },
+            required: ["prompt"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_list_chats",
+        description: "List saved ollanet chat transcripts (id, topic, machine, model, message count).",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_get_chat",
+        description: "Load one saved chat by id, including full message history.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chat_id: {
+                    type: "string",
+                    description: "Hex chat hash from a prior prompt",
+                },
+            },
+            required: ["chat_id"],
+            additionalProperties: false,
+        },
+    },
+];
+function writeMessage(msg) {
+    process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+function ok(id, result) {
+    if (id === undefined)
+        return;
+    writeMessage({ jsonrpc: "2.0", id, result });
+}
+function fail(id, code, message) {
+    if (id === undefined)
+        return;
+    writeMessage({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function textResult(data, isError = false) {
+    const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    return {
+        content: [{ type: "text", text }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+async function packageVersion() {
+    try {
+        const pkg = JSON.parse(await readFile(projectPath("package.json"), "utf8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function callTool(name, args) {
+    switch (name) {
+        case "ollanet_scan": {
+            const payload = await scanNetwork({
+                lanScan: Boolean(args.lan),
+                includeOffline: Boolean(args.all),
+            });
+            return textResult(payload);
+        }
+        case "ollanet_prompt": {
+            const prompt = typeof args.prompt === "string" ? args.prompt : "";
+            if (!prompt.trim()) {
+                return textResult({ error: "prompt is required" }, true);
+            }
+            const settings = {};
+            if (typeof args.system === "string")
+                settings.system = args.system;
+            if (typeof args.temperature === "number")
+                settings.temperature = args.temperature;
+            if (typeof args.num_predict === "number")
+                settings.num_predict = Math.trunc(args.num_predict);
+            if (typeof args.num_ctx === "number")
+                settings.num_ctx = Math.trunc(args.num_ctx);
+            if (typeof args.think === "boolean")
+                settings.think = args.think;
+            if (args.keep_alive !== undefined) {
+                const raw = args.keep_alive;
+                if (typeof raw === "number")
+                    settings.keep_alive = raw;
+                else if (typeof raw === "string") {
+                    const asNum = Number(raw);
+                    settings.keep_alive =
+                        raw.trim() !== "" && Number.isFinite(asNum) && String(asNum) === raw ? asNum : raw;
+                }
+            }
+            const result = await runPrompt({
+                prompt,
+                machine: typeof args.machine === "string" ? args.machine : undefined,
+                model: typeof args.model === "string" ? args.model : undefined,
+                chatId: typeof args.chat_id === "string" ? args.chat_id : undefined,
+                save: args.save === undefined ? true : Boolean(args.save),
+                settings,
+                writeStdout: false,
+                stream: false,
+                quiet: true,
+            });
+            return textResult(result);
+        }
+        case "ollanet_list_chats": {
+            const chats = await listChats();
+            return textResult(chats.map((c) => ({
+                id: c.id,
+                topic: c.topic,
+                machine: c.machine,
+                model: c.model,
+                messages: c.messages.length,
+                created_at: c.created_at,
+                updated_at: c.updated_at,
+            })));
+        }
+        case "ollanet_get_chat": {
+            const id = typeof args.chat_id === "string" ? args.chat_id : "";
+            if (!id)
+                return textResult({ error: "chat_id is required" }, true);
+            const chat = await loadChat(id);
+            return textResult(chat);
+        }
+        default:
+            return textResult({ error: `Unknown tool: ${name}` }, true);
+    }
+}
+async function handleRequest(msg, version) {
+    const { id, method } = msg;
+    if (!method) {
+        fail(id, -32600, "Invalid Request: missing method");
+        return;
+    }
+    // Notifications (no id) — acknowledge silently.
+    if (method === "notifications/initialized" || method.startsWith("notifications/")) {
+        return;
+    }
+    switch (method) {
+        case "initialize":
+            ok(id, {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: { name: "ollanet", version },
+            });
+            return;
+        case "ping":
+            ok(id, {});
+            return;
+        case "tools/list":
+            ok(id, { tools: TOOLS });
+            return;
+        case "tools/call": {
+            const params = (msg.params ?? {});
+            const name = params.name;
+            if (!name) {
+                fail(id, -32602, "tools/call requires params.name");
+                return;
+            }
+            try {
+                const result = await callTool(name, params.arguments ?? {});
+                ok(id, result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                ok(id, textResult({ error: message }, true));
+            }
+            return;
+        }
+        default:
+            fail(id, -32601, `Method not found: ${method}`);
+    }
+}
+export async function main() {
+    const version = await packageVersion();
+    console.error(`ollanet mcp ${version} (stdio) — tools: ${TOOLS.map((t) => t.name).join(", ")}`);
+    const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            writeMessage({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            continue;
+        }
+        // JSON-RPC batch
+        if (Array.isArray(msg)) {
+            for (const item of msg) {
+                await handleRequest(item, version);
+            }
+            continue;
+        }
+        await handleRequest(msg, version);
+    }
+}

package/dist/ollama-chat.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared Ollama /api/chat client used by prompt and bench.
+ */
+import type { GenerateSettings } from "./config.js";
+export interface ChatChunk {
+    model?: string;
+    message?: {
+        role?: string;
+        content?: string;
+        thinking?: string;
+    };
+    done?: boolean;
+    done_reason?: string;
+    error?: string;
+    total_duration?: number;
+    load_duration?: number;
+    prompt_eval_count?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+export interface OllamaChatOptions {
+    baseUrl: string;
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    stream: boolean;
+    settings: GenerateSettings;
+    /** Write assistant content to stdout / thinking to stderr when streaming. */
+    writeStdout: boolean;
+    /** Timeout in ms; 0 = none. */
+    timeoutMs: number;
+}
+export interface OllamaChatResult {
+    content: string;
+    thinking: string;
+    chunk: ChatChunk;
+}
+/** POST /api/chat with optional streaming and AbortSignal timeout. */
+export declare function ollamaChat(opts: OllamaChatOptions): Promise<OllamaChatResult>;
+export interface OllamaModelInfo {
+    name: string;
+    digest?: string;
+    size?: number;
+    details?: {
+        parameter_size?: string;
+        quantization_level?: string;
+        family?: string;
+    };
+}
+export declare function ollamaTags(baseUrl: string, timeoutMs: number): Promise<OllamaModelInfo[]>;
+export declare function ollamaShow(baseUrl: string, model: string, timeoutMs: number): Promise<{
+    capabilities?: string[];
+}>;
+export declare function ollamaVersion(baseUrl: string, timeoutMs: number): Promise<string | undefined>;
+export interface PsModel {
+    name?: string;
+    model?: string;
+    size_vram?: number;
+    context_length?: number;
+    digest?: string;
+}
+export declare function ollamaPs(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;
+/**
+ * Capability filter: omitempty / empty means "unknown → treat as completion".
+ * Only skip when a non-empty capabilities array is present and lacks completion.
+ */
+export declare function isCompletionCapable(capabilities: string[] | undefined | null): boolean;
+/**
+ * Vision-capable models (moondream, llava, …) often fail a text-only suite.
+ * Only true when capabilities are present and include vision — absent/empty → false
+ * (don't skip unknown older servers).
+ */
+export declare function isVisionCapable(capabilities: string[] | undefined | null): boolean;
+/** True when capabilities are known and lack thinking (absent/empty → no warning). */
+export declare function shouldWarnNoThinking(capabilities: string[] | undefined | null): boolean;
+/** Poll /api/ps until model is absent (or timeout). Returns elapsed ms. */
+export declare function waitUntilUnloaded(baseUrl: string, model: string, timeoutMs: number, pollMs?: number): Promise<{
+    unloaded: boolean;
+    waitedMs: number;
+}>;
+/** Request unload via keep_alive: 0 (no-op-ish if already unloaded after a short chat). */
+export declare function ollamaUnload(baseUrl: string, model: string, timeoutMs: number): Promise<void>;

package/dist/paths.d.ts

@@ -0,0 +1,17 @@
+/** Package root: parent of `src/` in a checkout, parent of `dist/` when installed. */
+export declare const PROJECT_ROOT: string;
+export declare function projectPath(...parts: string[]): string;
+/**
+ * True when running from an installed copy (npx cache, global install, or as a
+ * dependency) rather than a source checkout. Installed copies always live under
+ * a `node_modules` directory.
+ */
+export declare const IS_INSTALLED: boolean;
+/** Per-user data dir used when installed (config + chat transcripts). */
+export declare const USER_DIR: string;
+/** Default config location: repo-local in a checkout, `~/.ollanet/` when installed. */
+export declare function defaultConfigPath(): string;
+/** Default transcript dir: repo-local in a checkout, `~/.ollanet/` when installed. */
+export declare function defaultResponsesDir(): string;
+/** Default benchmark results dir (mirrors responses layout). */
+export declare function defaultBenchmarksDir(): string;

package/dist/prompt.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Run a prompt / continue a chat against an Ollama server on the network.
+ *
+ * New chat (saved by default):
+ *   ollanet prompt localhost "What is Tailscale?"
+ *   ollanet prompt 192.168.1.50 "Hello"
+ *
+ * Continue:
+ *   ollanet prompt --chat a1b2c3d4e5f6 "Tell me more"
+ *
+ * List chats:
+ *   ollanet chats
+ */
+import { type AppConfig, type GenerateSettings } from "./config.js";
+export interface PromptRunOptions {
+    machine?: string;
+    model?: string;
+    prompt: string;
+    chatId?: string;
+    /** Persist transcript. Default true; pass false for one-shot app calls. */
+    save?: boolean;
+    settings?: GenerateSettings;
+    /** When false, never write the reply to stdout (MCP / programmatic). Default true for CLI. */
+    writeStdout?: boolean;
+    stream?: boolean;
+    quiet?: boolean;
+    /** In-memory config; skips the config file when set. */
+    config?: Partial<AppConfig>;
+}
+export interface PromptRunResult {
+    chat_id: string | null;
+    topic: string;
+    content: string;
+    thinking: string | null;
+    machine: string;
+    model: string;
+    ollama: Record<string, unknown>;
+}
+/** Programmatic prompt used by CLI `--json` and the MCP server. */
+export declare function runPrompt(opts: PromptRunOptions): Promise<PromptRunResult>;
+export declare function main(): Promise<void>;