@pnpm/workspace.injected-deps-syncer 1100.0.32 → 1100.0.34

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @pnpm/workspace.injected-deps-syncer
 
+## 1100.0.34
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/bins.linker@1100.0.28
+  - @pnpm/bins.remover@1100.0.21
+  - @pnpm/bins.resolver@1100.0.15
+  - @pnpm/error@1100.1.3
+  - @pnpm/fetching.directory-fetcher@1100.0.30
+  - @pnpm/installing.modules-yaml@1101.0.0
+  - @pnpm/pkg-manifest.reader@1100.0.17
+  - @pnpm/types@1102.0.0
+  - @pnpm/workspace.projects-reader@1101.0.24
+
+## 1100.0.33
+
+### Patch Changes
+
+- `syncInjectedDepsAfterScripts` no longer fails with `ERR_PNPM_UNSUPPORTED_INODE_TYPE` when a workspace package contains an inode that is neither a file nor a directory, such as the FIFO 1Password's environments create for `.env`. Such an inode cannot be hardlinked into the injected copy, so it is skipped and the rest of the package still syncs [#13550](https://github.com/pnpm/pnpm/issues/13550).
+
+  `syncInjectedDepsAfterScripts` also no longer fails with `EEXIST` when a workspace package replaced a file with a directory of the same name since the injected copy was last synced.
+
+- `syncInjectedDepsAfterScripts` no longer fails with `ENOTDIR` when a workspace package replaced a directory with a file of the same name and the injected copy still held that directory's contents.
+
+- `syncInjectedDepsAfterScripts` now removes the bin link of a bin the script dropped. Previously only new bins were linked, so a build step that stopped declaring one left its shim behind, pointing at a command that was no longer there.
+
+- `syncInjectedDepsAfterScripts` now identifies a file by its device as well as its inode number. An inode number is only unique within one filesystem, so on its own it could match an unrelated file on another device and leave that path stale in the injected copy.
+
+- Updated dependencies:
+  - @pnpm/bins.linker@1100.0.27
+  - @pnpm/bins.remover@1100.0.20
+  - @pnpm/error@1100.1.2
+  - @pnpm/fetching.directory-fetcher@1100.0.29
+  - @pnpm/pkg-manifest.reader@1100.0.16
+  - @pnpm/workspace.projects-reader@1101.0.23
+
 ## 1100.0.32
 
 ### Patch Changes

package/lib/DirPatcher.d.ts

@@ -1,6 +1,12 @@
 import fs from 'node:fs';
 export declare const DIR: unique symbol;
-export type File = number;
+/**
+ * A file's identity, as `<device>:<inode>`. An inode number is only unique
+ * within one filesystem, so the device it came from is part of the identity:
+ * without it two unrelated files on different devices can collide and be
+ * taken for the same file, leaving the injected copy stale.
+ */
+export type File = string;
 export type Dir = typeof DIR;
 export type Value = File | Dir;
 export type InodeMap = Record<string, Value>;
@@ -43,7 +49,7 @@ export declare function diffDir(oldIndex: InodeMap, newIndex: InodeMap): DirDiff
  * The {@link optimizedDirPatch} is assumed to be already optimized (i.e. `removed` is already reversed).
  */
 export declare function applyPatch(optimizedDirPatch: DirDiff, sourceDir: string, targetDir: string): Promise<void>;
