@stim-cli/core 1.6.0 → 1.8.0-rc.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { S as quotedPath, _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-DGxNcAcy.mjs";
+import { S as quotedPath, _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-Cn3NHqBS.mjs";
 import fs, { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path, { basename, dirname, join } from "node:path";
@@ -11,12 +11,20 @@ const OWNER_MARKER = /^\.stim-claim-[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-
 function sleepSync(ms) {
 	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+/**
+* Whether Windows refused a call on the lock directory because another process is removing it at that
+* moment. NTFS answers ERROR_ACCESS_DENIED, which Node reports as EPERM, until that removal completes,
+* where POSIX answers EEXIST or ENOENT: https://github.com/appandflow/stim/issues/883.
+*/
+function removalInFlight(error) {
+	return process.platform === "win32" && error?.code === "EPERM";
+}
 function createLockDirectory(lockPath) {
 	try {
 		mkdirSync(lockPath);
 		return true;
 	} catch (error) {
-		if (error?.code === "EEXIST") return false;
+		if (error?.code === "EEXIST" || removalInFlight(error)) return false;
 		throw error;
 	}
 }
@@ -24,7 +32,7 @@ function removeLockDirectory(lockPath, marker) {
 	try {
 		unlinkSync(marker);
 	} catch (error) {
-		if (error?.code === "ENOENT") return false;
+		if (error?.code === "ENOENT" || removalInFlight(error)) return false;
 		throw error;
 	}
 	try {
@@ -36,6 +44,7 @@ function removeLockDirectory(lockPath, marker) {
 			"ENOTEMPTY",
 			"EEXIST"
 		].includes(error?.code ?? "")) return false;
+		if (removalInFlight(error)) return false;
 		throw error;
 	}
 }
@@ -45,7 +54,7 @@ function takeLockDirectory(lockPath, claim) {
 		try {
 			entries = readdirSync(lockPath);
 		} catch (error) {
-			if (error?.code === "ENOENT") return null;
+			if (error?.code === "ENOENT" || removalInFlight(error)) return null;
 			throw error;
 		}
 		const name = entries.length === 1 ? entries[0] : void 0;
@@ -55,7 +64,7 @@ function takeLockDirectory(lockPath, claim) {
 		try {
 			entry = lstatSync(marker);
 		} catch (error) {
-			if (error?.code === "ENOENT") return null;
+			if (error?.code === "ENOENT" || removalInFlight(error)) return null;
 			throw error;
 		}
 		if (!entry.isFile() || entry.size !== 0) throw new ClaimRefusedError({
@@ -212,7 +221,7 @@ function workspaceLogDir(projectRoot) {
 function cachePathSetting(key) {
 	try {
 		const value = JSON.parse(fs.readFileSync(path.join(configDir(), "config.json"), "utf-8"))?.caches?.[key];
-		return typeof value === "string" && value.startsWith("/") ? value : null;
+		return typeof value === "string" && path.isAbsolute(value) ? value : null;
 	} catch {
 		return null;
 	}

package/dist/{ownership-claim-DGxNcAcy.mjs → ownership-claim-Cn3NHqBS.mjs}

@@ -2,6 +2,7 @@ import { captureProcessIdentity, inspectProcessIdentity } from "./process-identi
 import { lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
+import { debuglog } from "node:util";
 //#region quoted-path.ts
 /** Quote a path for a shell command Stim prints for a human to copy and run. */
 function quotedPath(path) {
@@ -17,6 +18,9 @@ const CLAIM_SUFFIX = ".claim";
 const CHILD_SUFFIX = ".child";
 const STAGING_PREFIX = ".staging-";
 const PUBLISH_ATTEMPTS = 64;
+const WIN32_SETTLE_MS = 250;
+const WIN32_SETTLE_STEP_MS = 5;
+const debug = debuglog("stim:claim");
 var ClaimRefusedError = class extends Error {
 	code = CLAIM_REFUSED;
 	claimPath;
@@ -37,7 +41,7 @@ var ClaimUnavailableError = class extends Error {
 	constructor(reason, { claimPath } = {}) {
 		super(claimPath ? `Stim could not write the ownership claim at ${claimPath}: ${reason}.` : `Stim could not record a process identity, so it cannot take an ownership claim: ${reason}.`);
 		this.reason = reason;
-		this.remedy = claimPath ? `Restore write access to the existing claim store at ${quotedPath(claimPath)} (check parent permissions, symlink targets, mount access and sandbox rules)` : "Reinstall Stim so the unique-pid native module for this platform is present";
+		this.remedy = claimPath ? `Restore write access to the existing claim store at ${quotedPath(claimPath)} (check parent permissions, an antivirus or endpoint agent holding its files, symlink targets, mount access and sandbox rules)` : "Reinstall Stim so the unique-pid native module for this platform is present";
 	}
 };
 /**
@@ -88,10 +92,40 @@ function asOwner(record) {
 		processToken: candidate.processToken
 	};
 }
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+* Run a read, listing or removal and resolve the one answer Windows leaves ambiguous. NTFS answers
+* ERROR_ACCESS_DENIED, which Node reports as EPERM, for a name whose removal by another process is still
+* in flight, and for every name below it, where POSIX answers ENOENT; measured to settle within 134 ms
+* with 12 processes on 4 cores (https://github.com/appandflow/stim/issues/883). The call is reissued in
+* small steps for at most WIN32_SETTLE_MS: a result or ENOENT is the settled answer, and an EPERM that
+* outlasts the window is a real denial, thrown exactly as a POSIX EACCES is. This bounds the resolution
+* of an ambiguous OS answer; it never waits on a holder.
+*/
+function settledAnswer(path, call) {
+	if (process.platform !== "win32") return call();
+	const started = Date.now();
+	for (;;) {
+		try {
+			const result = call();
+			if (Date.now() > started) debug("%s settled after %d ms", path, Date.now() - started);
+			return result;
+		} catch (err) {
+			const code = err?.code;
+			if (code !== "EPERM" || Date.now() - started >= WIN32_SETTLE_MS) {
+				if (code === "EPERM") debug("%s still answers EPERM after %d ms", path, Date.now() - started);
+				throw err;
+			}
+		}
+		sleepSync(WIN32_SETTLE_STEP_MS);
+	}
+}
 function readChild(claimPath) {
 	let text;
 	try {
-		text = readFileSync(childPath(claimPath), "utf-8");
+		text = settledAnswer(childPath(claimPath), () => readFileSync(childPath(claimPath), "utf-8"));
 	} catch (err) {
 		if (err?.code === "ENOENT") return null;
 		return "unreadable";
@@ -105,7 +139,7 @@ function readChild(claimPath) {
 function readClaim(path, mode) {
 	let text;
 	try {
-		text = readFileSync(path, "utf-8");
+		text = settledAnswer(path, () => readFileSync(path, "utf-8"));
 	} catch (err) {
 		if (err?.code === "ENOENT") return null;
 		return "unreadable";
@@ -195,7 +229,7 @@ function refuseNonDirectory(root, path, label) {
 }
 function names(dir) {
 	try {
-		return readdirSync(dir).toSorted();
+		return settledAnswer(dir, () => readdirSync(dir)).toSorted();
 	} catch (err) {
 		if (err?.code === "ENOENT") return [];
 		return "unreadable";
@@ -252,7 +286,7 @@ function readClaimSet(root) {
 }
 function removeOrRefuse(path, root, claimPath, label) {
 	try {
-		unlinkSync(path);
+		settledAnswer(path, () => unlinkSync(path));
 	} catch (err) {
 		const code = err?.code;
 		if (code === "ENOENT") return;
@@ -370,10 +404,12 @@ function selfOwner() {
 		processToken: captured.token
 	};
 }
-function contended(error) {
-	if (error instanceof MissingClaimStoreError) return false;
-	const code = error?.code;
-	return code === "EEXIST" || code === "ENOTEMPTY" || code === "ENOENT" || code === "EINVAL";
+function contention(error) {
+	if (error instanceof MissingClaimStoreError) return null;
+	const { code, syscall } = error ?? {};
+	if (code === "EPERM" && process.platform === "win32") return { denied: syscall !== "rename" };
+	if (code === "EEXIST" || code === "ENOTEMPTY" || code === "ENOENT" || code === "EINVAL") return { denied: false };
+	return null;
 }
 var MissingClaimStoreError = class extends Error {
 	code = "ENOENT";
@@ -409,6 +445,12 @@ function createClaimDir(path) {
 		if (error?.code !== "EEXIST") throw error;
 	}
 }
+function removeStaging(staging, { recursive }) {
+	settledAnswer(staging, () => rmSync(staging, {
+		recursive,
+		force: true
+	}));
+}
 function publishExclusive(root, payload, claimId, label) {
 	const staging = join(root, `${STAGING_PREFIX}${claimId}`);
 	const target = exclusiveClaimDir(root);
@@ -418,12 +460,10 @@ function publishExclusive(root, payload, claimId, label) {
 		renameSync(staging, target);
 		return join(target, `${claimId}${CLAIM_SUFFIX}`);
 	} catch (err) {
-		rmSync(staging, {
-			recursive: true,
-			force: true
-		});
+		removeStaging(staging, { recursive: true });
 		const code = err?.code;
-		if (contended(err)) return null;
+		const why = contention(err);
+		if (why) return why;
 		if (code === "ENOTDIR") refuseNonDirectory(root, target, label);
 		throw err;
 	}
@@ -437,8 +477,9 @@ function publishShared(root, payload, claimId) {
 		renameSync(staging, target);
 		return target;
 	} catch (err) {
-		rmSync(staging, { force: true });
-		if (contended(err)) return null;
+		removeStaging(staging, { recursive: false });
+		const why = contention(err);
+		if (why) return why;
 		throw err;
 	}
 }
@@ -450,17 +491,32 @@ function settleOrRelease(claim) {
 		throw err;
 	}
 }
+/**
+* On Windows, removal in progress can answer EPERM or ENOENT while a releaser removes the store.
+* A spinning contender can outpace 64 attempts; yielding lets that removal finish. A real denial
+* still spends at most PUBLISH_ATTEMPTS of these before it is reported.
+*/
+function yieldToRemoval() {
+	sleepSync(WIN32_SETTLE_STEP_MS);
+}
 function tryAcquireClaim({ root, mode, details = {}, label = "ownership" }) {
 	const owner = selfOwner();
 	const reaped = [];
+	let denied = true;
+	const retry = (why) => {
+		denied &&= why.denied;
+		if (process.platform === "win32") yieldToRemoval();
+	};
 	for (let attempt = 0; attempt < PUBLISH_ATTEMPTS; attempt++) {
 		try {
 			createClaimDir(root);
 		} catch (err) {
 			const code = err?.code;
 			if (code === "EEXIST" || code === "ENOTDIR") refuseNonDirectory(root, root, label);
-			if (contended(err)) continue;
-			throw err;
+			const why = contention(err);
+			if (!why) throw err;
+			retry(why);
+			continue;
 		}
 		const state = inspectClaimSet(root, { label });
 		reaped.push(...state.reaped);
@@ -489,7 +545,10 @@ function tryAcquireClaim({ root, mode, details = {}, label = "ownership" }) {
 		});
 		if (mode === "shared") {
 			const published = publishShared(root, payload, claimId);
-			if (!published) continue;
+			if (typeof published !== "string") {
+				retry(published);
+				continue;
+			}
 			const claim = handle(published);
 			const settled = settleOrRelease(claim);
 			reaped.push(...settled.reaped);
@@ -504,7 +563,10 @@ function tryAcquireClaim({ root, mode, details = {}, label = "ownership" }) {
 			};
 		}
 		const path = publishExclusive(root, payload, claimId, label);
-		if (!path) continue;
+		if (typeof path !== "string") {
+			retry(path);
+			continue;
+		}
 		const claim = handle(path);
 		const settled = settleOrRelease(claim);
 		reaped.push(...settled.reaped);
@@ -525,6 +587,7 @@ function tryAcquireClaim({ root, mode, details = {}, label = "ownership" }) {
 		held: holder,
 		reaped
 	};
+	if (denied) throw new ClaimUnavailableError(`access was denied on every one of ${PUBLISH_ATTEMPTS} attempts to publish it`, { claimPath: root });
 	refuse(root, root, label, `another process took and gave up the claim on every one of ${PUBLISH_ATTEMPTS} attempts to take it`);
 }
 function settleClaim(pending) {

package/dist/ownership-claim.mjs

@@ -1,2 +1,2 @@
-import { _ as releaseClaim, a as claimFailure, b as sharedClaimDir, c as clearClaimChild, d as inspectClaimSet, f as isClaimRefusal, g as readClaimSet, h as processGroupAlive, i as ClaimUnavailableError, l as clearFreeClaimSet, m as markClaimChildPending, n as CLAIM_UNAVAILABLE, o as claimLiveness, p as isClaimUnavailable, r as ClaimRefusedError, s as claimRemoveCommand, t as CLAIM_REFUSED, u as exclusiveClaimDir, v as setClaimChild, x as tryAcquireClaim, y as settleClaim } from "./ownership-claim-DGxNcAcy.mjs";
+import { _ as releaseClaim, a as claimFailure, b as sharedClaimDir, c as clearClaimChild, d as inspectClaimSet, f as isClaimRefusal, g as readClaimSet, h as processGroupAlive, i as ClaimUnavailableError, l as clearFreeClaimSet, m as markClaimChildPending, n as CLAIM_UNAVAILABLE, o as claimLiveness, p as isClaimUnavailable, r as ClaimRefusedError, s as claimRemoveCommand, t as CLAIM_REFUSED, u as exclusiveClaimDir, v as setClaimChild, x as tryAcquireClaim, y as settleClaim } from "./ownership-claim-Cn3NHqBS.mjs";
 export { CLAIM_REFUSED, CLAIM_UNAVAILABLE, ClaimRefusedError, ClaimUnavailableError, claimFailure, claimLiveness, claimRemoveCommand, clearClaimChild, clearFreeClaimSet, exclusiveClaimDir, inspectClaimSet, isClaimRefusal, isClaimUnavailable, markClaimChildPending, processGroupAlive, readClaimSet, releaseClaim, setClaimChild, settleClaim, sharedClaimDir, tryAcquireClaim };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stim-cli/core",
-  "version": "1.6.0",
+  "version": "1.8.0-rc.1",
   "description": "Shared internal cache and runtime primitives for Stim packages.",
   "license": "MIT",
   "repository": {
@@ -37,7 +37,7 @@
     "unique-pid": "0.1.1"
   },
   "engines": {
-    "node": "^20.19.4 || >=22.12.0"
+    "node": ">=22.12.0"
   },
   "scripts": {
     "build": "tsdown"