ollanet 0.1.0

package/dist/config.js

@@ -0,0 +1,225 @@
+import { readFile } from "node:fs/promises";
+import { shortName, } from "./hosts.js";
+import { defaultConfigPath } from "./paths.js";
+function emptyConfig() {
+    return {
+        hosts: [],
+        discovery: {},
+        defaultModels: {},
+        defaults: {},
+        machineDefaults: {},
+    };
+}
+const CONFIG_PATH = process.env.OLLANET_CONFIG ??
+    process.env.OLLAMA_CONFIG ??
+    defaultConfigPath();
+export async function loadConfig() {
+    try {
+        const raw = await readFile(CONFIG_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const machineDefaults = normalizeMachineDefaults(parsed.machineDefaults);
+        const defaultModels = {
+            ...normalizeStringMap(parsed.defaultModels),
+            // Allow `machineDefaults.<host>.model` as an alternate place to set defaults.
+            ...Object.fromEntries(Object.entries(machineDefaults)
+                .filter(([, v]) => typeof v.model === "string" && v.model.trim())
+                .map(([k, v]) => [k, v.model.trim()])),
+        };
+        return {
+            hosts: Array.isArray(parsed.hosts) ? parsed.hosts : [],
+            discovery: normalizeDiscovery(parsed.discovery),
+            defaultModels,
+            defaults: normalizeSettings(parsed.defaults),
+            machineDefaults,
+        };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            return emptyConfig();
+        }
+        throw new Error(`Failed to read config at ${CONFIG_PATH}: ${err instanceof Error ? err.message : err}`);
+    }
+}
+function normalizeDiscovery(input) {
+    if (!input || typeof input !== "object")
+        return {};
+    const src = input;
+    const out = {};
+    if (typeof src.localhost === "boolean")
+        out.localhost = src.localhost;
+    if (typeof src.tailscale === "boolean")
+        out.tailscale = src.tailscale;
+    if (typeof src.lan === "boolean")
+        out.lan = src.lan;
+    if (Array.isArray(src.cidrs)) {
+        out.cidrs = src.cidrs.filter((c) => typeof c === "string" && c.includes("/"));
+    }
+    return out;
+}
+function normalizeStringMap(map) {
+    const out = {};
+    for (const [key, value] of Object.entries(map ?? {})) {
+        if (typeof value !== "string" || !value.trim())
+            continue;
+        out[key.trim().toLowerCase()] = value.trim();
+    }
+    return out;
+}
+function normalizeMachineDefaults(map) {
+    const out = {};
+    for (const [key, value] of Object.entries(map ?? {})) {
+        if (!value || typeof value !== "object")
+            continue;
+        out[key.trim().toLowerCase()] = {
+            ...normalizeSettings(value),
+            ...(typeof value.model === "string" && value.model.trim()
+                ? { model: value.model.trim() }
+                : {}),
+        };
+    }
+    return out;
+}
+export function normalizeSettings(input) {
+    if (!input || typeof input !== "object")
+        return {};
+    const src = input;
+    const out = {};
+    const temperature = asFiniteNumber(src.temperature ?? src.temp);
+    if (temperature != null)
+        out.temperature = temperature;
+    const numPredict = asFiniteNumber(src.num_predict ?? src.numPredict);
+    if (numPredict != null)
+        out.num_predict = Math.trunc(numPredict);
+    const numCtx = asFiniteNumber(src.num_ctx ?? src.numCtx);
+    if (numCtx != null)
+        out.num_ctx = Math.trunc(numCtx);
+    const keepAlive = src.keep_alive ?? src.keepAlive;
+    if (typeof keepAlive === "string" && keepAlive.trim()) {
+        out.keep_alive = keepAlive.trim();
+    }
+    else if (typeof keepAlive === "number" && Number.isFinite(keepAlive)) {
+        out.keep_alive = keepAlive;
+    }
+    const format = parseFormat(src.format);
+    if (format !== undefined)
+        out.format = format;
+    if (typeof src.system === "string" && src.system.trim()) {
+        out.system = src.system;
+    }
+    return out;
+}
+function asFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    return undefined;
+}
+export function parseFormat(value) {
+    if (value == null || value === "")
+        return undefined;
+    if (value === "json")
+        return "json";
+    if (typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "json")
+            return "json";
+        if (trimmed.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    return parsed;
+                }
+            }
+            catch {
+                throw new Error(`Invalid --format JSON schema: ${trimmed.slice(0, 80)}`);
+            }
+        }
+        throw new Error(`Invalid format "${value}". Use "json" or a JSON schema object/string.`);
+    }
+    return undefined;
+}
+export function hostLookupKeys(host) {
+    return [
+        shortName(host),
+        host.hostname,
+        host.dnsName,
+        host.dnsName.split(".")[0] ?? "",
+        host.ip,
+    ]
+        .map((k) => k.toLowerCase())
+        .filter(Boolean);
+}
+/** Resolve a default model for a host using short name, hostname, DNS, or IP keys. */
+export function defaultModelForHost(config, host) {
+    for (const key of hostLookupKeys(host)) {
+        const hit = config.defaultModels[key];
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+export function machineSettingsForHost(config, host) {
+    for (const key of hostLookupKeys(host)) {
+        const hit = config.machineDefaults[key];
+        if (hit) {
+            const { model: _model, ...settings } = hit;
+            return settings;
+        }
+    }
+    return {};
+}
+/** Later layers win. Undefined values are skipped. */
+export function mergeSettings(...layers) {
+    const out = {};
+    for (const layer of layers) {
+        if (!layer)
+            continue;
+        if (layer.temperature != null)
+            out.temperature = layer.temperature;
+        if (layer.num_predict != null)
+            out.num_predict = layer.num_predict;
+        if (layer.num_ctx != null)
+            out.num_ctx = layer.num_ctx;
+        if (layer.keep_alive != null)
+            out.keep_alive = layer.keep_alive;
+        if (layer.format !== undefined)
+            out.format = layer.format;
+        if (layer.system != null)
+            out.system = layer.system;
+    }
+    return out;
+}
+export function settingsFromEnv() {
+    return normalizeSettings({
+        temperature: process.env.OLLAMA_TEMPERATURE,
+        num_predict: process.env.OLLAMA_NUM_PREDICT,
+        num_ctx: process.env.OLLAMA_NUM_CTX,
+        keep_alive: process.env.OLLAMA_KEEP_ALIVE,
+        format: process.env.OLLAMA_FORMAT,
+        system: process.env.OLLAMA_SYSTEM,
+    });
+}
+export function settingsSummary(settings) {
+    const parts = [];
+    if (settings.temperature != null)
+        parts.push(`temp=${settings.temperature}`);
+    if (settings.num_predict != null)
+        parts.push(`num_predict=${settings.num_predict}`);
+    if (settings.num_ctx != null)
+        parts.push(`num_ctx=${settings.num_ctx}`);
+    if (settings.keep_alive != null)
+        parts.push(`keep_alive=${settings.keep_alive}`);
+    if (settings.format !== undefined) {
+        parts.push(settings.format === "json" ? "format=json" : "format=<schema>");
+    }
+    return parts.join(" ");
+}
+export function configPath() {
+    return CONFIG_PATH;
+}

package/dist/hosts.js

@@ -0,0 +1,383 @@
+import { execFile } from "node:child_process";
+import net from "node:net";
+import os from "node:os";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export const OLLAMA_PORT = Number(process.env.OLLAMA_PORT ?? 11434);
+function cleanDnsName(dnsName) {
+    if (!dnsName)
+        return "";
+    return dnsName.replace(/\.$/, "");
+}
+function pickIpv4(ips) {
+    return ips?.find((ip) => !ip.includes(":"));
+}
+export function shortName(host) {
+    if (host.dnsName) {
+        return host.dnsName.split(".")[0] ?? host.hostname;
+    }
+    return host.hostname;
+}
+export function ollamaBaseUrl(host, port = host.port || OLLAMA_PORT) {
+    const hostPart = host.ip.includes(":") ? `[${host.ip}]` : host.ip;
+    return `http://${hostPart}:${port}`;
+}
+function makeHost(partial) {
+    return {
+        hostname: partial.hostname,
+        dnsName: partial.dnsName ?? "",
+        ip: partial.ip,
+        online: partial.online ?? true,
+        os: partial.os ?? "unknown",
+        isSelf: partial.isSelf ?? false,
+        source: partial.source,
+        port: partial.port ?? OLLAMA_PORT,
+    };
+}
+function dedupeKey(host) {
+    return `${host.ip}:${host.port}`;
+}
+function mergeHosts(hosts) {
+    const byKey = new Map();
+    for (const host of hosts) {
+        const key = dedupeKey(host);
+        const existing = byKey.get(key);
+        if (!existing) {
+            byKey.set(key, host);
+            continue;
+        }
+        // Prefer named / richer metadata when merging duplicates.
+        byKey.set(key, {
+            ...existing,
+            hostname: existing.hostname === existing.ip && host.hostname !== host.ip
+                ? host.hostname
+                : existing.hostname,
+            dnsName: existing.dnsName || host.dnsName,
+            online: existing.online || host.online,
+            os: existing.os !== "unknown" ? existing.os : host.os,
+            isSelf: existing.isSelf || host.isSelf,
+            source: existing.source === "direct" ? host.source : existing.source,
+        });
+    }
+    return [...byKey.values()].sort((a, b) => {
+        if (a.isSelf !== b.isSelf)
+            return a.isSelf ? -1 : 1;
+        return shortName(a).localeCompare(shortName(b));
+    });
+}
+function localhostTargets() {
+    const hostname = os.hostname() || "localhost";
+    return [
+        makeHost({
+            hostname,
+            dnsName: "localhost",
+            ip: "127.0.0.1",
+            source: "localhost",
+            isSelf: true,
+            online: true,
+            os: process.platform,
+        }),
+    ];
+}
+function parseHostEntry(entry) {
+    if (typeof entry === "string") {
+        const trimmed = entry.trim();
+        if (!trimmed)
+            return null;
+        return makeHost({
+            hostname: trimmed,
+            ip: trimmed,
+            source: "config",
+            online: true,
+        });
+    }
+    const address = (entry.host ?? entry.ip ?? "").trim();
+    if (!address)
+        return null;
+    const name = (entry.name ?? address).trim();
+    return makeHost({
+        hostname: name,
+        dnsName: address.includes(".") ? address : "",
+        ip: address,
+        source: "config",
+        online: true,
+        port: typeof entry.port === "number" ? entry.port : OLLAMA_PORT,
+    });
+}
+function envHostTargets() {
+    const raw = process.env.OLLANET_HOSTS ?? "";
+    return raw
+        .split(/[,;\s]+/)
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((address) => makeHost({
+        hostname: address,
+        ip: address,
+        source: "env",
+        online: true,
+    }));
+}
+function peerToTarget(peer, isSelf) {
+    const ip = pickIpv4(peer.TailscaleIPs);
+    if (!ip)
+        return null;
+    return makeHost({
+        hostname: peer.HostName ?? ip,
+        dnsName: cleanDnsName(peer.DNSName),
+        ip,
+        online: peer.Online ?? false,
+        os: peer.OS ?? "unknown",
+        isSelf,
+        source: "tailscale",
+    });
+}
+async function tryTailscaleTargets(includeOffline) {
+    try {
+        const { stdout } = await execFileAsync("tailscale", ["status", "--json"], {
+            maxBuffer: 20 * 1024 * 1024,
+            windowsHide: true,
+        });
+        const status = JSON.parse(stdout);
+        const hosts = [];
+        if (status.Self) {
+            const self = peerToTarget(status.Self, true);
+            if (self)
+                hosts.push(self);
+        }
+        for (const peer of Object.values(status.Peer ?? {})) {
+            const target = peerToTarget(peer, false);
+            if (!target)
+                continue;
+            if (!includeOffline && !target.online && !target.isSelf)
+                continue;
+            hosts.push(target);
+        }
+        const label = status.CurrentTailnet?.Name ??
+            status.MagicDNSSuffix ??
+            status.CurrentTailnet?.MagicDNSSuffix;
+        return { hosts, label };
+    }
+    catch {
+        return { hosts: [] };
+    }
+}
+function ipv4ToInt(ip) {
+    return ip.split(".").reduce((acc, part) => (acc << 8) + Number(part), 0) >>> 0;
+}
+function intToIpv4(value) {
+    return [
+        (value >>> 24) & 255,
+        (value >>> 16) & 255,
+        (value >>> 8) & 255,
+        value & 255,
+    ].join(".");
+}
+function cidrToIps(cidr) {
+    const [base, bitsRaw] = cidr.split("/");
+    if (!base || !bitsRaw)
+        return [];
+    const bits = Number(bitsRaw);
+    if (!Number.isInteger(bits) || bits < 16 || bits > 30)
+        return [];
+    const baseInt = ipv4ToInt(base);
+    const mask = bits === 0 ? 0 : (~0 << (32 - bits)) >>> 0;
+    const network = (baseInt & mask) >>> 0;
+    const size = 2 ** (32 - bits);
+    const ips = [];
+    // Skip network + broadcast addresses.
+    for (let i = 1; i < size - 1; i += 1) {
+        ips.push(intToIpv4((network + i) >>> 0));
+    }
+    return ips;
+}
+function guessLocalCidrs() {
+    const cidrs = new Set();
+    for (const entries of Object.values(os.networkInterfaces())) {
+        for (const entry of entries ?? []) {
+            if (String(entry.family) !== "IPv4")
+                continue;
+            if (entry.internal)
+                continue;
+            const ip = entry.address;
+            if (!ip || ip.startsWith("127."))
+                continue;
+            // Prefer a /24 around each interface address for scan speed.
+            const parts = ip.split(".").map(Number);
+            if (parts.length !== 4)
+                continue;
+            cidrs.add(`${parts[0]}.${parts[1]}.${parts[2]}.0/24`);
+        }
+    }
+    return [...cidrs];
+}
+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]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(items.length, 1)) }, () => run()));
+    return results;
+}
+async function tcpOpen(ip, port, timeoutMs) {
+    return await new Promise((resolve) => {
+        const socket = net.connect({ host: ip, port });
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, timeoutMs);
+        socket.once("connect", () => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("error", () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+}
+async function lanScanTargets(cidrs, port) {
+    const timeoutMs = Number(process.env.OLLANET_LAN_TIMEOUT_MS ?? 200);
+    const concurrency = Number(process.env.OLLANET_LAN_CONCURRENCY ?? 64);
+    const ips = [...new Set(cidrs.flatMap((cidr) => cidrToIps(cidr)))];
+    if (ips.length === 0)
+        return [];
+    const flags = await mapPool(ips, concurrency, async (ip) => ({
+        ip,
+        open: await tcpOpen(ip, port, timeoutMs),
+    }));
+    return flags
+        .filter((f) => f.open)
+        .map((f) => makeHost({
+        hostname: f.ip,
+        ip: f.ip,
+        source: "lan",
+        online: true,
+        port,
+    }));
+}
+function looksLikeAddress(query) {
+    const q = query.trim();
+    if (!q)
+        return false;
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(q))
+        return true;
+    if (q.includes(":") && !q.includes(" "))
+        return true; // hostname:port or ipv6-ish
+    if (/^[a-z0-9][a-z0-9._-]*$/i.test(q))
+        return true;
+    return false;
+}
+function parseDirectAddress(query) {
+    const q = query.trim();
+    if (!looksLikeAddress(q))
+        return null;
+    let hostname = q;
+    let ip = q;
+    let port = OLLAMA_PORT;
+    const ipv4WithPort = q.match(/^(\d{1,3}(?:\.\d{1,3}){3}):(\d+)$/);
+    if (ipv4WithPort) {
+        ip = ipv4WithPort[1];
+        hostname = ip;
+        port = Number(ipv4WithPort[2]);
+    }
+    else if (!q.includes("://") && q.includes(".") === false && q.includes(":")) {
+        // host:port without dots (rare) — skip to avoid mangling IPv6
+    }
+    else {
+        const hostPort = q.match(/^([a-z0-9][a-z0-9._-]*):(\d+)$/i);
+        if (hostPort) {
+            hostname = hostPort[1];
+            ip = hostname;
+            port = Number(hostPort[2]);
+        }
+    }
+    return makeHost({
+        hostname,
+        ip,
+        source: "direct",
+        online: true,
+        port,
+    });
+}
+/** Discover candidate Ollama hosts from localhost, config, env, Tailscale, and optional LAN scan. */
+export async function discoverHosts(opts = {}) {
+    const discovery = opts.discovery ?? {};
+    const sources = [];
+    const collected = [];
+    const labels = [];
+    if (discovery.localhost !== false) {
+        collected.push(...localhostTargets());
+        sources.push("localhost");
+    }
+    const fromConfig = (opts.hosts ?? [])
+        .map(parseHostEntry)
+        .filter((h) => h != null);
+    if (fromConfig.length > 0) {
+        collected.push(...fromConfig);
+        sources.push("config");
+    }
+    const fromEnv = envHostTargets();
+    if (fromEnv.length > 0) {
+        collected.push(...fromEnv);
+        sources.push("env");
+    }
+    if (discovery.tailscale !== false) {
+        const { hosts, label } = await tryTailscaleTargets(opts.includeOffline ?? false);
+        if (hosts.length > 0) {
+            collected.push(...hosts);
+            sources.push("tailscale");
+            if (label)
+                labels.push(label);
+        }
+    }
+    const lanEnabled = opts.lanScan ?? discovery.lan === true;
+    if (lanEnabled) {
+        const cidrs = discovery.cidrs && discovery.cidrs.length > 0 ? discovery.cidrs : guessLocalCidrs();
+        const lanHosts = await lanScanTargets(cidrs, OLLAMA_PORT);
+        if (lanHosts.length > 0) {
+            collected.push(...lanHosts);
+            sources.push("lan");
+            labels.push(...cidrs);
+        }
+        else {
+            sources.push("lan");
+        }
+    }
+    const hosts = mergeHosts(collected);
+    const networkLabel = labels[0] ??
+        (sources.includes("tailscale")
+            ? "tailscale"
+            : sources.includes("lan")
+                ? "lan"
+                : sources.join("+") || "local");
+    return { hosts, sources, networkLabel };
+}
+/** Resolve a machine name against discovered hosts, or treat it as a direct address. */
+export function resolveHost(targets, query) {
+    const q = query.trim().toLowerCase().replace(/\.$/, "");
+    if (!q) {
+        throw new Error("Machine name is empty.");
+    }
+    const matches = targets.filter((host) => {
+        const names = [host.hostname, host.dnsName, shortName(host), host.ip].map((n) => n.toLowerCase());
+        return names.includes(q) || names.some((n) => n.startsWith(`${q}.`));
+    });
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1) {
+        const list = matches.map((h) => `${shortName(h)} (${h.ip})`).join(", ");
+        throw new Error(`Ambiguous machine "${query}". Matches: ${list}`);
+    }
+    const direct = parseDirectAddress(query);
+    if (direct)
+        return direct;
+    const available = targets.map((h) => shortName(h)).join(", ") || "(none)";
+    throw new Error(`Unknown machine "${query}". Known hosts: ${available}\n` +
+        `Tip: pass an IP/hostname directly, add it under config.hosts, or set OLLANET_HOSTS.`);
+}

package/dist/paths.js

@@ -0,0 +1,24 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Package root: parent of `src/` in a checkout, parent of `dist/` when installed. */
+export const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+export function projectPath(...parts) {
+    return path.join(PROJECT_ROOT, ...parts);
+}
+/**
+ * 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 const IS_INSTALLED = PROJECT_ROOT.split(path.sep).includes("node_modules");
+/** Per-user data dir used when installed (config + chat transcripts). */
+export const USER_DIR = path.join(os.homedir(), ".ollanet");
+/** Default config location: repo-local in a checkout, `~/.ollanet/` when installed. */
+export function defaultConfigPath() {
+    return IS_INSTALLED ? path.join(USER_DIR, "config.json") : projectPath("config.json");
+}
+/** Default transcript dir: repo-local in a checkout, `~/.ollanet/` when installed. */
+export function defaultResponsesDir() {
+    return IS_INSTALLED ? path.join(USER_DIR, "responses") : projectPath("responses");
+}