@pnpm/fs.graceful-fs 1100.2.2 → 1100.2.4

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @pnpm/fs.graceful-fs
 
+## 1100.2.4
+
+### Patch Changes
+
+- Fixed concurrent installs failing when replacing the same stale hoisted dependency link.
+
+- `pnpm install` now works in StackBlitz WebContainers on projects without a lockfile. It used to fail there with `ENOENT ... pnpm-lock.yaml`, because pnpm did not recognize the errors that WebContainers return from asynchronous file system calls [#15649](https://github.com/pnpm/pnpm/issues/15649).
+
+- Updated dependencies:
+  - @pnpm/error@1100.2.1
+
+## 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

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,6 +32,11 @@ 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}.
@@ -45,3 +51,14 @@ 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;
+/**
+ * Asynchronous {@link withFileLockRetry}, which waits between attempts
+ * without blocking the event loop.
+ */
+export declare function withFileLockRetryAsync<T>(operation: () => Promise<T>): Promise<T>;
+export declare function isTransientFileLockError(err: unknown): err is NodeJS.ErrnoException;

package/lib/index.js

@@ -1,5 +1,7 @@
 import fs from 'node:fs';
-import util, { promisify } from 'node:util';
+import os from 'node:os';
+import { promisify } from 'node:util';
+import { isError } from '@pnpm/error';
 import gfs from 'graceful-fs';
 const FILE_LOCK_RETRY_BUDGET_MS = 60_000;
 const PERMISSION_DENIED_RETRY_BUDGET_MS = 1_000;
@@ -33,7 +35,7 @@ function withEagainRetry(fn, maxRetries = 15) {
                 return fn(...args);
             }
             catch (err) {
-                if (util.types.isNativeError(err) && 'code' in err && err.code === 'EAGAIN' && attempts < maxRetries) {
+                if (isError(err) && 'code' in err && err.code === 'EAGAIN' && attempts < maxRetries) {
                     attempts++;
                     // Exponential backoff: wait 2^attempts milliseconds, max 300ms
                     const delay = Math.min(Math.pow(2, attempts), 300);
@@ -48,6 +50,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.
@@ -61,6 +64,13 @@ export function renameFileWithRetry(src, dest) {
         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}.
@@ -81,15 +91,51 @@ export function unlinkWithRetry(target) {
         fs.unlinkSync(target);
     });
 }
-function withFileLockRetry(operation) {
-    const startedAt = Date.now();
-    let backoffMs = 0;
-    let budgetMs = FILE_LOCK_RETRY_BUDGET_MS;
+/**
+ * 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);
+        }
+    }
+}
+/**
+ * Asynchronous {@link withFileLockRetry}, which waits between attempts
+ * without blocking the event loop.
+ */
+export async function withFileLockRetryAsync(operation) {
+    const retry = createFileLockRetry();
+    for (;;) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            return await operation();
+        }
+        catch (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')
@@ -97,18 +143,25 @@ function withFileLockRetry(operation) {
             const remainingMs = budgetMs - (Date.now() - startedAt);
             if (remainingMs <= 0)
                 throw err;
-            if (backoffMs > 0)
-                Atomics.wait(fileLockRetrySleepBuffer, 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, FILE_LOCK_RETRY_BACKOFF_CAP_MS);
-        }
-    }
+        },
+    };
 }
-function isTransientFileLockError(err) {
-    return process.platform === 'win32' &&
-        util.types.isNativeError(err) &&
+export function isTransientFileLockError(err) {
+    return (process.platform === 'win32' || isWsl()) &&
+        isError(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.2",
+  "version": "1100.2.4",
   "description": "Promisified graceful-fs",
   "keywords": [
     "pnpm",
@@ -27,11 +27,12 @@
     "!*.map"
   ],
   "dependencies": {
+    "@pnpm/error": "1100.2.1",
     "graceful-fs": "^4.2.11"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/fs.graceful-fs": "1100.2.2",
+    "@pnpm/fs.graceful-fs": "1100.2.4",
     "@types/graceful-fs": "^4.1.9"
   },
   "engines": {