@xopcai/xopc 0.0.190 → 0.0.192

package/dist/src/runtime-tools/manager.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from 'node:events';
+import type { ResolvedRuntime, RuntimeKind, RuntimeManagerOptions, RuntimeRequest, RuntimeStatus } from './types.js';
+export declare class ManagedRuntimeManager extends EventEmitter {
+    private readonly options;
+    private readonly inFlight;
+    constructor(options: RuntimeManagerOptions);
+    defaultVersion(runtime: RuntimeKind): string;
+    resolve(request: RuntimeRequest): Promise<ResolvedRuntime>;
+    private resolveUncached;
+    probeManaged(runtime: RuntimeKind, requestedVersion: string): Promise<ResolvedRuntime | null>;
+    install(runtime: RuntimeKind, version?: string, signal?: AbortSignal): Promise<ResolvedRuntime>;
+    private installDistribution;
+    private installPython;
+    private installBundledPython;
+    private uvEnvironment;
+    status(runtime: RuntimeKind): Promise<RuntimeStatus>;
+    statusAll(): Promise<RuntimeStatus[]>;
+    repair(runtime: RuntimeKind): Promise<ResolvedRuntime>;
+    private progress;
+}

package/dist/src/runtime-tools/manager.js

@@ -0,0 +1,641 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { RuntimeError } from "./errors.js";
+import { atomicInstallRuntime, extractRuntimeArchive } from "./archive.js";
+import { runRuntimeCommand } from "./command.js";
+import { DEFAULT_RUNTIME_VERSIONS, RUNTIME_CATALOG_VERSION, detectRuntimePlatform, resolveRuntimeAsset } from "./catalog.js";
+import { canFallbackRuntimeDownload, downloadVerifiedArchive } from "./downloader.js";
+import { canFallbackPythonInstall, resolveRuntimeDownloadSource, runtimeGatewayPythonMirror } from "./download-source.js";
+import { withInstallLock } from "./install-lock.js";
+import { runtimeDownloadPath, runtimeLockPath, runtimeStagingDir, runtimeToolsRoot, runtimeVersionDir } from "./paths.js";
+import { readRuntimeManifest, writeRuntimeManifest } from "./manifest-store.js";
+import { bundledPythonArchiveName, resolveOfflineBundleArtifact } from "./offline-bundle.js";
+import { parseRuntimeVersion, probeSystemRuntime, versionSatisfies } from "./probe.js";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { access, mkdir, realpath, rename, rm } from "node:fs/promises";
+import { EventEmitter } from "node:events";
+//#region src/runtime-tools/manager.ts
+init_logger();
+const log = createLogger("RuntimeManager");
+function executableName(name) {
+	return process.platform === "win32" ? `${name}.exe` : name;
+}
+function nodeExecutables(installDir) {
+	if (process.platform === "win32") return {
+		primary: join(installDir, "node.exe"),
+		node: join(installDir, "node.exe"),
+		npm: join(installDir, "npm.cmd"),
+		npx: join(installDir, "npx.cmd"),
+		corepack: join(installDir, "corepack.cmd")
+	};
+	const bin = join(installDir, "bin");
+	return {
+		primary: join(bin, "node"),
+		node: join(bin, "node"),
+		npm: join(bin, "npm"),
+		npx: join(bin, "npx"),
+		corepack: join(bin, "corepack")
+	};
+}
+function uvExecutables(installDir) {
+	const uv = join(installDir, executableName("uv"));
+	return {
+		primary: uv,
+		uv,
+		uvx: join(installDir, executableName("uvx"))
+	};
+}
+function runtimeConfig(options, runtime) {
+	if (runtime === "node") return options.config.node;
+	if (runtime === "python") return options.config.python;
+	return {
+		enabled: options.config.uv.enabled,
+		version: options.config.uv.version,
+		preference: "managed-only",
+		provision: "eager"
+	};
+}
+var ManagedRuntimeManager = class extends EventEmitter {
+	inFlight = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+	defaultVersion(runtime) {
+		return runtimeConfig(this.options, runtime).version ?? DEFAULT_RUNTIME_VERSIONS[runtime];
+	}
+	async resolve(request) {
+		const config = runtimeConfig(this.options, request.runtime);
+		const requestedVersion = request.version ?? this.defaultVersion(request.runtime);
+		if (!this.options.config.enabled || !config.enabled) throw new RuntimeError(`${request.runtime} runtime is disabled`, "RUNTIME_DISABLED", request.runtime, "resolve", false);
+		const key = `${request.runtime}:${requestedVersion}:${request.allowProvision === true}`;
+		const existing = this.inFlight.get(key);
+		if (existing) return await existing;
+		const operation = this.resolveUncached(request.runtime, requestedVersion, request);
+		this.inFlight.set(key, operation);
+		try {
+			return await operation;
+		} finally {
+			this.inFlight.delete(key);
+		}
+	}
+	async resolveUncached(runtime, requestedVersion, request) {
+		const config = runtimeConfig(this.options, runtime);
+		const order = config.preference.startsWith("system") ? ["system", "managed"] : ["managed", "system"];
+		const allowed = config.preference.endsWith("only") ? order.slice(0, 1) : order;
+		for (const source of allowed) if (source === "managed") {
+			const managed = await this.probeManaged(runtime, requestedVersion);
+			if (managed) return managed;
+			if (request.allowProvision && config.provision !== "disabled") try {
+				return await this.install(runtime, requestedVersion, request.signal);
+			} catch (error) {
+				if (allowed.length === 1) throw error;
+				log.warn({
+					err: error,
+					runtime,
+					requestedVersion,
+					phase: "managed_install"
+				}, `Managed ${runtime} installation failed; checking the system runtime`);
+			}
+		} else {
+			const system = await probeSystemRuntime(runtime, requestedVersion);
+			if (system) return {
+				runtime,
+				version: system.version,
+				source: "system",
+				executable: system.executables.primary,
+				executables: system.executables
+			};
+		}
+		throw new RuntimeError(`${runtime} ${requestedVersion} is not available`, "RUNTIME_NOT_FOUND", runtime, "resolve", true, [`Run xopc runtime install ${runtime}`]);
+	}
+	async probeManaged(runtime, requestedVersion) {
+		const manifest = await readRuntimeManifest(this.options.stateDir, runtime);
+		if (!manifest || !versionSatisfies(manifest.version, requestedVersion)) return null;
+		try {
+			const toolsRoot = await realpath(runtimeToolsRoot(this.options.stateDir));
+			const installDir = await realpath(manifest.installDir);
+			if (installDir !== toolsRoot && !installDir.startsWith(`${toolsRoot}${process.platform === "win32" ? "\\" : "/"}`)) return null;
+			await access(manifest.executables.primary);
+			const result = await runRuntimeCommand({
+				command: manifest.executables.primary,
+				args: ["--version"]
+			});
+			const version = parseRuntimeVersion(`${result.stdout}\n${result.stderr}`);
+			if (!result.ok || !version || !versionSatisfies(version, requestedVersion)) return null;
+			if (runtime === "node") {
+				const npm = manifest.executables.npm;
+				const npx = manifest.executables.npx;
+				if (!npm || !npx) return null;
+				const [npmProbe, npxProbe] = await Promise.all([runRuntimeCommand({
+					command: npm,
+					args: ["--version"]
+				}), runRuntimeCommand({
+					command: npx,
+					args: ["--version"]
+				})]);
+				if (!npmProbe.ok || !npxProbe.ok) return null;
+			}
+			return {
+				runtime,
+				version,
+				source: "managed",
+				executable: manifest.executables.primary,
+				executables: manifest.executables,
+				installDir: manifest.installDir
+			};
+		} catch {
+			return null;
+		}
+	}
+	async install(runtime, version = this.defaultVersion(runtime), signal) {
+		const config = runtimeConfig(this.options, runtime);
+		if (!this.options.config.enabled || !config.enabled) throw new RuntimeError(`${runtime} runtime is disabled`, "RUNTIME_DISABLED", runtime, "install", false);
+		if (runtime === "python") return await this.installPython(version, signal);
+		return await this.installDistribution(runtime, version, signal);
+	}
+	async installDistribution(runtime, version, signal) {
+		const platform = detectRuntimePlatform();
+		if (!platform) throw new RuntimeError(`Managed ${runtime} is not supported on ${process.platform}-${process.arch}`, "RUNTIME_UNSUPPORTED", runtime, "resolve_asset", false);
+		const operationId = randomUUID();
+		const asset = resolveRuntimeAsset({
+			runtime,
+			version,
+			platform
+		});
+		const installDir = runtimeVersionDir(this.options.stateDir, runtime, version);
+		return await withInstallLock(runtimeLockPath(this.options.stateDir, runtime, version), {
+			operationId,
+			runtime,
+			version
+		}, async () => {
+			const ready = await this.probeManaged(runtime, version);
+			if (ready) return ready;
+			this.progress({
+				operationId,
+				runtime,
+				phase: "resolve",
+				message: `Preparing ${runtime} ${version}`
+			});
+			const offline = this.options.config.download.bundleDir ? await resolveOfflineBundleArtifact({
+				bundleDir: this.options.config.download.bundleDir,
+				runtime,
+				archiveFile: asset.archiveFile
+			}) : null;
+			let selectedDownload = offline ? null : await resolveRuntimeDownloadSource({
+				asset,
+				platform,
+				config: this.options.config.download,
+				signal,
+				onFallback: (message) => this.progress({
+					operationId,
+					runtime,
+					phase: "resolve",
+					message
+				})
+			});
+			let expectedSha256 = offline?.sha256 ?? selectedDownload.sha256;
+			let archivePath;
+			if (offline) archivePath = offline.archivePath;
+			else {
+				const download = async () => await downloadVerifiedArchive({
+					runtime,
+					url: selectedDownload.url,
+					targetPath: runtimeDownloadPath(this.options.stateDir, asset.archiveFile),
+					expectedSha256,
+					timeoutMs: this.options.config.download.timeoutMs,
+					proxy: this.options.config.download.proxy,
+					signal,
+					onProgress: (downloadedBytes, totalBytes) => this.progress({
+						operationId,
+						runtime,
+						phase: "download",
+						message: `Downloading ${runtime} ${version}`,
+						downloadedBytes,
+						totalBytes
+					})
+				});
+				try {
+					archivePath = await download();
+				} catch (error) {
+					if (signal?.aborted || this.options.config.download.source !== "auto" || selectedDownload.source !== "website" || !canFallbackRuntimeDownload(error)) throw error;
+					this.progress({
+						operationId,
+						runtime,
+						phase: "resolve",
+						message: `Runtime gateway download failed; downloading ${runtime} directly`
+					});
+					selectedDownload = await resolveRuntimeDownloadSource({
+						asset,
+						platform,
+						config: {
+							...this.options.config.download,
+							source: "direct-only"
+						},
+						signal
+					});
+					expectedSha256 = selectedDownload.sha256;
+					archivePath = await download();
+				}
+			}
+			const stagingDir = runtimeStagingDir(this.options.stateDir, runtime, version, operationId);
+			this.progress({
+				operationId,
+				runtime,
+				phase: "extract",
+				message: `Extracting ${runtime} ${version}`
+			});
+			await atomicInstallRuntime(await extractRuntimeArchive({
+				runtime,
+				archivePath,
+				archiveType: asset.archiveType,
+				stagingDir
+			}), installDir);
+			await rm(stagingDir, {
+				recursive: true,
+				force: true
+			});
+			const executables = runtime === "node" ? nodeExecutables(installDir) : uvExecutables(installDir);
+			const probe = await runRuntimeCommand({
+				command: executables.primary,
+				args: ["--version"]
+			});
+			const actualVersion = parseRuntimeVersion(`${probe.stdout}\n${probe.stderr}`);
+			if (!probe.ok || !actualVersion || !versionSatisfies(actualVersion, version)) {
+				await rm(installDir, {
+					recursive: true,
+					force: true
+				});
+				throw new RuntimeError(`${runtime} ${version} failed its installation probe`, "RUNTIME_PROBE_FAILED", runtime, "probe", true);
+			}
+			let packageManagerVersion;
+			if (runtime === "node") {
+				const npmProbe = await runRuntimeCommand({
+					command: executables.npm,
+					args: ["--version"]
+				});
+				const npxProbe = await runRuntimeCommand({
+					command: executables.npx,
+					args: ["--version"]
+				});
+				if (!npmProbe.ok || !npxProbe.ok) {
+					await rm(installDir, {
+						recursive: true,
+						force: true
+					});
+					throw new RuntimeError(`Node ${version} is missing npm or npx`, "RUNTIME_PROBE_FAILED", runtime, "probe_package_manager", true);
+				}
+				packageManagerVersion = npmProbe.stdout;
+			}
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const manifest = {
+				schemaVersion: 1,
+				runtime,
+				version: actualVersion,
+				source: "managed",
+				platform: process.platform,
+				arch: process.arch,
+				installDir,
+				executables,
+				installedAt: now,
+				verifiedAt: now,
+				distribution: {
+					url: offline ? `offline:${asset.archiveFile}` : selectedDownload.url,
+					sha256: expectedSha256,
+					archiveFile: asset.archiveFile,
+					catalogVersion: RUNTIME_CATALOG_VERSION
+				},
+				probe: {
+					versionOutput: probe.stdout || probe.stderr,
+					packageManagerVersion
+				}
+			};
+			await writeRuntimeManifest(this.options.stateDir, manifest);
+			this.progress({
+				operationId,
+				runtime,
+				phase: "complete",
+				message: `${runtime} ${actualVersion} is ready`
+			});
+			return {
+				runtime,
+				version: actualVersion,
+				source: "managed",
+				executable: executables.primary,
+				executables,
+				installDir
+			};
+		});
+	}
+	async installPython(version, signal) {
+		const operationId = randomUUID();
+		const installDir = runtimeVersionDir(this.options.stateDir, "python", version);
+		return await withInstallLock(runtimeLockPath(this.options.stateDir, "python", version), {
+			operationId,
+			runtime: "python",
+			version
+		}, async () => {
+			const ready = await this.probeManaged("python", version);
+			if (ready) return ready;
+			if (this.options.config.download.bundleDir) return await this.installBundledPython({
+				version,
+				operationId,
+				installDir,
+				bundleDir: this.options.config.download.bundleDir
+			});
+			const uv = await this.resolve({
+				runtime: "uv",
+				allowProvision: true,
+				signal
+			});
+			await mkdir(dirname(installDir), { recursive: true });
+			const uvEnv = this.uvEnvironment(installDir);
+			this.progress({
+				operationId,
+				runtime: "python",
+				phase: "install",
+				message: `Installing Python ${version}`
+			});
+			const installArgs = [
+				"python",
+				"install",
+				version,
+				"--install-dir",
+				installDir,
+				"--no-config"
+			];
+			const runInstall = async (env) => await runRuntimeCommand({
+				command: uv.executable,
+				args: installArgs,
+				env,
+				timeoutMs: this.options.config.download.timeoutMs,
+				signal
+			});
+			let installProbe = this.options.config.download.source === "direct-only" ? await runInstall(uvEnv) : await runInstall({
+				...uvEnv,
+				UV_PYTHON_INSTALL_MIRROR: runtimeGatewayPythonMirror(this.options.config.download.gatewayBaseUrl)
+			});
+			if (!installProbe.ok && !installProbe.aborted && this.options.config.download.source === "auto" && canFallbackPythonInstall(`${installProbe.stdout}\n${installProbe.stderr}`, installProbe.timedOut)) {
+				this.progress({
+					operationId,
+					runtime: "python",
+					phase: "install",
+					message: `Runtime gateway unavailable; installing Python ${version} directly`
+				});
+				installProbe = await runInstall(uvEnv);
+			}
+			if (!installProbe.ok) throw new RuntimeError(`Python ${version} installation failed: ${installProbe.stderr || installProbe.stdout}`, "RUNTIME_PROBE_FAILED", "python", "install", true);
+			const findProbe = await runRuntimeCommand({
+				command: uv.executable,
+				args: [
+					"python",
+					"find",
+					version,
+					"--managed-python",
+					"--no-config"
+				],
+				env: uvEnv
+			});
+			const python = findProbe.stdout.split(/\r?\n/).find(Boolean)?.trim();
+			if (!findProbe.ok || !python) throw new RuntimeError(`Python ${version} executable was not found after installation`, "RUNTIME_PROBE_FAILED", "python", "find", true);
+			const versionProbe = await runRuntimeCommand({
+				command: python,
+				args: ["-I", "--version"],
+				env: uvEnv
+			});
+			const actualVersion = parseRuntimeVersion(`${versionProbe.stdout}\n${versionProbe.stderr}`);
+			if (!versionProbe.ok || !actualVersion || !versionSatisfies(actualVersion, version)) throw new RuntimeError(`Python ${version} failed its installation probe`, "RUNTIME_PROBE_FAILED", "python", "probe", true);
+			const executables = {
+				primary: python,
+				python
+			};
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			await writeRuntimeManifest(this.options.stateDir, {
+				schemaVersion: 1,
+				runtime: "python",
+				version: actualVersion,
+				source: "managed",
+				platform: process.platform,
+				arch: process.arch,
+				installDir,
+				executables,
+				installedAt: now,
+				verifiedAt: now,
+				probe: { versionOutput: versionProbe.stdout || versionProbe.stderr }
+			});
+			this.progress({
+				operationId,
+				runtime: "python",
+				phase: "complete",
+				message: `Python ${actualVersion} is ready`
+			});
+			return {
+				runtime: "python",
+				version: actualVersion,
+				source: "managed",
+				executable: python,
+				executables,
+				installDir
+			};
+		});
+	}
+	async installBundledPython(params) {
+		const platform = detectRuntimePlatform();
+		if (!platform) throw new RuntimeError(`Managed python is not supported on ${process.platform}-${process.arch}`, "RUNTIME_UNSUPPORTED", "python", "offline_bundle", false);
+		const archiveFile = bundledPythonArchiveName({
+			version: params.version,
+			platform
+		});
+		const artifact = await resolveOfflineBundleArtifact({
+			bundleDir: params.bundleDir,
+			runtime: "python",
+			archiveFile
+		});
+		const stagingDir = runtimeStagingDir(this.options.stateDir, "python", params.version, params.operationId);
+		this.progress({
+			operationId: params.operationId,
+			runtime: "python",
+			phase: "extract",
+			message: `Extracting Python ${params.version} from offline bundle`
+		});
+		await atomicInstallRuntime(await extractRuntimeArchive({
+			runtime: "python",
+			archivePath: artifact.archivePath,
+			archiveType: artifact.archiveType,
+			stagingDir
+		}), params.installDir);
+		await rm(stagingDir, {
+			recursive: true,
+			force: true
+		});
+		const candidates = process.platform === "win32" ? [join(params.installDir, "python.exe")] : [join(params.installDir, "bin", "python3"), join(params.installDir, "bin", "python")];
+		let python;
+		for (const candidate of candidates) try {
+			await access(candidate);
+			python = candidate;
+			break;
+		} catch {}
+		if (!python) {
+			await rm(params.installDir, {
+				recursive: true,
+				force: true
+			});
+			throw new RuntimeError(`Offline Python ${params.version} has no Python executable`, "RUNTIME_PROBE_FAILED", "python", "probe", true);
+		}
+		const probe = await runRuntimeCommand({
+			command: python,
+			args: ["-I", "--version"]
+		});
+		const actualVersion = parseRuntimeVersion(`${probe.stdout}\n${probe.stderr}`);
+		if (!probe.ok || !actualVersion || !versionSatisfies(actualVersion, params.version)) {
+			await rm(params.installDir, {
+				recursive: true,
+				force: true
+			});
+			throw new RuntimeError(`Offline Python ${params.version} failed its installation probe`, "RUNTIME_PROBE_FAILED", "python", "probe", true);
+		}
+		const executables = {
+			primary: python,
+			python
+		};
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await writeRuntimeManifest(this.options.stateDir, {
+			schemaVersion: 1,
+			runtime: "python",
+			version: actualVersion,
+			source: "managed",
+			platform: process.platform,
+			arch: process.arch,
+			installDir: params.installDir,
+			executables,
+			installedAt: now,
+			verifiedAt: now,
+			distribution: {
+				url: `offline:${artifact.archiveFile}`,
+				sha256: artifact.sha256,
+				archiveFile: artifact.archiveFile,
+				catalogVersion: RUNTIME_CATALOG_VERSION
+			},
+			probe: { versionOutput: probe.stdout || probe.stderr }
+		});
+		this.progress({
+			operationId: params.operationId,
+			runtime: "python",
+			phase: "complete",
+			message: `Python ${actualVersion} is ready`
+		});
+		return {
+			runtime: "python",
+			version: actualVersion,
+			source: "managed",
+			executable: python,
+			executables,
+			installDir: params.installDir
+		};
+	}
+	uvEnvironment(pythonInstallDir) {
+		const toolsRoot = runtimeToolsRoot(this.options.stateDir);
+		const env = {
+			...process.env,
+			UV_PYTHON_INSTALL_DIR: pythonInstallDir,
+			UV_PYTHON_BIN_DIR: join(toolsRoot, "python", "bin"),
+			UV_CACHE_DIR: join(toolsRoot, "cache", "uv"),
+			UV_MANAGED_PYTHON: "1",
+			UV_NO_CONFIG: "1",
+			UV_HTTP_TIMEOUT: String(Math.ceil(this.options.config.download.timeoutMs / 1e3))
+		};
+		delete env.UV_PYTHON_INSTALL_MIRROR;
+		if (this.options.config.download.proxy) {
+			env.HTTP_PROXY = this.options.config.download.proxy;
+			env.HTTPS_PROXY = this.options.config.download.proxy;
+		}
+		return env;
+	}
+	async status(runtime) {
+		const config = runtimeConfig(this.options, runtime);
+		const requestedVersion = this.defaultVersion(runtime);
+		if (!this.options.config.enabled || !config.enabled) return {
+			runtime,
+			state: "disabled",
+			requestedVersion,
+			message: "Runtime is disabled",
+			repairable: false
+		};
+		try {
+			const resolved = await this.resolve({
+				runtime,
+				version: requestedVersion,
+				allowProvision: false
+			});
+			return {
+				runtime,
+				state: "ready",
+				requestedVersion,
+				resolved,
+				message: `${runtime} ${resolved.version} is ready (${resolved.source})`,
+				repairable: false
+			};
+		} catch {}
+		if (await readRuntimeManifest(this.options.stateDir, runtime)) return {
+			runtime,
+			state: "corrupted",
+			requestedVersion,
+			message: `${runtime} managed installation is incomplete or invalid`,
+			repairable: true
+		};
+		return {
+			runtime,
+			state: "absent",
+			requestedVersion,
+			message: `${runtime} ${requestedVersion} is not installed`,
+			repairable: true
+		};
+	}
+	async statusAll() {
+		return await Promise.all([
+			"node",
+			"uv",
+			"python"
+		].map((runtime) => this.status(runtime)));
+	}
+	async repair(runtime) {
+		const version = this.defaultVersion(runtime);
+		const installDir = runtimeVersionDir(this.options.stateDir, runtime, version);
+		const backupDir = `${installDir}.repair-backup-${randomUUID()}`;
+		let hasBackup = false;
+		try {
+			await rename(installDir, backupDir);
+			hasBackup = true;
+		} catch {}
+		try {
+			const resolved = await this.install(runtime, version);
+			if (hasBackup) await rm(backupDir, {
+				recursive: true,
+				force: true
+			});
+			return resolved;
+		} catch (error) {
+			if (hasBackup) {
+				await rm(installDir, {
+					recursive: true,
+					force: true
+				});
+				await rename(backupDir, installDir);
+			}
+			throw error;
+		}
+	}
+	progress(event) {
+		this.emit("progress", event);
+		log.info({
+			operationId: event.operationId,
+			runtime: event.runtime,
+			phase: event.phase,
+			downloadedBytes: event.downloadedBytes,
+			totalBytes: event.totalBytes
+		}, event.message);
+	}
+};
+//#endregion
+export { ManagedRuntimeManager };

