@mawesome/npm-vm 0.0.0-alpha.0 → 0.1.0

package/dist/runtime/journal-_bs-eJRJ.cjs

@@ -0,0 +1,282 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BGT596CS.cjs");
+const require_proc = require("./proc-hB8N9WjN.cjs");
+const require_lease = require("./lease-HBD4CmBx.cjs");
+const require_atomic = require("./atomic-C3shKdH9.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_crypto = require("node:crypto");
+//#region src/state/meta.ts
+function sha256(content) {
+	return (0, node_crypto.createHash)("sha256").update(content).digest("hex");
+}
+function isUtf8(content) {
+	return !content.includes(0) && Buffer.from(content.toString("utf8"), "utf8").equals(content);
+}
+function lineEndingsOf(text) {
+	const crlf = (text.match(/\r\n/g) ?? []).length;
+	const lf = (text.match(/\n/g) ?? []).length - crlf;
+	if (crlf === 0 && lf === 0) return "none";
+	if (crlf > 0 && lf > 0) return "mixed";
+	return crlf > 0 ? "crlf" : "lf";
+}
+const MISSING = {
+	type: "missing",
+	mode: 0,
+	sha256: null,
+	encoding: null,
+	lineEndings: null,
+	symlinkTarget: null
+};
+/** Captures `path` without following symlinks; a missing path is a valid state, not an error. */
+function captureMeta(path) {
+	let stat;
+	try {
+		stat = (0, node_fs.lstatSync)(path);
+	} catch {
+		return MISSING;
+	}
+	const mode = process.platform === "win32" ? 0 : stat.mode & 4095;
+	if (stat.isSymbolicLink()) return {
+		type: "symlink",
+		mode,
+		sha256: null,
+		encoding: null,
+		lineEndings: null,
+		symlinkTarget: (0, node_fs.readlinkSync)(path)
+	};
+	if (stat.isDirectory()) return {
+		type: "directory",
+		mode,
+		sha256: null,
+		encoding: null,
+		lineEndings: null,
+		symlinkTarget: null
+	};
+	if (!stat.isFile()) return {
+		type: "other",
+		mode,
+		sha256: null,
+		encoding: null,
+		lineEndings: null,
+		symlinkTarget: null
+	};
+	const content = (0, node_fs.readFileSync)(path);
+	const utf8 = isUtf8(content);
+	return {
+		type: "file",
+		mode,
+		sha256: sha256(content),
+		encoding: utf8 ? "utf8" : "binary",
+		lineEndings: utf8 ? lineEndingsOf(content.toString("utf8")) : null,
+		symlinkTarget: null
+	};
+}
+/** Whether the path still holds exactly what `meta` recorded (spec MUT-5): same type, same bytes or link target. */
+function metaMatches(path, meta) {
+	const now = captureMeta(path);
+	return now.type === meta.type && now.sha256 === meta.sha256 && now.symlinkTarget === meta.symlinkTarget;
+}
+//#endregion
+//#region src/state/journal.ts
+var journal_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	hasJournals: () => hasJournals,
+	journalPath: () => journalPath,
+	listJournals: () => listJournals,
+	mutateFile: () => mutateFile,
+	readJournal: () => readJournal,
+	recoverDeadJournals: () => recoverDeadJournals,
+	recoverForeignJournal: () => recoverForeignJournal,
+	recoverJournal: () => recoverJournal
+});
+function journalPath(journalDir, id) {
+	return (0, node_path.join)(journalDir, `${id}.json`);
+}
+function readJournal(file) {
+	try {
+		const parsed = JSON.parse((0, node_fs.readFileSync)(file, "utf8"));
+		return typeof parsed.id === "string" && typeof parsed.target === "string" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function listJournals(journalDir) {
+	let names;
+	try {
+		names = (0, node_fs.readdirSync)(journalDir);
+	} catch {
+		return [];
+	}
+	return names.filter((name) => name.endsWith(".json")).map((name) => readJournal((0, node_path.join)(journalDir, name))).filter((journal) => journal !== null);
+}
+function hasJournals(journalDir) {
+	return listJournals(journalDir).length > 0;
+}
+/**
+* Applies one file change under a journal: backup and staged copy first, the journal, then the write.
+* The journal and its sidecars disappear only after the target holds the intended bytes.
+*/
+function mutateFile(journalDir, kind, owner, target, content, mode = 420) {
+	(0, node_fs.mkdirSync)(journalDir, {
+		recursive: true,
+		mode: 448
+	});
+	const id = `${kind}-${require_lease.newToken()}`;
+	const original = captureMeta(target);
+	let backup = null;
+	if (original.type === "file") {
+		backup = (0, node_path.join)(journalDir, `${id}.bak`);
+		(0, node_fs.copyFileSync)(target, backup);
+	}
+	let staged = null;
+	if (content !== null) {
+		staged = (0, node_path.join)(journalDir, `${id}.new`);
+		require_atomic.atomicWrite(staged, content, 384);
+	}
+	const journal = {
+		id,
+		kind,
+		owner,
+		target,
+		original,
+		intended: content === null ? null : sha256(content),
+		staged,
+		backup,
+		mode,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	require_atomic.atomicWrite(journalPath(journalDir, id), JSON.stringify(journal), 384);
+	apply(journal, content);
+	discard(journalDir, journal);
+}
+function apply(journal, content) {
+	if (content === null) {
+		require_atomic.withSharingRetry(() => {
+			if ((0, node_fs.existsSync)(journal.target)) (0, node_fs.unlinkSync)(journal.target);
+		});
+		return;
+	}
+	require_atomic.atomicWrite(journal.target, content, journal.mode);
+}
+function discard(journalDir, journal) {
+	for (const sidecar of [journal.backup, journal.staged]) if (sidecar !== null) (0, node_fs.rmSync)(sidecar, { force: true });
+	(0, node_fs.rmSync)(journalPath(journalDir, journal.id), { force: true });
+}
+function targetSha(target) {
+	const meta = captureMeta(target);
+	return meta.type === "file" ? meta.sha256 : null;
+}
+/**
+* Finishes one journal (spec MUT-2): a target already at the intended bytes is done; one still at the
+* original is replayed from the staged copy; anything else is left alone and reported as changed (MUT-5).
+*/
+function recoverJournal(journalDir, journal, report) {
+	const current = targetSha(journal.target);
+	const exists = captureMeta(journal.target).type !== "missing";
+	if (journal.intended === null ? !exists : current === journal.intended) {
+		discard(journalDir, journal);
+		report.finished.push(journal.id);
+		return;
+	}
+	if (metaMatches(journal.target, journal.original)) {
+		if (journal.intended === null) {
+			apply(journal, null);
+			report.replayed.push(journal.id);
+		} else if (journal.staged !== null && (0, node_fs.existsSync)(journal.staged) && sha256((0, node_fs.readFileSync)(journal.staged)) === journal.intended) {
+			apply(journal, (0, node_fs.readFileSync)(journal.staged));
+			report.replayed.push(journal.id);
+		} else report.rolledBack.push(journal.id);
+		discard(journalDir, journal);
+		return;
+	}
+	report.changed.push(journal.target);
+	discard(journalDir, journal);
+}
+/** Recovers every journal whose owner is dead on this machine; foreign and live ones are skipped. */
+function recoverDeadJournals(journalDir, machineId, kinds) {
+	const report = {
+		finished: [],
+		replayed: [],
+		rolledBack: [],
+		changed: [],
+		skipped: []
+	};
+	for (const journal of listJournals(journalDir)) {
+		if (kinds !== void 0 && !kinds.includes(journal.kind)) continue;
+		if (journal.owner.machineId !== machineId || require_proc.isLive(journal.owner)) {
+			report.skipped.push(journal.id);
+			continue;
+		}
+		recoverJournal(journalDir, journal, report);
+	}
+	return report;
+}
+/** Recovers one journal the operator vouched for, whatever machine owns it (the `recover` command). */
+function recoverForeignJournal(journalDir, id, confirmedMachineId) {
+	const report = {
+		finished: [],
+		replayed: [],
+		rolledBack: [],
+		changed: [],
+		skipped: []
+	};
+	const journal = readJournal(journalPath(journalDir, id));
+	if (journal === null) throw new Error(`no journal ${id} in ${journalDir}`);
+	if (journal.owner.machineId !== confirmedMachineId) throw new Error(`journal ${id} belongs to machine ${journal.owner.machineId}, not ${confirmedMachineId}`);
+	recoverJournal(journalDir, journal, report);
+	return report;
+}
+//#endregion
+Object.defineProperty(exports, "MISSING", {
+	enumerable: true,
+	get: function() {
+		return MISSING;
+	}
+});
+Object.defineProperty(exports, "captureMeta", {
+	enumerable: true,
+	get: function() {
+		return captureMeta;
+	}
+});
+Object.defineProperty(exports, "journal_exports", {
+	enumerable: true,
+	get: function() {
+		return journal_exports;
+	}
+});
+Object.defineProperty(exports, "listJournals", {
+	enumerable: true,
+	get: function() {
+		return listJournals;
+	}
+});
+Object.defineProperty(exports, "metaMatches", {
+	enumerable: true,
+	get: function() {
+		return metaMatches;
+	}
+});
+Object.defineProperty(exports, "mutateFile", {
+	enumerable: true,
+	get: function() {
+		return mutateFile;
+	}
+});
+Object.defineProperty(exports, "recoverDeadJournals", {
+	enumerable: true,
+	get: function() {
+		return recoverDeadJournals;
+	}
+});
+Object.defineProperty(exports, "recoverForeignJournal", {
+	enumerable: true,
+	get: function() {
+		return recoverForeignJournal;
+	}
+});
+Object.defineProperty(exports, "sha256", {
+	enumerable: true,
+	get: function() {
+		return sha256;
+	}
+});

package/dist/runtime/launchers/cmd.tmpl

@@ -0,0 +1,2 @@
+@rem npm-vm launcher abi={{ABI}}
+@for %%i in (node.exe) do @if "%%~$PATH:i"=="" (echo npm-vm: node.exe is not on PATH 1>&2 & exit /b 1) else @"%%~$PATH:i" "{{BOOTSTRAP}}" {{SELECTOR}} %*

package/dist/runtime/launchers/ps1.tmpl

@@ -0,0 +1,5 @@
+# npm-vm launcher abi={{ABI}}
+$node = Get-Command node.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
+if (-not $node) { [Console]::Error.WriteLine('npm-vm: node.exe is not on PATH'); exit 1 }
+& $node.Source '{{BOOTSTRAP}}' {{SELECTOR}} @args
+exit $LASTEXITCODE

package/dist/runtime/launchers/sh.tmpl

@@ -0,0 +1,3 @@
+#!/bin/sh
+# npm-vm launcher abi={{ABI}}
+exec node "{{BOOTSTRAP}}" {{SELECTOR}} "$@"

package/dist/runtime/lease-HBD4CmBx.cjs

@@ -0,0 +1,224 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BGT596CS.cjs");
+const require_proc = require("./proc-hB8N9WjN.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_crypto = require("node:crypto");
+let node_os = require("node:os");
+//#region src/state/lease.ts
+var lease_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	acquireShared: () => acquireShared,
+	createGate: () => createGate,
+	createLease: () => createLease,
+	gatePath: () => gatePath,
+	leaseSurvived: () => leaseSurvived,
+	leasesDir: () => leasesDir,
+	listLeases: () => listLeases,
+	newToken: () => newToken,
+	ownerLive: () => ownerLive,
+	ownerRecord: () => ownerRecord,
+	readOwner: () => readOwner,
+	removeGate: () => removeGate
+});
+function leasesDir(entry) {
+	return `${entry}.leases`;
+}
+function gatePath(entry) {
+	return `${entry}.prune`;
+}
+function newToken() {
+	return (0, node_crypto.randomBytes)(8).toString("hex");
+}
+function ownerRecord(machineId, identity = require_proc.ownIdentity()) {
+	return {
+		...identity,
+		host: (0, node_os.hostname)(),
+		machineId,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function readOwner(file) {
+	try {
+		const parsed = JSON.parse((0, node_fs.readFileSync)(file, "utf8"));
+		if (typeof parsed.pid !== "number") return null;
+		return {
+			pid: parsed.pid,
+			start: typeof parsed.start === "string" ? parsed.start : null,
+			host: typeof parsed.host === "string" ? parsed.host : "?",
+			machineId: typeof parsed.machineId === "string" ? parsed.machineId : "?",
+			createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : ""
+		};
+	} catch {
+		return null;
+	}
+}
+/** A file in the per-machine cache belongs to a dead owner only when PROC-1 says so; unreadable means live. */
+function ownerLive(file) {
+	const owner = readOwner(file);
+	return owner === null ? true : require_proc.isLive(owner);
+}
+/** Creates a shared lease on `entry`; the file name is unique, so a prune can never delete a live one by mistake. */
+function createLease(entry, owner) {
+	const dir = leasesDir(entry);
+	for (let attempt = 0;; attempt += 1) {
+		(0, node_fs.mkdirSync)(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const path = (0, node_path.join)(dir, newToken());
+		try {
+			(0, node_fs.writeFileSync)(path, JSON.stringify(owner), {
+				mode: 384,
+				flag: "wx"
+			});
+		} catch (error) {
+			(0, node_fs.rmSync)(path, { force: true });
+			if (error.code === "ENOENT" && attempt < 3) continue;
+			throw error;
+		}
+		return {
+			path,
+			release() {
+				(0, node_fs.rmSync)(path, { force: true });
+			}
+		};
+	}
+}
+/**
+* Whether a lease created before a gate check is still in place (spec LEASE-1).
+* A prune that passed its own lease check first moves the whole leases dir away, taking the file with it.
+*/
+function leaseSurvived(lease) {
+	return (0, node_fs.existsSync)(lease.path);
+}
+function listLeases(entry) {
+	try {
+		return (0, node_fs.readdirSync)(leasesDir(entry)).map((name) => (0, node_path.join)(leasesDir(entry), name));
+	} catch {
+		return [];
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const GATE_WAIT_MS = 5e3;
+/**
+* The runtime's shared lease (spec LEASE-1): lease first, then look for a live prune gate.
+* A live gate means the entry is going away: wait briefly, retry once, else return null so the caller fetches a private entry.
+*/
+async function acquireShared(entry, owner, options = {}) {
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const lease = createLease(entry, owner);
+		const gate = gatePath(entry);
+		let gated = false;
+		try {
+			gated = ownerLive(gate);
+		} catch {
+			gated = false;
+		}
+		if (!gated || !gateExists(gate)) {
+			if (leaseSurvived(lease)) return lease;
+			continue;
+		}
+		lease.release();
+		const deadline = Date.now() + (options.waitMs ?? GATE_WAIT_MS);
+		while (Date.now() < deadline && gateExists(gate)) await sleep(50);
+	}
+	return null;
+}
+function gateExists(gate) {
+	try {
+		return readOwner(gate) !== null;
+	} catch {
+		return false;
+	}
+}
+/** Creates the prune gate with O_EXCL; false when another gate exists (there is only ever one prune, so a leftover). */
+function createGate(entry, owner) {
+	try {
+		(0, node_fs.writeFileSync)(gatePath(entry), JSON.stringify(owner), {
+			flag: "wx",
+			mode: 384
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") return false;
+		(0, node_fs.rmSync)(gatePath(entry), { force: true });
+		throw error;
+	}
+	return true;
+}
+function removeGate(entry) {
+	(0, node_fs.rmSync)(gatePath(entry), { force: true });
+}
+//#endregion
+Object.defineProperty(exports, "acquireShared", {
+	enumerable: true,
+	get: function() {
+		return acquireShared;
+	}
+});
+Object.defineProperty(exports, "createGate", {
+	enumerable: true,
+	get: function() {
+		return createGate;
+	}
+});
+Object.defineProperty(exports, "createLease", {
+	enumerable: true,
+	get: function() {
+		return createLease;
+	}
+});
+Object.defineProperty(exports, "gatePath", {
+	enumerable: true,
+	get: function() {
+		return gatePath;
+	}
+});
+Object.defineProperty(exports, "leaseSurvived", {
+	enumerable: true,
+	get: function() {
+		return leaseSurvived;
+	}
+});
+Object.defineProperty(exports, "lease_exports", {
+	enumerable: true,
+	get: function() {
+		return lease_exports;
+	}
+});
+Object.defineProperty(exports, "leasesDir", {
+	enumerable: true,
+	get: function() {
+		return leasesDir;
+	}
+});
+Object.defineProperty(exports, "listLeases", {
+	enumerable: true,
+	get: function() {
+		return listLeases;
+	}
+});
+Object.defineProperty(exports, "newToken", {
+	enumerable: true,
+	get: function() {
+		return newToken;
+	}
+});
+Object.defineProperty(exports, "ownerLive", {
+	enumerable: true,
+	get: function() {
+		return ownerLive;
+	}
+});
+Object.defineProperty(exports, "ownerRecord", {
+	enumerable: true,
+	get: function() {
+		return ownerRecord;
+	}
+});
+Object.defineProperty(exports, "removeGate", {
+	enumerable: true,
+	get: function() {
+		return removeGate;
+	}
+});

package/dist/runtime/lock-DBeYN-Zg.cjs

@@ -0,0 +1,141 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BGT596CS.cjs");
+const require_messages = require("./messages-vUDkl1-0.cjs");
+const require_proc = require("./proc-hB8N9WjN.cjs");
+const require_lease = require("./lease-HBD4CmBx.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+//#region src/state/lock.ts
+var lock_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	LOCK_FILE: () => LOCK_FILE,
+	acquireLock: () => acquireLock,
+	lockOwnerLive: () => lockOwnerLive,
+	lockPath: () => lockPath,
+	readLock: () => readLock,
+	tryLock: () => tryLock
+});
+const LOCK_FILE = "lock";
+const WAIT_LIMIT_MS = 1e4;
+function lockPath(stateDir) {
+	return (0, node_path.join)(stateDir, LOCK_FILE);
+}
+function readLock(stateDir) {
+	try {
+		const parsed = JSON.parse((0, node_fs.readFileSync)(lockPath(stateDir), "utf8"));
+		if (typeof parsed.pid !== "number" || typeof parsed.token !== "string") return null;
+		return {
+			pid: parsed.pid,
+			start: typeof parsed.start === "string" ? parsed.start : null,
+			host: typeof parsed.host === "string" ? parsed.host : "?",
+			machineId: typeof parsed.machineId === "string" ? parsed.machineId : "?",
+			createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : "",
+			token: parsed.token
+		};
+	} catch {
+		return null;
+	}
+}
+/** Whether the lock owner can be shown to be dead: only on this machine, and only by PROC-1. */
+function lockOwnerLive(record, machineId) {
+	if (record === null) return true;
+	if (record.machineId !== machineId) return true;
+	return require_proc.isLive(record);
+}
+function tryCreate(path, record) {
+	try {
+		(0, node_fs.writeFileSync)(path, JSON.stringify(record), {
+			flag: "wx",
+			mode: 384
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") return false;
+		(0, node_fs.rmSync)(path, { force: true });
+		throw error;
+	}
+	return true;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Takes the exclusive lock (spec MUT-1): created with O_EXCL, released only by its owner, never reclaimed.
+* Waits with backoff for up to 10 s, then fails with M-LOCKED naming the file and whether the owner is live.
+*/
+async function acquireLock(stateDir, owner, options = {}) {
+	(0, node_fs.mkdirSync)(stateDir, {
+		recursive: true,
+		mode: 448
+	});
+	const path = lockPath(stateDir);
+	const record = {
+		...owner,
+		token: require_lease.newToken()
+	};
+	const deadline = Date.now() + (options.waitMs ?? WAIT_LIMIT_MS);
+	let delay = 50;
+	for (;;) {
+		if (tryCreate(path, record)) return {
+			path,
+			release() {
+				if (readLock(stateDir)?.token === record.token) (0, node_fs.rmSync)(path, { force: true });
+			}
+		};
+		if (Date.now() + delay > deadline) {
+			const holder = readLock(stateDir);
+			const foreign = holder !== null && holder.machineId !== owner.machineId;
+			const live = lockOwnerLive(holder, owner.machineId);
+			throw new require_messages.NpmVmError("M-LOCKED", require_messages.EXIT.problems, require_messages.lockedMessage(path, holder, live, foreign));
+		}
+		await sleep(delay);
+		delay = Math.min(delay * 2, 1e3);
+	}
+}
+/** One attempt, no waiting; for the launcher's recovery check, which must never delay npm. */
+function tryLock(stateDir, owner) {
+	(0, node_fs.mkdirSync)(stateDir, {
+		recursive: true,
+		mode: 448
+	});
+	const path = lockPath(stateDir);
+	const record = {
+		...owner,
+		token: require_lease.newToken()
+	};
+	if (!tryCreate(path, record)) return null;
+	return {
+		path,
+		release() {
+			if (readLock(stateDir)?.token === record.token) (0, node_fs.rmSync)(path, { force: true });
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "acquireLock", {
+	enumerable: true,
+	get: function() {
+		return acquireLock;
+	}
+});
+Object.defineProperty(exports, "lockOwnerLive", {
+	enumerable: true,
+	get: function() {
+		return lockOwnerLive;
+	}
+});
+Object.defineProperty(exports, "lockPath", {
+	enumerable: true,
+	get: function() {
+		return lockPath;
+	}
+});
+Object.defineProperty(exports, "lock_exports", {
+	enumerable: true,
+	get: function() {
+		return lock_exports;
+	}
+});
+Object.defineProperty(exports, "readLock", {
+	enumerable: true,
+	get: function() {
+		return readLock;
+	}
+});