@overdeck/desktop 0.45.22 → 0.45.23

package/server/{validation-CabEISJT.js → validation-B5JxoPUS.js}

@@ -1,12 +1,221 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { jr as init_errors } from "./config-yaml-ig8Nwtiw.js";
-import { f as init_config, m as loadConfigSync } from "./config-q4Gvd8dq.js";
-import { n as init_workspace_config, r as replacePlaceholdersSync } from "./workspace-config-Bigl_-Lk.js";
+import { Br as getOverdeckHome, Vr as init_paths, mr as init_errors } from "./config-yaml-DvyMuOle.js";
+import { f as init_config, m as loadConfigSync } from "./config-CCvjQf27.js";
+import { n as init_workspace_config, r as replacePlaceholdersSync } from "./workspace-config-cEGcO6UT.js";
+import { join } from "node:path";
 import { Effect } from "effect";
 import "fs";
-import { join } from "path";
+import { join as join$1 } from "path";
+import { cpus, loadavg } from "node:os";
+import { mkdir, open, readFile, readdir, unlink } from "node:fs/promises";
 import { exec } from "child_process";
 import { promisify } from "util";
+//#region ../../lib/cloister/quality-gate-admission.ts
+function isErrnoException(error) {
+	return error instanceof Error && "code" in error;
+}
+function processIsAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return isErrnoException(error) && error.code === "EPERM";
+	}
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function cpuTotals() {
+	const records = cpus();
+	let idle = 0;
+	let total = 0;
+	for (const cpu of records) {
+		idle += cpu.times.idle;
+		total += Object.values(cpu.times).reduce((sum, value) => sum + value, 0);
+	}
+	return {
+		idle,
+		total,
+		cores: Math.max(1, records.length)
+	};
+}
+async function sampleQualityGatePressure(sleep = delay) {
+	const before = cpuTotals();
+	await sleep(250);
+	const after = cpuTotals();
+	const totalDelta = after.total - before.total;
+	const idleDelta = after.idle - before.idle;
+	const cpuUtilization = totalDelta > 0 ? (totalDelta - idleDelta) / totalDelta : 0;
+	const loadPerCore = loadavg()[0] / after.cores;
+	return {
+		cpuUtilization,
+		loadPerCore,
+		pressured: cpuUtilization >= .75 || loadPerCore >= 1
+	};
+}
+function admissionRoot(rootDir) {
+	return rootDir ?? join(getOverdeckHome(), "verification-workers", "admission");
+}
+function ownerPath(root) {
+	return join(root, "owner.json");
+}
+function breakerPath(root) {
+	return join(root, "owner.break");
+}
+function ticketPath(root, ticketId) {
+	return join(root, `waiter-${ticketId}.json`);
+}
+async function writeExclusive(path, value) {
+	const file = await open(path, "wx", 384);
+	try {
+		await file.writeFile(`${JSON.stringify(value)}\n`, "utf8");
+	} finally {
+		await file.close();
+	}
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return null;
+	}
+}
+async function unlinkIfExists(path) {
+	try {
+		await unlink(path);
+	} catch (error) {
+		if (!isErrnoException(error) || error.code !== "ENOENT") throw error;
+	}
+}
+function sameOwner(left, right) {
+	return left?.ticketId === right.ticketId && left.pid === right.pid && left.acquiredAt === right.acquiredAt;
+}
+function ownerIsStale(owner, now, staleMs, isProcessAlive) {
+	return now - owner.acquiredAt > staleMs || !isProcessAlive(owner.pid);
+}
+async function acquireBreaker(root, now, staleMs, isProcessAlive) {
+	const path = breakerPath(root);
+	for (let attempt = 0; attempt < 2; attempt++) try {
+		await writeExclusive(path, {
+			pid: process.pid,
+			acquiredAt: now()
+		});
+		return true;
+	} catch (error) {
+		if (!isErrnoException(error) || error.code !== "EEXIST") throw error;
+		const existing = await readJson(path);
+		if (existing && now() - existing.acquiredAt <= staleMs && isProcessAlive(existing.pid)) return false;
+		await unlinkIfExists(path);
+	}
+	return false;
+}
+async function clearStaleOwner(root, observed, now, staleMs, isProcessAlive) {
+	if (!await acquireBreaker(root, now, staleMs, isProcessAlive)) return;
+	try {
+		const current = await readJson(ownerPath(root));
+		if (!observed && !current || observed && sameOwner(current, observed) && ownerIsStale(observed, now(), staleMs, isProcessAlive)) await unlinkIfExists(ownerPath(root));
+	} finally {
+		await unlinkIfExists(breakerPath(root));
+	}
+}
+async function listLiveTickets(root, isProcessAlive) {
+	const entries = await readdir(root);
+	const tickets = [];
+	for (const entry of entries) {
+		if (!entry.startsWith("waiter-") || !entry.endsWith(".json")) continue;
+		const path = join(root, entry);
+		const ticket = await readJson(path);
+		if (!ticket || typeof ticket.ticketId !== "string" || !Number.isFinite(ticket.createdAt)) {
+			await unlinkIfExists(path);
+			continue;
+		}
+		if (!isProcessAlive(ticket.pid)) {
+			await unlinkIfExists(path);
+			continue;
+		}
+		tickets.push(ticket);
+	}
+	return tickets.sort((left, right) => left.createdAt - right.createdAt || left.ticketId.localeCompare(right.ticketId));
+}
+async function acquireQualityGateAdmission(request, deps = {}) {
+	const root = admissionRoot(deps.rootDir);
+	const now = deps.now ?? Date.now;
+	const sleep = deps.sleep ?? delay;
+	const pid = deps.pid ?? process.pid;
+	const isProcessAlive = deps.isProcessAlive ?? processIsAlive;
+	const samplePressure = deps.samplePressure ?? (() => sampleQualityGatePressure(sleep));
+	const pollMs = deps.pollMs ?? 1e3;
+	const settleMs = deps.settleMs ?? 1500;
+	const staleMs = deps.staleMs ?? 15e5;
+	await mkdir(root, { recursive: true });
+	const createdAt = now();
+	const ticketId = `${String(createdAt).padStart(16, "0")}-${String(pid).padStart(10, "0")}-${String(ticketSequence++).padStart(6, "0")}`;
+	const ticket = {
+		...request,
+		ticketId,
+		pid,
+		createdAt
+	};
+	const ownTicketPath = ticketPath(root, ticketId);
+	await writeExclusive(ownTicketPath, ticket);
+	try {
+		for (;;) {
+			if ((await listLiveTickets(root, isProcessAlive))[0]?.ticketId !== ticketId) {
+				await sleep(pollMs);
+				continue;
+			}
+			const observedOwner = await readJson(ownerPath(root));
+			if (observedOwner) {
+				if (ownerIsStale(observedOwner, now(), staleMs, isProcessAlive)) await clearStaleOwner(root, observedOwner, now, staleMs, isProcessAlive);
+				await sleep(pollMs);
+				continue;
+			}
+			if ((await samplePressure()).pressured) {
+				await sleep(pollMs);
+				continue;
+			}
+			const owner = {
+				...ticket,
+				acquiredAt: now()
+			};
+			try {
+				await writeExclusive(ownerPath(root), owner);
+			} catch (error) {
+				if (isErrnoException(error) && error.code === "EEXIST") {
+					if (!await readJson(ownerPath(root))) await clearStaleOwner(root, null, now, staleMs, isProcessAlive);
+					await sleep(pollMs);
+					continue;
+				}
+				throw error;
+			}
+			await sleep(settleMs);
+			if ((await samplePressure()).pressured) {
+				if (sameOwner(await readJson(ownerPath(root)), owner)) await unlinkIfExists(ownerPath(root));
+				await sleep(pollMs);
+				continue;
+			}
+			await unlinkIfExists(ownTicketPath);
+			let released = false;
+			return {
+				admittedAt: new Date(owner.acquiredAt).toISOString(),
+				async release() {
+					if (released) return;
+					released = true;
+					if (sameOwner(await readJson(ownerPath(root)), owner)) await unlinkIfExists(ownerPath(root));
+				}
+			};
+		}
+	} catch (error) {
+		await unlinkIfExists(ownTicketPath);
+		throw error;
+	}
+}
+var ticketSequence;
+var init_quality_gate_admission = __esmMin((() => {
+	init_paths();
+	ticketSequence = 0;
+}));
+//#endregion
 //#region ../../lib/cloister/validation.ts
 /**
 * Merge Validation - Validation utilities for merge completeness
@@ -71,12 +280,18 @@ async function runQualityGatesPromise(gates, projectPath, phase = "pre_push", op
 	for (const [name, gate] of Object.entries(gates)) {
 		if ((gate.phase || "pre_push") !== phase) continue;
 		const required = gate.required !== false;
-		const cwd = gate.path ? join(projectPath, gate.path) : projectPath;
+		const cwd = gate.path ? join$1(projectPath, gate.path) : projectPath;
 		console.log(`[quality-gate] Running "${name}" (${required ? "required" : "optional"}) in ${cwd}`);
 		opts.onLog?.(`Running gate "${name}"${required ? "" : " (optional)"}…`);
 		opts.onGateStart?.(name);
 		const startTime = Date.now();
 		if (gate.type === "http_health") {
+			opts.onAdmissionPhase?.({
+				phase: "running",
+				gateName: name,
+				attempt: 1,
+				admittedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
 			const result = await runHttpHealthGate(name, gate, required);
 			results.push(result);
 			opts.onGateResult?.(result);
@@ -138,7 +353,36 @@ async function runQualityGatesPromise(gates, projectPath, phase = "pre_push", op
 		let passOutput = "";
 		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
 			let gatePgid;
+			let admission = null;
 			try {
+				if (!isRemote) {
+					const identity = `${opts.issueId ?? "unscoped"} gate="${name}" attempt=${attempt}/${maxAttempts} workspace=${cwd}`;
+					console.log(`[quality-gate] Queued for CPU admission: ${identity}`);
+					opts.onLog?.(`Queued ${name} for CPU admission…`);
+					opts.onAdmissionPhase?.({
+						phase: "queued",
+						gateName: name,
+						attempt
+					});
+					admission = await acquireQualityGateAdmission({
+						issueId: opts.issueId,
+						workspacePath: cwd,
+						gateName: name,
+						attempt
+					});
+					console.log(`[quality-gate] Admitted: ${identity}`);
+					opts.onAdmissionPhase?.({
+						phase: "running",
+						gateName: name,
+						attempt,
+						admittedAt: admission.admittedAt
+					});
+				} else opts.onAdmissionPhase?.({
+					phase: "running",
+					gateName: name,
+					attempt,
+					admittedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
 				const useHostCwd = !isRemote && !(gate.container && gate.container_name);
 				const env = buildQualityGateEnv(gate.env);
 				const execPromise = execAsync(resolvedCommand, {
@@ -154,18 +398,23 @@ async function runQualityGatesPromise(gates, projectPath, phase = "pre_push", op
 					execPromise.child.stderr?.on("data", (chunk) => opts.onGateOutput(name, String(chunk)));
 				}
 				const { stdout, stderr } = await execPromise;
-				killGateProcessGroup(gatePgid);
 				passedGate = true;
 				passOutput = formatGateOutput(stdout, stderr);
-				break;
 			} catch (error) {
-				killGateProcessGroup(gatePgid);
 				lastError = error;
 				if (attempt < maxAttempts) {
 					console.log(`[quality-gate] ✗ "${name}" failed attempt ${attempt}/${maxAttempts} — retrying (gate declares retry: ${gate.retry})`);
 					opts.onLog?.(`↻ ${name} failed attempt ${attempt}/${maxAttempts} — retrying`);
 				}
+			} finally {
+				killGateProcessGroup(gatePgid);
+				try {
+					await admission?.release();
+				} catch (error) {
+					console.warn(`[quality-gate] Failed to release CPU admission for ${opts.issueId ?? "unscoped"} gate="${name}": ${error instanceof Error ? error.message : String(error)}`);
+				}
 			}
+			if (passedGate) break;
 		}
 		if (passedGate) {
 			const durationMs = Date.now() - startTime;
@@ -253,6 +502,7 @@ var init_validation = __esmMin((() => {
 	init_workspace_config();
 	init_config();
 	init_errors();
+	init_quality_gate_admission();
 	execAsync = promisify(exec);
 	DASHBOARD_RUNTIME_ENV_KEYS = [
 		"API_PORT",
@@ -272,4 +522,4 @@ var init_validation = __esmMin((() => {
 //#endregion
 export { runQualityGates as i, init_validation as n, killAllGateProcessGroups as r, DEFAULT_GATES as t };
 
-//# sourceMappingURL=validation-CabEISJT.js.map
+//# sourceMappingURL=validation-B5JxoPUS.js.map

package/server/{validation-DcAgXTQp.js → validation-CIi6pnI2.js}

@@ -1,3 +1,3 @@
-import { i as runQualityGates, n as init_validation, r as killAllGateProcessGroups } from "./validation-CabEISJT.js";
+import { i as runQualityGates, n as init_validation, r as killAllGateProcessGroups } from "./validation-B5JxoPUS.js";
 init_validation();
 export { killAllGateProcessGroups, runQualityGates };

package/server/{verification-artifact-BuTA1QbL.js → verification-artifact-BcnIbigL.js}

@@ -53,4 +53,4 @@ function readVerificationArtifact(workspacePath) {
 //#endregion
 export { verificationArtifactPath as n, writeVerificationArtifact as r, readVerificationArtifact as t };
 
-//# sourceMappingURL=verification-artifact-BuTA1QbL.js.map
+//# sourceMappingURL=verification-artifact-BcnIbigL.js.map

package/server/{verification-artifact-Ck1tefmz.js → verification-artifact-C-lIHfUa.js}

@@ -1,2 +1,2 @@
-import { t as readVerificationArtifact } from "./verification-artifact-BuTA1QbL.js";
+import { t as readVerificationArtifact } from "./verification-artifact-BcnIbigL.js";
 export { readVerificationArtifact };