package/dist/src/runtime-tools/manifest-store.d.ts

@@ -0,0 +1,3 @@
+import type { InstalledRuntimeManifest, RuntimeKind } from './types.js';
+export declare function readRuntimeManifest(stateDir: string, runtime: RuntimeKind): Promise<InstalledRuntimeManifest | null>;
+export declare function writeRuntimeManifest(stateDir: string, manifest: InstalledRuntimeManifest): Promise<void>;

package/dist/src/runtime-tools/manifest-store.js

@@ -0,0 +1,26 @@
+import { runtimeManifestPath } from "./paths.js";
+import { dirname } from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+//#region src/runtime-tools/manifest-store.ts
+function isManifest(value, runtime) {
+	if (!value || typeof value !== "object") return false;
+	const item = value;
+	return item.schemaVersion === 1 && item.runtime === runtime && typeof item.version === "string" && typeof item.installDir === "string" && !!item.executables && typeof item.executables.primary === "string";
+}
+async function readRuntimeManifest(stateDir, runtime) {
+	try {
+		const parsed = JSON.parse(await readFile(runtimeManifestPath(stateDir, runtime), "utf8"));
+		return isManifest(parsed, runtime) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+async function writeRuntimeManifest(stateDir, manifest) {
+	const target = runtimeManifestPath(stateDir, manifest.runtime);
+	await mkdir(dirname(target), { recursive: true });
+	const temporary = `${target}.${process.pid}.tmp`;
+	await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 384 });
+	await rename(temporary, target);
+}
+//#endregion
+export { readRuntimeManifest, writeRuntimeManifest };

package/dist/src/runtime-tools/network.d.ts

@@ -0,0 +1,9 @@
+import { type RequestInit, type Response } from 'undici';
+export declare function fetchRuntimeResource(params: {
+    url: string;
+    timeoutMs: number;
+    proxy?: string;
+    signal?: AbortSignal;
+    init?: Omit<RequestInit, 'dispatcher' | 'signal'>;
+}): Promise<Response>;
+export declare function readRuntimeResponseText(response: Response, maxBytes: number): Promise<string>;