smolcoder-plus 1.0.0

package/dist/detect.js

@@ -0,0 +1,474 @@
+"use strict";
+// Zero-config backend detection. Build a list of places a model server could
+// be — loopback on the usual ports, $OLLAMA_HOST, the port LM Studio says it
+// serves on, ports published by Docker containers, the host machine when we
+// run inside WSL or a container, and network hosts the user added — then ask
+// each one what it is. The ANSWER decides the backend, never the port, so
+// Ollama and LM Studio are found the same way wherever they listen.
+//
+// The two backends are asymmetric on context windows:
+//   - Ollama: WE choose the window (num_ctx is a per-request option). Read the
+//     model's true maximum from /api/show and set num_ctx explicitly, because
+//     Ollama's defaults vary by version and silently truncate the prompt.
+//   - LM Studio: the window is fixed when the model is loaded in LM Studio's
+//     UI. We READ it from /api/v1/models (or the older /api/v0) and adapt.
+//     The same endpoint tells us which reasoning levels the model supports
+//     and which one it defaults to — that default is often the MAXIMUM.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ollamaBaseUrls = ollamaBaseUrls;
+exports.lmStudioBaseUrls = lmStudioBaseUrls;
+exports.parseLmStudioServerPort = parseLmStudioServerPort;
+exports.readLmStudioPort = readLmStudioPort;
+exports.parseDockerBaseUrls = parseDockerBaseUrls;
+exports.parseDefaultGateway = parseDefaultGateway;
+exports.parseLmStudioV1 = parseLmStudioV1;
+exports.identifyServer = identifyServer;
+exports.groupServers = groupServers;
+exports.probeHosts = probeHosts;
+exports.detectAll = detectAll;
+exports.resolveContextWindow = resolveContextWindow;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const hosts_1 = require("./hosts");
+const util_1 = require("./util");
+const DEFAULT_OLLAMA_BASE = `http://127.0.0.1:${hosts_1.OLLAMA_PORT}`;
+const LOCAL_PROBE_TIMEOUT_MS = 3000;
+// An added machine that is switched off must not hold up startup for long.
+const NETWORK_PROBE_TIMEOUT_MS = 1500;
+const DOCKER_DISCOVERY_TIMEOUT_MS = 2000;
+const LOOPBACK_RE = /^(https?:\/\/)(localhost|127(?:\.\d+){3}|\[::1\])(?=[:/]|$)/i;
+function normalizeOllamaBase(env) {
+    let base;
+    if (!env)
+        base = DEFAULT_OLLAMA_BASE;
+    else if (env.startsWith("http://") || env.startsWith("https://"))
+        base = env.replace(/\/$/, "");
+    else
+        base = `http://${env.replace(/\/$/, "")}`;
+    // OLLAMA_HOST=0.0.0.0 is the documented way to expose the SERVER on the LAN,
+    // but as a CLIENT connect address 0.0.0.0/:: fails on Windows (WSAEADDRNOTAVAIL)
+    // and would make detection silently return no models. Rewrite to loopback.
+    base = base.replace(/^(https?:\/\/)(0\.0\.0\.0|\[::\]|::)(?=[:/]|$)/, "$1127.0.0.1");
+    // A bare local OLLAMA_HOST is common in desktop environment settings. Ollama
+    // means port 11434 there, while fetch would otherwise try port 80.
+    if (/^https?:\/\/(localhost|127(?:\.\d+){3}|\[::1\])$/i.test(base))
+        base += `:${hosts_1.OLLAMA_PORT}`;
+    return base;
+}
+function loopbackAliases(base) {
+    const match = base.match(LOOPBACK_RE);
+    if (!match)
+        return [base];
+    const tail = base.slice(match[0].length);
+    return [match[2], "127.0.0.1", "localhost", "[::1]"]
+        .map((host) => `${match[1]}${host}${tail}`)
+        .filter((url, i, urls) => urls.indexOf(url) === i);
+}
+/** Probe the configured endpoint first, then every loopback spelling. A stale
+ * OLLAMA_HOST does not hide a healthy local or Docker-published server. */
+function ollamaBaseUrls(env) {
+    const primary = normalizeOllamaBase(env);
+    const candidates = [...loopbackAliases(primary), ...loopbackAliases(DEFAULT_OLLAMA_BASE)];
+    return candidates.filter((url, i) => candidates.indexOf(url) === i);
+}
+/** Loopback spellings for LM Studio: the port its settings file names (it is
+ * changeable in the app), then the default. */
+function lmStudioBaseUrls(configuredPort) {
+    const ports = [configuredPort, hosts_1.LMSTUDIO_PORT].filter((p, i, all) => !!p && all.indexOf(p) === i);
+    return ports.flatMap((port) => loopbackAliases(`http://127.0.0.1:${port}`));
+}
+/** Exported for tests: the port in LM Studio's http-server-config.json. */
+function parseLmStudioServerPort(text) {
+    try {
+        const port = JSON.parse(text)?.port;
+        return Number.isInteger(port) && port > 0 && port < 65536 ? port : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** LM Studio keeps its live server settings in its home folder, which the
+ * pointer file relocates when the user moved it. Missing or unreadable just
+ * means we fall back to the default port. */
+function readLmStudioPort(home = os.homedir()) {
+    const homes = [];
+    try {
+        const pointed = fs.readFileSync(path.join(home, ".lmstudio-home-pointer"), "utf8").trim();
+        if (pointed)
+            homes.push(pointed);
+    }
+    catch {
+        /* not relocated */
+    }
+    homes.push(path.join(home, ".lmstudio"), path.join(home, ".cache", "lm-studio"));
+    for (const dir of homes) {
+        try {
+            const port = parseLmStudioServerPort(fs.readFileSync(path.join(dir, ".internal", "http-server-config.json"), "utf8"));
+            if (port)
+                return port;
+        }
+        catch {
+            /* try the next location */
+        }
+    }
+    return undefined;
+}
+/** Parse `docker ps --format {{.Ports}}` and return host endpoints that publish
+ * a container's model-server port. Unpublished/expose-only ports are
+ * intentionally ignored because the CLI cannot reach them from the host. */
+function parseDockerBaseUrls(output, containerPorts = [hosts_1.OLLAMA_PORT, hosts_1.LMSTUDIO_PORT]) {
+    const urls = [];
+    const mapping = /(\[[^\]]+\]|(?:\d{1,3}\.){3}\d{1,3}|localhost):(\d+)->(\d+)\/tcp\b/gi;
+    for (const match of output.matchAll(mapping)) {
+        if (!containerPorts.includes(Number(match[3])))
+            continue;
+        let host = match[1].toLowerCase();
+        if (host === "0.0.0.0")
+            host = "127.0.0.1";
+        else if (host === "[::]")
+            host = "[::1]";
+        urls.push(`http://${host}:${match[2]}`);
+    }
+    return urls.filter((url, i) => urls.indexOf(url) === i);
+}
+function containerPublishedUrls(containerPorts) {
+    const ask = (cli) => new Promise((resolve) => {
+        (0, child_process_1.execFile)(cli, ["ps", "--format", "{{.Ports}}"], { encoding: "utf8", timeout: DOCKER_DISCOVERY_TIMEOUT_MS, windowsHide: true }, (err, stdout) => resolve(err ? null : parseDockerBaseUrls(stdout, containerPorts)));
+    });
+    // Podman prints the same port format; only ask it when Docker is absent.
+    return ask("docker").then((urls) => urls ?? ask("podman")).then((urls) => urls ?? []);
+}
+/** Exported for tests: the default gateway in /proc/net/route (little-endian hex). */
+function parseDefaultGateway(procNetRoute) {
+    for (const line of procNetRoute.split("\n").slice(1)) {
+        const cols = line.trim().split(/\s+/);
+        if (cols.length < 3 || cols[1] !== "00000000" || !/^[0-9a-f]{8}$/i.test(cols[2]) || cols[2] === "00000000")
+            continue;
+        const hex = cols[2];
+        return [6, 4, 2, 0].map((i) => parseInt(hex.slice(i, i + 2), 16)).join(".");
+    }
+    return undefined;
+}
+/** Inside WSL or a container, "this computer" includes the machine hosting
+ * us: loopback does not reach a model server running there. */
+function hostMachineUrls(ports) {
+    if (process.platform !== "linux")
+        return [];
+    const read = (file) => {
+        try {
+            return fs.readFileSync(file, "utf8");
+        }
+        catch {
+            return "";
+        }
+    };
+    const wsl = !!process.env.WSL_DISTRO_NAME || /microsoft/i.test(read("/proc/version"));
+    const container = fs.existsSync("/.dockerenv") || fs.existsSync("/run/.containerenv");
+    if (!wsl && !container)
+        return [];
+    const names = [parseDefaultGateway(read("/proc/net/route")), container ? "host.docker.internal" : undefined];
+    return names.filter((n) => !!n).flatMap((name) => ports.map((port) => `http://${name}:${port}`));
+}
+// ---- asking a server what it is ---------------------------------------------
+const NOT_LOADED_NOTE = "not loaded yet — LM Studio will load it on first use, likely at a small default context. For longer sessions, load it in LM Studio with a bigger context first.";
+const LMSTUDIO_JIT_GUESS = 4096; // LM Studio's usual default when a model is JIT-loaded
+const DEFAULT_LMSTUDIO_BASE = `http://127.0.0.1:${hosts_1.LMSTUDIO_PORT}`;
+/** LM Studio labels vision models "vlm" and text-only ones "llm". */
+function visionOf(type) {
+    return type === "vlm" ? true : type === "llm" ? false : undefined;
+}
+function parseOllamaTags(data, base) {
+    if (!data || !Array.isArray(data.models) || !data.models.every((m) => typeof m?.name === "string"))
+        return null;
+    return data.models.map((m) => ({
+        id: m.name,
+        backend: "ollama",
+        baseUrl: base,
+        contextWindow: 0, // resolved lazily via /api/show when the model is chosen
+    }));
+}
+/** Exported for tests: parse LM Studio's /api/v1/models listing. */
+function parseLmStudioV1(data, base = DEFAULT_LMSTUDIO_BASE) {
+    if (!data || !Array.isArray(data.models))
+        return null;
+    return data.models
+        .filter((m) => m.type === "llm" || m.type === "vlm" || m.type === undefined)
+        .map((m) => {
+        const inst = Array.isArray(m.loaded_instances) ? m.loaded_instances[0] : undefined;
+        const loaded = !!inst;
+        const max = typeof m.max_context_length === "number" ? m.max_context_length : undefined;
+        const loadedCtx = typeof inst?.config?.context_length === "number" ? inst.config.context_length : undefined;
+        const r = m.capabilities?.reasoning;
+        const reasoning = r && Array.isArray(r.allowed_options)
+            ? { allowed: r.allowed_options.map(String), default: r.default ? String(r.default) : undefined }
+            : undefined;
+        return {
+            id: String(inst?.id ?? m.key),
+            backend: "lmstudio",
+            baseUrl: base,
+            contextWindow: loaded && loadedCtx ? loadedCtx : Math.min(max ?? LMSTUDIO_JIT_GUESS, LMSTUDIO_JIT_GUESS),
+            maxContext: max,
+            loaded,
+            reasoning,
+            vision: visionOf(m.type),
+            note: loaded && loadedCtx ? undefined : NOT_LOADED_NOTE,
+        };
+    });
+}
+function parseLmStudioV0(data, base) {
+    if (!data || !Array.isArray(data.data))
+        return null;
+    return data.data
+        .filter((m) => m.type === "llm" || m.type === "vlm" || m.type === undefined)
+        .map((m) => {
+        const loaded = m.state === "loaded";
+        const max = typeof m.max_context_length === "number" ? m.max_context_length : undefined;
+        const loadedCtx = typeof m.loaded_context_length === "number" ? m.loaded_context_length : undefined;
+        let contextWindow;
+        let note;
+        if (loaded && loadedCtx) {
+            contextWindow = loadedCtx;
+        }
+        else {
+            contextWindow = Math.min(max ?? LMSTUDIO_JIT_GUESS, LMSTUDIO_JIT_GUESS);
+            note = NOT_LOADED_NOTE;
+        }
+        return {
+            id: m.id,
+            backend: "lmstudio",
+            baseUrl: base,
+            contextWindow,
+            maxContext: max,
+            loaded,
+            vision: visionOf(m.type),
+            note,
+        };
+    });
+}
+/** Ask one address whether it is Ollama or LM Studio. null means neither (or
+ * nothing there). Both native listings are requested together so a dead
+ * address costs one timeout, not one per backend. */
+async function identifyServer(base, timeoutMs = NETWORK_PROBE_TIMEOUT_MS) {
+    const [tags, v1] = await Promise.all([
+        (0, util_1.probeJson)(`${base}/api/tags`, timeoutMs),
+        (0, util_1.probeJson)(`${base}/api/v1/models`, timeoutMs),
+    ]);
+    if (!tags.reached && !v1.reached)
+        return null;
+    // LM Studio first: its listing names models by "key", which nothing else does.
+    const lmKeyed = Array.isArray(v1.data?.models) && v1.data.models.length > 0 && v1.data.models.every((m) => typeof m?.key === "string");
+    if (lmKeyed)
+        return { backend: "lmstudio", baseUrl: base, models: parseLmStudioV1(v1.data, base) ?? [] };
+    const ollama = parseOllamaTags(tags.data, base);
+    if (ollama)
+        return { backend: "ollama", baseUrl: base, models: ollama };
+    const lmV1 = parseLmStudioV1(v1.data, base);
+    if (lmV1)
+        return { backend: "lmstudio", baseUrl: base, models: lmV1 };
+    const v0 = parseLmStudioV0(await (0, util_1.tryFetchJson)(`${base}/api/v0/models`, undefined, timeoutMs), base);
+    if (v0)
+        return { backend: "lmstudio", baseUrl: base, models: v0 };
+    // Older LM Studio builds: fall back to the OpenAI-compat listing (no context info).
+    const compat = await (0, util_1.tryFetchJson)(`${base}/v1/models`, undefined, timeoutMs);
+    if (compat && Array.isArray(compat.data)) {
+        const models = compat.data
+            .filter((m) => !String(m.id).includes("embed"))
+            .map((m) => ({
+            id: m.id,
+            backend: "lmstudio",
+            baseUrl: base,
+            contextWindow: LMSTUDIO_JIT_GUESS,
+            note: "context window unknown (older LM Studio) — assuming 4096 to be safe.",
+        }));
+        return { backend: "lmstudio", baseUrl: base, models };
+    }
+    return null;
+}
+/** Exported for tests. Loopback spellings of the same port are one server;
+ * every other URL is its own. Order of first appearance is kept. */
+function groupServers(urls, timeoutMs, host) {
+    const groups = new Map();
+    for (const url of urls) {
+        const loop = url.match(LOOPBACK_RE);
+        const key = loop ? `loopback${url.slice(loop[0].length)}` : url;
+        const group = groups.get(key) ?? { urls: [], timeoutMs, host };
+        if (!group.urls.includes(url))
+            group.urls.push(url);
+        groups.set(key, group);
+    }
+    return [...groups.values()];
+}
+async function probeGroup(group) {
+    for (const url of group.urls) {
+        const info = await identifyServer(url, group.timeoutMs);
+        if (info)
+            return { ...info, models: info.models.map((m) => ({ ...m, host: group.host })) };
+    }
+    return null;
+}
+/** What each saved host is serving right now (for the hosts manager). */
+async function probeHosts(hosts) {
+    return Promise.all(hosts.map(async (host) => {
+        const found = await Promise.all(groupServers((0, hosts_1.hostUrls)(host), NETWORK_PROBE_TIMEOUT_MS, (0, hosts_1.hostLabel)(host)).map(probeGroup));
+        return { host, servers: found.filter((s) => !!s) };
+    }));
+}
+async function detectAll(opts = {}) {
+    const lmPort = readLmStudioPort();
+    const ports = [hosts_1.OLLAMA_PORT, lmPort ?? hosts_1.LMSTUDIO_PORT, hosts_1.LMSTUDIO_PORT].filter((p, i, all) => all.indexOf(p) === i);
+    const local = groupServers([...ollamaBaseUrls(process.env.OLLAMA_HOST), ...lmStudioBaseUrls(lmPort), ...hostMachineUrls(ports)], LOCAL_PROBE_TIMEOUT_MS);
+    const covered = new Set(local.flatMap((g) => g.urls));
+    // One slot per source, in display order: this computer, its containers,
+    // then each added host. Slots finish at different times.
+    const slots = [
+        ...local.map((g) => probeGroup(g).then((s) => s?.models ?? [])),
+        containerPublishedUrls(ports).then(async (urls) => {
+            const groups = groupServers(urls.filter((u) => !covered.has(u)), LOCAL_PROBE_TIMEOUT_MS);
+            return (await Promise.all(groups.map(probeGroup))).flatMap((s) => s?.models ?? []);
+        }),
+        ...(opts.hosts ?? []).flatMap((host) => groupServers((0, hosts_1.hostUrls)(host), NETWORK_PROBE_TIMEOUT_MS, (0, hosts_1.hostLabel)(host)).map((g) => probeGroup(g).then((s) => s?.models ?? []))),
+    ];
+    const done = slots.map(() => undefined);
+    const merged = () => {
+        const seen = new Set();
+        return done.flatMap((models) => models ?? []).filter((m) => {
+            const key = `${m.baseUrl}|${m.id}`;
+            return seen.has(key) ? false : (seen.add(key), true);
+        });
+    };
+    return new Promise((resolve) => {
+        let left = slots.length;
+        slots.forEach((slot, i) => slot
+            .catch(() => [])
+            .then((models) => {
+            done[i] = models;
+            if (--left === 0 || (opts.until && models.some(opts.until)))
+                resolve(merged());
+        }));
+    });
+}
+const DEFAULT_OLLAMA_CTX_CAP = 32768; // avoid surprise VRAM blowups on huge-window models
+/**
+ * Resolve the context window we will actually budget against for a chosen model.
+ *
+ * Ollama: by default we respect the SERVER's configured context (the Ollama
+ * app's Context Length setting / OLLAMA_CONTEXT_LENGTH) and never send
+ * num_ctx. To learn the effective value we preload the model and read
+ * context_length from /api/ps. Only two cases send an explicit num_ctx: a
+ * --ctx override, or an old Ollama whose /api/ps doesn't report context (where
+ * the tiny silent default is the classic footgun).
+ */
+async function resolveContextWindow(model, ctxOverride) {
+    if (ctxOverride !== undefined && (!Number.isSafeInteger(ctxOverride) || ctxOverride < 1024))
+        throw new Error("Context window must be a whole number of at least 1024 tokens.");
+    if (model.backend === "ollama") {
+        const info = await (0, util_1.tryFetchJson)(`${model.baseUrl}/api/show`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: model.id }),
+        });
+        // Newer Ollama lists what the model can do; "vision" means it takes images.
+        if (Array.isArray(info?.capabilities))
+            model = { ...model, vision: info.capabilities.includes("vision") };
+        let max;
+        const mi = info?.model_info;
+        if (mi && typeof mi === "object") {
+            for (const key of Object.keys(mi)) {
+                if (key.endsWith(".context_length") && typeof mi[key] === "number") {
+                    max = mi[key];
+                    break;
+                }
+            }
+        }
+        if (ctxOverride) {
+            const window = Math.min(ctxOverride, max ?? ctxOverride);
+            return { ...model, maxContext: max, contextWindow: window, numCtx: window };
+        }
+        // Preload the model (documented no-op chat), then read the effective
+        // context the server actually allocated.
+        await (0, util_1.tryFetchJson)(`${model.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: model.id, messages: [] }),
+        }, 180_000);
+        const ps = await (0, util_1.tryFetchJson)(`${model.baseUrl}/api/ps`, undefined, 3000);
+        // Match the CHOSEN model only — never fall back to models[0]. If our
+        // preload failed (e.g. too big for VRAM) but a different model is still
+        // resident, models[0] would anchor the budget to the wrong window.
+        const entry = ps?.models?.find((m) => m.name === model.id || m.model === model.id);
+        if (typeof entry?.context_length === "number" && entry.context_length > 0) {
+            return {
+                ...model,
+                maxContext: max,
+                contextWindow: entry.context_length,
+                numCtx: undefined, // respect the server's configuration
+            };
+        }
+        // Older Ollama: no visibility into the server default, which is tiny and
+        // silently truncates — set num_ctx explicitly ourselves.
+        const window = Math.min(max ?? DEFAULT_OLLAMA_CTX_CAP, DEFAULT_OLLAMA_CTX_CAP);
+        return {
+            ...model,
+            maxContext: max,
+            contextWindow: window,
+            numCtx: window,
+            note: `older Ollama — setting the context to ${window.toLocaleString()} explicitly (adjust with --ctx).`,
+        };
+    }
+    if (model.loaded === false && ctxOverride) {
+        const desired = Math.min(ctxOverride, model.maxContext ?? ctxOverride);
+        const response = await fetch(`${model.baseUrl}/api/v1/models/load`, {
+            method: "POST", headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: model.id, context_length: desired, echo_load_config: true }),
+            signal: AbortSignal.timeout(180_000),
+        });
+        if (!response.ok)
+            throw new Error(`LM Studio could not load ${model.id} with ${desired} context tokens (${response.status}). Load the model in LM Studio or reduce --ctx.`);
+        const loaded = await response.json();
+        const actual = loaded.load_config?.context_length;
+        if (!Number.isSafeInteger(actual) || actual < 1024 || !loaded.instance_id)
+            throw new Error("LM Studio did not confirm the loaded context. Load the model in LM Studio and select it again.");
+        return { ...model, id: loaded.instance_id, loaded: true, contextWindow: Math.min(desired, actual), note: undefined };
+    }
+    // LM Studio: an already-loaded model stays resident; an override only shrinks our budget
+    // (we cannot change what LM Studio allocated).
+    if (ctxOverride && ctxOverride < model.contextWindow) {
+        return { ...model, contextWindow: ctxOverride };
+    }
+    return model;
+}

package/dist/events.js

@@ -0,0 +1,24 @@
+"use strict";
+// Internal lifecycle event bus. Handlers run sequentially and may be async,
+// so a pre_request handler can finish compaction before the request goes out.
+// Not user-configurable in v1 by design — this is the spine that compaction,
+// the context meter, and logging hang off. User-facing hooks can come later.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+class EventBus {
+    handlers = new Map();
+    on(event, handler) {
+        const list = this.handlers.get(event) ?? [];
+        list.push(handler);
+        this.handlers.set(event, list);
+    }
+    async emit(event, payload) {
+        const list = this.handlers.get(event);
+        if (!list)
+            return;
+        for (const h of list) {
+            await h(payload);
+        }
+    }
+}
+exports.EventBus = EventBus;

package/dist/history.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHistoryPlaceholder = isHistoryPlaceholder;
+// Recognize the exact legacy compaction marker. It is history metadata, never
+// a replacement for source code. Keep this narrow so ordinary documentation
+// and comments containing examples remain writable.
+function isHistoryPlaceholder(value) {
+    return /^\[\d+ characters already applied to [^\r\n]+\. Read the file for current code\.\]$/.test(value.trim());
+}

package/dist/hosts.js

@@ -0,0 +1,107 @@
+"use strict";
+// Network hosts: other machines that serve models. People add them from the
+// model picker by searching the network or typing an address, so everything
+// here accepts loose input ("192.168.1.50", "gpu-box.local", "box:1234",
+// "https://llm.example.com") and works out the rest.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LMSTUDIO_PORT = exports.OLLAMA_PORT = void 0;
+exports.parseAddress = parseAddress;
+exports.hostUrls = hostUrls;
+exports.hostLabel = hostLabel;
+exports.addHost = addHost;
+exports.removeHost = removeHost;
+exports.renameHost = renameHost;
+exports.isPrivateHost = isPrivateHost;
+exports.OLLAMA_PORT = 11434;
+exports.LMSTUDIO_PORT = 1234;
+/** Parse what someone typed into the address box. Throws a plain-English
+ * error for input that cannot be a server address. */
+function parseAddress(input) {
+    let text = String(input ?? "").trim();
+    if (!text)
+        throw new Error("Type the address of the machine that runs your models.");
+    if (/\s/.test(text))
+        throw new Error("An address cannot contain spaces.");
+    const schemeMatch = /^([a-z][a-z0-9+.-]*):\/\//i.exec(text);
+    if (schemeMatch && !/^https?$/i.test(schemeMatch[1]))
+        throw new Error("Only http:// and https:// addresses work here.");
+    if (schemeMatch && text.length === schemeMatch[0].length)
+        throw new Error("The address needs a host name or IP.");
+    text = text.replace(/\/+$/, "");
+    // A bare IPv6 address needs brackets before it can carry a port.
+    if (!schemeMatch && !text.startsWith("[") && (text.match(/:/g) ?? []).length > 1)
+        text = `[${text}]`;
+    let url;
+    try {
+        url = new URL(schemeMatch ? text : `http://${text}`);
+    }
+    catch {
+        throw new Error(`"${input.trim()}" is not an address I can connect to. Try an IP like 192.168.1.50 or a name like gpu-box.local.`);
+    }
+    if (url.username || url.password)
+        throw new Error("Leave user names and passwords out of the address.");
+    if (!url.hostname)
+        throw new Error("The address needs a host name or IP.");
+    if (/^(0\.0\.0\.0|\[::\])$/.test(url.hostname))
+        throw new Error("0.0.0.0 is what a server listens on, not where to reach it. Use that machine's IP or name.");
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    const pathPart = url.pathname.replace(/\/+$/, "");
+    // URL drops a default port ("box:80"), so look at the text for one too.
+    const portTyped = /:\d+$/.test(text.replace(/^\[[^\]]*\]/, ""));
+    if (schemeMatch || portTyped || pathPart) {
+        const base = `${url.protocol}//${url.host}${pathPart}`;
+        return { address: base, hostname, urls: [base] };
+    }
+    return { address: url.hostname, hostname, urls: [`http://${url.host}:${exports.OLLAMA_PORT}`, `http://${url.host}:${exports.LMSTUDIO_PORT}`] };
+}
+/** Server URLs for a saved host; empty when the entry is unusable. */
+function hostUrls(host) {
+    try {
+        return parseAddress(host.address).urls;
+    }
+    catch {
+        return [];
+    }
+}
+function hostLabel(host) {
+    if (host.name)
+        return host.name;
+    try {
+        return parseAddress(host.address).hostname;
+    }
+    catch {
+        return host.address;
+    }
+}
+function sameAddress(a, b) {
+    return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+/** Add a host, or update the name of one that is already there. */
+function addHost(hosts, host) {
+    const at = hosts.findIndex((h) => sameAddress(h.address, host.address));
+    if (at < 0)
+        return [...hosts, host];
+    return hosts.map((h, i) => (i === at ? { ...h, ...(host.name ? { name: host.name } : {}) } : h));
+}
+function removeHost(hosts, address) {
+    return hosts.filter((h) => !sameAddress(h.address, address));
+}
+function renameHost(hosts, address, name) {
+    const clean = name.replace(/\s+/g, " ").trim().slice(0, 40);
+    return hosts.map((h) => (sameAddress(h.address, address) ? (clean ? { ...h, name: clean } : { address: h.address }) : h));
+}
+/** True for addresses that stay inside a home or office network (and for
+ * names, which we cannot judge). Used to warn before sending code over plain
+ * http to somewhere on the internet. */
+function isPrivateHost(hostname) {
+    const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(h);
+    if (v4) {
+        const [a, b] = [Number(v4[1]), Number(v4[2])];
+        return a === 10 || a === 127 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 169 && b === 254) || (a === 100 && b >= 64 && b <= 127);
+    }
+    if (h.includes(":"))
+        return h === "::1" || /^f[cd]/.test(h) || /^fe[89ab]/.test(h);
+    // Single-label and .local/.lan/.home names resolve inside the network.
+    return !h.includes(".") || /\.(local|lan|home|internal|localdomain|home\.arpa|ts\.net)$/.test(h);
+}