@questpie/sandbox 3.16.0 → 3.17.0

package/dist/adapter-http-w7SjAfcC.mjs

@@ -1,298 +0,0 @@
-//#region src/net-validation.ts
-/**
-* Parse a `host[:port]` allowlist entry (Deno `--allow-net` syntax).
-* Bracketed IPv6 (`[::1]:443`) and bare IPv6 (`::1`) are both handled.
-*/
-function parseHostEntry(entry) {
-	const trimmed = entry.trim();
-	if (trimmed.startsWith("[")) {
-		const close = trimmed.indexOf("]");
-		if (close === -1) return { host: trimmed };
-		const host = trimmed.slice(1, close);
-		const rest = trimmed.slice(close + 1);
-		if (rest.startsWith(":")) {
-			const port = Number(rest.slice(1));
-			return Number.isInteger(port) ? {
-				host,
-				port
-			} : { host };
-		}
-		return { host };
-	}
-	if ((trimmed.match(/:/g)?.length ?? 0) > 1) return { host: trimmed };
-	const lastColon = trimmed.lastIndexOf(":");
-	if (lastColon !== -1) {
-		const maybePort = Number(trimmed.slice(lastColon + 1));
-		if (Number.isInteger(maybePort)) return {
-			host: trimmed.slice(0, lastColon),
-			port: maybePort
-		};
-	}
-	return { host: trimmed };
-}
-/** True if `s` is a syntactically-valid dotted-quad IPv4 literal. */
-function isIpv4Literal(s) {
-	const parts = s.split(".");
-	if (parts.length !== 4) return false;
-	return parts.every((p) => {
-		if (!/^\d{1,3}$/.test(p)) return false;
-		const n = Number(p);
-		return n >= 0 && n <= 255;
-	});
-}
-/** True if `s` looks like an IPv6 literal (contains a colon, hex/`:`/`.` only). */
-function isIpv6Literal(s) {
-	if (!s.includes(":")) return false;
-	return /^[0-9a-fA-F:.]+$/.test(s);
-}
-/**
-* Classify an IPv4 literal as private/link-local/loopback/metadata/CGNAT.
-* Ranges (all per the task + cloud-metadata convention):
-*   0.0.0.0/8 (this-host), 127/8 (loopback), 10/8, 172.16/12, 192.168/16 (RFC-1918),
-*   169.254/16 (link-local, incl. 169.254.169.254 metadata), 100.64/10 (CGNAT/RFC-6598).
-*/
-function isPrivateIpv4(ip) {
-	const [a, b] = ip.split(".").map(Number);
-	if (a === 0) return true;
-	if (a === 127) return true;
-	if (a === 10) return true;
-	if (a === 172 && b >= 16 && b <= 31) return true;
-	if (a === 192 && b === 168) return true;
-	if (a === 169 && b === 254) return true;
-	if (a === 100 && b >= 64 && b <= 127) return true;
-	return false;
-}
-/** Normalize an IPv6 literal to lowercase, stripping a `%zone` suffix. */
-function normalizeIpv6(ip) {
-	const pct = ip.indexOf("%");
-	return (pct === -1 ? ip : ip.slice(0, pct)).toLowerCase();
-}
-/**
-* Classify an IPv6 literal as private/link-local/loopback/metadata.
-* Covers: ::1 (loopback), :: (unspecified), fc00::/7 (unique-local),
-* fe80::/10 (link-local), and IPv4-mapped/translated forms (::ffff:a.b.c.d,
-* ::a.b.c.d) by delegating their embedded IPv4 to `isPrivateIpv4`.
-*/
-function isPrivateIpv6(raw) {
-	const ip = normalizeIpv6(raw);
-	if (ip === "::1") return true;
-	if (ip === "::" || ip === "") return true;
-	const v4Tail = ip.match(/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
-	if (v4Tail && isIpv4Literal(v4Tail[1])) {
-		if (ip.startsWith("::")) return isPrivateIpv4(v4Tail[1]);
-	}
-	const mapped = ip.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
-	if (mapped) {
-		const hi = Number.parseInt(mapped[1], 16) & 65535;
-		const lo = Number.parseInt(mapped[2], 16) & 65535;
-		return isPrivateIpv4(`${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`);
-	}
-	if (/^f[cd][0-9a-f]{0,2}:/.test(ip) || ip.startsWith("fc") || ip.startsWith("fd")) {
-		const first = ip.split(":")[0];
-		if (first.length > 0) {
-			if ((Number.parseInt(first.padStart(4, "0").slice(0, 2), 16) & 254) === 252) return true;
-		}
-	}
-	if (ip.startsWith("fe8") || ip.startsWith("fe9") || ip.startsWith("fea") || ip.startsWith("feb")) return true;
-	return false;
-}
-/**
-* Classify a bare IP literal (v4 or v6) as a blocked egress target.
-* Returns `{ ok:false, reason }` when the IP is private/link-local/loopback/metadata.
-*/
-function classifyIpLiteral(ip) {
-	if (isIpv4Literal(ip)) return isPrivateIpv4(ip) ? {
-		ok: false,
-		reason: `private/link-local/loopback IPv4: ${ip}`
-	} : { ok: true };
-	if (isIpv6Literal(ip)) return isPrivateIpv6(ip) ? {
-		ok: false,
-		reason: `private/link-local/loopback IPv6: ${ip}`
-	} : { ok: true };
-	return { ok: true };
-}
-/** Bound each DNS lookup so a slow/hanging resolver can't stall validation. */
-const DNS_TIMEOUT_MS = 3e3;
-function withDnsTimeout(p) {
-	return Promise.race([p, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`DNS lookup timed out (${DNS_TIMEOUT_MS}ms)`)), DNS_TIMEOUT_MS))]);
-}
-/** Lazily load `node:dns/promises` `resolve` (works on both Bun and Deno). */
-let cachedResolver;
-async function defaultResolver(hostname) {
-	if (!cachedResolver) {
-		const dns = await import("node:dns/promises");
-		cachedResolver = async (h) => {
-			const [v4, v6] = await Promise.allSettled([withDnsTimeout(dns.resolve4(h)), withDnsTimeout(dns.resolve6(h))]);
-			const out = [];
-			if (v4.status === "fulfilled") out.push(...v4.value);
-			if (v6.status === "fulfilled") out.push(...v6.value);
-			if (out.length === 0 && v4.status === "rejected" && v6.status === "rejected") throw new Error(`DNS resolution failed (v4: ${reasonOf(v4)}, v6: ${reasonOf(v6)})`);
-			return out;
-		};
-	}
-	return cachedResolver(hostname);
-}
-function reasonOf(settled) {
-	const r = settled.reason;
-	return r instanceof Error ? r.message : String(r);
-}
-/**
-* Validate a single `host[:port]` allowlist entry against the private-IP policy.
-*
-* - IP literals are classified directly (no DNS).
-* - Hostnames are DNS-resolved; if ANY resolved address is private/link-local/
-*   loopback/metadata, the host is REJECTED (DNS-rebind defense at manifest time).
-* - `localhost` and the `.local` mDNS suffix are rejected up-front.
-*
-* `resolve` is injectable for tests / Deno; defaults to `node:dns/promises`.
-*/
-async function validateHostEgress(entry, opts = {}) {
-	const { host } = parseHostEntry(entry);
-	const lower = host.toLowerCase();
-	if (lower.length === 0) return {
-		ok: false,
-		reason: "empty host"
-	};
-	if (lower === "localhost" || lower.endsWith(".localhost") || lower.endsWith(".local")) return {
-		ok: false,
-		reason: `loopback/mDNS hostname not allowed: ${host}`
-	};
-	const literal = classifyIpLiteral(host);
-	if (!literal.ok) return literal;
-	if (isIpv4Literal(host) || isIpv6Literal(host)) return { ok: true };
-	const resolver = opts.resolve ?? defaultResolver;
-	let addrs;
-	try {
-		addrs = await resolver(host);
-	} catch (err) {
-		return {
-			ok: false,
-			reason: `DNS resolution failed for ${host}: ${err instanceof Error ? err.message : String(err)}`
-		};
-	}
-	if (addrs.length === 0) return {
-		ok: false,
-		reason: `DNS resolution returned no addresses for ${host}`
-	};
-	for (const addr of addrs) {
-		const c = classifyIpLiteral(addr);
-		if (!c.ok) return {
-			ok: false,
-			reason: `${host} resolves to a blocked address (${c.reason})`
-		};
-	}
-	return { ok: true };
-}
-/**
-* Validate ALL `net` + `import` hosts in a capability set.
-* Returns the first rejection found, or `{ ok:true }` if every host passes.
-*/
-async function validateEgressHosts(hosts, opts = {}) {
-	for (const entry of hosts) {
-		const r = await validateHostEgress(entry, opts);
-		if (!r.ok) return {
-			ok: false,
-			reason: `host "${entry}": ${r.reason}`
-		};
-	}
-	return { ok: true };
-}
-
-//#endregion
-//#region src/adapter-http.ts
-const DEFAULT_GUEST_TIMEOUT_MS = 5e3;
-/**
-* Production sandboxed `ExecutorAdapter` — POSTs the run to the standalone Deno
-* sandbox service over HTTP. The main app (Bun/Node) holds NO Deno; it only
-* speaks this JSON contract.
-*
-* Use as the `sandboxed` adapter in the executor config:
-*   executor: { sandboxed: httpSandboxAdapter({ url: process.env.SANDBOX_URL }) }
-*/
-var HttpSandboxAdapter = class {
-	fetchImpl;
-	validateEgress;
-	constructor(options = {}) {
-		this.options = options;
-		this.fetchImpl = options.fetch ?? globalThis.fetch;
-		this.validateEgress = options.validateEgress ?? true;
-	}
-	resolveUrl() {
-		const url = this.options.url ?? (typeof process !== "undefined" ? process.env?.SANDBOX_URL : void 0);
-		if (!url) throw new Error("HttpSandboxAdapter: no sandbox URL configured. Pass `url` or set SANDBOX_URL.");
-		return url.replace(/\/$/, "");
-	}
-	async run(options) {
-		const base = this.resolveUrl();
-		const caps = options.capabilities ?? {};
-		const net = caps.net ?? [];
-		const importHosts = caps.import ?? [];
-		const timeoutMs = caps.timeoutMs ?? DEFAULT_GUEST_TIMEOUT_MS;
-		if (this.validateEgress) {
-			const egress = await validateEgressHosts([...net, ...importHosts]);
-			if (!egress.ok) return {
-				ok: false,
-				error: `egress blocked: ${egress.reason}`,
-				logs: []
-			};
-		}
-		const sandboxCaps = {
-			net,
-			import: importHosts,
-			timeoutMs,
-			memoryMb: caps.memoryMb ?? 128
-		};
-		const fetchTimeoutMs = this.options.fetchTimeoutMs ?? timeoutMs + 1e4;
-		const controller = new AbortController();
-		const abortTimer = setTimeout(() => controller.abort(), fetchTimeoutMs);
-		try {
-			const bindings = options.sandboxBindings;
-			const res = await this.fetchImpl(`${base}/run`, {
-				method: "POST",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({
-					source: options.source,
-					input: options.input ?? null,
-					capabilities: sandboxCaps,
-					secrets: options.secrets ?? {},
-					...bindings ? { bindings } : {}
-				}),
-				signal: controller.signal
-			});
-			const text = await res.text();
-			let parsed;
-			try {
-				parsed = JSON.parse(text);
-			} catch {
-				return {
-					ok: false,
-					error: `sandbox returned non-JSON (HTTP ${res.status}): ${text.slice(0, 200)}`,
-					logs: []
-				};
-			}
-			return {
-				ok: !!parsed.ok,
-				output: parsed.output,
-				error: parsed.error,
-				logs: Array.isArray(parsed.logs) ? parsed.logs : [],
-				timedOut: parsed.timedOut,
-				ms: parsed.ms
-			};
-		} catch (err) {
-			return {
-				ok: false,
-				error: err instanceof Error && err.name === "AbortError" ? `sandbox request timed out after ${fetchTimeoutMs}ms` : `sandbox request failed: ${err instanceof Error ? err.message : String(err)}`,
-				logs: []
-			};
-		} finally {
-			clearTimeout(abortTimer);
-		}
-	}
-};
-/** Factory for the production sandboxed adapter. */
-function httpSandboxAdapter(options = {}) {
-	return new HttpSandboxAdapter(options);
-}
-
-//#endregion
-export { validateEgressHosts as a, parseHostEntry as i, httpSandboxAdapter as n, validateHostEgress as o, classifyIpLiteral as r, HttpSandboxAdapter as t };