glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/agent-api-core-Dz0r21y9.js

@@ -0,0 +1,103 @@
+import { a as AgentSpawnRequest, i as AgentAttentionRequest, t as AGENT_API_VERBS } from "./session-Cez8aIWg.js";
+import crypto from "node:crypto";
+var MAX_SPAWNS_IN_FLIGHT = 1;
+var SPAWNABLE_DEPTH = 0;
+var REFUSAL_REASON = "unknown session";
+var INVALID_BODY_STATUS = 400;
+function tokensMatch(presented, expected) {
+	if (presented.length !== expected.length) return false;
+	try {
+		return crypto.timingSafeEqual(Buffer.from(presented, "utf8"), Buffer.from(expected, "utf8"));
+	} catch {
+		return false;
+	}
+}
+function refused() {
+	return {
+		ok: false,
+		status: 404,
+		reason: REFUSAL_REASON
+	};
+}
+function decideAgentRequest({ sessionId, presentedToken, expectedToken, isLoopback, enabled }) {
+	if (!enabled) return refused();
+	if (!isLoopback) return refused();
+	if (!sessionId) return refused();
+	if (!expectedToken) return refused();
+	if (!presentedToken) return refused();
+	if (!tokensMatch(presentedToken, expectedToken)) return refused();
+	return { ok: true };
+}
+function decideSpawnAllowance({ liveChildren, lifetimeSpawns, inFlight, depth }) {
+	if (depth !== SPAWNABLE_DEPTH) return {
+		ok: false,
+		status: 403,
+		reason: "a spawned session may not spawn another"
+	};
+	if (inFlight >= MAX_SPAWNS_IN_FLIGHT) return {
+		ok: false,
+		status: 429,
+		reason: "a spawn is already in flight"
+	};
+	if (liveChildren >= 3) return {
+		ok: false,
+		status: 429,
+		reason: `at most 3 spawned sessions may be live at once`
+	};
+	if (lifetimeSpawns >= 10) return {
+		ok: false,
+		status: 429,
+		reason: `this session has used its 10 spawns`
+	};
+	return { ok: true };
+}
+function isAgentApiVerb(verb) {
+	return AGENT_API_VERBS.includes(verb);
+}
+function refuseInvalidBody(issues) {
+	return {
+		ok: false,
+		status: INVALID_BODY_STATUS,
+		error: issues[0]?.message || "invalid request"
+	};
+}
+function parseAgentVerb(verb, payload) {
+	if (!isAgentApiVerb(verb)) return {
+		ok: false,
+		status: 404,
+		error: REFUSAL_REASON
+	};
+	if (verb === "board") return {
+		ok: true,
+		verb
+	};
+	if (verb === "attention") {
+		const parsed = AgentAttentionRequest.safeParse(payload);
+		if (!parsed.success) return refuseInvalidBody(parsed.error.issues);
+		return {
+			ok: true,
+			verb,
+			request: parsed.data
+		};
+	}
+	const parsed = AgentSpawnRequest.safeParse(payload);
+	if (!parsed.success) return refuseInvalidBody(parsed.error.issues);
+	return {
+		ok: true,
+		verb,
+		request: parsed.data
+	};
+}
+function deriveChildSessionName(parentName, existingNames) {
+	const base = `${String(parentName || "").trim() || "session"} agent`;
+	const taken = new Set(existingNames);
+	let candidate = base;
+	let suffix = 1;
+	while (taken.has(candidate)) {
+		suffix += 1;
+		candidate = `${base} ${suffix}`;
+	}
+	return candidate;
+}
+//#endregion
+export { isAgentApiVerb as a, deriveChildSessionName as i, decideAgentRequest as n, parseAgentVerb as o, decideSpawnAllowance as r, REFUSAL_REASON as t };

package/dist/chunks/agent-setup-cli-B5Atxr3F.js

