@pnpm/bins.linker 1100.0.13 → 1100.0.15

package/lib/index.js

@@ -200,15 +200,23 @@ async function linkBin(cmd, binsDir, opts) {
     catch { }
     if (IS_WINDOWS) {
         const exePath = path.join(binsDir, `${cmd.name}${getExeExtension()}`);
+        // node.exe is the only bin pnpm links directly as a real executable rather
+        // than through a cmd-shim, so the existing-exe handling only applies to it.
+        // We could update our own cmd shims to support node.cmd, but we can't
+        // control npm's cmd shims, which break when node resolves to node.cmd.
+        // npm's cmd shims use `IF EXIST "%~dp0\node.exe"` to find the node binary.
+        const isNodeExe = cmd.name === 'node' && cmd.path.toLowerCase().endsWith('.exe');
         if (existsSync(exePath)) {
+            // Skip warning and re-linking when the existing node.exe already matches
+            // the target, otherwise every command that re-links node would spam the
+            // warning below on warm installs.
+            if (isNodeExe && await isSameFile(exePath, cmd.path)) {
+                return;
+            }
             globalWarn(`The target bin directory already contains an exe called ${cmd.name}, so removing ${exePath}`);
             await rimraf(exePath);
         }
-        // node.exe must exist as a real executable, not a cmd-shim wrapper.
-        // We could update our own cmd shims to support node.cmd, but we can't
-        // control npm's cmd shims, which break when node resolves to node.cmd.
-        // npm's cmd shims use `IF EXIST "%~dp0\node.exe"` to find the node binary.
-        if (cmd.name === 'node' && cmd.path.toLowerCase().endsWith('.exe')) {
+        if (isNodeExe) {
             try {
                 await fs.link(cmd.path, exePath);
             }
@@ -231,7 +239,7 @@ async function linkBin(cmd, binsDir, opts) {
     if (opts?.preferSymlinkedExecutables && !IS_WINDOWS && cmd.nodeExecPath == null) {
         try {
             await symlinkDir(cmd.path, externalBinPath);
-            await fixBin(cmd.path, 0o755);
+            await ensureExecutable(cmd.path, 0o755);
         }
         catch (err) { // eslint-disable-line
             if (err.code !== 'ENOENT' && err.code !== 'EISDIR') {
@@ -280,7 +288,115 @@ async function linkBin(cmd, binsDir, opts) {
     // ensure that bin are executable and not containing
     // windows line-endings(CRLF) on the hashbang line
     if (EXECUTABLE_SHEBANG_SUPPORTED) {
-        await fixBin(cmd.path, 0o755);
+        await ensureExecutable(cmd.path, 0o755);
+    }
+}
+// Reports whether two paths refer to the same file. A matching inode/device
+// pair (read as BigInts to avoid the precision loss of NTFS 64-bit file IDs)
+// proves a hard link cheaply. Whenever identity can't be established that way —
+// because the inodes genuinely differ or because Windows reports an unreliable
+// zero inode — we fall back to comparing the file contents after a quick size
+// check, which also treats a byte-identical copy as the same file.
+async function isSameFile(pathA, pathB) {
+    const [statA, statB] = await Promise.all([
+        fs.stat(pathA, { bigint: true }).catch(() => null),
+        fs.stat(pathB, { bigint: true }).catch(() => null),
+    ]);
+    if (statA == null || statB == null)
+        return false;
+    if (statA.ino && statB.ino && statA.ino === statB.ino && statA.dev === statB.dev) {
+        return true;
+    }
+    if (statA.size !== statB.size)
+        return false;
+    return haveEqualContents(pathA, pathB);
+}
+const FILE_COMPARE_CHUNK_SIZE = 64 * 1024;
+// Compares two equally-sized files chunk by chunk, so an executable is never
+// fully buffered in memory and a mismatch returns as early as possible.
+async function haveEqualContents(pathA, pathB) {
+    const [fhA, fhB] = await Promise.all([
+        fs.open(pathA, 'r').catch(() => null),
+        fs.open(pathB, 'r').catch(() => null),
+    ]);
+    if (fhA == null || fhB == null) {
+        await fhA?.close().catch(() => { });
+        await fhB?.close().catch(() => { });
+        return false;
+    }
+    try {
+        const bufA = Buffer.alloc(FILE_COMPARE_CHUNK_SIZE);
+        const bufB = Buffer.alloc(FILE_COMPARE_CHUNK_SIZE);
+        let position = 0;
+        for (;;) {
+            // Reading sequentially is intentional: each iteration compares one chunk
+            // and stops early on a mismatch or EOF.
+            const [readA, readB] = await Promise.all([
+                fhA.read(bufA, 0, FILE_COMPARE_CHUNK_SIZE, position),
+                fhB.read(bufB, 0, FILE_COMPARE_CHUNK_SIZE, position),
+            ]);
+            if (readA.bytesRead !== readB.bytesRead)
+                return false;
+            if (readA.bytesRead === 0)
+                return true;
+            if (!bufA.subarray(0, readA.bytesRead).equals(bufB.subarray(0, readB.bytesRead))) {
+                return false;
+            }
+            position += readA.bytesRead;
+        }
+    }
+    catch {
+        // A transient read error must not abort bin linking: treat the files as
+        // different so the caller falls back to the warn + remove + relink path.
+        return false;
+    }
+    finally {
+        await fhA.close().catch(() => { });
+        await fhB.close().catch(() => { });
+    }
+}
+// `fixBin` chmods the bin's source file (which lives inside the store) to make
+// it executable and rewrites a Windows CRLF shebang to LF. Under the global
+// virtual store that source is `{storeDir}/links/...`, so on a read-only store
+// (e.g. `frozenStore`) the chmod is refused — with EPERM/EACCES when the file is
+// owned but permissions forbid it, or EROFS on a genuinely read-only filesystem
+// (Nix store, RO bind mount, OCI layer). A complete seed already ships its bins
+// executable and shebang-normalized by the writable seed-build, so that work is
+// redundant: treat an already-correct target as a no-op, keeping bin-linking
+// write-free (see building/during-install: "Bin-linking reuses existing symlinks
+// write-free"). A non-executable bin — or one still carrying a CRLF shebang that
+// `fixBin` could not rewrite here — still throws, because that means the seed is
+// broken and the bin would not run.
+async function ensureExecutable(file, mode) {
+    try {
+        await fixBin(file, mode);
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'EROFS') {
+            const stat = await fs.stat(file).catch(() => undefined);
+            if (stat != null && (stat.mode & 0o111) !== 0 && !(await hasWindowsShebang(file)))
+                return;
+        }
+        throw err;
+    }
+}
+// Detects a `#!`-shebang line terminated by CRLF, which fails to execute on
+// POSIX. Mirrors bin-links' own fix-bin detection so a chmod failure on a
+// read-only store is only swallowed when the bin is genuinely already correct.
+async function hasWindowsShebang(file) {
+    const fh = await fs.open(file, 'r').catch(() => undefined);
+    if (fh == null)
+        return false;
+    try {
+        const buf = Buffer.alloc(2048);
+        await fh.read(buf, 0, 2048, 0);
+        return buf[0] === 0x23 /* # */ && buf[1] === 0x21 /* ! */ && /^#![^\n]+\r\n/.test(buf.toString());
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await fh.close().catch(() => { });
     }
 }
 function getExeExtension() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/bins.linker",
-  "version": "1100.0.13",
+  "version": "1100.0.15",
   "description": "Link bins to node_modules/.bin",
   "keywords": [
     "pnpm",
@@ -28,28 +28,28 @@
     "!*.map"
   ],
   "dependencies": {
-    "@zkochan/cmd-shim": "^9.0.3",
+    "@zkochan/cmd-shim": "^9.0.6",
     "@zkochan/rimraf": "^4.0.0",
     "bin-links": "^6.0.2",
     "is-subdir": "^2.0.0",
     "is-windows": "^1.0.2",
     "normalize-path": "^3.0.0",
     "ramda": "npm:@pnpm/ramda@0.28.1",
-    "semver": "^7.8.1",
+    "semver": "^7.8.4",
     "symlink-dir": "^10.0.1",
-    "@pnpm/bins.resolver": "1100.0.7",
-    "@pnpm/pkg-manifest.reader": "1100.0.7",
     "@pnpm/error": "1100.0.0",
+    "@pnpm/pkg-manifest.reader": "1100.0.8",
     "@pnpm/fs.read-modules-dir": "1100.0.1",
-    "@pnpm/pkg-manifest.utils": "1100.2.4",
-    "@pnpm/types": "1101.3.1",
-    "@pnpm/workspace.project-manifest-reader": "1100.0.12"
+    "@pnpm/bins.resolver": "1100.0.8",
+    "@pnpm/pkg-manifest.utils": "1100.2.5",
+    "@pnpm/workspace.project-manifest-reader": "1100.0.13",
+    "@pnpm/types": "1101.3.2"
   },
   "peerDependencies": {
-    "@pnpm/logger": "^1001.0.1"
+    "@pnpm/logger": "^1100.0.0"
   },
   "devDependencies": {
-    "@jest/globals": "30.3.0",
+    "@jest/globals": "30.4.1",
     "@types/is-windows": "^1.0.2",
     "@types/node": "^22.19.19",
     "@types/normalize-path": "^3.0.2",
@@ -57,7 +57,7 @@
     "@types/semver": "7.7.1",
     "cmd-extension": "^2.0.0",
     "tempy": "3.0.0",
-    "@pnpm/bins.linker": "1100.0.13",
+    "@pnpm/bins.linker": "1100.0.15",
     "@pnpm/logger": "1100.0.0",
     "@pnpm/test-fixtures": "1100.0.0"
   },