@noxsoft/anima 2.0.2 → 2.0.4

package/dist/models-cli-iDAlsbL2.js

@@ -0,0 +1,258 @@
+import { M as theme, h as defaultRuntime } from "./entry.js";
+import "./auth-profiles-CxSHydjn.js";
+import "./utils-DT8uXjFS.js";
+import "./exec-DDmuVVNq.js";
+import "./agent-scope-DZgptr9J.js";
+import "./pi-model-discovery-DzEIEgHL.js";
+import "./skills-BWFIEp4j.js";
+import "./manifest-registry-DbvPaBXY.js";
+import "./config-CU-Axg8P.js";
+import "./client-Dswwze5_.js";
+import "./call-BIzCaKZb.js";
+import "./message-channel-dua8OOGJ.js";
+import "./timeout-Ddn-5kAO.js";
+import "./sessions-CnRjwdVr.js";
+import "./subagent-registry-DNDhbHWi.js";
+import "./logging-CY-Q5cwf.js";
+import "./accounts-D8CPKNkN.js";
+import "./reply-r089HuRA.js";
+import "./plugins-D6PBOdkn.js";
+import "./tokens-BaM53PEx.js";
+import "./dock-BdXLb5oY.js";
+import "./paths-DfQGx0_k.js";
+import "./chunk-D2nLsrEW.js";
+import "./media-lUqN-0O9.js";
+import "./mime-CBg4KybI.js";
+import "./image-ops-Bp0C6Mvr.js";
+import "./common-DJbnT8ws.js";
+import "./server-context-DVh2z7om.js";
+import "./chrome-C4dOMO8z.js";
+import "./auth-DMPZWzEa.js";
+import "./ports-vd93M_Pt.js";
+import "./trash-Bmxs1Rnm.js";
+import "./control-service-8_wKHwBa.js";
+import "./cli-session-gtuYN2Iq.js";
+import "./thinking-2hxwmvTl.js";
+import "./context-DzgXOckU.js";
+import "./sandbox-CJTS3er6.js";
+import "./routes-ucJWAk5O.js";
+import "./paths-DHjlJ6cn.js";
+import "./commands-registry-cFqZ6Ib4.js";
+import "./deliver-DFnVaetP.js";
+import "./pairing-store-DoNj00-X.js";
+import "./nodes-screen-DHyWAlla.js";
+import "./memory-cli-BLXSpgnN.js";
+import "./manager-DRWMWM--.js";
+import "./sqlite-B6MojU1I.js";
+import "./redact-CyKvdFrg.js";
+import { t as formatDocsLink } from "./links-CNu_8RZl.js";
+import { n as runCommandWithRuntime, t as resolveOptionFromCommand } from "./cli-utils-C1YHVD4o.js";
+import "./progress-C9Ha1NJh.js";
+import "./dispatcher-DNd40gUn.js";
+import "./channel-selection-Bbm1lq3P.js";
+import "./delivery-queue-Bxm0nzw7.js";
+import "./pi-tools.policy-xYdDLEv9.js";
+import "./session-cost-usage-qdfsGU2a.js";
+import "./prompt-style-DQi8j03a.js";
+import "./note-Ctvglhp1.js";
+import "./clack-prompter-BI3RDW5w.js";
+import "./onboard-helpers-B8roRwLP.js";
+import "./table-DhXHfRX2.js";
+import { t as githubCopilotLoginCommand } from "./github-copilot-auth-DXpOMSd3.js";
+import "./shared-kzrojZ1B.js";
+import "./logging-C7lb3Vjc.js";
+import { C as modelsAliasesListCommand, S as modelsAliasesAddCommand, _ as modelsAuthOrderSetCommand, a as modelsStatusCommand, b as modelsAuthPasteTokenCommand, c as modelsImageFallbacksClearCommand, d as modelsFallbacksAddCommand, f as modelsFallbacksClearCommand, g as modelsAuthOrderGetCommand, h as modelsAuthOrderClearCommand, i as modelsScanCommand, l as modelsImageFallbacksListCommand, m as modelsFallbacksRemoveCommand, n as modelsSetImageCommand, o as modelsListCommand, p as modelsFallbacksListCommand, r as modelsSetCommand, s as modelsImageFallbacksAddCommand, u as modelsImageFallbacksRemoveCommand, v as modelsAuthAddCommand, w as modelsAliasesRemoveCommand, x as modelsAuthSetupTokenCommand, y as modelsAuthLoginCommand } from "./models-CExsNQPH.js";
+import "./auth-health-B7FqA26_.js";
+
+//#region src/cli/models-cli.ts
+function runModelsCommand(action) {
+	return runCommandWithRuntime(defaultRuntime, action);
+}
+function registerModelsCli(program) {
+	const models = program.command("models").description("Model discovery, scanning, and configuration").option("--status-json", "Output JSON (alias for `models status --json`)", false).option("--status-plain", "Plain output (alias for `models status --plain`)", false).option("--agent <id>", "Agent id to inspect (overrides OPENCLAW_AGENT_DIR/PI_CODING_AGENT_DIR)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/models", "docs.noxsoft.net/anima/cli/models")}\n`);
+	models.command("list").description("List models (configured by default)").option("--all", "Show full model catalog", false).option("--local", "Filter to local models", false).option("--provider <name>", "Filter by provider").option("--json", "Output JSON", false).option("--plain", "Plain line output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsListCommand(opts, defaultRuntime);
+		});
+	});
+	models.command("status").description("Show configured model state").option("--json", "Output JSON", false).option("--plain", "Plain output", false).option("--check", "Exit non-zero if auth is expiring/expired (1=expired/missing, 2=expiring)", false).option("--probe", "Probe configured provider auth (live)", false).option("--probe-provider <name>", "Only probe a single provider").option("--probe-profile <id>", "Only probe specific auth profile ids (repeat or comma-separated)", (value, previous) => {
+		const next = Array.isArray(previous) ? previous : previous ? [previous] : [];
+		next.push(value);
+		return next;
+	}).option("--probe-timeout <ms>", "Per-probe timeout in ms").option("--probe-concurrency <n>", "Concurrent probes").option("--probe-max-tokens <n>", "Probe max tokens (best-effort)").option("--agent <id>", "Agent id to inspect (overrides OPENCLAW_AGENT_DIR/PI_CODING_AGENT_DIR)").action(async (opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			await modelsStatusCommand({
+				json: Boolean(opts.json),
+				plain: Boolean(opts.plain),
+				check: Boolean(opts.check),
+				probe: Boolean(opts.probe),
+				probeProvider: opts.probeProvider,
+				probeProfile: opts.probeProfile,
+				probeTimeout: opts.probeTimeout,
+				probeConcurrency: opts.probeConcurrency,
+				probeMaxTokens: opts.probeMaxTokens,
+				agent
+			}, defaultRuntime);
+		});
+	});
+	models.command("set").description("Set the default model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			await modelsSetCommand(model, defaultRuntime);
+		});
+	});
+	models.command("set-image").description("Set the image model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			await modelsSetImageCommand(model, defaultRuntime);
+		});
+	});
+	const aliases = models.command("aliases").description("Manage model aliases");
+	aliases.command("list").description("List model aliases").option("--json", "Output JSON", false).option("--plain", "Plain output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsAliasesListCommand(opts, defaultRuntime);
+		});
+	});
+	aliases.command("add").description("Add or update a model alias").argument("<alias>", "Alias name").argument("<model>", "Model id or alias").action(async (alias, model) => {
+		await runModelsCommand(async () => {
+			await modelsAliasesAddCommand(alias, model, defaultRuntime);
+		});
+	});
+	aliases.command("remove").description("Remove a model alias").argument("<alias>", "Alias name").action(async (alias) => {
+		await runModelsCommand(async () => {
+			await modelsAliasesRemoveCommand(alias, defaultRuntime);
+		});
+	});
+	const fallbacks = models.command("fallbacks").description("Manage model fallback list");
+	fallbacks.command("list").description("List fallback models").option("--json", "Output JSON", false).option("--plain", "Plain output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsFallbacksListCommand(opts, defaultRuntime);
+		});
+	});
+	fallbacks.command("add").description("Add a fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			await modelsFallbacksAddCommand(model, defaultRuntime);
+		});
+	});
+	fallbacks.command("remove").description("Remove a fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			await modelsFallbacksRemoveCommand(model, defaultRuntime);
+		});
+	});
+	fallbacks.command("clear").description("Clear all fallback models").action(async () => {
+		await runModelsCommand(async () => {
+			await modelsFallbacksClearCommand(defaultRuntime);
+		});
+	});
+	const imageFallbacks = models.command("image-fallbacks").description("Manage image model fallback list");
+	imageFallbacks.command("list").description("List image fallback models").option("--json", "Output JSON", false).option("--plain", "Plain output", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsImageFallbacksListCommand(opts, defaultRuntime);
+		});
+	});
+	imageFallbacks.command("add").description("Add an image fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			await modelsImageFallbacksAddCommand(model, defaultRuntime);
+		});
+	});
+	imageFallbacks.command("remove").description("Remove an image fallback model").argument("<model>", "Model id or alias").action(async (model) => {
+		await runModelsCommand(async () => {
+			await modelsImageFallbacksRemoveCommand(model, defaultRuntime);
+		});
+	});
+	imageFallbacks.command("clear").description("Clear all image fallback models").action(async () => {
+		await runModelsCommand(async () => {
+			await modelsImageFallbacksClearCommand(defaultRuntime);
+		});
+	});
+	models.command("scan").description("Scan OpenRouter free models for tools + images").option("--min-params <b>", "Minimum parameter size (billions)").option("--max-age-days <days>", "Skip models older than N days").option("--provider <name>", "Filter by provider prefix").option("--max-candidates <n>", "Max fallback candidates", "6").option("--timeout <ms>", "Per-probe timeout in ms").option("--concurrency <n>", "Probe concurrency").option("--no-probe", "Skip live probes; list free candidates only").option("--yes", "Accept defaults without prompting", false).option("--no-input", "Disable prompts (use defaults)").option("--set-default", "Set agents.defaults.model to the first selection", false).option("--set-image", "Set agents.defaults.imageModel to the first image selection", false).option("--json", "Output JSON", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsScanCommand(opts, defaultRuntime);
+		});
+	});
+	models.action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsStatusCommand({
+				json: Boolean(opts?.statusJson),
+				plain: Boolean(opts?.statusPlain),
+				agent: opts?.agent
+			}, defaultRuntime);
+		});
+	});
+	const auth = models.command("auth").description("Manage model auth profiles");
+	auth.option("--agent <id>", "Agent id for auth order get/set/clear");
+	auth.action(() => {
+		auth.help();
+	});
+	auth.command("add").description("Interactive auth helper (setup-token or paste token)").action(async () => {
+		await runModelsCommand(async () => {
+			await modelsAuthAddCommand({}, defaultRuntime);
+		});
+	});
+	auth.command("login").description("Run a provider plugin auth flow (OAuth/API key)").option("--provider <id>", "Provider id registered by a plugin").option("--method <id>", "Provider auth method id").option("--set-default", "Apply the provider's default model recommendation", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsAuthLoginCommand({
+				provider: opts.provider,
+				method: opts.method,
+				setDefault: Boolean(opts.setDefault)
+			}, defaultRuntime);
+		});
+	});
+	auth.command("setup-token").description("Run a provider CLI to create/sync a token (TTY required)").option("--provider <name>", "Provider id (default: anthropic)").option("--yes", "Skip confirmation", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsAuthSetupTokenCommand({
+				provider: opts.provider,
+				yes: Boolean(opts.yes)
+			}, defaultRuntime);
+		});
+	});
+	auth.command("paste-token").description("Paste a token into auth-profiles.json and update config").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--profile-id <id>", "Auth profile id (default: <provider>:manual)").option("--expires-in <duration>", "Optional expiry duration (e.g. 365d, 12h). Stored as absolute expiresAt.").action(async (opts) => {
+		await runModelsCommand(async () => {
+			await modelsAuthPasteTokenCommand({
+				provider: opts.provider,
+				profileId: opts.profileId,
+				expiresIn: opts.expiresIn
+			}, defaultRuntime);
+		});
+	});
+	auth.command("login-github-copilot").description("Login to GitHub Copilot via GitHub device flow (TTY required)").option("--profile-id <id>", "Auth profile id (default: github-copilot:github)").option("--yes", "Overwrite existing profile without prompting", false).action(async (opts) => {
+		await runModelsCommand(async () => {
+			await githubCopilotLoginCommand({
+				profileId: opts.profileId,
+				yes: Boolean(opts.yes)
+			}, defaultRuntime);
+		});
+	});
+	const order = auth.command("order").description("Manage per-agent auth profile order overrides");
+	order.command("get").description("Show per-agent auth order override (from auth-profiles.json)").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--agent <id>", "Agent id (default: configured default agent)").option("--json", "Output JSON", false).action(async (opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			await modelsAuthOrderGetCommand({
+				provider: opts.provider,
+				agent,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	order.command("set").description("Set per-agent auth order override (locks rotation to this list)").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--agent <id>", "Agent id (default: configured default agent)").argument("<profileIds...>", "Auth profile ids (e.g. anthropic:default)").action(async (profileIds, opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			await modelsAuthOrderSetCommand({
+				provider: opts.provider,
+				agent,
+				order: profileIds
+			}, defaultRuntime);
+		});
+	});
+	order.command("clear").description("Clear per-agent auth order override (fall back to config/round-robin)").requiredOption("--provider <name>", "Provider id (e.g. anthropic)").option("--agent <id>", "Agent id (default: configured default agent)").action(async (opts, command) => {
+		const agent = resolveOptionFromCommand(command, "agent") ?? opts.agent;
+		await runModelsCommand(async () => {
+			await modelsAuthOrderClearCommand({
+				provider: opts.provider,
+				agent
+			}, defaultRuntime);
+		});
+	});
+}
+
+//#endregion
+export { registerModelsCli };

package/dist/net-0A_zcaQD.js

@@ -0,0 +1,218 @@
+import { t as pickPrimaryTailnetIPv4 } from "./tailnet-Ciwjv243.js";
+import os from "node:os";
+import { Buffer } from "node:buffer";
+import net from "node:net";
+
+//#region src/infra/ws.ts
+function rawDataToString(data, encoding = "utf8") {
+	if (typeof data === "string") return data;
+	if (Buffer.isBuffer(data)) return data.toString(encoding);
+	if (Array.isArray(data)) return Buffer.concat(data).toString(encoding);
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString(encoding);
+	return Buffer.from(String(data)).toString(encoding);
+}
+
+//#endregion
+//#region src/gateway/net.ts
+/**
+* Pick the primary non-internal IPv4 address (LAN IP).
+* Prefers common interface names (en0, eth0) then falls back to any external IPv4.
+*/
+function pickPrimaryLanIPv4() {
+	const nets = os.networkInterfaces();
+	for (const name of ["en0", "eth0"]) {
+		const entry = nets[name]?.find((n) => n.family === "IPv4" && !n.internal);
+		if (entry?.address) return entry.address;
+	}
+	for (const list of Object.values(nets)) {
+		const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+		if (entry?.address) return entry.address;
+	}
+}
+function isLoopbackAddress(ip) {
+	if (!ip) return false;
+	if (ip === "127.0.0.1") return true;
+	if (ip.startsWith("127.")) return true;
+	if (ip === "::1") return true;
+	if (ip.startsWith("::ffff:127.")) return true;
+	return false;
+}
+/**
+* Returns true if the IP belongs to a private or loopback network range.
+* Private ranges: RFC1918, link-local, ULA IPv6, and CGNAT (100.64/10), plus loopback.
+*/
+function isPrivateOrLoopbackAddress(ip) {
+	if (!ip) return false;
+	if (isLoopbackAddress(ip)) return true;
+	const normalized = normalizeIPv4MappedAddress(ip.trim().toLowerCase());
+	const family = net.isIP(normalized);
+	if (!family) return false;
+	if (family === 4) {
+		const octets = normalized.split(".").map((value) => Number.parseInt(value, 10));
+		if (octets.length !== 4 || octets.some((value) => Number.isNaN(value))) return false;
+		const [o1, o2] = octets;
+		if (o1 === 10 || o1 === 172 && o2 >= 16 && o2 <= 31 || o1 === 192 && o2 === 168) return true;
+		if (o1 === 169 && o2 === 254 || o1 === 100 && o2 >= 64 && o2 <= 127) return true;
+		return false;
+	}
+	if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
+	if (/^fe[89ab]/.test(normalized)) return true;
+	return false;
+}
+function normalizeIPv4MappedAddress(ip) {
+	if (ip.startsWith("::ffff:")) return ip.slice(7);
+	return ip;
+}
+function normalizeIp(ip) {
+	const trimmed = ip?.trim();
+	if (!trimmed) return;
+	return normalizeIPv4MappedAddress(trimmed.toLowerCase());
+}
+function stripOptionalPort(ip) {
+	if (ip.startsWith("[")) {
+		const end = ip.indexOf("]");
+		if (end !== -1) return ip.slice(1, end);
+	}
+	if (net.isIP(ip)) return ip;
+	const lastColon = ip.lastIndexOf(":");
+	if (lastColon > -1 && ip.includes(".") && ip.indexOf(":") === lastColon) {
+		const candidate = ip.slice(0, lastColon);
+		if (net.isIP(candidate) === 4) return candidate;
+	}
+	return ip;
+}
+function parseForwardedForClientIp(forwardedFor) {
+	const raw = forwardedFor?.split(",")[0]?.trim();
+	if (!raw) return;
+	return normalizeIp(stripOptionalPort(raw));
+}
+function parseRealIp(realIp) {
+	const raw = realIp?.trim();
+	if (!raw) return;
+	return normalizeIp(stripOptionalPort(raw));
+}
+/**
+* Check if an IP address matches a CIDR block.
+* Supports IPv4 CIDR notation (e.g., "10.42.0.0/24").
+*
+* @param ip - The IP address to check (e.g., "10.42.0.59")
+* @param cidr - The CIDR block (e.g., "10.42.0.0/24")
+* @returns True if the IP is within the CIDR block
+*/
+function ipMatchesCIDR(ip, cidr) {
+	if (!cidr.includes("/")) return ip === cidr;
+	const [subnet, prefixLenStr] = cidr.split("/");
+	const prefixLen = parseInt(prefixLenStr, 10);
+	if (Number.isNaN(prefixLen) || prefixLen < 0 || prefixLen > 32) return false;
+	const ipParts = ip.split(".").map((p) => parseInt(p, 10));
+	const subnetParts = subnet.split(".").map((p) => parseInt(p, 10));
+	if (ipParts.length !== 4 || subnetParts.length !== 4 || ipParts.some((p) => Number.isNaN(p) || p < 0 || p > 255) || subnetParts.some((p) => Number.isNaN(p) || p < 0 || p > 255)) return false;
+	const ipInt = ipParts[0] << 24 | ipParts[1] << 16 | ipParts[2] << 8 | ipParts[3];
+	const subnetInt = subnetParts[0] << 24 | subnetParts[1] << 16 | subnetParts[2] << 8 | subnetParts[3];
+	const mask = prefixLen === 0 ? 0 : -1 >>> 32 - prefixLen << 32 - prefixLen;
+	return (ipInt & mask) === (subnetInt & mask);
+}
+function isTrustedProxyAddress(ip, trustedProxies) {
+	const normalized = normalizeIp(ip);
+	if (!normalized || !trustedProxies || trustedProxies.length === 0) return false;
+	return trustedProxies.some((proxy) => {
+		if (proxy.includes("/")) return ipMatchesCIDR(normalized, proxy);
+		return normalizeIp(proxy) === normalized;
+	});
+}
+function resolveGatewayClientIp(params) {
+	const remote = normalizeIp(params.remoteAddr);
+	if (!remote) return;
+	if (!isTrustedProxyAddress(remote, params.trustedProxies)) return remote;
+	return parseForwardedForClientIp(params.forwardedFor) ?? parseRealIp(params.realIp) ?? remote;
+}
+/**
+* Resolves gateway bind host with fallback strategy.
+*
+* Modes:
+* - loopback: 127.0.0.1 (rarely fails, but handled gracefully)
+* - lan: always 0.0.0.0 (no fallback)
+* - tailnet: Tailnet IPv4 if available, else loopback
+* - auto: Loopback if available, else 0.0.0.0
+* - custom: User-specified IP, fallback to 0.0.0.0 if unavailable
+*
+* @returns The bind address to use (never null)
+*/
+async function resolveGatewayBindHost(bind, customHost) {
+	const mode = bind ?? "loopback";
+	if (mode === "loopback") {
+		if (await canBindToHost("127.0.0.1")) return "127.0.0.1";
+		return "0.0.0.0";
+	}
+	if (mode === "tailnet") {
+		const tailnetIP = pickPrimaryTailnetIPv4();
+		if (tailnetIP && await canBindToHost(tailnetIP)) return tailnetIP;
+		if (await canBindToHost("127.0.0.1")) return "127.0.0.1";
+		return "0.0.0.0";
+	}
+	if (mode === "lan") return "0.0.0.0";
+	if (mode === "custom") {
+		const host = customHost?.trim();
+		if (!host) return "0.0.0.0";
+		if (isValidIPv4(host) && await canBindToHost(host)) return host;
+		return "0.0.0.0";
+	}
+	if (mode === "auto") {
+		if (await canBindToHost("127.0.0.1")) return "127.0.0.1";
+		return "0.0.0.0";
+	}
+	return "0.0.0.0";
+}
+/**
+* Test if we can bind to a specific host address.
+* Creates a temporary server, attempts to bind, then closes it.
+*
+* @param host - The host address to test
+* @returns True if we can successfully bind to this address
+*/
+async function canBindToHost(host) {
+	return new Promise((resolve) => {
+		const testServer = net.createServer();
+		testServer.once("error", () => {
+			resolve(false);
+		});
+		testServer.once("listening", () => {
+			testServer.close();
+			resolve(true);
+		});
+		testServer.listen(0, host);
+	});
+}
+async function resolveGatewayListenHosts(bindHost, opts) {
+	if (bindHost !== "127.0.0.1") return [bindHost];
+	if (await (opts?.canBindToHost ?? canBindToHost)("::1")) return [bindHost, "::1"];
+	return [bindHost];
+}
+/**
+* Validate if a string is a valid IPv4 address.
+*
+* @param host - The string to validate
+* @returns True if valid IPv4 format
+*/
+function isValidIPv4(host) {
+	const parts = host.split(".");
+	if (parts.length !== 4) return false;
+	return parts.every((part) => {
+		const n = parseInt(part, 10);
+		return !Number.isNaN(n) && n >= 0 && n <= 255 && part === String(n);
+	});
+}
+/**
+* Check if a hostname or IP refers to the local machine.
+* Handles: localhost, 127.x.x.x, ::1, [::1], ::ffff:127.x.x.x
+* Note: 0.0.0.0 and :: are NOT loopback - they bind to all interfaces.
+*/
+function isLoopbackHost(host) {
+	if (!host) return false;
+	const h = host.trim().toLowerCase();
+	if (h === "localhost") return true;
+	return isLoopbackAddress(h.startsWith("[") && h.endsWith("]") ? h.slice(1, -1) : h);
+}
+
+//#endregion
+export { isValidIPv4 as a, resolveGatewayBindHost as c, rawDataToString as d, isTrustedProxyAddress as i, resolveGatewayClientIp as l, isLoopbackHost as n, parseForwardedForClientIp as o, isPrivateOrLoopbackAddress as r, pickPrimaryLanIPv4 as s, isLoopbackAddress as t, resolveGatewayListenHosts as u };