@@ -0,0 +1,139 @@
+import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-DuU8xVLZ.js";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region server/agent-setup-cli.ts
+var USAGE = "Usage: glimmervoid agent setup grok";
+function errorCode(error) {
+	const code = error?.code;
+	return typeof code === "string" ? code : void 0;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function setupInputs(env = process.env) {
+	return {
+		filePath: grok.hooksFilePath(env),
+		relayPath: grok.RELAY_PATH,
+		hookToolRelayPath: grok.HOOK_TOOL_RELAY_PATH,
+		events: grok.HOOK_EVENTS,
+		managedEventSets: grok.MANAGED_HOOK_EVENT_SETS
+	};
+}
+function inspectGrokAgentSetup({ env = process.env, readFileSync = fs.readFileSync } = {}) {
+	const inputs = setupInputs(env);
+	let contents = null;
+	try {
+		contents = readFileSync(inputs.filePath, "utf8");
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") return {
+			filePath: inputs.filePath,
+			classification: "absent"
+		};
+		return {
+			filePath: inputs.filePath,
+			classification: "unreadable",
+			reason: errorMessage(error)
+		};
+	}
+	return {
+		filePath: inputs.filePath,
+		classification: classifyGrokHooksFile(contents, inputs),
+		saneYoloReady: contents === renderGrokHooksFile(inputs)
+	};
+}
+function assertRealDirectory(directory, fileSystem, requireOwnership = true) {
+	const directoryStat = fileSystem.lstatSync(directory);
+	if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) throw new Error(`refusing to write Grok hooks: ${directory} is not a real directory`);
+	if (requireOwnership && typeof process.getuid === "function" && directoryStat.uid !== process.getuid()) throw new Error(`refusing to write Grok hooks: ${directory} is owned by another account`);
+}
+function ensureWritableHooksDirectory(directory, fileSystem) {
+	const resolvedDirectory = path.resolve(directory);
+	const trustedParent = path.dirname(path.dirname(resolvedDirectory));
+	assertRealDirectory(trustedParent, fileSystem, false);
+	const relativeParts = path.relative(trustedParent, resolvedDirectory).split(path.sep).filter(Boolean);
+	let currentDirectory = trustedParent;
+	for (const part of relativeParts) {
+		currentDirectory = path.join(currentDirectory, part);
+		try {
+			assertRealDirectory(currentDirectory, fileSystem);
+			continue;
+		} catch (directoryError) {
+			if (errorCode(directoryError) !== "ENOENT") throw directoryError;
+		}
+		fileSystem.mkdirSync(currentDirectory, { mode: 448 });
+		assertRealDirectory(currentDirectory, fileSystem);
+	}
+	try {
+		fileSystem.chmodSync(directory, 448);
+	} catch {}
+}
+function replaceFileAtomically(filePath, contents, fileSystem) {
+	const temporaryPath = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString("hex")}.tmp`;
+	try {
+		fileSystem.writeFileSync(temporaryPath, contents, {
+			encoding: "utf8",
+			mode: 384,
+			flag: "wx"
+		});
+		fileSystem.renameSync(temporaryPath, filePath);
+	} catch (writeError) {
+		try {
+			fileSystem.rmSync(temporaryPath, { force: true });
+		} catch {}
+		throw writeError;
+	}
+	try {
+		fileSystem.chmodSync(filePath, 384);
+	} catch {}
+}
+function runGrokSetup({ env, fileSystem, log, error }) {
+	const inputs = setupInputs(env);
+	const expectedContents = renderGrokHooksFile(inputs);
+	if (!expectedContents) {
+		error("Could not render the Grok hooks file. Nothing was written.");
+		return 1;
+	}
+	const inspection = inspectGrokAgentSetup({
+		env,
+		readFileSync: fileSystem.readFileSync
+	});
+	if (inspection.classification === "current" && inspection.saneYoloReady) {
+		log(`Grok hooks are already current at ${inputs.filePath}`);
+		return 0;
+	}
+	if (inspection.classification === "foreign" || inspection.classification === "unreadable") {
+		error(`Refusing to replace ${inputs.filePath}: the existing file is ${inspection.classification}.`);
+		return 1;
+	}
+	const hooksDirectory = path.dirname(inputs.filePath);
+	try {
+		ensureWritableHooksDirectory(hooksDirectory, fileSystem);
+		if (fileSystem.existsSync(inputs.filePath)) {
+			const targetStat = fileSystem.lstatSync(inputs.filePath);
+			if (!targetStat.isFile() || targetStat.isSymbolicLink()) {
+				error(`Refusing to replace ${inputs.filePath}: the target is not a real file.`);
+				return 1;
+			}
+		}
+		replaceFileAtomically(inputs.filePath, expectedContents, fileSystem);
+	} catch (writeError) {
+		error(`Could not write ${inputs.filePath}: ${errorMessage(writeError)}`);
+		return 1;
+	}
+	log(`Installed Grok hooks at ${inputs.filePath}`);
+	return 0;
+}
+function runAgentSetupCli(args, deps = {}) {
+	const { env = process.env, fileSystem = fs, log = console.log, error = console.error } = deps;
+	if (args[0] === "setup" && args[1] === "grok" && args.length === 2) return runGrokSetup({
+		env,
+		fileSystem,
+		log,
+		error
+	});
+	error(USAGE);
+	return 1;
+}
+//#endregion
+export { inspectGrokAgentSetup, runAgentSetupCli };

package/dist/chunks/ascii-figure-core-pDAwtlKO.js

@@ -0,0 +1,45 @@
+//#region server/core/ascii-figure-core.ts
+function widthOf(text) {
+	return Array.from(text).length;
+}
+function padToWidth(text, width, alignment) {
+	const paddedLength = text.length + Math.max(0, width - widthOf(text));
+	return alignment === "right" ? text.padStart(paddedLength) : text.padEnd(paddedLength);
+}
+function splitIntoPhysicalRows(row) {
+	const linesPerCell = row.map((cell) => cell.split(/\r?\n/));
+	const rowHeight = Math.max(1, ...linesPerCell.map((cellLines) => cellLines.length));
+	return Array.from({ length: rowHeight }, (_, lineIndex) => linesPerCell.map((cellLines) => cellLines[lineIndex] ?? ""));
+}
+function renderTable({ title, headers, rows, align, terminalColumns }) {
+	const headerRows = headers ? splitIntoPhysicalRows(headers) : [];
+	const bodyRows = rows.flatMap(splitIntoPhysicalRows);
+	const allRows = [...headerRows, ...bodyRows];
+	const columnCount = Math.max(1, ...allRows.map((row) => row.length));
+	const widths = Array.from({ length: columnCount }, (_, index) => Math.max(0, ...allRows.map((row) => widthOf(row[index] ?? ""))));
+	const separator = headers ? " | " : "  ";
+	const renderCells = (row) => Array.from({ length: columnCount }, (_, index) => padToWidth(row[index] ?? "", widths[index] ?? 0, align?.[index] ?? (index === 0 || !headers ? "left" : "right"))).join(separator);
+	const lines = headers ? [
+		...headerRows.map(renderCells),
+		widths.map((width) => "-".repeat(width)).join("-+-"),
+		...bodyRows.map(renderCells)
+	] : bodyRows.map(renderCells);
+	const caption = title.trim() ? `[ ${title.trim().toUpperCase()} ]` : "";
+	const availableColumns = typeof terminalColumns === "number" && Number.isFinite(terminalColumns) ? terminalColumns : 80;
+	const innerWidth = Math.max(0, ...lines.map(widthOf), caption ? widthOf(caption) + 4 : 0, Math.min(48, availableColumns - 4));
+	const span = innerWidth + 2;
+	const captionLabel = ` ${caption} `;
+	const remainingDashes = Math.max(0, span - widthOf(captionLabel));
+	const leftDashes = Math.floor(remainingDashes / 2);
+	const top = caption ? `+${"-".repeat(leftDashes)}${captionLabel}${"-".repeat(remainingDashes - leftDashes)}+` : `+${"-".repeat(span)}+`;
+	const empty = `| ${" ".repeat(innerWidth)} |`;
+	return [
+		top,
+		empty,
+		...lines.map((line) => `| ${padToWidth(line, innerWidth, "left")} |`),
+		empty,
+		`+${"-".repeat(span)}+`
+	].join("\n");
+}
+//#endregion
+export { renderTable as t };

package/dist/chunks/child-process-safe-DRGsp0TE.js

@@ -0,0 +1,69 @@
+import cp from "node:child_process";
+import { promisify } from "node:util";
+//#region server/child-process-safe.ts
+function hide(options) {
+	if (!options || typeof options !== "object") return { windowsHide: true };
+	return {
+		...options,
+		windowsHide: true
+	};
+}
+function split(rest) {
+	let args;
+	let options;
+	let callback;
+	for (const v of rest) {
+		if (Array.isArray(v) && v.every((entry) => typeof entry === "string")) args = v;
+		if (typeof v === "function") callback = v;
+		if (v && typeof v === "object" && !Array.isArray(v)) options = v;
+	}
+	return {
+		args,
+		options,
+		callback
+	};
+}
+var execFile = Object.assign(function execFile(file, ...rest) {
+	const { args, options, callback } = split(rest);
+	const execOptions = hide(options);
+	return cp.execFile(file, args, execOptions, callback);
+}, { [promisify.custom]: (file, ...rest) => new Promise((resolve, reject) => {
+	const { args, options } = split(rest);
+	const { input, ...commandOptions } = options ?? {};
+	const execOptions = hide(commandOptions);
+	const callback = (err, stdout, stderr) => {
+		if (err) {
+			const failure = err;
+			failure.stdout = stdout;
+			failure.stderr = stderr;
+			return reject(failure);
+		}
+		resolve({
+			stdout,
+			stderr
+		});
+	};
+	const child = cp.execFile(file, args, execOptions, callback);
+	if (typeof input !== "string") return;
+	if (!child.stdin) return reject(/* @__PURE__ */ new Error("execFile stdin unavailable"));
+	child.stdin.on("error", reject);
+	child.stdin.end(input);
+}) });
+function execFileSync(file, ...rest) {
+	const { args, options } = split(rest);
+	const execOptions = hide(options);
+	if (args) return cp.execFileSync(file, args, execOptions);
+	return cp.execFileSync(file, execOptions);
+}
+function execSync(command, options) {
+	return cp.execSync(command, hide(options));
+}
+function spawn(file, ...rest) {
+	const { args, options } = split(rest);
+	const spawnOptions = hide(options);
+	if (args) return cp.spawn(file, args, spawnOptions);
+	return cp.spawn(file, spawnOptions);
+}
+var execFileAsync = promisify(execFile);
+//#endregion
+export { hide as a, execSync as i, execFileAsync as n, spawn as o, execFileSync as r, execFile as t };

package/dist/chunks/child-process-safe-DvQjXsgz.js

@@ -0,0 +1,2 @@
+import { r as execFileSync } from "./child-process-safe-DRGsp0TE.js";
+export { execFileSync };

package/dist/chunks/config-path-core-DFt-TemS.js

@@ -0,0 +1,38 @@
+import path from "node:path";
+//#region server/core/config-path-core.ts
+function glimmervoidHomeDir(homeDirectory, env) {
+	if (env.GLIMMERVOID_HOME) return path.resolve(env.GLIMMERVOID_HOME);
+	return path.join(homeDirectory, ".glimmervoid");
+}
+function decideConfigPath({ env = {}, homeDir }, exists) {
+	const homePath = path.join(homeDir, "config.json");
+	if (env.GLIMMERVOID_CONFIG) {
+		const envPath = path.resolve(env.GLIMMERVOID_CONFIG);
+		if (exists(envPath)) return {
+			path: envPath,
+			source: "env",
+			homePath,
+			envPath
+		};
+		return {
+			path: null,
+			source: "env",
+			homePath,
+			envPath
+		};
+	}
+	if (exists(homePath)) return {
+		path: homePath,
+		source: "home",
+		homePath,
+		envPath: null
+	};
+	return {
+		path: null,
+		source: "none",
+		homePath,
+		envPath: null
+	};
+}
+//#endregion
+export { glimmervoidHomeDir as n, decideConfigPath as t };

package/dist/chunks/config-store-CC8T3okC.js

@@ -0,0 +1,2 @@
+import { c as loadConfigFile } from "./config-store-mm7MgzoL.js";
+export { loadConfigFile };