#!/usr/bin/env node
/**
 * Reproduce the kernel-venv install race against a real uv install.
 *
 * A rebuild replaces ~/.prime/agent/kernel-venv while other sessions may be booting a
 * kernel from it. This probe runs the real bootstrap (staged temp venv, PRIME_AGENT_KERNEL_VENV
 * pointed at it) and a reader that keeps launching the venv's own python to import the
 * runtime, so it measures what a concurrently booting kernel would have imported.
 *
 * Usage: node scripts/kernel-venv-race-probe.mjs [--venv <dir>] [--samples <file>]
 * Exits non-zero when any sample caught the live path holding a partial venv.
 */
import { spawn, spawnSync } from "node:child_process";
import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join, resolve } from "node:path";
import { fileURLToPath } from "node:url";

const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const BOOTSTRAP_CLI = join(repoRoot, "packages", "coding-agent", "src", "core", "kernel", "bootstrap-cli.ts");

function argValue(name, fallback) {
	const index = process.argv.indexOf(name);
	return index >= 0 ? process.argv[index + 1] : fallback;
}

const venv = resolve(argValue("--venv", mkdtempSync(join(tmpdir(), "prime-agent-venv-race-"))));
const samplesPath = argValue("--samples", `${venv}.samples.json`);
const python = join(venv, "bin", "python");
const manifest = join(venv, ".bootstrap-version");

function bootstrap() {
	return new Promise((settle) => {
		const child = spawn("npx", ["tsx", BOOTSTRAP_CLI], {
			cwd: repoRoot,
			stdio: ["ignore", "ignore", "inherit"],
			env: { ...process.env, PRIME_AGENT_KERNEL_VENV: venv },
		});
		child.on("close", (code) => settle(code));
	});
}

/** What a kernel booting right now would import, plus the state it would read. */
function inspect() {
	// Read the whole fs state first, so every field of one sample describes one instant.
	const venvExists = existsSync(venv);
	const pythonExists = venvExists && existsSync(python);
	const manifestExists = venvExists && existsSync(manifest);
	const attempt = pythonExists
		? spawnSync(python, ["-c", "import rlm, rlm.mcp, remote"], { encoding: "utf8", timeout: 30_000 })
		: undefined;
	const importOk = attempt?.status === 0;
	return {
		venvExists,
		pythonExists,
		manifestExists,
		importOk,
		error: importOk ? "" : ((attempt?.stderr ?? (pythonExists ? "" : "no python")).trim().split("\n").at(-1) ?? ""),
	};
}

function sample(index) {
	let entry = inspect();
	// The swap renames the live venv away and back within two renames; re-read once so a
	// transition between two complete trees is not mistaken for a partially installed one.
	if (entry.venvExists && !entry.importOk) entry = inspect();
	// Partial is the bug: the live path is there but cannot serve the runtime.
	return { index, ...entry, partial: entry.venvExists && (!entry.importOk || !entry.manifestExists) };
}

async function main() {
	// First build: the state every later boot starts from.
	if ((await bootstrap()) !== 0) {
		throw new Error("the first bootstrap failed; the probe needs a working uv and network");
	}
	console.log(`warm venv: ${python}`);

	const samples = [];
	let building = true;
	const reader = (async () => {
		for (let index = 0; building; index += 1) {
			samples.push(sample(index));
			await new Promise((settle) => setTimeout(settle, 50));
		}
		samples.push(sample(samples.length));
	})();

	// Second build: a rebuild of the same venv, the 2026-09-17 install path.
	const rebuildCode = await bootstrap();
	building = false;
	await reader;

	const partial = samples.filter((entry) => entry.partial);
	const absent = samples.filter((entry) => !entry.venvExists);
	const complete = samples.filter((entry) => entry.venvExists && entry.importOk);
	writeFileSync(samplesPath, `${JSON.stringify({ venv, rebuildCode, samples }, null, 2)}\n`);
	console.log(`samples: ${samples.length} complete=${complete.length} absent=${absent.length} partial=${partial.length}`);
	for (const entry of partial.slice(0, 5)) {
		console.log(`  partial sample ${entry.index}: manifest=${entry.manifestExists} ${entry.error}`);
	}
	console.log(`samples file: ${samplesPath}`);
	if (rebuildCode !== 0) throw new Error(`the rebuild failed with exit code ${rebuildCode}`);
	if (partial.length > 0) throw new Error("a concurrently booting kernel imported the venv mid-install");

	const manifestRuntime = JSON.parse(readFileSync(manifest, "utf8")).runtime;
	console.log(`promoted runtime: ${manifestRuntime}`);
	if (process.env.PRIME_AGENT_RACE_PROBE_KEEP !== "1") {
		rmSync(venv, { recursive: true, force: true });
	}
}

main().catch((error) => {
	console.error(error instanceof Error ? error.message : String(error));
	process.exitCode = 1;
});