@pnpm/bins.linker 1000.2.6

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @pnpm/link-bins
+
+> Link bins to node_modules/.bin
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/link-bins.svg)](https://www.npmjs.com/package/@pnpm/link-bins)
+<!--/@-->
+
+## Installation
+
+```sh
+pnpm add @pnpm/link-bins
+```
+
+## Usage
+
+```ts
+import linkBins, {linkBinsOfPackages} from '@pnpm/link-bins'
+
+function warn (msg) { console.warn(msg) }
+
+await linkBins('node_modules', 'node_modules/.bin', {warn})
+
+const packages = [{manifest: packageJson, location: pathToPackage}]
+await linkBinsOfPackages(packages, 'node_modules/.bin', {warn})
+```
+
+## License
+
+[MIT](./LICENSE)

package/lib/getBinNodePaths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns the node_modules paths relevant to a binary in the virtual store layout.
+ * For a binary at `.pnpm/pkg@version/node_modules/pkg/bin/cli.js`, this returns:
+ *   1. `.pnpm/pkg@version/node_modules/pkg/node_modules` (bundled dependencies)
+ *   2. `.pnpm/pkg@version/node_modules` (sibling/regular dependencies)
+ *
+ * These directories must be in NODE_PATH so that tools like `import-local`
+ * (used by jest, eslint, etc.) which resolve from CWD can find the correct
+ * dependency versions.
+ */
+export declare function getBinNodePaths(target: string): Promise<string[]>;

package/lib/getBinNodePaths.js

@@ -0,0 +1,55 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * Returns the node_modules paths relevant to a binary in the virtual store layout.
+ * For a binary at `.pnpm/pkg@version/node_modules/pkg/bin/cli.js`, this returns:
+ *   1. `.pnpm/pkg@version/node_modules/pkg/node_modules` (bundled dependencies)
+ *   2. `.pnpm/pkg@version/node_modules` (sibling/regular dependencies)
+ *
+ * These directories must be in NODE_PATH so that tools like `import-local`
+ * (used by jest, eslint, etc.) which resolve from CWD can find the correct
+ * dependency versions.
+ */
+export async function getBinNodePaths(target) {
+    const targetDir = path.dirname(target);
+    let dir;
+    try {
+        dir = await fs.realpath(targetDir);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+        dir = targetDir;
+    }
+    // Walk up from the resolved directory to find the first non-nested node_modules
+    let currentDir = dir;
+    while (true) {
+        if (path.basename(currentDir) === 'node_modules') {
+            // Skip nested node_modules (e.g., node_modules/node_modules)
+            if (path.basename(path.dirname(currentDir)) !== 'node_modules') {
+                const nodeModulesDir = currentDir;
+                const result = [];
+                // Determine the package directory from the relative path between
+                // node_modules and the resolved binary directory
+                const rel = path.relative(nodeModulesDir, dir);
+                if (rel) {
+                    const relSegments = rel.split(path.sep);
+                    // For scoped packages, the package dir is two levels deep: @scope/pkg
+                    const pkgDir = relSegments[0].startsWith('@')
+                        ? path.join(nodeModulesDir, relSegments[0], relSegments[1])
+                        : path.join(nodeModulesDir, relSegments[0]);
+                    result.push(path.join(pkgDir, 'node_modules'));
+                }
+                result.push(nodeModulesDir);
+                return result;
+            }
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir)
+            break;
+        currentDir = parent;
+    }
+    return [];
+}
+//# sourceMappingURL=getBinNodePaths.js.map

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+import type { DependencyManifest, ProjectManifest } from '@pnpm/types';
+export type WarningCode = 'BINARIES_CONFLICT' | 'EMPTY_BIN';
+export type WarnFunction = (msg: string, code: WarningCode) => void;
+export declare function linkBins(modulesDir: string, binsDir: string, opts: LinkBinOptions & {
+    allowExoticManifests?: boolean;
+    projectManifest?: ProjectManifest;
+    warn: WarnFunction;
+}): Promise<string[]>;
+export declare function linkBinsOfPkgsByAliases(depsAliases: string[], binsDir: string, opts: LinkBinOptions & {
+    modulesDir: string;
+    allowExoticManifests?: boolean;
+    projectManifest?: ProjectManifest;
+    warn: WarnFunction;
+}): Promise<string[]>;
+export declare function linkBinsOfPackages(pkgs: Array<{
+    manifest: DependencyManifest;
+    location: string;
+}>, binsTarget: string, opts?: LinkBinOptions & {
+    excludeBins?: Set<string>;
+}): Promise<string[]>;
+export interface LinkBinOptions {
+    extraNodePaths?: string[];
+    preferSymlinkedExecutables?: boolean;
+}

package/lib/index.js

@@ -0,0 +1,314 @@
+import { existsSync, promises as fs } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { getBinsFromPackageManifest } from '@pnpm/bins.resolver';
+import { getBunBinLocationForCurrentOS, getDenoBinLocationForCurrentOS, getNodeBinLocationForCurrentOS } from '@pnpm/constants';
+import { PnpmError } from '@pnpm/error';
+import { readModulesDir } from '@pnpm/fs.read-modules-dir';
+import { globalWarn, logger } from '@pnpm/logger';
+import { readPackageJsonFromDir } from '@pnpm/pkg-manifest.reader';
+import { getAllDependenciesFromManifest } from '@pnpm/pkg-manifest.utils';
+import { safeReadProjectManifestOnly } from '@pnpm/workspace.project-manifest-reader';
+import cmdShim from '@zkochan/cmd-shim';
+import { rimraf } from '@zkochan/rimraf';
+import fixBin from 'bin-links/lib/fix-bin.js';
+import { isSubdir } from 'is-subdir';
+import isWindows from 'is-windows';
+import normalizePath from 'normalize-path';
+import { groupBy, isEmpty, partition, unnest } from 'ramda';
+import semver from 'semver';
+import symlinkDir from 'symlink-dir';
+import { getBinNodePaths } from './getBinNodePaths.js';
+const binsConflictLogger = logger('bins-conflict');
+const IS_WINDOWS = isWindows();
+const EXECUTABLE_SHEBANG_SUPPORTED = !IS_WINDOWS;
+const POWER_SHELL_IS_SUPPORTED = IS_WINDOWS;
+export async function linkBins(modulesDir, binsDir, opts) {
+    const allDeps = await readModulesDir(modulesDir);
+    // If the modules dir does not exist, do nothing
+    if (allDeps === null)
+        return [];
+    return linkBinsOfPkgsByAliases(allDeps, binsDir, {
+        ...opts,
+        modulesDir,
+    });
+}
+export async function linkBinsOfPkgsByAliases(depsAliases, binsDir, opts) {
+    const pkgBinOpts = {
+        allowExoticManifests: false,
+        ...opts,
+    };
+    const directDependencies = opts.projectManifest == null
+        ? undefined
+        : new Set(Object.keys(getAllDependenciesFromManifest(opts.projectManifest)));
+    const allCmds = unnest((await Promise.all(depsAliases
+        .map((alias) => ({
+        depDir: path.resolve(opts.modulesDir, alias),
+        isDirectDependency: directDependencies?.has(alias),
+    }))
+        .filter(({ depDir }) => !isSubdir(depDir, binsDir)) // Don't link own bins
+        .map(async ({ depDir, isDirectDependency }) => {
+        const target = normalizePath(depDir);
+        const cmds = await getPackageBins(pkgBinOpts, target);
+        return cmds.map((cmd) => ({ ...cmd, isDirectDependency }));
+    })))
+        .filter((cmds) => cmds.length));
+    const cmdsToLink = directDependencies != null ? preferDirectCmds(allCmds) : allCmds;
+    return _linkBins(cmdsToLink, binsDir, opts);
+}
+function preferDirectCmds(allCmds) {
+    const [directCmds, hoistedCmds] = partition((cmd) => cmd.isDirectDependency === true, allCmds);
+    const usedDirectCmds = new Set(directCmds.map((directCmd) => directCmd.name));
+    return [
+        ...directCmds,
+        ...hoistedCmds.filter(({ name }) => !usedDirectCmds.has(name)),
+    ];
+}
+export async function linkBinsOfPackages(pkgs, binsTarget, opts = {}) {
+    if (pkgs.length === 0)
+        return [];
+    let allCmds = unnest((await Promise.all(pkgs
+        .map(async (pkg) => getPackageBinsFromManifest(pkg.manifest, pkg.location))))
+        .filter((cmds) => cmds.length));
+    const excludeBins = opts.excludeBins;
+    if (excludeBins?.size) {
+        allCmds = allCmds.filter((cmd) => !excludeBins.has(cmd.name));
+    }
+    return _linkBins(allCmds, binsTarget, opts);
+}
+async function _linkBins(allCmds, binsDir, opts) {
+    if (allCmds.length === 0)
+        return [];
+    // deduplicate bin names to prevent race conditions (multiple writers for the same file)
+    allCmds = deduplicateCommands(allCmds, binsDir);
+    await fs.mkdir(binsDir, { recursive: true });
+    const results = await Promise.allSettled(allCmds.map(async cmd => linkBin(cmd, binsDir, opts)));
+    // We want to create all commands that we can create before throwing an exception
+    for (const result of results) {
+        if (result.status === 'rejected') {
+            throw result.reason;
+        }
+    }
+    return allCmds.map(cmd => cmd.pkgName);
+}
+function deduplicateCommands(commands, binsDir) {
+    const cmdGroups = groupBy(cmd => cmd.name, commands);
+    return Object.values(cmdGroups)
+        .filter((group) => group !== undefined && group.length !== 0)
+        .map(group => resolveCommandConflicts(group, binsDir));
+}
+function resolveCommandConflicts(group, binsDir) {
+    return group.reduce((a, b) => {
+        const [chosen, skipped] = compareCommandsInConflict(a, b) >= 0 ? [a, b] : [b, a];
+        logCommandConflict(chosen, skipped, binsDir);
+        return chosen;
+    });
+}
+function compareCommandsInConflict(a, b) {
+    if (a.ownName && !b.ownName)
+        return 1;
+    if (!a.ownName && b.ownName)
+        return -1;
+    if (a.pkgName !== b.pkgName)
+        return a.pkgName.localeCompare(b.pkgName); // it's pointless to compare versions of 2 different package
+    return semver.compare(a.pkgVersion, b.pkgVersion);
+}
+function logCommandConflict(chosen, skipped, binsDir) {
+    binsConflictLogger.debug({
+        binaryName: skipped.name,
+        binsDir,
+        linkedPkgName: chosen.pkgName,
+        linkedPkgVersion: chosen.pkgVersion,
+        skippedPkgName: skipped.pkgName,
+        skippedPkgVersion: skipped.pkgVersion,
+    });
+}
+async function isFromModules(filename) {
+    const real = await fs.realpath(filename);
+    return normalizePath(real).includes('/node_modules/');
+}
+async function getPackageBins(opts, target) {
+    const manifest = opts.allowExoticManifests
+        ? await safeReadProjectManifestOnly(target)
+        : await safeReadPkgJson(target);
+    if (manifest == null) {
+        // There is a probably a better way to do this.
+        // It isn't good to have these hardcoded here.
+        switch (path.basename(target)) {
+            case 'node':
+                return [{
+                        name: 'node',
+                        path: path.join(target, getNodeBinLocationForCurrentOS()),
+                        ownName: true,
+                        pkgName: '',
+                        pkgVersion: '',
+                        makePowerShellShim: false,
+                    }];
+            case 'deno':
+                return [{
+                        name: 'deno',
+                        path: path.join(target, getDenoBinLocationForCurrentOS()),
+                        ownName: true,
+                        pkgName: '',
+                        pkgVersion: '',
+                        makePowerShellShim: false,
+                    }];
+            case 'bun':
+                return [{
+                        name: 'bun',
+                        path: path.join(target, getBunBinLocationForCurrentOS()),
+                        ownName: true,
+                        pkgName: '',
+                        pkgVersion: '',
+                        makePowerShellShim: false,
+                    }];
+        }
+        // There's a directory in node_modules without package.json: ${target}.
+        // This used to be a warning but it didn't really cause any issues.
+        return [];
+    }
+    if (isEmpty(manifest.bin) && !await isFromModules(target)) {
+        opts.warn(`Package in ${target} must have a non-empty bin field to get bin linked.`, 'EMPTY_BIN');
+    }
+    if (typeof manifest.bin === 'string' && !manifest.name) {
+        throw new PnpmError('INVALID_PACKAGE_NAME', `Package in ${target} must have a name to get bin linked.`);
+    }
+    return getPackageBinsFromManifest(manifest, target);
+}
+async function getPackageBinsFromManifest(manifest, pkgDir) {
+    const cmds = await getBinsFromPackageManifest(manifest, pkgDir);
+    let nodeExecPath;
+    if (manifest.engines?.runtime && runtimeHasNodeDownloaded(manifest.engines.runtime)) {
+        const require = createRequire(import.meta.dirname);
+        // Using Node.js’ resolution algorithm is the most reliable way to find the Node.js
+        // package that comes from this CLI's dependencies, because the layout of node_modules can vary.
+        // In an isolated layout, it will be located in the same node_modules directory as the CLI.
+        // In a hoisted layout, it may be in one of the parent node_modules directories.
+        const nodeDir = path.dirname(require.resolve('node/CHANGELOG.md', { paths: [pkgDir] }));
+        if (nodeDir) {
+            nodeExecPath = path.join(nodeDir, IS_WINDOWS ? 'node.exe' : 'bin/node');
+        }
+    }
+    return cmds.map((cmd) => ({
+        ...cmd,
+        ownName: cmd.name === manifest.name,
+        pkgName: manifest.name,
+        pkgVersion: manifest.version,
+        makePowerShellShim: POWER_SHELL_IS_SUPPORTED && manifest.name !== 'pnpm',
+        nodeExecPath,
+    }));
+}
+function runtimeHasNodeDownloaded(runtime) {
+    if (!Array.isArray(runtime)) {
+        return runtime.name === 'node' && runtime.onFail === 'download';
+    }
+    return runtime.find(({ name }) => name === 'node')?.onFail === 'download';
+}
+async function linkBin(cmd, binsDir, opts) {
+    const externalBinPath = path.join(binsDir, cmd.name);
+    if (IS_WINDOWS) {
+        const exePath = path.join(binsDir, `${cmd.name}${getExeExtension()}`);
+        if (existsSync(exePath)) {
+            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')) {
+            try {
+                await fs.link(cmd.path, exePath);
+            }
+            catch {
+                await fs.copyFile(cmd.path, exePath);
+            }
+            return;
+        }
+    }
+    else if (cmd.name === 'node') {
+        // On non-Windows, node should be symlinked directly to the binary
+        // instead of wrapped in a shell shim.
+        // Use rimraf unconditionally instead of existsSync check, because
+        // existsSync follows symlinks and returns false for broken symlinks,
+        // causing EEXIST when the dangling symlink still exists on disk.
+        await rimraf(externalBinPath);
+        await fs.symlink(cmd.path, externalBinPath, 'file');
+        return;
+    }
+    if (opts?.preferSymlinkedExecutables && !IS_WINDOWS && cmd.nodeExecPath == null) {
+        try {
+            await symlinkDir(cmd.path, externalBinPath);
+            await fixBin(cmd.path, 0o755);
+        }
+        catch (err) { // eslint-disable-line
+            if (err.code !== 'ENOENT' && err.code !== 'EISDIR') {
+                throw err;
+            }
+            globalWarn(`Failed to create bin at ${externalBinPath}. ${err.message}`);
+        }
+        return;
+    }
+    try {
+        let nodePath;
+        if (opts?.extraNodePaths?.length) {
+            const binNodePaths = await getBinNodePaths(cmd.path);
+            if (binNodePaths.length === 0) {
+                nodePath = opts.extraNodePaths;
+            }
+            else {
+                nodePath = [...binNodePaths];
+                for (const p of opts.extraNodePaths) {
+                    if (!binNodePaths.includes(p)) {
+                        nodePath.push(p);
+                    }
+                }
+            }
+        }
+        await cmdShim(cmd.path, externalBinPath, {
+            createPwshFile: cmd.makePowerShellShim,
+            nodePath,
+            nodeExecPath: cmd.nodeExecPath,
+        });
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code === 'ENOENT' || err.code === 'EISDIR') {
+            globalWarn(`Failed to create bin at ${externalBinPath}. ${err.message}`);
+            return;
+        }
+        // On Windows, EPERM during bin creation can happen when another process
+        // (e.g. a parallel dlx call) is writing to the same shared bin directory.
+        // The other process will finish creating the bin, so we can safely skip.
+        if (IS_WINDOWS && err.code === 'EPERM') {
+            globalWarn(`Failed to create bin at ${externalBinPath}. ${err.message}`);
+            return;
+        }
+        throw err;
+    }
+    // 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);
+    }
+}
+function getExeExtension() {
+    let cmdExtension;
+    if (process.env.PATHEXT) {
+        cmdExtension = process.env.PATHEXT
+            .split(path.delimiter)
+            .find(ext => ext.toUpperCase() === '.EXE');
+    }
+    return cmdExtension ?? '.exe';
+}
+async function safeReadPkgJson(pkgDir) {
+    try {
+        return await readPackageJsonFromDir(pkgDir);
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@pnpm/bins.linker",
+  "version": "1000.2.6",
+  "description": "Link bins to node_modules/.bin",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "bin"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/bins/linker",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/bins/linker#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@zkochan/cmd-shim": "^8.0.1",
+    "@zkochan/rimraf": "^4.0.0",
+    "bin-links": "^5.0.0",
+    "is-subdir": "^2.0.0",
+    "is-windows": "^1.0.2",
+    "normalize-path": "^3.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "semver": "^7.7.2",
+    "symlink-dir": "^7.0.0",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/bins.resolver": "1000.0.11",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/fs.read-modules-dir": "1000.0.0",
+    "@pnpm/pkg-manifest.utils": "1001.0.6",
+    "@pnpm/pkg-manifest.reader": "1000.1.2",
+    "@pnpm/workspace.project-manifest-reader": "1001.1.4",
+    "@pnpm/types": "1000.9.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@types/is-windows": "^1.0.2",
+    "@types/node": "^22.19.11",
+    "@types/normalize-path": "^3.0.2",
+    "@types/ramda": "0.29.12",
+    "@types/semver": "7.7.1",
+    "cmd-extension": "^2.0.0",
+    "tempy": "3.0.0",
+    "@pnpm/bins.linker": "1000.2.6",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/test-fixtures": "1000.0.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "fix": "tslint -c tslint.json --project . --fix",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}