glimmervoid 0.30.0 → 0.32.0

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

@@ -0,0 +1,192 @@
+import { a as AgentDispatchRequest, c as ORCHESTRATOR_AGENT_VERBS, i as AgentAttentionRequest, o as AgentSpawnRequest, t as AGENT_API_VERBS } from "./session-B8fJb_Or.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;
+var PUSH_REFUSED_STATUS = 409;
+var PUSH_UNAVAILABLE_REASON = "not-operator-session";
+var PUSH_REFUSAL_COPY = Object.freeze({
+	[PUSH_UNAVAILABLE_REASON]: () => "only an operator session or a session it spawned can push",
+	"no-worktree": () => "this session has no worktree of its own, so there is nothing of its own to land",
+	"merge-in-progress": () => "a merge for this session is already running, so try again when it ends",
+	"not-continuable": () => "this session cannot be merged in its current state",
+	destroyed: () => "this session is ending",
+	"nothing-to-commit": () => "no commit on this branch is missing from the integration branch, so commit your work first",
+	"rebase-conflict": ({ base, conflicts = [] }) => `this branch conflicts with ${base} in ${conflicts.join(", ") || "one or more files"}, so rebase onto ${base}, resolve the conflicts, commit, then push again`,
+	"not-fast-forward": ({ base }) => `${base} could not be fast-forwarded to this branch, and a push is never forced`,
+	"base-diverged": ({ base }) => `the local ${base} and origin/${base} have diverged, which the operator has to reconcile`
+});
+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 }) {
+	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 isOrchestratorAgentVerb(verb) {
+	return ORCHESTRATOR_AGENT_VERBS.includes(verb);
+}
+var TICKET_ACTION_STATES = Object.freeze({
+	reopen: Object.freeze(["blocked"]),
+	cancel: Object.freeze(["open", "blocked"])
+});
+function decideTicketAction({ verb, intentId, ticket }) {
+	if (!ticket) return {
+		ok: false,
+		reason: "no such ticket"
+	};
+	if (ticket.parent !== intentId) return {
+		ok: false,
+		reason: "the ticket is not a child of the active intent"
+	};
+	const allowed = TICKET_ACTION_STATES[verb];
+	if (!allowed.includes(ticket.state)) return {
+		ok: false,
+		reason: `only a ${allowed.join(" or ")} ticket can be ${verb === "reopen" ? "reopened" : "cancelled"}, and this one is ${ticket.state}`
+	};
+	if (verb === "reopen") return {
+		ok: true,
+		kind: "transition",
+		to: "open"
+	};
+	return {
+		ok: true,
+		kind: "close",
+		outcome: "cancelled"
+	};
+}
+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 === "dispatch") {
+		const parsed = AgentDispatchRequest.safeParse(payload);
+		if (!parsed.success) return refuseInvalidBody(parsed.error.issues);
+		return {
+			ok: true,
+			verb,
+			request: parsed.data
+		};
+	}
+	if (verb === "reopen" || verb === "cancel") return {
+		ok: false,
+		status: 403,
+		error: `${verb} requires a live factory orchestrator`
+	};
+	if (verb === "board" || verb === "push") 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 describePushLanding(landing) {
+	if (!landing.merged) {
+		const reason = landing.reason || "unknown";
+		const explain = PUSH_REFUSAL_COPY[reason];
+		return {
+			status: PUSH_REFUSED_STATUS,
+			body: {
+				ok: false,
+				reason,
+				error: explain ? explain(landing) : `the merge stopped: ${reason}`
+			}
+		};
+	}
+	if (landing.pushed) return {
+		status: 200,
+		body: {
+			ok: true,
+			landedOn: landing.base ?? null,
+			pushed: true
+		}
+	};
+	return {
+		status: 200,
+		body: {
+			ok: true,
+			landedOn: landing.base ?? null,
+			pushed: false,
+			note: "landed locally and nothing was pushed, because the repository has no origin remote or origin did not take a fast-forward"
+		}
+	};
+}
+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 { decideTicketAction as a, isAgentApiVerb as c, decideSpawnAllowance as i, isOrchestratorAgentVerb as l, REFUSAL_REASON as n, deriveChildSessionName as o, decideAgentRequest as r, describePushLanding as s, PUSH_UNAVAILABLE_REASON as t, parseAgentVerb as u };

package/dist/chunks/{agent-setup-cli-B5Atxr3F.js → agent-setup-cli-D4956BfN.js}

