dsh-web-fetch-enhanced 0.0.1

package/lib/index.js

@@ -0,0 +1,645 @@
+import z from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { isIP } from "node:net";
+import ipaddr from "ipaddr.js";
+import { WebError } from "@deepseek-ai/dsh-web";
+import { deadline, timeoutOf } from "@deepseek-ai/dsh-timeout";
+import { lookup } from "node:dns/promises";
+//#region lib/types/address-policy.js
+/**
+* Immutable address policy. Public unicast remains allowed. A non-public address
+* must match one configured CIDR and, when hostname rules exist, one hostname rule.
+*/
+var AddressPolicy = class {
+	#cidrs;
+	#hostnames;
+	constructor(options = {}) {
+		this.#cidrs = (options.allowCidrs ?? []).map(compileCidr);
+		this.#hostnames = (options.allowHostnames ?? []).map(compileHostname);
+	}
+	/** Return true when an address is public or explicitly exempted for this hostname. */
+	allows(hostname, address) {
+		const parsed = parseAddress(address);
+		if (parsed === void 0) return false;
+		if (isPublicAddress(parsed)) return true;
+		if (!this.#matchesHostname(hostname)) return false;
+		return this.#cidrs.some((cidr) => matchesCidr(parsed, cidr));
+	}
+	/** Return true only when a non-public address is covered by the configured exception. */
+	allowsNonPublic(hostname, address) {
+		const parsed = parseAddress(address);
+		if (parsed === void 0 || isPublicAddress(parsed)) return false;
+		return this.#matchesHostname(hostname) && this.#cidrs.some((cidr) => matchesCidr(parsed, cidr));
+	}
+	#matchesHostname(hostname) {
+		if (this.#hostnames.length === 0) return true;
+		const normalized = normalizeHostname(hostname);
+		return this.#hostnames.some((rule) => {
+			if (rule.kind === "exact") return normalized === rule.hostname;
+			return normalized.endsWith(rule.suffix) && normalized.length > rule.suffix.length;
+		});
+	}
+};
+function isPublicAddress(address) {
+	return address.range() === "unicast";
+}
+function parseAddress(input) {
+	try {
+		const parsed = ipaddr.parse(stripIpv6Brackets(input));
+		if (parsed instanceof ipaddr.IPv6) {
+			if (parsed.isIPv4MappedAddress()) return parsed.toIPv4Address();
+			const bytes = parsed.toByteArray();
+			if (bytes.slice(0, 12).every((byte) => byte === 0)) return new ipaddr.IPv4(bytes.slice(12));
+		}
+		return parsed;
+	} catch {
+		return;
+	}
+}
+function compileCidr(input) {
+	const source = input.trim();
+	if (source.length === 0) throw new Error("web-fetch-enhanced: allowCidrs must not contain an empty value");
+	const parts = source.split("/");
+	const addressText = parts[0];
+	const prefixText = parts[1];
+	if (parts.length !== 2 || addressText === void 0 || prefixText === void 0 || !/^(0|[1-9]\d*)$/u.test(prefixText)) throw new Error(`web-fetch-enhanced: invalid CIDR ${JSON.stringify(input)}`);
+	let parsed;
+	try {
+		parsed = ipaddr.parseCIDR(source);
+	} catch (error) {
+		throw new Error(`web-fetch-enhanced: invalid CIDR ${JSON.stringify(input)}`, { cause: error });
+	}
+	const [network, prefixLength] = parsed;
+	if (network instanceof ipaddr.IPv4 && !isStrictIpv4Literal(addressText)) throw new Error(`web-fetch-enhanced: IPv4 CIDR must use four decimal octets: ${JSON.stringify(input)}`);
+	if (network instanceof ipaddr.IPv6 && addressText.includes("%")) throw new Error(`web-fetch-enhanced: IPv6 CIDR must not contain a zone id: ${JSON.stringify(input)}`);
+	if (network instanceof ipaddr.IPv6 && network.isIPv4MappedAddress()) throw new Error(`web-fetch-enhanced: IPv4-mapped CIDR ${JSON.stringify(input)} is ambiguous; use its IPv4 CIDR`);
+	const base = network instanceof ipaddr.IPv4 ? ipaddr.IPv4.networkAddressFromCIDR(source) : ipaddr.IPv6.networkAddressFromCIDR(source);
+	if (!network.toByteArray().every((byte, index) => base.toByteArray()[index] === byte)) throw new Error(`web-fetch-enhanced: CIDR must use its network base address: ${JSON.stringify(input)}`);
+	return {
+		network,
+		prefixLength
+	};
+}
+function isStrictIpv4Literal(input) {
+	const octets = input.split(".");
+	return octets.length === 4 && octets.every((octet) => {
+		if (!/^(0|[1-9]\d{0,2})$/u.test(octet)) return false;
+		return Number(octet) <= 255;
+	});
+}
+function matchesCidr(address, cidr) {
+	if (address.kind() !== cidr.network.kind()) return false;
+	return address.match(cidr.network, cidr.prefixLength);
+}
+function compileHostname(input) {
+	const source = input.trim();
+	if (source.startsWith("*.")) {
+		const base = source.slice(2);
+		if (base.length === 0 || isIP(stripIpv6Brackets(base)) !== 0) throw new Error(`web-fetch-enhanced: invalid wildcard hostname ${JSON.stringify(input)}`);
+		return {
+			kind: "suffix",
+			suffix: `.${normalizeHostname(base)}`
+		};
+	}
+	if (source.includes("*")) throw new Error(`web-fetch-enhanced: hostname wildcard is only allowed as the left-most "*." label: ${JSON.stringify(input)}`);
+	return {
+		kind: "exact",
+		hostname: normalizeHostname(source)
+	};
+}
+function normalizeHostname(input) {
+	const source = stripIpv6Brackets(input.trim()).replace(/\.$/u, "");
+	if (source.length === 0 || /[\\\s/?#@]/u.test(source)) throw new Error(`web-fetch-enhanced: invalid hostname ${JSON.stringify(input)}`);
+	if (isIP(source) !== 0) return ipaddr.parse(source).toString().toLowerCase();
+	if (source.includes(":")) throw new Error(`web-fetch-enhanced: hostname rules must not include a port: ${JSON.stringify(input)}`);
+	const parsed = new URL(`http://${source}/`);
+	if (parsed.hostname === "") throw new Error(`web-fetch-enhanced: invalid hostname ${JSON.stringify(input)}`);
+	return parsed.hostname.replace(/\.$/u, "").toLowerCase();
+}
+/** WHATWG URL retains brackets around IPv6 hostnames; IP parsers do not. */
+function stripIpv6Brackets(hostname) {
+	return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+//#endregion
+//#region lib/types/resolver.js
+const RFC6052_PREFIX_LENGTHS = [
+	32,
+	40,
+	48,
+	56,
+	64,
+	96
+];
+const IPV4ONLY_DISCOVERY_HOST = "ipv4only.arpa";
+const IPV4ONLY_SENTINELS = new Set(["192.0.0.170", "192.0.0.171"]);
+/** Build the resolver injected into the address-pinned HTTP provider. */
+function createAllowlistResolver(policy, resolver = lookup) {
+	return (hostname, signal) => resolveAllowedAddresses(hostname, signal, policy, resolver);
+}
+/** Resolve once and reject the complete answer set when any entry is disallowed. */
+async function resolveAllowedAddresses(hostname, signal, policy, resolver = lookup) {
+	const unbracketed = stripIpv6Brackets(hostname);
+	const literalFamily = isIP(unbracketed);
+	const resolved = literalFamily === 0 ? await raceWithSignal(resolver(unbracketed, {
+		all: true,
+		order: "verbatim"
+	}), signal) : [{
+		address: unbracketed,
+		family: literalFamily
+	}];
+	if (resolved.length === 0) throw new WebError(`hostname "${hostname}" resolved to no addresses`, "WEB_PROVIDER_ERROR");
+	const nat64Prefixes = resolved.some((entry) => entry.family === 6 && isIP(entry.address) === 6) ? await discoverNat64Prefixes(signal, resolver) : [];
+	const addresses = [];
+	for (const entry of resolved) {
+		if (entry.family !== 4 && entry.family !== 6 || isIP(entry.address) !== entry.family) throw new WebError(`hostname "${hostname}" resolved to an invalid IP address`, "WEB_PROVIDER_ERROR");
+		if (!policy.allows(hostname, entry.address)) throw new WebError(`URL hostname "${hostname}" resolves to non-public IP address "${entry.address}" outside the configured allowlist`, "WEB_BLOCKED_URL");
+		for (const translatedIpv4 of translatedIpv4Addresses(entry.address, nat64Prefixes)) if (!policy.allows(hostname, translatedIpv4)) throw new WebError(`URL hostname "${hostname}" resolves through NAT64 to non-public IPv4 address "${translatedIpv4}" outside the configured allowlist`, "WEB_BLOCKED_URL");
+		addresses.push({
+			address: entry.address,
+			family: entry.family
+		});
+	}
+	return addresses;
+}
+async function discoverNat64Prefixes(signal, resolver) {
+	const discovered = await raceWithSignal(resolver(IPV4ONLY_DISCOVERY_HOST, {
+		all: true,
+		order: "verbatim"
+	}), signal);
+	const prefixes = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of discovered) {
+		if (entry.family !== 6 || isIP(entry.address) !== 6) continue;
+		const bytes = ipaddr.parse(entry.address).toByteArray();
+		for (const length of RFC6052_PREFIX_LENGTHS) {
+			const embedded = embeddedIpv4Address(bytes, length);
+			if (embedded === void 0 || !IPV4ONLY_SENTINELS.has(embedded)) continue;
+			const prefixBytes = bytes.slice(0, length / 8);
+			const key = `${String(length)}:${prefixBytes.join(".")}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			prefixes.push({
+				bytes: prefixBytes,
+				length
+			});
+		}
+	}
+	return prefixes;
+}
+function translatedIpv4Addresses(input, prefixes) {
+	if (isIP(input) !== 6) return [];
+	const bytes = ipaddr.parse(input).toByteArray();
+	const translated = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const prefix of prefixes) {
+		if (!prefix.bytes.every((byte, index) => bytes[index] === byte)) continue;
+		const embedded = embeddedIpv4Address(bytes, prefix.length);
+		if (embedded === void 0 || seen.has(embedded)) continue;
+		seen.add(embedded);
+		translated.push(embedded);
+	}
+	return translated;
+}
+function embeddedIpv4Address(bytes, prefixLength) {
+	if (prefixLength === 96) return bytes.slice(12, 16).join(".");
+	if (bytes[8] !== 0) return void 0;
+	const prefixBytes = prefixLength / 8;
+	const beforeReservedOctet = 8 - prefixBytes;
+	return [...bytes.slice(prefixBytes, prefixBytes + beforeReservedOctet), ...bytes.slice(9, 13 - beforeReservedOctet)].join(".");
+}
+/** Fetch while preserving the URL hostname for Host and TLS SNI. */
+async function requestPinned(url, addresses, headers, signal) {
+	const { Agent, fetch } = await import("undici");
+	const dispatcher = new Agent({
+		autoSelectFamily: true,
+		connect: { lookup: createPinnedLookup(addresses) }
+	});
+	try {
+		return {
+			response: await fetch(url, {
+				method: "GET",
+				redirect: "manual",
+				headers,
+				signal,
+				dispatcher
+			}),
+			close: async () => {
+				await dispatcher.close();
+			}
+		};
+	} catch (error) {
+		await dispatcher.close();
+		throw error;
+	}
+}
+/** Create a Node lookup callback that returns only the prevalidated answer set. */
+function createPinnedLookup(addresses) {
+	return (hostname, options, callback) => {
+		const family = typeof options.family === "number" ? options.family : options.family === "IPv4" ? 4 : options.family === "IPv6" ? 6 : 0;
+		const eligible = family === 0 ? addresses : addresses.filter((address) => address.family === family);
+		const selected = eligible[0];
+		if (selected === void 0) {
+			callback(Object.assign(/* @__PURE__ */ new Error(`no validated address for ${hostname} in family ${family}`), {
+				code: "ENOTFOUND",
+				hostname
+			}), options.all === true ? [] : "", family);
+			return;
+		}
+		if (options.all === true) {
+			callback(null, eligible.map((address) => ({ ...address })));
+			return;
+		}
+		callback(null, selected.address, selected.family);
+	};
+}
+function raceWithSignal(promise, signal) {
+	const abortError = () => new Error("web fetch aborted during hostname resolution", { cause: signal.reason });
+	if (signal.aborted) return Promise.reject(abortError());
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			reject(abortError());
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", abort);
+		});
+	});
+}
+//#endregion
+//#region lib/types/policy.js
+/** Maximum accepted request URL length. */
+const WEB_FETCH_MAX_URL_LENGTH = 2048;
+/** Parse a URL and enforce HTTP(S)-only, anonymous requests. */
+function parseFetchUrl(input) {
+	let url;
+	try {
+		url = new URL(input);
+	} catch (error) {
+		throw new WebError(`invalid URL: ${input}`, "WEB_INVALID_URL", { cause: error });
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new WebError(`unsupported URL scheme "${url.protocol}" (only http and https are allowed)`, "WEB_INVALID_URL");
+	if (url.username.length > 0 || url.password.length > 0) throw new WebError("credentials in URLs are not allowed", "WEB_BLOCKED_URL");
+	return url;
+}
+/** Validate URL length before parsing. */
+function validateFetchUrl(input) {
+	if (input.length > 2048) throw new WebError(`URL exceeds the maximum length of ${WEB_FETCH_MAX_URL_LENGTH}`, "WEB_INVALID_URL");
+	return parseFetchUrl(input);
+}
+/** Same origin means the scheme, hostname, and port are all equal. */
+function isSameOrigin(a, b) {
+	return a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
+}
+/** Classify supported textual response types. */
+function classifyContentType(contentType) {
+	const mime = (contentType ?? "").replace(/;.*$/s, "").trim().toLowerCase();
+	if (mime === "text/html" || mime === "application/xhtml+xml") return "html";
+	if (mime.startsWith("text/")) return "text";
+	if (mime === "application/json" || mime === "application/xml" || mime.endsWith("+json") || mime.endsWith("+xml")) return "text";
+}
+/** Return the declared charset, normalized to lower case. */
+function parseCharset(contentType) {
+	return /;\s*charset\s*=\s*"?([^";]+)"?/i.exec(contentType ?? "")?.[1]?.trim().toLowerCase();
+}
+/** Create a decoder, rejecting unsupported charset labels. */
+function decoderForCharset(charset) {
+	if (charset === void 0) return new TextDecoder("utf-8");
+	try {
+		return new TextDecoder(charset);
+	} catch (error) {
+		throw new WebError(`unsupported charset "${charset}"`, "WEB_UNSUPPORTED_CONTENT_TYPE", { cause: error });
+	}
+}
+//#endregion
+//#region lib/types/provider.js
+var __addDisposableResource = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __disposeResources = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/** Anonymous HTTP(S) provider with allowlist-aware address validation. */
+var EnhancedHttpFetchProvider = class {
+	id;
+	limits;
+	resolveAddresses;
+	constructor(id, limits, resolveAddresses) {
+		this.id = id;
+		this.limits = limits;
+		this.resolveAddresses = resolveAddresses;
+	}
+	available() {
+		return true;
+	}
+	async fetch(request, signal) {
+		const env_1 = {
+			stack: [],
+			error: void 0,
+			hasError: false
+		};
+		try {
+			if (signal?.aborted) throw new WebError("web fetch aborted", "WEB_ABORTED");
+			const d = __addDisposableResource(env_1, deadline(signal, this.limits.timeoutMs, "WEB_FETCH_TIMEOUT"), false);
+			return await this.followAndRead(request.url, d.signal);
+		} catch (e_1) {
+			env_1.error = e_1;
+			env_1.hasError = true;
+		} finally {
+			__disposeResources(env_1);
+		}
+	}
+	async followAndRead(initialUrl, signal) {
+		let currentUrl = validateFetchUrl(initialUrl);
+		let redirectsFollowed = 0;
+		for (;;) {
+			const request = await this.requestOnce(currentUrl, signal);
+			const { response } = request;
+			try {
+				if (isRedirectStatus(response.status)) {
+					if (redirectsFollowed >= this.limits.maxRedirects) {
+						await response.body?.cancel();
+						throw new WebError(`exceeded the maximum of ${this.limits.maxRedirects} redirects`, "WEB_REDIRECT_BLOCKED");
+					}
+					const location = response.headers.get("location");
+					if (location === null) {
+						await response.body?.cancel();
+						throw new WebError(`redirect response (HTTP ${response.status}) without a Location header`, "WEB_PROVIDER_ERROR");
+					}
+					let validatedTarget;
+					try {
+						validatedTarget = validateFetchUrl(resolveRedirect(location, currentUrl).toString());
+						if (!isSameOrigin(validatedTarget, currentUrl)) throw new WebError(`cross-origin redirect to ${validatedTarget.origin} is not followed automatically; retry against that URL directly`, "WEB_REDIRECT_BLOCKED");
+					} catch (error) {
+						await response.body?.cancel();
+						throw error;
+					}
+					await response.body?.cancel();
+					currentUrl = validatedTarget;
+					redirectsFollowed++;
+					continue;
+				}
+				return await this.readBody(response, currentUrl, signal);
+			} finally {
+				await request.close();
+			}
+		}
+	}
+	async requestOnce(url, signal) {
+		try {
+			return await requestPinned(url, await this.resolveAddresses(url.hostname, signal), {
+				"user-agent": this.limits.userAgent,
+				"accept": "text/html,application/xhtml+xml,text/*;q=0.9,application/json;q=0.8"
+			}, signal);
+		} catch (error) {
+			if (error instanceof WebError) throw error;
+			throw translateAbortOrNetwork(error, signal);
+		}
+	}
+	async readBody(response, finalUrl, signal) {
+		const contentType = response.headers.get("content-type");
+		const kind = classifyContentType(contentType);
+		if (kind === void 0) {
+			await response.body?.cancel();
+			throw new WebError(`unsupported content type "${contentType ?? "unknown"}"`, "WEB_UNSUPPORTED_CONTENT_TYPE");
+		}
+		let decoder;
+		try {
+			decoder = decoderForCharset(parseCharset(contentType));
+		} catch (error) {
+			await response.body?.cancel();
+			throw error;
+		}
+		const { bytes, truncatedByBytes } = await this.readCapped(response, signal);
+		const decoded = decoder.decode(bytes);
+		const truncatedByChars = decoded.length > this.limits.maxBodyChars;
+		const content = truncatedByChars ? decoded.slice(0, this.limits.maxBodyChars) : decoded;
+		const body = kind === "html" ? {
+			kind: "html",
+			content
+		} : {
+			kind: "text",
+			content
+		};
+		return {
+			url: finalUrl.toString(),
+			statusCode: response.status,
+			body,
+			truncated: truncatedByBytes || truncatedByChars
+		};
+	}
+	async readCapped(response, signal) {
+		const declared = response.headers.get("content-length");
+		if (declared !== null) {
+			const length = Number(declared);
+			if (Number.isFinite(length) && length > this.limits.maxResponseBytes) {
+				await response.body?.cancel();
+				throw new WebError(`response exceeds the maximum of ${this.limits.maxResponseBytes} bytes`, "WEB_FETCH_TOO_LARGE");
+			}
+		}
+		if (response.body === null) return {
+			bytes: new Uint8Array(0),
+			truncatedByBytes: false
+		};
+		const chunks = [];
+		let total = 0;
+		let truncatedByBytes = false;
+		const reader = response.body.getReader();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				const remaining = this.limits.maxResponseBytes - total;
+				if (value.byteLength > remaining) {
+					chunks.push(value.subarray(0, remaining));
+					total += remaining;
+					truncatedByBytes = true;
+					break;
+				}
+				chunks.push(value);
+				total += value.byteLength;
+			}
+		} catch (error) {
+			throw translateAbortOrNetwork(error, signal);
+		} finally {
+			await reader.cancel().catch(() => {});
+		}
+		const bytes = new Uint8Array(total);
+		let offset = 0;
+		for (const chunk of chunks) {
+			bytes.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return {
+			bytes,
+			truncatedByBytes
+		};
+	}
+};
+function isRedirectStatus(status) {
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function resolveRedirect(location, base) {
+	try {
+		return new URL(location, base);
+	} catch (error) {
+		throw new WebError(`invalid redirect Location "${location}"`, "WEB_PROVIDER_ERROR", { cause: error });
+	}
+}
+function translateAbortOrNetwork(error, signal) {
+	const timeout = timeoutOf(signal, "WEB_FETCH_TIMEOUT");
+	if (timeout !== void 0) return new WebError("web fetch timed out", "WEB_FETCH_TIMEOUT", { cause: timeout });
+	if (signal.aborted) return new WebError("web fetch aborted", "WEB_ABORTED", { cause: error });
+	return new WebError(`web fetch failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* DeepSeek Harness HTTP fetch provider with explicit non-public CIDR exceptions.
+* It preserves the native security model while making non-public exceptions explicit.
+*
+* @module dsh-web-fetch-enhanced
+*/
+const MAX_NODE_TIMER_DELAY_MS = 2147483647;
+/** Explicit product User-Agent used by default. */
+const DEFAULT_USER_AGENT = "dsh-web-fetch-enhanced/0.1.0";
+/** Default provider id; select it in the dsh-web row with fetchProvider. */
+const DEFAULT_PROVIDER_ID = "http-enhanced";
+/** Settings namespace paired with the Web Profile configuration card. */
+const SETTINGS_NAMESPACE = settingsNamespace("web-fetch-enhanced");
+/** Cordis plugin name used by loader diagnostics. */
+const name = "web-fetch-enhanced";
+/** The web seam this provider contributes to. */
+const inject = ["web"];
+const Config = z.object({
+	providerId: z.string().default(DEFAULT_PROVIDER_ID),
+	allowCidrs: z.array(z.string()).default([]),
+	allowHostnames: z.array(z.string()).default([]),
+	maxResponseBytes: z.number().default(5e6),
+	maxBodyChars: z.number().default(1e5),
+	timeoutMs: z.number().default(3e4),
+	maxRedirects: z.number().default(5),
+	userAgent: z.string().default(DEFAULT_USER_AGENT)
+});
+/** Construct the provider without mounting it, useful for tests and custom compositions. */
+function createProvider(config = {}) {
+	const resolved = resolveConfig(config);
+	assertProviderId(resolved.providerId);
+	assertPositiveFinite("maxResponseBytes", resolved.maxResponseBytes);
+	assertPositiveFinite("maxBodyChars", resolved.maxBodyChars);
+	assertTimeoutMs(resolved.timeoutMs);
+	assertNonNegativeInteger("maxRedirects", resolved.maxRedirects);
+	const policy = new AddressPolicy({
+		allowCidrs: resolved.allowCidrs,
+		allowHostnames: resolved.allowHostnames
+	});
+	const limits = {
+		maxResponseBytes: resolved.maxResponseBytes,
+		maxBodyChars: resolved.maxBodyChars,
+		timeoutMs: resolved.timeoutMs,
+		maxRedirects: resolved.maxRedirects,
+		userAgent: resolved.userAgent
+	};
+	return new EnhancedHttpFetchProvider(resolved.providerId, limits, createAllowlistResolver(policy));
+}
+/** Register the enhanced fetch provider and its live Web Profile settings section. */
+function apply(ctx, config) {
+	const providerId = resolveConfig(config).providerId;
+	let current = () => config;
+	installSettingsSection(ctx, SETTINGS_NAMESPACE, Config, config, {
+		setSource: (source) => {
+			current = source;
+		},
+		onChange: () => {},
+		validate: (value) => {
+			if (resolveConfig(value).providerId !== providerId) throw new Error("web-fetch-enhanced: providerId cannot be changed through live settings");
+			createProvider(value);
+		}
+	});
+	const dynamicProvider = {
+		id: providerId,
+		available: () => true,
+		fetch: async (request, signal) => {
+			return await createProvider(current()).fetch(request, signal);
+		}
+	};
+	ctx.web.registerFetchProvider(dynamicProvider);
+}
+function resolveConfig(config) {
+	return {
+		providerId: config.providerId ?? "http-enhanced",
+		allowCidrs: config.allowCidrs ?? [],
+		allowHostnames: config.allowHostnames ?? [],
+		maxResponseBytes: config.maxResponseBytes ?? 5e6,
+		maxBodyChars: config.maxBodyChars ?? 1e5,
+		timeoutMs: config.timeoutMs ?? 3e4,
+		maxRedirects: config.maxRedirects ?? 5,
+		userAgent: config.userAgent ?? "dsh-web-fetch-enhanced/0.1.0"
+	};
+}
+function assertProviderId(value) {
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value)) throw new Error("web-fetch-enhanced: providerId must be 1-128 letters, digits, dots, underscores, or hyphens");
+}
+function assertPositiveFinite(field, value) {
+	if (!Number.isFinite(value) || value <= 0) throw new Error(`web-fetch-enhanced: ${field} must be a positive finite number`);
+}
+function assertTimeoutMs(value) {
+	assertPositiveFinite("timeoutMs", value);
+	if (value > MAX_NODE_TIMER_DELAY_MS) throw new Error(`web-fetch-enhanced: timeoutMs must be no greater than ${MAX_NODE_TIMER_DELAY_MS}`);
+}
+function assertNonNegativeInteger(field, value) {
+	if (!Number.isInteger(value) || value < 0) throw new Error(`web-fetch-enhanced: ${field} must be a non-negative integer`);
+}
+//#endregion
+export { Config, DEFAULT_PROVIDER_ID, DEFAULT_USER_AGENT, SETTINGS_NAMESPACE, apply, createProvider, inject, name };

package/lib/types/address-policy.d.ts

@@ -0,0 +1,24 @@
+/** Inputs used to compile the non-public destination allowlist. */
+export interface AddressPolicyOptions {
+    /** IPv4 and IPv6 CIDRs allowed as exceptions to the public-address rule. */
+    readonly allowCidrs?: readonly string[];
+    /** Optional exact hostnames or left-most wildcards that must also match an exception. */
+    readonly allowHostnames?: readonly string[];
+}
+/**
+ * Immutable address policy. Public unicast remains allowed. A non-public address
+ * must match one configured CIDR and, when hostname rules exist, one hostname rule.
+ */
+export declare class AddressPolicy {
+    #private;
+    constructor(options?: AddressPolicyOptions);
+    /** Return true when an address is public or explicitly exempted for this hostname. */
+    allows(hostname: string, address: string): boolean;
+    /** Return true only when a non-public address is covered by the configured exception. */
+    allowsNonPublic(hostname: string, address: string): boolean;
+}
+/** Return true only for globally reachable unicast, matching the native provider. */
+export declare function isPublicIpAddress(input: string): boolean;
+/** WHATWG URL retains brackets around IPv6 hostnames; IP parsers do not. */
+export declare function stripIpv6Brackets(hostname: string): string;
+//# sourceMappingURL=address-policy.d.ts.map

package/lib/types/client/AllowlistCard.d.ts

@@ -0,0 +1,16 @@
+import type { SettingsScope } from '@deepseek-ai/dsh-client-runtime/client';
+import type { LocaleKey } from './locales.ts';
+export interface AllowlistSettings {
+    allowCidrs?: string[];
+    allowHostnames?: string[];
+}
+export interface AllowlistCardProps {
+    scope: SettingsScope<AllowlistSettings>;
+    t: (key: LocaleKey) => string;
+}
+export declare function parseLines(text: string): {
+    values: string[];
+    duplicate: boolean;
+};
+export declare function AllowlistCard({ scope, t }: AllowlistCardProps): import("react").JSX.Element | null;
+//# sourceMappingURL=AllowlistCard.d.ts.map