glimmervoid 0.36.0 → 0.37.0

package/dist/chunks/git-version-6QFnKbWa.js

@@ -0,0 +1,139 @@
+import { t as AGENT_API_VERBS } from "./session-BZbariv5.js";
+import { r as execFileSync } from "./child-process-safe-CbQnyh7D.js";
+//#region server/core/command-line-core.ts
+var SUBCOMMANDS_HONORING_TRAILING_GLOBAL_OPTIONS = /* @__PURE__ */ new Set([
+	"doctor",
+	"pair",
+	"visions"
+]);
+var SUBCOMMANDS_HONORING_A_LEADING_HELP_OR_VERSION = /* @__PURE__ */ new Set([...AGENT_API_VERBS, "factory"]);
+var OPTIONS_TAKING_A_VALUE = {
+	"--config": "configPath",
+	"--port": "port"
+};
+function scanGlobalOption(argv, index, state) {
+	const token = argv[index];
+	const valueKey = OPTIONS_TAKING_A_VALUE[token];
+	if (valueKey) {
+		const value = argv[index + 1];
+		if (value !== void 0) state[valueKey] = value;
+		return index + 2;
+	}
+	if (token === "--help" || token === "-h") state.wantsHelp = true;
+	if (token === "--version") state.wantsVersion = true;
+	if (token === "--doctor") state.wantsDoctor = true;
+	if (token === "--no-open") state.wantsNoOpen = true;
+	return index + 1;
+}
+function scanTrailingGlobalOptions(subcommandArgs, state) {
+	let index = 0;
+	while (index < subcommandArgs.length) {
+		if (!subcommandArgs[index].startsWith("-")) {
+			index += 1;
+			continue;
+		}
+		index = scanGlobalOption(subcommandArgs, index, state);
+	}
+}
+function scanLeadingHelpOrVersion(subcommandArgs, state) {
+	const firstArgument = subcommandArgs[0];
+	if (firstArgument === "--help" || firstArgument === "-h") state.wantsHelp = true;
+	if (firstArgument === "--version") state.wantsVersion = true;
+}
+function parseCommandLine(argv) {
+	const state = {
+		configPath: null,
+		port: null,
+		wantsHelp: false,
+		wantsVersion: false,
+		wantsDoctor: false,
+		wantsNoOpen: false
+	};
+	let index = 0;
+	while (index < argv.length && argv[index].startsWith("-")) index = scanGlobalOption(argv, index, state);
+	const name = argv[index];
+	const subcommandArgs = argv.slice(index + 1);
+	if (name !== void 0 && SUBCOMMANDS_HONORING_TRAILING_GLOBAL_OPTIONS.has(name)) scanTrailingGlobalOptions(subcommandArgs, state);
+	if (name !== void 0 && SUBCOMMANDS_HONORING_A_LEADING_HELP_OR_VERSION.has(name)) scanLeadingHelpOrVersion(subcommandArgs, state);
+	if (state.wantsHelp) return { kind: "help" };
+	if (state.wantsVersion) return { kind: "version" };
+	const globalOptions = {
+		configPath: state.configPath,
+		port: state.port
+	};
+	if (state.wantsDoctor) return {
+		kind: "subcommand",
+		name: "doctor",
+		subcommandArgs: [],
+		globalOptions
+	};
+	if (name === void 0) return {
+		kind: "server",
+		globalOptions,
+		isBrowserOpenSkipped: state.wantsNoOpen
+	};
+	return {
+		kind: "subcommand",
+		name,
+		subcommandArgs,
+		globalOptions
+	};
+}
+//#endregion
+//#region server/git/core/git-version-core.ts
+var NEW_WORK_ISOLATION_FLOOR = Object.freeze({
+	major: 2,
+	minor: 48
+});
+var NEW_WORK_ISOLATION_FLOOR_LABEL = `${NEW_WORK_ISOLATION_FLOOR.major}.${NEW_WORK_ISOLATION_FLOOR.minor}`;
+var WHOLE_RANGE_CONSEQUENCE = "a team re-review cannot single out the author's new work and reviews the whole pull request range";
+var GIT_UPDATE_HINT = `Update git to ${NEW_WORK_ISOLATION_FLOOR_LABEL} or newer`;
+var UNKNOWN_GIT_VERSION = Object.freeze({
+	version: null,
+	isTooOldToIsolateNewWork: false
+});
+function gitVersionReport(versionOutput) {
+	const match = /^git version (\d+)\.(\d+)(?:\.(\d+))?/.exec(versionOutput?.trim() ?? "");
+	if (!match) return UNKNOWN_GIT_VERSION;
+	const [, major = "", minor = "", patch] = match;
+	const isBelowFloorMajor = Number(major) < NEW_WORK_ISOLATION_FLOOR.major;
+	const isBelowFloorMinor = Number(major) === NEW_WORK_ISOLATION_FLOOR.major && Number(minor) < NEW_WORK_ISOLATION_FLOOR.minor;
+	return {
+		version: [
+			major,
+			minor,
+			patch
+		].filter((part) => part !== void 0).join("."),
+		isTooOldToIsolateNewWork: isBelowFloorMajor || isBelowFloorMinor
+	};
+}
+function gitBootWarning(report) {
+	if (!report.isTooOldToIsolateNewWork) return null;
+	return `[git] git ${report.version} is older than ${NEW_WORK_ISOLATION_FLOOR_LABEL}, so ${WHOLE_RANGE_CONSEQUENCE}. ${GIT_UPDATE_HINT}.`;
+}
+function gitDoctorRows(report) {
+	const versionRow = ["git", report.version ?? "unknown"];
+	if (!report.isTooOldToIsolateNewWork) return [versionRow];
+	return [versionRow, ["hint", `${GIT_UPDATE_HINT}: on an older one ${WHOLE_RANGE_CONSEQUENCE}`]];
+}
+//#endregion
+//#region server/git/git-version.ts
+function readGitVersionOutput() {
+	return execFileSync("git", ["--version"], {
+		encoding: "utf8",
+		timeout: 3e3
+	});
+}
+function probeGitVersion({ readVersionOutput = readGitVersionOutput } = {}) {
+	try {
+		return gitVersionReport(readVersionOutput());
+	} catch {
+		return gitVersionReport(null);
+	}
+}
+function warnWhenGitIsTooOld({ probe = probeGitVersion, log = console } = {}) {
+	const warning = gitBootWarning(probe());
+	if (warning !== null) log.warn(warning);
+}
+//#endregion
+export { parseCommandLine as i, warnWhenGitIsTooOld as n, gitDoctorRows as r, probeGitVersion as t };

