@stim-cli/core 1.15.0 → 1.16.0

package/README.md

@@ -34,6 +34,9 @@ path layout, the config and workspace state types and readers, the settings
 registry and its JSON Schema, the created-device and EAS session ledger readers,
 NDJSON log records and queries, and the status and settings payload types. The
 CLI owns every write to that state. The cache packages do not import it.
+Setup journals are an exception: stim-server writes and prunes
+`$STIM_HOME/server/setup/<sha256(ticket) hex>.json`; core owns their paths,
+strict parser and reader.
 
 `@stim-cli/core/oversight` holds the pure notification and needs-attention rules
 shared by stim-server and the phone. It imports no Node APIs; mobile consumers

package/dist/{core-BwaxUjLX.mjs → core-DWOUn9xp.mjs}

@@ -1,8 +1,9 @@
 import { S as quotedPath, _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-O31Y5iIb.mjs";
-import fs, { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import fs, { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path, { basename, dirname, join } from "node:path";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import { connect, createServer, isIP } from "node:net";
 //#region dir-lock.ts
 const DEFAULT_LOCK_WAIT_MS = 12e3;
@@ -255,27 +256,72 @@ function storeArtifact(dest, buildPath, { runFile, overwrite = false, writeMetad
 }
 //#endregion
 //#region compiled-helper.ts
+const RECENT_MS = 6e5;
+const pruned = /* @__PURE__ */ new Set();
+function isHelperName(entry, name) {
+	return entry.length === name.length + 17 && entry.startsWith(`${name}-`) && /^[0-9a-f]{16}$/.test(entry.slice(name.length + 1));
+}
+function selectHelpersToPrune(entries, currentName, name, running) {
+	return entries.filter((entry) => isHelperName(entry.name, name) && entry.name !== currentName).toSorted((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name)).slice(1).filter((entry) => !running.has(entry.name)).map((entry) => entry.name);
+}
+function runningExecutablePaths() {
+	const result = spawnSync("ps", ["-axo", "comm="], {
+		encoding: "utf8",
+		timeout: 500
+	});
+	if (result.error || result.status !== 0 || typeof result.stdout !== "string" || !result.stdout.trim()) return null;
+	return new Set(result.stdout.split("\n").map((line) => line.trim()).filter(Boolean));
+}
+function pruneCompiledHelpers(dir, currentName, name, runningPaths = runningExecutablePaths) {
+	try {
+		const entries = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && isHelperName(entry.name, name)).map((entry) => ({
+			name: entry.name,
+			mtimeMs: statSync(join(dir, entry.name)).mtimeMs
+		}));
+		if (entries.length <= 2) return;
+		const paths = runningPaths();
+		if (paths === null) return;
+		const canonicalPaths = /* @__PURE__ */ new Set();
+		for (const path of paths) try {
+			canonicalPaths.add(realpathSync(path));
+		} catch {}
+		const running = /* @__PURE__ */ new Set();
+		for (const entry of entries) try {
+			if (canonicalPaths.has(realpathSync(join(dir, entry.name)))) running.add(entry.name);
+		} catch {
+			running.add(entry.name);
+		}
+		const recent = Date.now() - RECENT_MS;
+		for (const entry of entries) if (entry.mtimeMs > recent) running.add(entry.name);
+		for (const entry of selectHelpersToPrune(entries, currentName, name, running)) rmSync(join(dir, entry), { force: true });
+	} catch {}
+}
 /**
 * Returns `<dir>/<name>-<hash>`, compiling it with `compile` first when it is missing. The hash covers `version` and
 * each input's name and bytes, so a changed source or compiler builds a new helper beside the old one. `compile`
 * writes to a private temporary path that is renamed into place, so concurrent builders never expose a partial file.
+* Pruning is best effort and keeps this helper, the newest previous build, helpers modified in the last ten minutes and running helpers. It runs after a build and on the first call per process.
 */
 async function compiledHelper({ dir, name, inputs, version, compile }) {
 	const hash = createHash("sha256").update(version);
 	for (const input of inputs) hash.update(basename(input)).update(readFileSync(input));
 	const helper = join(dir, `${name}-${hash.digest("hex").slice(0, 16)}`);
-	if (existsSync(helper)) return helper;
-	mkdirSync(dir, {
-		recursive: true,
-		mode: 448
-	});
-	const output = `${helper}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
-	try {
-		await compile(output);
-		renameSync(output, helper);
-	} finally {
-		rmSync(output, { force: true });
+	const built = !existsSync(helper);
+	if (built) {
+		mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const output = `${helper}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+		try {
+			await compile(output);
+			renameSync(output, helper);
+		} finally {
+			rmSync(output, { force: true });
+		}
 	}
+	if (built || !pruned.has(`${dir}/${name}`)) pruneCompiledHelpers(dir, basename(helper), name);
+	pruned.add(`${dir}/${name}`);
 	return helper;
 }
 //#endregion