-export type ExtendFilesMapStats = Pick<fs.Stats, 'ino' | 'isFile' | 'isDirectory'>;
+export type ExtendFilesMapStats = Pick<fs.Stats, 'dev' | 'ino' | 'isFile' | 'isDirectory'>;
 export interface ExtendFilesMapOptions {
     /** Map relative path of each file to their real path */
     filesMap: Map<string, string>;

package/lib/DirPatcher.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import util from 'node:util';
-import { PnpmError } from '@pnpm/error';
 import { fetchFromDir } from '@pnpm/fetching.directory-fetcher';
 export const DIR = Symbol('Path is a directory');
 // length comparison should place every directory before the files it contains because
@@ -36,16 +35,34 @@ export function diffDir(oldIndex, newIndex) {
 export async function applyPatch(optimizedDirPatch, sourceDir, targetDir) {
     async function addRecursive(sourcePath, targetPath, value) {
         if (value === DIR) {
-            await fs.promises.mkdir(targetPath, { recursive: true });
+            await retryOverBlockingInode(targetPath, async () => fs.promises.mkdir(targetPath, { recursive: true }));
         }
-        else if (typeof value === 'number') {
+        else if (typeof value === 'string') {
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-            await fs.promises.link(sourcePath, targetPath);
+            await retryOverBlockingInode(targetPath, async () => fs.promises.link(sourcePath, targetPath));
         }
         else {
             const _ = value; // static type guard
         }
     }
+    /**
+     * The target may hold an inode that {@link extendFilesMap} skips — a FIFO, a
+     * socket, a device. The diff cannot see it, so it is never scheduled for
+     * removal, and adding over it fails with `EEXIST`. Clear that path and retry
+     * once instead of aborting the sync partway through.
+     */
+    async function retryOverBlockingInode(targetPath, add) {
+        try {
+            await add();
+        }
+        catch (error) {
+            if (!util.types.isNativeError(error) || !('code' in error) || (error.code !== 'EEXIST')) {
+                throw error;
+            }
+            await removeRecursive(targetPath);
+            await add();
+        }
+    }
     async function removeRecursive(targetPath) {
         try {
             await fs.promises.rm(targetPath, { recursive: true, force: true });
@@ -56,24 +73,33 @@ export async function applyPatch(optimizedDirPatch, sourceDir, targetDir) {
             }
         }
     }
-    const adding = Promise.all(optimizedDirPatch.added.map(async (item) => {
-        const sourcePath = path.join(sourceDir, item.path);
-        const targetPath = path.join(targetDir, item.path);
-        await addRecursive(sourcePath, targetPath, item.newValue);
-    }));
-    const removing = Promise.all(optimizedDirPatch.removed.map(async (item) => {
-        const targetPath = path.join(targetDir, item.path);
-        await removeRecursive(targetPath);
-    }));
-    const modifying = Promise.all(optimizedDirPatch.modified.map(async (item) => {
+    async function applyChange(item) {
         const sourcePath = path.join(sourceDir, item.path);
         const targetPath = path.join(targetDir, item.path);
-        if (item.oldValue === item.newValue)
-            return;
-        await removeRecursive(targetPath);
+        if (item.oldValue !== undefined) {
+            await removeRecursive(targetPath);
+        }
         await addRecursive(sourcePath, targetPath, item.newValue);
+    }
+    const changes = [...optimizedDirPatch.added, ...optimizedDirPatch.modified]
+        .filter(item => item.oldValue !== item.newValue);
+    const newDirs = changes.filter(item => item.newValue === DIR).sort((a, b) => comparePaths(a.path, b.path));
+    const newFiles = changes.filter(item => item.newValue !== DIR);
+    // The phase order is load-bearing twice over. Removals go first, so a path
+    // the source turned from a directory into a file still has a directory in it
+    // when its dropped children are unlinked. Directories then go in ahead of the
+    // files they hold, so a directory is always empty when it displaces what the
+    // target held at its path — otherwise a removal landing late would take out
+    // files a sibling had already linked. A path the target holds as a file and
+    // the source as a directory lands in `modified` rather than `added`, so both
+    // arrays feed the directory pass.
+    await Promise.all(optimizedDirPatch.removed.map(async (item) => {
+        await removeRecursive(path.join(targetDir, item.path));
     }));
-    await Promise.all([adding, removing, modifying]);
+    for (const item of newDirs) {
+        await applyChange(item); // eslint-disable-line no-await-in-loop
+    }
+    await Promise.all(newFiles.map(applyChange));
 }
 /**
  * Convert a pair of a files index map, which is a map from relative path of each file to their real paths,
@@ -93,17 +119,17 @@ export async function extendFilesMap({ filesMap, filesStats }) {
     await Promise.all(Array.from(filesMap.entries()).map(async ([relativePath, realPath]) => {
         const stats = filesStats?.[relativePath] ?? await fs.promises.stat(realPath);
         if (stats.isFile()) {
-            addInodeAndAncestors(relativePath, stats.ino);
+            addInodeAndAncestors(relativePath, fileId(stats));
         }
         else if (stats.isDirectory()) {
             addInodeAndAncestors(relativePath, DIR);
         }
-        else {
-            throw new PnpmError('UNSUPPORTED_INODE_TYPE', `Filesystem inode at ${realPath} is neither a file, a directory, or a symbolic link`);
-        }
+        // Anything else — a FIFO, a socket, a device — cannot be hardlinked into
+        // the injected copy, so it is left out of the map.
     }));
     return result;
 }
+const fileId = (stats) => `${stats.dev}:${stats.ino}`;
 export class DirPatcher {
     sourceDir;
     targetDir;

package/lib/index.d.ts

@@ -1,6 +1,14 @@
+import type { DependencyManifest } from '@pnpm/types';
 export interface SyncInjectedDepsOptions {
     pkgName: string | undefined;
     pkgRootDir: string;
     workspaceDir: string | undefined;
+    /**
+     * The package's manifest as it was before the scripts ran. A script that
+     * drops a bin leaves its shim behind, and the copies cannot say which bins
+     * they used to have: their `package.json` is hardlinked to the source, so
+     * an in-place rewrite has already reached them.
+     */
+    manifestBeforeScripts?: DependencyManifest;
 }
 export declare function syncInjectedDeps(opts: SyncInjectedDepsOptions): Promise<void>;

package/lib/index.js

@@ -1,5 +1,7 @@
 import path from 'node:path';
 import { linkBins, linkBinsOfPackages } from '@pnpm/bins.linker';
+import { removeBin } from '@pnpm/bins.remover';
+import { getBinsFromPackageManifest } from '@pnpm/bins.resolver';
 import { PnpmError } from '@pnpm/error';
 import { readModulesManifest } from '@pnpm/installing.modules-yaml';
 import { logger as createLogger } from '@pnpm/logger';
@@ -41,21 +43,53 @@ export async function syncInjectedDeps(opts) {
         });
         return;
     }
-    const patchers = await DirPatcher.fromMultipleTargets(pkgRootDir, targetDirs.map(targetDir => path.resolve(opts.workspaceDir, targetDir)));
+    const resolvedTargetDirs = targetDirs.map(targetDir => path.resolve(opts.workspaceDir, targetDir));
+    const patchers = await DirPatcher.fromMultipleTargets(pkgRootDir, resolvedTargetDirs);
     await Promise.all(patchers.map(patcher => patcher.apply()));
-    // After syncing files, also sync bin links if the package has binaries
-    await syncBinLinks(pkgRootDir, targetDirs, opts.workspaceDir);
+    await syncBinLinks({
+        // The install hoists bins into the virtual store's own `.bin` as well.
+        hoistedBinDir: modules.virtualStoreDir == null
+            ? undefined
+            : path.join(path.resolve(opts.workspaceDir, modules.virtualStoreDir), 'node_modules', '.bin'),
+        pkgRootDir,
+        previousBinNames: opts.manifestBeforeScripts == null
+            ? []
+            : (await getBinsFromPackageManifest(opts.manifestBeforeScripts, pkgRootDir)).map(command => command.name),
+        resolvedTargetDirs,
+        workspaceDir: opts.workspaceDir,
+    });
+}
+/** The commands a package declares, or none when it declares no bins. */
+async function readBinNames(pkgDir) {
+    const manifest = await safeReadPackageJsonFromDir(pkgDir);
+    if (!manifest?.name)
+        return [];
+    const commands = await getBinsFromPackageManifest(manifest, pkgDir);
+    return commands.map(command => command.name);
 }
-async function syncBinLinks(pkgRootDir, targetDirs, workspaceDir) {
-    const manifest = await safeReadPackageJsonFromDir(pkgRootDir);
-    if (!manifest?.bin || !manifest?.name) {
+async function syncBinLinks(opts) {
+    const manifest = await safeReadPackageJsonFromDir(opts.pkgRootDir);
+    if (!manifest?.name) {
         return;
     }
+    // A script can drop a bin as easily as it can add one. `linkBins` only ever
+    // creates shims, so without this the shim for a dropped bin survives and
+    // points at a command that is no longer there.
+    const currentBinNames = new Set(await readBinNames(opts.pkgRootDir));
+    const staleBinNames = opts.previousBinNames.filter(name => !currentBinNames.has(name));
     // Step 1: Link bins in .pnpm virtual store
-    const binLinkPromises = targetDirs.map(async (targetDir) => {
-        const resolvedTargetDir = path.resolve(workspaceDir, targetDir);
+    const binLinkPromises = opts.resolvedTargetDirs.map(async (resolvedTargetDir) => {
         const parentNodeModulesDir = path.dirname(resolvedTargetDir);
         const binDir = path.join(parentNodeModulesDir, '.bin');
+        // The installer writes an injected package's own bins inside the copy,
+        // while this function writes them beside it. A dropped bin has to be
+        // cleared from both, or the one this function never wrote survives.
+        const binDirs = [binDir, path.join(resolvedTargetDir, 'node_modules', '.bin')];
+        if (opts.hoistedBinDir != null)
+            binDirs.push(opts.hoistedBinDir);
+        await Promise.all(binDirs.flatMap(dir => staleBinNames.map(async (name) => removeBin(path.join(dir, name)))));
+        if (manifest.bin == null)
+            return;
         await linkBinsOfPackages([{
                 manifest,
                 location: resolvedTargetDir,
@@ -65,10 +99,14 @@ async function syncBinLinks(pkgRootDir, targetDirs, workspaceDir) {
     // We need to relink bins for all workspace projects because injected deps
     // can be used by any project in the workspace. We relink all bins (not just
     // this package) to ensure consistency.
-    const allProjects = await findWorkspaceProjectsNoCheck(workspaceDir, {});
+    const allProjects = await findWorkspaceProjectsNoCheck(opts.workspaceDir, {});
     const consumerLinkPromises = allProjects.map(async (project) => {
         const projectNodeModules = path.join(project.rootDir, 'node_modules');
         const projectBinDir = path.join(projectNodeModules, '.bin');
+        // A stale name another package legitimately owns is put back by the
+        // relink below, so removing first costs nothing and catches the shim
+        // this package left behind.
+        await Promise.all(staleBinNames.map(async (name) => removeBin(path.join(projectBinDir, name))));
         // Relink all bins in the project's node_modules
         await linkBins(projectNodeModules, projectBinDir, {
             allowExoticManifests: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/workspace.injected-deps-syncer",
-  "version": "1100.0.32",
+  "version": "1100.0.34",
   "description": "Update all injected replica of a workspace package",
   "keywords": [
     "pnpm",
@@ -27,14 +27,16 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/bins.linker": "1100.0.26",
-    "@pnpm/error": "1100.1.1",
-    "@pnpm/fetching.directory-fetcher": "1100.0.28",
-    "@pnpm/installing.modules-yaml": "1100.0.15",
-    "@pnpm/pkg-manifest.reader": "1100.0.15",
+    "@pnpm/bins.linker": "1100.0.28",
+    "@pnpm/bins.remover": "1100.0.21",
+    "@pnpm/bins.resolver": "1100.0.15",
+    "@pnpm/error": "1100.1.3",
+    "@pnpm/fetching.directory-fetcher": "1100.0.30",
+    "@pnpm/installing.modules-yaml": "1101.0.0",
+    "@pnpm/pkg-manifest.reader": "1100.0.17",
     "@pnpm/text.ordinal-comparator": "1100.0.0",
-    "@pnpm/types": "1101.9.0",
-    "@pnpm/workspace.projects-reader": "1101.0.22",
+    "@pnpm/types": "1102.0.0",
+    "@pnpm/workspace.projects-reader": "1101.0.24",
     "@types/normalize-path": "^3.0.2",
     "normalize-path": "^3.0.0"
   },
@@ -44,8 +46,10 @@
   "devDependencies": {
     "@jest/globals": "30.4.1",
     "@pnpm/logger": "1100.0.0",
-    "@pnpm/prepare": "1100.0.25",
-    "@pnpm/workspace.injected-deps-syncer": "1100.0.32"
+    "@pnpm/prepare": "1100.0.27",
+    "@pnpm/workspace.injected-deps-syncer": "1100.0.34",
+    "@types/is-windows": "^1.0.2",
+    "is-windows": "^1.0.2"
   },
   "engines": {
     "node": ">=22.13"