package/dist/chunks/{grok-Ch4-35_r.js → grok-CZ6kP_vD.js}

@@ -1,6 +1,6 @@
 import { r as errorMessage } from "./text-DoirglWV.js";
 import { o as relayPath } from "./runtime-paths-BkeftE60.js";
-import { n as AGENT_URL_ENV, v as SIGN_URL_ENV } from "./session-B8RhqQJe.js";
+import { T as SIGN_URL_ENV, n as AGENT_URL_ENV } from "./session-BZbariv5.js";
 import { t as HOOK_URL_ENV } from "./hook-relay-core-DA_bz2KA.js";
 import { n as isRecord } from "./coerce-NSst8oRP.js";
 import { o as SANE_YOLO_PATH_ENV, r as RTK_PATH_ENV, s as saneYoloEnv } from "./rtk-hook-core-VrUafGAp.js";
@@ -271,6 +271,9 @@ function mayContributeHooks(configText) {
 	if (!isRecord(settings)) return false;
 	return Object.hasOwn(settings, "hooks");
 }
+function userConfigFolders() {
+	return [path.join(os.homedir(), ".claude")];
+}
 function mapHookToSignal(event, payload) {
 	const normalizedEvent = String(event || "").toLowerCase();
 	if (normalizedEvent === "subagentstart") return "subagent-start";
@@ -403,6 +406,7 @@ var grok = {
 				hookToolRelayPath: HOOK_TOOL_RELAY_PATH
 			}),
 			projectConfigCandidates: PROJECT_CONFIG_CANDIDATES,
+			userConfigFolders,
 			mayContributeHooks
 		}
 	},

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/{knowledge-graph-cli-DD7QvcFd.js → knowledge-graph-cli-DApeMzA8.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-BYc2z1Oc.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-DJ6iYWuL.js}

@@ -1,5 +1,5 @@
 import { a as isLoopbackHostname } from "./hook-relay-core-DA_bz2KA.js";
-import { n as decideSandboxProxy } from "./sandbox-proxy-core-hnQgKR0T.js";
+import { n as decideGuardrailsProxy } from "./guardrails-proxy-core-BI3rdY-m.js";
 import http from "node:http";
 //#region session/loopback-post.ts
 var POST_TIMEOUT_MS = 1500;
@@ -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;