smolcoder-plus 1.0.0

package/dist/index.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+"use strict";
+// smolcoder — a smol, zero-config CLI coding agent for local models.
+//
+// Interactive: an opencode-style inline TUI. No upfront questions — the last
+// (or first) detected model is picked automatically; switch with /models,
+// cycle modes with shift+tab, set reasoning effort with /effort.
+// Web: smol --web serves a browser UI with a workspace sidebar — many
+// projects and sessions side by side, started from anywhere.
+// Headless: smol -p "prompt" for people and automations.
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const agent_1 = require("./agent");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const events_1 = require("./events");
+const logo_1 = require("./logo");
+const plan_1 = require("./plan");
+const prompt_1 = require("./prompt");
+const session_1 = require("./session");
+const shell_1 = require("./tools/shell");
+const tasks_1 = require("./tools/tasks");
+const tui_1 = require("./tui/tui");
+const ui_1 = require("./ui");
+const util_1 = require("./util");
+const hub_1 = require("./web/hub");
+const VERSION = require("../package.json").version;
+const DEFAULT_WEB_PORT = 7433;
+function parseArgs(argv) {
+    const args = { workspace: process.cwd() };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--help" || a === "-h")
+            args.help = true;
+        else if (a === "--version" || a === "-v")
+            args.version = true;
+        else if (a === "--mode" || a === "-m") {
+            const v = argv[++i];
+            if (v === "ro" || v === "read-only" || v === "readonly")
+                args.mode = "ro";
+            else if (v === "edit" || v === "e" || v === "write" || v === "w")
+                args.mode = "edit";
+            else if (v === "bypass" || v === "bypass-permissions" || v === "b" || v === "yolo" || v === "y")
+                args.mode = "bypass";
+            else {
+                console.error(`Unknown mode "${v}". Use ro, edit, or bypass.`);
+                process.exit(1);
+            }
+        }
+        else if (a === "--bypass" || a === "--bypass-permissions" || a === "--yolo")
+            args.mode = "bypass";
+        else if (a === "--model")
+            args.model = argv[++i];
+        else if (a === "--ctx") {
+            args.ctx = Number(argv[++i]);
+            if (!Number.isSafeInteger(args.ctx) || args.ctx < 1024) {
+                console.error("--ctx must be a whole number of at least 1024 tokens.");
+                process.exit(1);
+            }
+        }
+        else if (a === "--effort") {
+            const v = argv[++i];
+            if (v === "off" || v === "low" || v === "medium" || v === "high")
+                args.effort = v;
+            else if (v === "default")
+                args.effort = null;
+            else {
+                console.error(`Unknown effort "${v}". Use off, low, medium, high, or default.`);
+                process.exit(1);
+            }
+        }
+        else if (a === "--verify") {
+            args.verify = argv[++i];
+            if (!args.verify?.trim())
+                throw new Error('--verify needs an acceptance command');
+        }
+        else if (a === "--verify-attempts") {
+            args.verifyAttempts = Number(argv[++i]);
+            if (!Number.isSafeInteger(args.verifyAttempts) || args.verifyAttempts < 1)
+                throw new Error('--verify-attempts must be a positive whole number');
+        }
+        else if (a === "--print" || a === "-p")
+            args.print = argv[++i];
+        else if (a === "--web") {
+            args.web = true;
+            if (argv[i + 1] && /^\d+$/.test(argv[i + 1]))
+                args.webPort = Number(argv[++i]);
+        }
+        else if (!a.startsWith("-")) {
+            args.workspace = path.resolve(a);
+            args.workspaceGiven = true;
+        }
+        else {
+            console.error(`Unknown option "${a}". Try smolcoder-plus --help.`);
+            process.exit(1);
+        }
+    }
+    return args;
+}
+const HELP = `
+${util_1.c.bold("smolcoder-plus")} v${VERSION} — a smol, zero-config coding agent for local models.
+
+Detects Ollama and LM Studio on this computer automatically — any port, Docker
+containers included. Models on other machines: /models → "Find models on
+another machine" searches your network or takes an address, and remembers it.
+
+${util_1.c.bold("Usage:")}
+  smolcoder-plus [workspace] [options]
+
+${util_1.c.bold("Options:")}
+  -m, --mode <ro|edit|bypass>  ro: read files only. edit: read/write files and run
+                               commands inside the workspace; anything reaching
+                               outside it asks y/n. bypass: no approvals at all.
+  --model <name>               pick a model by (partial) name
+  --ctx <tokens>               force a context window (Ollama: sends num_ctx)
+  --verify <command>           headless acceptance gate; automatically repair failures
+  --verify-attempts <count>     maximum acceptance checks (default 6; requires --verify)
+  --effort <level>             reasoning effort: off, low, medium, high, default
+  --web [port]                 browser UI (default port ${DEFAULT_WEB_PORT}): a sidebar of your
+                               workspaces and sessions, an embedded browser and
+                               terminal panel. Run it from anywhere; a second
+                               smolcoder-plus --web adds its folder to the running UI.
+  -p, --print "<prompt>"       headless: run a single prompt and exit
+  -h, --help                   this help
+  -v, --version                version
+
+${util_1.c.bold("Keys:")}
+  shift+tab   cycle mode (read-only → edit → bypass permissions)
+  /           slash commands (autocomplete menu)
+  esc         cancel a running turn · clear the input
+  ctrl+c ×2   quit
+
+${util_1.c.bold("Slash commands:")}
+  /models     switch model         /tasks        background tasks
+  /mode       set mode             /logs <id>    task output
+  /effort     reasoning effort     /stop <id>    kill a task
+  /context    context usage        /clear        reset conversation
+  /compact    compact now          /exit         quit
+`;
+/** Node fires 'exit' on normal termination but NOT on a killing signal, so
+ * background tasks (dev servers) survive a closed terminal (SIGHUP) or `kill`
+ * (SIGTERM) unless we handle those explicitly. Runs synchronous cleanup then
+ * re-exits so the 'exit' path is still reached. */
+function installSignalCleanup(cleanup) {
+    let done = false;
+    const run = (code) => {
+        if (done)
+            return;
+        done = true;
+        try {
+            cleanup();
+        }
+        catch {
+            /* best effort */
+        }
+        process.exit(code);
+    };
+    process.on("SIGTERM", () => run(143));
+    process.on("SIGHUP", () => run(129));
+    process.on("SIGINT", () => run(130));
+}
+/** The SMOL banner that opens every interactive session. */
+function printLogo() {
+    for (const line of (0, logo_1.terminalLogo)(process.stdout.columns || 80, VERSION))
+        console.log(line);
+}
+function prefsOf(args) {
+    return { mode: args.mode, model: args.model, ctx: args.ctx, effort: args.effort };
+}
+// ---------------------------------------------------------------------------
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    if (args.version) {
+        console.log(VERSION);
+        return;
+    }
+    if (args.verify && (!args.print || args.web))
+        throw new Error('--verify requires a headless -p run');
+    if (args.verifyAttempts !== undefined && !args.verify)
+        throw new Error('--verify-attempts requires --verify');
+    if (!fs.existsSync(args.workspace) || !fs.statSync(args.workspace).isDirectory()) {
+        console.error(`Workspace folder does not exist: ${args.workspace}`);
+        process.exit(1);
+    }
+    if (args.print !== undefined)
+        await runHeadless(args);
+    else if (args.web)
+        await runWeb(args);
+    else
+        await runInteractive(args);
+}
+// ---- headless (-p) ---------------------------------------------------------
+async function runHeadless(args) {
+    const ui = new ui_1.UI();
+    const bus = new events_1.EventBus();
+    const cfg = (0, config_1.loadConfig)();
+    const chosen = await (0, session_1.prepareModel)(prefsOf(args), cfg);
+    if (!chosen) {
+        ui.println((0, session_1.noBackendsMessage)());
+        ui.close();
+        process.exit(1);
+    }
+    const mode = args.mode ?? cfg.lastMode ?? "edit";
+    const shell = (0, shell_1.pickShell)();
+    const provider = (0, session_1.makeProvider)(chosen);
+    provider.setEffort(args.effort !== undefined ? args.effort : (cfg.effort ?? null));
+    const taskManager = new tasks_1.TaskManager(args.workspace);
+    const toolCtx = {
+        workspace: args.workspace,
+        taskManager,
+        plan: new plan_1.Plan(),
+        filesTouched: new Set(),
+        commandsRun: [],
+    };
+    const ctxMgr = new context_1.ContextManager(chosen.contextWindow, provider.maxOutputTokens);
+    const agentsMd = (0, prompt_1.loadAgentsMd)(args.workspace);
+    if (agentsMd)
+        ui.status(`· AGENTS.md loaded (${agentsMd.split("\n").length} lines)`);
+    const systemPrompt = (0, prompt_1.buildSystemPrompt)({ workspace: args.workspace, mode, shellLabel: shell.label, agentsMd });
+    const agent = new agent_1.Agent(provider, mode, systemPrompt, toolCtx, ctxMgr, bus, ui, false, 1000, args.verify ? { command: args.verify, maxAttempts: args.verifyAttempts } : undefined);
+    (0, session_1.reportCompactions)(bus, ui);
+    process.on("exit", () => taskManager.killAll());
+    installSignalCleanup(() => taskManager.killAll());
+    ui.println((0, session_1.sessionLine)(chosen, mode));
+    if (chosen.note)
+        ui.warn(`  ${chosen.note}`);
+    const effortSetting = args.effort !== undefined ? args.effort : (cfg.effort ?? null);
+    ui.status(`  effort ${provider.effortLabel() ?? effortSetting ?? "default"}`);
+    const advice = (0, session_1.effortAdvice)(chosen, effortSetting);
+    if (advice)
+        ui.warn(`  ${advice}`);
+    try {
+        await agent.runTurn(args.print);
+        if (agent.outcome !== "completed")
+            process.exitCode = 1;
+    }
+    catch (err) {
+        ui.error(`\n${err?.message ?? err}`);
+        process.exitCode = 1;
+    }
+    const st = agent.lastTurnStats;
+    if (st) {
+        // Machine-readable summary for scripts/benchmarks comparing backends.
+        process.stderr.write(`[stats] ${JSON.stringify({
+            backend: chosen.backend,
+            outcome: agent.outcome,
+            verification: agent.verificationResult ? { attempts: agent.verificationResult.attempts, passed: agent.verificationResult.passed } : null,
+            model: chosen.id,
+            durationMs: st.durationMs,
+            modelCalls: st.modelCalls,
+            toolCalls: st.toolCalls,
+            generatedTokens: st.generatedTokens,
+            thinkingTokensEst: Math.round(st.thinkingChars / 4),
+            genTokPerSec: st.genSeconds > 0 ? Math.round(st.generatedTokens / st.genSeconds) : null,
+            promptTokensLast: st.promptTokensLast,
+            contextWindow: chosen.contextWindow,
+            planDone: toolCtx.plan.exists ? `${toolCtx.plan.doneCount}/${toolCtx.plan.steps.length}` : null,
+        })}\n`);
+    }
+    taskManager.killAll();
+    ui.close();
+}
+// ---- interactive TUI -------------------------------------------------------
+async function runInteractive(args) {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        console.error('Interactive mode needs a terminal. For headless use, run: smolcoder-plus -p "your prompt" — or serve a browser UI with --web');
+        process.exit(1);
+    }
+    printLogo();
+    const cfg = (0, config_1.loadConfig)();
+    process.stdout.write(util_1.c.dim("· looking for Ollama and LM Studio…"));
+    let chosen = await (0, session_1.prepareModel)(prefsOf(args), cfg, (label) => {
+        process.stdout.write("\r\x1b[2K" + util_1.c.dim(`· ${label}…`));
+    });
+    process.stdout.write("\r\x1b[2K");
+    const tui = new tui_1.Tui();
+    if (!chosen) {
+        // Nothing on this computer: open the TUI early and offer to look on the
+        // network. Until a session exists, esc/ctrl+c while it searches quits.
+        tui.onCancel = () => {
+            tui.close();
+            process.exit(130);
+        };
+        tui.start();
+        chosen = await (0, session_1.setupWithoutLocalModels)(tui, prefsOf(args));
+        if (!chosen) {
+            tui.close();
+            console.log((0, session_1.noBackendsMessage)());
+            process.exit(1);
+        }
+    }
+    const session = new session_1.Session(tui, { workspace: args.workspace, chosen, prefs: prefsOf(args), cfg, help: HELP });
+    session.onExit = () => process.exit(0);
+    process.on("exit", () => session.taskManager.killAll());
+    installSignalCleanup(() => {
+        session.taskManager.killAll();
+        try {
+            tui.close(); // restore the raw-mode terminal on signal death
+        }
+        catch {
+            /* best effort */
+        }
+    });
+    tui.start();
+    session.announce();
+    tui.println("");
+    await session.run();
+}
+// ---- web hub (--web) -------------------------------------------------------
+/** The home folder or a drive root is not a project: launching there opens
+ * the hub with the sidebar and lets the user pick a workspace. */
+function isHomeOrRoot(p) {
+    const norm = (s) => (process.platform === "win32" ? s.toLowerCase() : s);
+    const r = path.resolve(p);
+    return norm(r) === norm(os.homedir()) || path.dirname(r) === r;
+}
+async function runWeb(args) {
+    console.log(`${util_1.c.bold("smolcoder-plus")} ${util_1.c.dim("v" + VERSION + " · web")}`);
+    const port = args.webPort ?? DEFAULT_WEB_PORT;
+    const workspace = args.workspace;
+    const autoStart = !!args.workspaceGiven || !isHomeOrRoot(workspace);
+    // A hub is already running: hand it this folder instead of starting another.
+    const rec = (0, hub_1.readHubRecord)();
+    if (rec && (args.webPort === undefined || rec.port === port) && (await (0, hub_1.pingHub)(rec))) {
+        const r = await (0, hub_1.askHubToOpen)(rec, workspace, autoStart);
+        if (r) {
+            const url = `http://127.0.0.1:${rec.port}/?k=${rec.token}${r.id ? "#" + r.id : ""}`;
+            console.log(`\n  ${autoStart ? "started a session for" : "added"} ${workspace} in the running web UI:\n  ${url}\n`);
+            return;
+        }
+    }
+    const hub = new hub_1.WebHub({ port, prefs: prefsOf(args), help: HELP, version: VERSION });
+    try {
+        await hub.start();
+    }
+    catch (err) {
+        if (err?.code === "EADDRINUSE") {
+            console.error(`\nPort ${port} is already in use. Pick another with: smolcoder-plus --web ${port + 1}`);
+            process.exit(1);
+        }
+        throw err;
+    }
+    process.on("exit", () => hub.shutdownSync());
+    installSignalCleanup(() => hub.shutdownSync());
+    if (autoStart)
+        hub.openSession(workspace);
+    console.log(`\n  smolcoder web UI:  ${hub.url()}\n  ${autoStart ? `workspace ${workspace}` : "pick a workspace in the sidebar"} · ctrl+c stops the server\n`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/logo.js

@@ -0,0 +1,48 @@
+"use strict";
+// The SMOL block-letter logo. One source for both surfaces — the banner
+// printed when an interactive terminal session starts, and the web UI's
+// welcome screen and fresh-session view — so the branding cannot drift or
+// quietly disappear from one of them again.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGO_TEXT = exports.LOGO_WIDTH = exports.LOGO_ROWS = void 0;
+exports.plainBrand = plainBrand;
+exports.terminalLogo = terminalLogo;
+const util_1 = require("./util");
+exports.LOGO_ROWS = [
+    "███████╗ ███╗   ███╗  ██████╗  ██╗     ",
+    "██╔════╝ ████╗ ████║ ██╔═══██╗ ██║     ",
+    "███████╗ ██╔████╔██║ ██║   ██║ ██║     ",
+    "╚════██║ ██║╚██╔╝██║ ██║   ██║ ██║     ",
+    "███████║ ██║ ╚═╝ ██║ ╚██████╔╝ ███████╗",
+    "╚══════╝ ╚═╝     ╚═╝  ╚═════╝  ╚══════╝",
+];
+/** Every row is padded to this many cells. */
+exports.LOGO_WIDTH = exports.LOGO_ROWS[0].length;
+/** The logo as one block of text (trailing padding removed) for the web page. */
+exports.LOGO_TEXT = exports.LOGO_ROWS.map((r) => r.trimEnd()).join("\n");
+/** One-line fallback for wherever the art does not fit. */
+function plainBrand(version) {
+    return `${util_1.c.bold("smol")}${util_1.c.dim(util_1.c.bold("coder"))} ${util_1.c.dim("v" + version)}`;
+}
+/**
+ * Lines of the terminal banner for a terminal `cols` wide: the block logo in
+ * the accent colour with "coder vX" beside its last row, or the plain
+ * one-liner when the terminal is too narrow for the art.
+ */
+function terminalLogo(cols, version) {
+    const indent = " ";
+    if (cols < indent.length + exports.LOGO_WIDTH)
+        return [plainBrand(version)];
+    const tailText = `coder v${version}`;
+    const tail = util_1.c.dim(util_1.c.bold("coder") + " v" + version);
+    const tailFits = cols >= indent.length + exports.LOGO_WIDTH + 2 + tailText.length;
+    const lines = [""];
+    exports.LOGO_ROWS.forEach((row, i) => {
+        const last = i === exports.LOGO_ROWS.length - 1;
+        lines.push(indent + util_1.c.cyan(row) + (last && tailFits ? "  " + tail : ""));
+    });
+    if (!tailFits)
+        lines.push(indent + tail);
+    lines.push("");
+    return lines;
+}

package/dist/netscan.js

@@ -0,0 +1,159 @@
+"use strict";
+// "Find models on my network": an ordinary TCP connect sweep of the local
+// subnet on the two model-server ports, then a question to each open port
+// about what it is. No ping, no raw sockets, no admin rights — the same on
+// Windows, macOS and Linux. Only ever run when the user asks for it.
+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.localSubnets = localSubnets;
+exports.scanSubnets = scanSubnets;
+const dns = __importStar(require("dns"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const detect_1 = require("./detect");
+const hosts_1 = require("./hosts");
+const CONNECT_TIMEOUT_MS = 350;
+// Well under macOS's default limit of 256 open files per process.
+const CONCURRENCY = 64;
+// Wider networks are searched around our own address only.
+const MIN_PREFIX = 22;
+const CLAMPED_PREFIX = 24;
+// Virtual switches that never lead to another machine. Deliberately short:
+// a Hyper-V "external" switch IS the real network, so names are not a general filter.
+const VIRTUAL_IFACE = /^(vEthernet \((WSL|Default Switch)|docker\d*$|br-[0-9a-f]+$|veth[0-9a-f]+$|virbr\d*$)/i;
+const toInt = (ip) => ip.split(".").reduce((n, part) => n * 256 + Number(part), 0);
+const toIp = (n) => [24, 16, 8, 0].map((shift) => Math.floor(n / 2 ** shift) % 256).join(".");
+function isPrivateV4(ip) {
+    const [a, b] = ip.split(".").map(Number);
+    return a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168);
+}
+/** The private IPv4 networks this computer is on. Chosen by address, not by
+ * adapter name, so it behaves the same on every OS. */
+function localSubnets(ifaces = os.networkInterfaces()) {
+    const own = new Set();
+    for (const list of Object.values(ifaces))
+        for (const i of list ?? [])
+            own.add(i.address);
+    const subnets = new Map();
+    for (const [name, list] of Object.entries(ifaces)) {
+        if (VIRTUAL_IFACE.test(name))
+            continue;
+        for (const i of list ?? []) {
+            const v4 = i.family === "IPv4" || i.family === 4;
+            if (!v4 || i.internal || !isPrivateV4(i.address))
+                continue;
+            const mask = toInt(i.netmask);
+            let prefix = 0;
+            for (let bit = 31; bit >= 0 && Math.floor(mask / 2 ** bit) % 2 === 1; bit--)
+                prefix++;
+            if (prefix >= 31)
+                continue; // point-to-point link, nobody else on it
+            if (prefix < MIN_PREFIX)
+                prefix = CLAMPED_PREFIX;
+            const size = 2 ** (32 - prefix);
+            const network = Math.floor(toInt(i.address) / size) * size;
+            const cidr = `${toIp(network)}/${prefix}`;
+            if (subnets.has(cidr))
+                continue;
+            const addresses = [];
+            for (let n = network + 1; n < network + size - 1; n++)
+                if (!own.has(toIp(n)))
+                    addresses.push(toIp(n));
+            subnets.set(cidr, { cidr, addresses });
+        }
+    }
+    return [...subnets.values()];
+}
+function canConnect(ip, port, timeoutMs) {
+    return new Promise((resolve) => {
+        const socket = net.connect({ host: ip, port });
+        const finish = (open) => {
+            socket.destroy();
+            resolve(open);
+        };
+        socket.setTimeout(timeoutMs, () => finish(false));
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}
+/** A name for the machine, but only one that leads back to the same address —
+ * that is what makes it safe to save instead of an IP the router may reassign. */
+function stableName(ip) {
+    const lookup = async () => {
+        try {
+            for (const name of await dns.promises.reverse(ip)) {
+                const back = await dns.promises.lookup(name, { family: 4 }).catch(() => null);
+                if (back?.address === ip)
+                    return name.replace(/\.$/, "");
+            }
+        }
+        catch {
+            /* no reverse DNS on this network */
+        }
+        return undefined;
+    };
+    // A resolver that never answers must not stall the results; the IP will do.
+    return Promise.race([lookup(), new Promise((resolve) => setTimeout(() => resolve(undefined), 1500).unref())]);
+}
+/** Sweep the subnets and report every machine running Ollama or LM Studio. */
+async function scanSubnets(subnets, opts = {}) {
+    const ports = opts.ports ?? [hosts_1.OLLAMA_PORT, hosts_1.LMSTUDIO_PORT];
+    const timeout = opts.connectTimeoutMs ?? CONNECT_TIMEOUT_MS;
+    const targets = subnets.flatMap((s) => s.addresses).flatMap((ip) => ports.map((port) => ({ ip, port })));
+    const open = [];
+    let next = 0;
+    let checked = 0;
+    const worker = async () => {
+        while (next < targets.length) {
+            const target = targets[next++];
+            if (await canConnect(target.ip, target.port, timeout))
+                open.push(target);
+            opts.onProgress?.(++checked, targets.length);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, targets.length) }, worker));
+    const byIp = new Map();
+    await Promise.all(open.map(async ({ ip, port }) => {
+        const info = await (0, detect_1.identifyServer)(`http://${ip}:${port}`);
+        if (!info)
+            return;
+        const host = byIp.get(ip) ?? { ip, servers: [] };
+        host.servers.push({ url: info.baseUrl, backend: info.backend, models: info.models.length });
+        byIp.set(ip, host);
+    }));
+    const hosts = [...byIp.values()].sort((a, b) => toInt(a.ip) - toInt(b.ip));
+    await Promise.all(hosts.map(async (h) => (h.name = await stableName(h.ip))));
+    return hosts;
+}