@@ -1,16 +1,10 @@
-import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-DuU8xVLZ.js";
+import { a as isMissingFileError, r as errorMessage } from "./text-DoirglWV.js";
+import { a as classifyGrokHooksFile, o as renderGrokHooksFile, t as grok } from "./grok-C4lzPFEg.js";
+import { p as writeTextAtomicSync } from "./json-file-oEH9vt-0.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),
@@ -26,7 +20,7 @@ function inspectGrokAgentSetup({ env = process.env, readFileSync = fs.readFileSy
 	try {
 		contents = readFileSync(inputs.filePath, "utf8");
 	} catch (error) {
-		if (errorCode(error) === "ENOENT") return {
+		if (isMissingFileError(error, { includeNotDir: false })) return {
 			filePath: inputs.filePath,
 			classification: "absent"
 		};
@@ -59,7 +53,7 @@ function ensureWritableHooksDirectory(directory, fileSystem) {
 			assertRealDirectory(currentDirectory, fileSystem);
 			continue;
 		} catch (directoryError) {
-			if (errorCode(directoryError) !== "ENOENT") throw directoryError;
+			if (!isMissingFileError(directoryError, { includeNotDir: false })) throw directoryError;
 		}
 		fileSystem.mkdirSync(currentDirectory, { mode: 448 });
 		assertRealDirectory(currentDirectory, fileSystem);
@@ -69,23 +63,12 @@ function ensureWritableHooksDirectory(directory, fileSystem) {
 	} 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 {}
+	writeTextAtomicSync(filePath, contents, {
+		mode: 384,
+		exclusive: true,
+		enforceMode: true,
+		fsSync: fileSystem
+	});
 }
 function runGrokSetup({ env, fileSystem, log, error }) {
 	const inputs = setupInputs(env);

package/dist/chunks/backoff-DjVpfHk7.js

@@ -0,0 +1,14 @@
+//#region shared/backoff.ts
+var DEFAULT_BASE_MS = 6e4;
+var DEFAULT_MAX_MS = 18e5;
+var MAX_DOUBLING_ATTEMPT = 20;
+function nextBackoffMs({ attempt = 1, baseMs = DEFAULT_BASE_MS, maxMs = DEFAULT_MAX_MS, retryAfterMs = null, random = Math.random, jitter = "full" } = {}) {
+	if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) return Math.min(retryAfterMs, maxMs);
+	const exponent = Math.max(0, Math.min(attempt, MAX_DOUBLING_ATTEMPT) - 1);
+	const ceiling = Math.min(maxMs, baseMs * 2 ** exponent);
+	if (jitter === "none") return ceiling;
+	if (jitter === "half") return Math.round(ceiling * (.5 + .5 * random()));
+	return Math.round(random() * ceiling);
+}
+//#endregion
+export { DEFAULT_MAX_MS as n, nextBackoffMs as r, DEFAULT_BASE_MS as t };

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

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

package/dist/chunks/{child-process-safe-DRGsp0TE.js → child-process-safe-DDELk9XC.js}

@@ -1,5 +1,5 @@
-import cp from "node:child_process";
 import { promisify } from "node:util";
+import cp from "node:child_process";
 //#region server/child-process-safe.ts
 function hide(options) {
 	if (!options || typeof options !== "object") return { windowsHide: true };
@@ -13,7 +13,8 @@ function split(rest) {
 	let options;
 	let callback;
 	for (const v of rest) {
-		if (Array.isArray(v) && v.every((entry) => typeof entry === "string")) args = v;
+		if (Array.isArray(v) && !v.every((entry) => typeof entry === "string")) throw new TypeError("command arguments must all be strings");
+		if (Array.isArray(v)) args = v;
 		if (typeof v === "function") callback = v;
 		if (v && typeof v === "object" && !Array.isArray(v)) options = v;
 	}

package/dist/chunks/coerce-NSst8oRP.js

@@ -0,0 +1,32 @@
+//#region shared/coerce.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textOr(value, fallback) {
+	return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function rawTextOr(value, fallback) {
+	return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function numberOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function positiveNumberOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function nonNegativeIntOr(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return fallback;
+	return Math.floor(value);
+}
+function coercedNumberOr(value, fallback) {
+	const number = Number(value);
+	if (!Number.isFinite(number)) return fallback;
+	return number;
+}
+function positiveIntOr(value, fallback) {
+	const number = Number(value);
+	if (!Number.isFinite(number) || number <= 0) return fallback;
+	return Math.floor(number);
+}
+//#endregion
+export { positiveIntOr as a, textOr as c, numberOr as i, isRecord as n, positiveNumberOr as o, nonNegativeIntOr as r, rawTextOr as s, coercedNumberOr as t };