@pnpm/fs.graceful-fs 1100.2.1 → 1100.2.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pnpm/fs.graceful-fs
 
+## 1100.2.3
+
+### Patch Changes
+
+- `pnpm install` in WSL now waits out Windows file locks on a Windows drive such as `/mnt/c`, as it already does on Windows. Before, an antivirus or indexer scan holding a file open could fail the install with `EACCES` [pnpm/pnpm#6155](https://github.com/pnpm/pnpm/issues/6155).
+
+- On Windows, pnpm now retries saving `pnpm-lock.yaml` for up to a minute while another process holds the file open. The save used to fail at once with `EPERM`, `EBUSY`, or "Access is denied" [#9461](https://github.com/pnpm/pnpm/issues/9461).
+
+## 1100.2.2
+
+### Patch Changes
+
+- Installs in different projects that share a global virtual store no longer fail on Windows with `Access is denied` while repairing the same slot [#15114](https://github.com/pnpm/pnpm/issues/15114).
+
 ## 1100.2.1
 
 ### Patch Changes

package/lib/index.d.ts

@@ -22,6 +22,7 @@ declare const _default: {
 export default _default;
 /**
  * Renames `src` over `dest`, retrying Windows EBUSY errors for up to a minute.
+ * Windows drives mounted into WSL get the same retries.
  * EPERM and EACCES have a one-second budget because they can also indicate
  * permanent permission or destination conflicts. Other errors are thrown
  * right away.
@@ -31,3 +32,27 @@ export default _default;
  * that was there or the whole file replacing it.
  */
 export declare function renameFileWithRetry(src: string, dest: string): void;
+/**
+ * Asynchronous {@link renameFileWithRetry}, which waits between attempts
+ * without blocking the event loop.
+ */
+export declare function renameFileWithRetryAsync(src: string, dest: string): Promise<void>;
+/**
+ * Reads `target`'s stats without following it, with the retry policy of
+ * {@link renameFileWithRetry}.
+ *
+ * A Windows path another process has just unlinked stays delete-pending until
+ * the last handle on it closes, and inspecting it fails with EPERM for as long
+ * as that lasts. Retrying lets the unlink land, so a caller that reads ENOENT
+ * as an absent entry sees the same absence POSIX shows it at once.
+ */
+export declare function lstatWithRetry(target: string): fs.Stats;
+/**
+ * Removes a file, with the retry policy of {@link renameFileWithRetry}.
+ */
+export declare function unlinkWithRetry(target: string): void;
+/**
+ * Runs a filesystem operation with the retry policy of
+ * {@link renameFileWithRetry}.
+ */
+export declare function withFileLockRetry<T>(operation: () => T): T;

package/lib/index.js

@@ -1,10 +1,11 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import util, { promisify } from 'node:util';
 import gfs from 'graceful-fs';
-const RENAME_RETRY_BUDGET_MS = 60_000;
+const FILE_LOCK_RETRY_BUDGET_MS = 60_000;
 const PERMISSION_DENIED_RETRY_BUDGET_MS = 1_000;
-const RENAME_RETRY_BACKOFF_CAP_MS = 100;
-const renameRetrySleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+const FILE_LOCK_RETRY_BACKOFF_CAP_MS = 100;
+const fileLockRetrySleepBuffer = new Int32Array(new SharedArrayBuffer(4));
 export default {
     chmod: promisify(gfs.chmod),
     copyFile: promisify(gfs.copyFile),
@@ -48,6 +49,7 @@ function withEagainRetry(fn, maxRetries = 15) {
 }
 /**
  * Renames `src` over `dest`, retrying Windows EBUSY errors for up to a minute.
+ * Windows drives mounted into WSL get the same retries.
  * EPERM and EACCES have a one-second budget because they can also indicate
  * permanent permission or destination conflicts. Other errors are thrown
  * right away.
@@ -57,34 +59,104 @@ function withEagainRetry(fn, maxRetries = 15) {
  * that was there or the whole file replacing it.
  */
 export function renameFileWithRetry(src, dest) {
-    const startedAt = Date.now();
-    let backoffMs = 0;
-    let budgetMs = RENAME_RETRY_BUDGET_MS;
+    withFileLockRetry(() => {
+        fs.renameSync(src, dest);
+    });
+}
+/**
+ * Asynchronous {@link renameFileWithRetry}, which waits between attempts
+ * without blocking the event loop.
+ */
+export async function renameFileWithRetryAsync(src, dest) {
+    await withFileLockRetryAsync(() => fs.promises.rename(src, dest));
+}
+/**
+ * Reads `target`'s stats without following it, with the retry policy of
+ * {@link renameFileWithRetry}.
+ *
+ * A Windows path another process has just unlinked stays delete-pending until
+ * the last handle on it closes, and inspecting it fails with EPERM for as long
+ * as that lasts. Retrying lets the unlink land, so a caller that reads ENOENT
+ * as an absent entry sees the same absence POSIX shows it at once.
+ */
+export function lstatWithRetry(target) {
+    return withFileLockRetry(() => fs.lstatSync(target));
+}
+/**
+ * Removes a file, with the retry policy of {@link renameFileWithRetry}.
+ */
+export function unlinkWithRetry(target) {
+    withFileLockRetry(() => {
+        fs.unlinkSync(target);
+    });
+}
+/**
+ * Runs a filesystem operation with the retry policy of
+ * {@link renameFileWithRetry}.
+ */
+export function withFileLockRetry(operation) {
+    const retry = createFileLockRetry();
+    for (;;) {
+        try {
+            return operation();
+        }
+        catch (err) {
+            const delayMs = retry.delayBeforeNextAttempt(err);
+            if (delayMs > 0)
+                Atomics.wait(fileLockRetrySleepBuffer, 0, 0, delayMs);
+            retry.checkBudgetAfterDelay(err);
+        }
+    }
+}
+async function withFileLockRetryAsync(operation) {
+    const retry = createFileLockRetry();
     for (;;) {
         try {
-            fs.renameSync(src, dest);
-            return;
+            // eslint-disable-next-line no-await-in-loop
+            return await operation();
         }
         catch (err) {
-            if (!isTransientRenameError(err))
+            const delayMs = retry.delayBeforeNextAttempt(err);
+            if (delayMs > 0) {
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+            retry.checkBudgetAfterDelay(err);
+        }
+    }
+}
+function createFileLockRetry() {
+    const startedAt = Date.now();
+    let backoffMs = 0;
+    let budgetMs = FILE_LOCK_RETRY_BUDGET_MS;
+    return {
+        delayBeforeNextAttempt(err) {
+            if (!isTransientFileLockError(err))
                 throw err;
             if (err.code === 'EPERM' || err.code === 'EACCES')
                 budgetMs = Math.min(budgetMs, PERMISSION_DENIED_RETRY_BUDGET_MS);
             const remainingMs = budgetMs - (Date.now() - startedAt);
             if (remainingMs <= 0)
                 throw err;
-            if (backoffMs > 0)
-                Atomics.wait(renameRetrySleepBuffer, 0, 0, Math.min(backoffMs, remainingMs));
+            return Math.min(backoffMs, remainingMs);
+        },
+        checkBudgetAfterDelay(err) {
             if (Date.now() - startedAt >= budgetMs)
                 throw err;
-            backoffMs = Math.min(backoffMs + 10, RENAME_RETRY_BACKOFF_CAP_MS);
-        }
-    }
+            backoffMs = Math.min(backoffMs + 10, FILE_LOCK_RETRY_BACKOFF_CAP_MS);
+        },
+    };
 }
-function isTransientRenameError(err) {
-    return process.platform === 'win32' &&
+function isTransientFileLockError(err) {
+    return (process.platform === 'win32' || isWsl()) &&
         util.types.isNativeError(err) &&
         'code' in err &&
         (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'EBUSY');
 }
+// A Windows drive mounted into WSL (/mnt/c) keeps Windows file locking, so an
+// antivirus or indexer handle fails a rename there with EACCES. WSL kernels
+// carry "microsoft" in their release, e.g. 5.15.167.4-microsoft-standard-WSL2.
+function isWsl() {
+    return process.platform === 'linux' && os.release().toLowerCase().includes('microsoft');
+}
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/fs.graceful-fs",
-  "version": "1100.2.1",
+  "version": "1100.2.3",
   "description": "Promisified graceful-fs",
   "keywords": [
     "pnpm",
@@ -31,7 +31,7 @@
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/fs.graceful-fs": "1100.2.1",
+    "@pnpm/fs.graceful-fs": "1100.2.3",
     "@types/graceful-fs": "^4.1.9"
   },
   "engines": {