@qredence/fleet 0.10.0 → 0.10.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.10.1
+
+### Patch Changes
+
+- 0b78235: Keep the packaged kernel runtime when `fleet-prime` installs Prime Agent
+  
+  0.10.0 fixed the runtime install inside the web server, but the `fleet-prime`
+  command installs Prime Agent itself before it starts the server, and that path
+  still kept only the `prime-agent` executable and deleted the
+  `prime-agent-runtime` directory the kernel bootstraps from. The server then
+  reused that binary as-is, so sessions started from the npm package could still
+  fail with "the runtime bundle that ships beside the Prime Agent binary is
+  missing".
+  
+  `fleet-prime` and the server now share one installer. It keeps
+  `prime-agent-runtime` beside the binary, and an existing binary-only install
+  under `~/.prime/fleet/runtimes` is repaired automatically on the next start; no
+  manual cleanup is needed.
+
 ## 0.10.0
 
 ### Minor Changes

package/bin/prime-runtime.d.mts

@@ -0,0 +1,19 @@
+export interface PrimeRuntimeAsset {
+	archive: string;
+	sha256: string;
+	executableSha256: string;
+}
+
+export interface PrimeRuntimeManifest {
+	rust: { version: string; baseUrl: string; platforms: Record<string, PrimeRuntimeAsset | undefined> };
+}
+
+export function runtimeTarget(os?: string, cpu?: string): string;
+
+export function ensurePrimeRuntime(options: {
+	manifest: PrimeRuntimeManifest;
+	installRoot?: string;
+	home?: string;
+	fetch?: typeof fetch;
+	target?: string;
+}): Promise<string>;

package/bin/prime-runtime.mjs

@@ -1,9 +1,13 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { chmod, mkdir, mkdtemp, open, rename, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, open, rename, rm, stat, writeFile } from "node:fs/promises";
 import { arch, homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 
+// This module is the single Prime Agent runtime installer. The npm launcher
+// (`fleet-prime`) runs it directly, and the web server re-exports it from
+// `web/server/src/prime-runtime.ts`, so both install the same payload.
+
 export function runtimeTarget(os = platform(), cpu = arch()) {
 	const target = `${os}-${cpu}`;
 	if (!["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64"].includes(target)) {
@@ -26,7 +30,13 @@ export async function ensurePrimeRuntime({
 	if (!asset) throw new Error(`Fleet has no pinned Prime Agent runtime for ${target}`);
 	const destination = installRoot ?? join(home, ".prime", "fleet", "runtimes", runtime.version, target);
 	const executable = join(destination, "prime-agent");
-	if (await matchesDigest(executable, asset.executableSha256)) return executable;
+	const packagedRuntime = join(destination, "prime-agent-runtime");
+	// A verified binary is not enough: the kernel bootstraps from the packaged
+	// runtime beside it. Installs made by earlier Fleet releases kept only the
+	// executable, so that state is repaired rather than short-circuited.
+	if ((await matchesDigest(executable, asset.executableSha256)) && (await directoryExists(packagedRuntime))) {
+		return executable;
+	}
 
 	await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
 	const staging = await mkdtemp(join(dirname(destination), ".fleet-prime-runtime-"));
@@ -50,18 +60,45 @@ export async function ensurePrimeRuntime({
 		const result = spawnSync("tar", ["-xzf", archivePath, "-C", unpacked], { encoding: "utf8" });
 		if (result.status !== 0)
 			throw new Error(`Could not extract Prime Agent runtime: ${result.stderr || "tar failed"}`);
-		if (!(await matchesDigest(join(unpacked, "prime-agent"), asset.executableSha256))) {
+		const extractedBinary = join(unpacked, "prime-agent");
+		if (!(await matchesDigest(extractedBinary, asset.executableSha256))) {
 			throw new Error("Extracted Prime Agent executable checksum mismatch; refusing to install it.");
 		}
-		await chmod(join(unpacked, "prime-agent"), 0o755);
+		await chmod(extractedBinary, 0o755);
 		await mkdir(destination, { recursive: true, mode: 0o700 });
-		await rename(join(unpacked, "prime-agent"), executable);
+		// The kernel bootstraps from `prime-agent-runtime/`, which ships beside the
+		// binary. It lands before the executable is replaced, so a failed rename
+		// cannot leave a binary that looks current with no runtime. Any existing
+		// copy (possibly damaged) is moved aside into the private staging dir
+		// rather than deleted in place, so the window with no runtime is two
+		// renames, and the verified copy always replaces it.
+		const extractedRuntime = join(unpacked, "prime-agent-runtime");
+		if (await directoryExists(extractedRuntime)) {
+			await rename(packagedRuntime, join(staging, "previous-runtime")).catch((error) => {
+				if (error.code !== "ENOENT") throw error;
+			});
+			await rename(extractedRuntime, packagedRuntime).catch((error) => {
+				// A concurrent install of the same checksummed archive placed it first.
+				if (error.code !== "ENOTEMPTY" && error.code !== "EEXIST") throw error;
+			});
+		}
+		await rename(extractedBinary, executable);
 		return executable;
 	} finally {
 		await rm(staging, { recursive: true, force: true });
 	}
 }
 
+async function directoryExists(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch (error) {
+		// Only absence means "not installed"; surface permission or symlink errors.
+		if (error.code === "ENOENT" || error.code === "ENOTDIR") return false;
+		throw error;
+	}
+}
+
 async function matchesDigest(path, expected) {
 	let file;
 	try {