glimmervoid 0.36.0 → 0.38.0

package/dist/chunks/guardrails-deps-Cb-ki4EU.js

@@ -0,0 +1,70 @@
+import { i as execSync } from "./child-process-safe-CbQnyh7D.js";
+import { r as resolvePathCommandMatches } from "./spawn-command-Cc40FiZI.js";
+//#region server/guardrails/core/guardrails-deps-core.ts
+var LINUX_GUARDRAILS_BINARIES = Object.freeze([
+	"bwrap",
+	"socat",
+	"rg"
+]);
+var NO_GUARDRAILS_BINARIES = Object.freeze([]);
+var GUARDRAILS_INSTALL_HINT = "Install bubblewrap, socat and ripgrep, for example: sudo apt install bubblewrap socat ripgrep";
+var GUARDED_WORK = "guarded sessions and factory checks";
+function requiredGuardrailsBinaries(platform) {
+	return platform === "linux" ? LINUX_GUARDRAILS_BINARIES : NO_GUARDRAILS_BINARIES;
+}
+function guardrailsDependencyReport({ platform, binariesOnPath }) {
+	const requiredBinaries = requiredGuardrailsBinaries(platform);
+	const missingBinaries = requiredBinaries.filter((binary) => !binariesOnPath.has(binary));
+	return {
+		platform,
+		requiredBinaries,
+		missingBinaries,
+		installHint: missingBinaries.length > 0 ? GUARDRAILS_INSTALL_HINT : null
+	};
+}
+function namesList(names) {
+	if (names.length <= 1) return names.join("");
+	return `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+function missingBinariesPhrase(report) {
+	return `${namesList(report.missingBinaries)} ${report.missingBinaries.length === 1 ? "is" : "are"} not on PATH`;
+}
+function guardrailsSpawnRefusal(report) {
+	if (report.missingBinaries.length === 0) return null;
+	return `not started: the guardrails need ${namesList(report.requiredBinaries)}, and ${missingBinariesPhrase(report)}. ${report.installHint}`;
+}
+function guardrailsBootWarning(report) {
+	if (report.missingBinaries.length === 0) return null;
+	return `[guardrails] ${missingBinariesPhrase(report)}, so ${GUARDED_WORK} will refuse to start. ${report.installHint}`;
+}
+function guardrailsDoctorRows(report) {
+	if (report.requiredBinaries.length === 0) return [["guardrails", `nothing to check on ${report.platform}`]];
+	const binaryRows = report.requiredBinaries.map((binary) => [binary, report.missingBinaries.includes(binary) ? "MISSING" : "found"]);
+	if (report.installHint === null) return binaryRows;
+	return [...binaryRows, ["hint", report.installHint]];
+}
+function guardrailsInstallNotice(report) {
+	if (report.installHint === null) return null;
+	return `glimmervoid: ${missingBinariesPhrase(report)}; ${GUARDED_WORK} need ${namesList(report.requiredBinaries)}. ${report.installHint}`;
+}
+//#endregion
+//#region server/guardrails/guardrails-deps.ts
+function probeGuardrailsDependencies({ platform = process.platform, exec = execSync } = {}) {
+	return guardrailsDependencyReport({
+		platform,
+		binariesOnPath: new Set(requiredGuardrailsBinaries(platform).filter((binary) => resolvePathCommandMatches(binary, {
+			platform,
+			exec
+		}).length > 0))
+	});
+}
+function checkGuardrailsDependencies({ probe = probeGuardrailsDependencies, log = console } = {}) {
+	const report = probe();
+	const warning = guardrailsBootWarning(report);
+	if (warning !== null) log.warn(warning);
+	const refusal = guardrailsSpawnRefusal(report);
+	return () => refusal;
+}
+var allowGuardedSpawn = () => null;
+//#endregion
+export { guardrailsInstallNotice as a, guardrailsDoctorRows as i, checkGuardrailsDependencies as n, probeGuardrailsDependencies as r, allowGuardedSpawn as t };

package/dist/chunks/{sandbox-proxy-core-hnQgKR0T.js → guardrails-proxy-core-BI3rdY-m.js}

@@ -1,6 +1,6 @@
 import { a as isLoopbackHostname } from "./hook-relay-core-DA_bz2KA.js";
-//#region session/core/sandbox-proxy-core.ts
-var HOOK_VIA_SANDBOX_PROXY_ENV = "GLIMMERVOID_HOOK_VIA_SANDBOX_PROXY";
+//#region session/core/guardrails-proxy-core.ts
+var HOOK_VIA_GUARDRAILS_PROXY_ENV = "GLIMMERVOID_HOOK_VIA_GUARDRAILS_PROXY";
 function decodeProxyCredential(percentEncoded) {
 	try {
 		return decodeURIComponent(percentEncoded);
@@ -8,7 +8,7 @@ function decodeProxyCredential(percentEncoded) {
 		return null;
 	}
 }
-function decideSandboxProxy(env) {
+function decideGuardrailsProxy(env) {
 	if (env.SANDBOX_RUNTIME !== "1") return null;
 	const rawProxyUrl = env.HTTP_PROXY || env.http_proxy || "";
 	if (!URL.canParse(rawProxyUrl)) return null;
@@ -24,4 +24,4 @@ function decideSandboxProxy(env) {
 	};
 }
 //#endregion
-export { decideSandboxProxy as n, HOOK_VIA_SANDBOX_PROXY_ENV as t };
+export { decideGuardrailsProxy as n, HOOK_VIA_GUARDRAILS_PROXY_ENV as t };

package/dist/chunks/{json-file-BaxGcB2R.js → json-file-CIJf0Cel.js}

@@ -3,11 +3,60 @@ import { r as nextBackoffMs } from "./backoff-DjVpfHk7.js";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
+//#region server/core/memory-admission-core.ts
+var BYTES_PER_MEGABYTE$1 = 1048576;
+var MEMORY_RECHECK_MS = 5e3;
+var MEMORY_RESERVATION_SETTLE_MS = 3e4;
+var DEFAULT_CHECK_MEMORY_RESERVE_MB = 1500;
+function memoryReserveBytes(config, kind) {
+	return (kind === "session" ? config.sessionMemoryReserveMB ?? 600 : config.checkMemoryReserveMB ?? 1500) * BYTES_PER_MEGABYTE$1;
+}
+function parseCgroupV2Path(procSelfCgroupText) {
+	const unifiedLine = procSelfCgroupText.split("\n").find((line) => line.startsWith("0::"));
+	if (unifiedLine === void 0) return null;
+	const cgroupPath = unifiedLine.slice(3).trim();
+	return cgroupPath.startsWith("/") ? cgroupPath : null;
+}
+function cgroupAncestorPaths(cgroupPath) {
+	const segments = cgroupPath.split("/").filter((segment) => segment.length > 0);
+	return segments.map((_segment, depthFromLeaf) => `/${segments.slice(0, segments.length - depthFromLeaf).join("/")}`);
+}
+function parseCgroupBytes(text) {
+	if (text === null) return null;
+	const trimmed = text.trim();
+	return /^\d+$/.test(trimmed) ? Number(trimmed) : null;
+}
+function cgroupLimitBytes(memoryHighText, memoryMaxText) {
+	return parseCgroupBytes(memoryHighText) ?? parseCgroupBytes(memoryMaxText);
+}
+function parseMemAvailableBytes(meminfoText) {
+	const match = /^MemAvailable:\s+(\d+)\s+kB$/m.exec(meminfoText);
+	return match ? Number(match[1]) * 1024 : null;
+}
+function headroomFromReadings({ cgroupLevels, hostAvailableBytes }) {
+	const candidates = cgroupLevels.flatMap(({ limitBytes, currentBytes }) => limitBytes === null || currentBytes === null ? [] : [Math.max(0, limitBytes - currentBytes)]);
+	if (hostAvailableBytes !== null) candidates.push(hostAvailableBytes);
+	return candidates.length === 0 ? null : Math.min(...candidates);
+}
+function liveReservations(reservations, nowMs) {
+	return reservations.filter((reservation) => nowMs - reservation.admittedAtMs < MEMORY_RESERVATION_SETTLE_MS);
+}
+function shouldAdmitStart({ reading, reserveBytes, reservations, nowMs }) {
+	if (!reading.ok) return true;
+	const reservedBytes = liveReservations(reservations, nowMs).reduce((total, reservation) => total + reservation.bytes, 0);
+	return reading.headroomBytes - reservedBytes >= reserveBytes;
+}
+//#endregion
 //#region server/spawn-gate.ts
+var BYTES_PER_MEGABYTE = 1048576;
 var QUEUE_ADMISSION_TIMED_OUT = "serial-queue-admission-timed-out";
+var QUEUE_ADMISSION_ABANDONED = "serial-queue-admission-abandoned";
 function isQueueAdmissionTimeout(error) {
 	return error instanceof Error && error.message === QUEUE_ADMISSION_TIMED_OUT;
 }
+function isQueueAdmissionAbandoned(error) {
+	return error instanceof Error && error.message === QUEUE_ADMISSION_ABANDONED;
+}
 function createSerialQueue() {
 	let tail = Promise.resolve();
 	function run(fn, options = {}) {
@@ -19,19 +68,27 @@ function createSerialQueue() {
 			return fn();
 		});
 		tail = result.then(() => void 0, () => void 0);
-		const admissionTimeoutMs = options.admissionTimeoutMs;
-		if (admissionTimeoutMs === void 0) return result;
+		const { admissionTimeoutMs, signal } = options;
+		if (admissionTimeoutMs === void 0 && signal === void 0) return result;
 		return new Promise((resolve, reject) => {
-			const admissionTimer = setTimeout(() => {
+			const leaveUnlessStarted = (reason) => {
 				if (started) return;
 				abandoned = true;
-				reject(/* @__PURE__ */ new Error(QUEUE_ADMISSION_TIMED_OUT));
-			}, admissionTimeoutMs);
-			result.then((value) => {
+				reject(new Error(reason));
+			};
+			const admissionTimer = admissionTimeoutMs === void 0 ? void 0 : setTimeout(() => leaveUnlessStarted(QUEUE_ADMISSION_TIMED_OUT), admissionTimeoutMs);
+			const leaveOnAbort = () => leaveUnlessStarted(QUEUE_ADMISSION_ABANDONED);
+			signal?.addEventListener("abort", leaveOnAbort, { once: true });
+			if (signal?.aborted) leaveOnAbort();
+			const stopWatching = () => {
 				clearTimeout(admissionTimer);
+				signal?.removeEventListener("abort", leaveOnAbort);
+			};
+			result.then((value) => {
+				stopWatching();
 				resolve(value);
 			}, (error) => {
-				clearTimeout(admissionTimer);
+				stopWatching();
 				reject(error);
 			});
 		});
@@ -59,7 +116,131 @@ function createKeyedSerialQueue() {
 	}
 	return { run };
 }
-var createSpawnGate = createSerialQueue;
+function toMegabytes(bytes) {
+	return Math.round(bytes / BYTES_PER_MEGABYTE);
+}
+function createMemoryAdmission({ readHeadroom, reserveBytesFor, nowMs = Date.now, sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+}), warn = (message) => console.warn(message) }) {
+	let reservations = [];
+	let isInProbeFailureStreak = false;
+	let heldStartCount = 0;
+	let latestHeadroomBytes = null;
+	let latestHeadroomReadAtMs = null;
+	function noteReading(reading, readAtMs) {
+		latestHeadroomReadAtMs = readAtMs;
+		latestHeadroomBytes = reading.ok ? reading.headroomBytes : null;
+		if (reading.ok) {
+			isInProbeFailureStreak = false;
+			return;
+		}
+		if (isInProbeFailureStreak) return;
+		isInProbeFailureStreak = true;
+		warn(`[memory] could not read memory headroom, so starts go ahead unchecked: ${reading.reason}`);
+	}
+	async function admitOrDescribeShortfall(kind, { isDryRun = false } = {}) {
+		const reserveBytes = reserveBytesFor(kind);
+		if (reserveBytes <= 0) return null;
+		const reading = await readHeadroom();
+		const admittedAtMs = nowMs();
+		reservations = liveReservations(reservations, admittedAtMs);
+		noteReading(reading, admittedAtMs);
+		if (!(isDryRun && reading.ok && heldStartCount > 0) && shouldAdmitStart({
+			reading,
+			reserveBytes,
+			reservations,
+			nowMs: admittedAtMs
+		})) {
+			if (!isDryRun) reservations.push({
+				bytes: reserveBytes,
+				admittedAtMs
+			});
+			return null;
+		}
+		const heldBytes = reservations.reduce((total, reservation) => total + reservation.bytes, 0);
+		return {
+			headroomBytes: reading.ok ? reading.headroomBytes : 0,
+			heldBytes,
+			reserveBytes,
+			waitingStartCount: heldStartCount
+		};
+	}
+	async function recheckUntilAdmitted(kind, isStillWanted) {
+		do {
+			await sleep(MEMORY_RECHECK_MS);
+			if (!isStillWanted()) return false;
+		} while (await admitOrDescribeShortfall(kind) !== null);
+		return true;
+	}
+	async function waitForHeadroom(kind, { isStillWanted = () => true, onMemoryWait = () => {} } = {}) {
+		if (!isStillWanted()) return;
+		const shortfall = await admitOrDescribeShortfall(kind);
+		if (shortfall === null) return;
+		if (!isStillWanted()) return;
+		const waitStartedAtMs = nowMs();
+		warn(`[memory] holding a ${kind} start: ${toMegabytes(shortfall.headroomBytes)} MB headroom, ${toMegabytes(shortfall.heldBytes)} MB held for recent starts, ${toMegabytes(shortfall.reserveBytes)} MB reserve needed`);
+		onMemoryWait(true);
+		if (!await recheckUntilAdmitted(kind, isStillWanted).finally(() => onMemoryWait(false))) return;
+		warn(`[memory] admitted a ${kind} start after waiting ${Math.round((nowMs() - waitStartedAtMs) / 1e3)} s`);
+	}
+	return {
+		waitForHeadroom,
+		noteStartHeld: (isHeld) => {
+			heldStartCount += isHeld ? 1 : -1;
+		},
+		gateStatus: () => ({
+			headroomBytes: latestHeadroomBytes,
+			headroomReadAtMs: latestHeadroomReadAtMs,
+			heldStartCount
+		}),
+		describeShortfallNow: (kind) => admitOrDescribeShortfall(kind, { isDryRun: true })
+	};
+}
+function createSpawnGate({ memoryAdmission = null, kind = "session" } = {}) {
+	const queue = createSerialQueue();
+	if (!memoryAdmission) return queue;
+	const admission = memoryAdmission;
+	const queuedStarts = /* @__PURE__ */ new Set();
+	const flaggedStarts = /* @__PURE__ */ new Set();
+	let isHeadStartHeld = false;
+	function flagWaitingForMemory(queuedStart) {
+		if (flaggedStarts.has(queuedStart) || !queuedStart.isStillWanted()) return;
+		flaggedStarts.add(queuedStart);
+		admission.noteStartHeld(true);
+		queuedStart.onMemoryWait(true);
+	}
+	function leaveQueue(queuedStart) {
+		queuedStarts.delete(queuedStart);
+		if (!flaggedStarts.delete(queuedStart)) return;
+		admission.noteStartHeld(false);
+		queuedStart.onMemoryWait(false);
+	}
+	function noteHeadStartHeld(isHeld) {
+		isHeadStartHeld = isHeld;
+		if (!isHeld) return;
+		for (const queuedStart of queuedStarts) flagWaitingForMemory(queuedStart);
+	}
+	function run(fn, options = {}) {
+		const { isStillWanted = () => true, onMemoryWait = () => {} } = options;
+		const queuedStart = {
+			isStillWanted,
+			onMemoryWait
+		};
+		queuedStarts.add(queuedStart);
+		if (isHeadStartHeld) flagWaitingForMemory(queuedStart);
+		const release = () => leaveQueue(queuedStart);
+		const result = queue.run(() => admission.waitForHeadroom(kind, {
+			isStillWanted,
+			onMemoryWait: noteHeadStartHeld
+		}).finally(release).then(fn), options);
+		result.then(release, release);
+		return result;
+	}
+	return {
+		run,
+		idle: queue.idle
+	};
+}
 //#endregion
 //#region server/json-file.ts
 function tmpPathFor(filePath) {
@@ -349,4 +530,4 @@ function createJsonStateStore({ name, filePath, fsPromises = fs.promises, parse,
 	};
 }
 //#endregion
-export { isQueueAdmissionTimeout as _, jsonStateLoadError as a, loadedJsonValue as c, writeJsonAtomicSync as d, writeTextAtomic as f, createSpawnGate as g, createSerialQueue as h, createJsonStateWriter as i, sleepSync as l, createKeyedSerialQueue as m, appendJsonLines as n, loadJsonStateFile as o, writeTextAtomicSync as p, createJsonStateStore as r, loadJsonStateFileSync as s, appendJsonLine as t, writeJsonAtomic as u };
+export { headroomFromReadings as C, parseMemAvailableBytes as D, parseCgroupV2Path as E, cgroupLimitBytes as S, parseCgroupBytes as T, createSpawnGate as _, jsonStateLoadError as a, DEFAULT_CHECK_MEMORY_RESERVE_MB as b, loadedJsonValue as c, writeJsonAtomicSync as d, writeTextAtomic as f, createSerialQueue as g, createMemoryAdmission as h, createJsonStateWriter as i, sleepSync as l, createKeyedSerialQueue as m, appendJsonLines as n, loadJsonStateFile as o, writeTextAtomicSync as p, createJsonStateStore as r, loadJsonStateFileSync as s, appendJsonLine as t, writeJsonAtomic as u, isQueueAdmissionAbandoned as v, memoryReserveBytes as w, cgroupAncestorPaths as x, isQueueAdmissionTimeout as y };

package/dist/chunks/{knowledge-graph-cli-DD7QvcFd.js → knowledge-graph-cli-DcspNqhz.js}

@@ -2,7 +2,7 @@ import { r as errorMessage } from "./text-DoirglWV.js";
 import { s as resolvePackageBin } from "./runtime-paths-BkeftE60.js";
 import { r as execFileSync } from "./child-process-safe-CbQnyh7D.js";
 import { n as glimmervoidHomeDir, t as decideConfigPath } from "./config-path-core-DFt-TemS.js";
-import { r as BrowserConfig } from "./config-CuZ16F9W.js";
+import { r as BrowserConfig } from "./config-BHBZsCBc.js";
 import fs, { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import path, { dirname, join, posix, resolve, win32 } from "node:path";
 import os from "node:os";

package/dist/chunks/{loopback-post-DepQfdcM.js → loopback-post-DZK7YibD.js}

@@ -1,8 +1,8 @@
 import { a as isLoopbackHostname } from "./hook-relay-core-DA_bz2KA.js";
-import { n as decideSandboxProxy } from "./sandbox-proxy-core-hnQgKR0T.js";
-import http from "node:http";
+import { n as decideGuardrailsProxy } from "./guardrails-proxy-core-BI3rdY-m.js";
 //#region session/loopback-post.ts
 var POST_TIMEOUT_MS = 1500;
+var http = process.getBuiltinModule("node:http");
 function refusal(reason) {
 	return {
 		reason,
@@ -16,11 +16,11 @@ function directRoute(target) {
 		path: `${target.pathname}${target.search}`
 	};
 }
-function sandboxProxyRoute(sandboxProxy, target) {
-	const proxyHeaders = sandboxProxy.authorization ? { "proxy-authorization": sandboxProxy.authorization } : {};
+function guardrailsProxyRoute(guardrailsProxy, target) {
+	const proxyHeaders = guardrailsProxy.authorization ? { "proxy-authorization": guardrailsProxy.authorization } : {};
 	return {
-		hostname: sandboxProxy.hostname,
-		port: sandboxProxy.port,
+		hostname: guardrailsProxy.hostname,
+		port: guardrailsProxy.port,
 		path: target.href,
 		headers: {
 			...proxyHeaders,
@@ -81,10 +81,10 @@ async function postToLoopback(url, body, env = process.env) {
 	const target = new URL(url);
 	if (target.protocol !== "http:") return refusal("not-http");
 	if (!isLoopbackHostname(target.hostname)) return refusal("not-loopback");
-	if (env["GLIMMERVOID_HOOK_VIA_SANDBOX_PROXY"] !== "1") return sendPost(directRoute(target), body);
-	const sandboxProxy = decideSandboxProxy(env);
-	if (!sandboxProxy) return refusal("sandbox-proxy-missing");
-	return sendPost(sandboxProxyRoute(sandboxProxy, target), body);
+	if (env["GLIMMERVOID_HOOK_VIA_GUARDRAILS_PROXY"] !== "1") return sendPost(directRoute(target), body);
+	const guardrailsProxy = decideGuardrailsProxy(env);
+	if (!guardrailsProxy) return refusal("guardrails-proxy-missing");
+	return sendPost(guardrailsProxyRoute(guardrailsProxy, target), body);
 }
 async function postPayload(url, body) {
 	return (await postToLoopback(url, body)).responseBody;