@pnpm/exec.commands 1001.0.15

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,15 @@
+# @pnpm/plugin-commands-script-runners
+
+> Commands for running scripts
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/plugin-commands-script-runners.svg)](https://www.npmjs.com/package/@pnpm/plugin-commands-script-runners)
+
+## Installation
+
+```sh
+pnpm add @pnpm/plugin-commands-script-runners
+```
+
+## License
+
+MIT

package/lib/buildCommandNotFoundHint.d.ts

@@ -0,0 +1,10 @@
+import type { PackageScripts } from '@pnpm/types';
+export declare function getNearestProgram({ dir, modulesDir, programName, workspaceDir }: {
+    dir: string;
+    modulesDir: string;
+    programName: string;
+    workspaceDir: string | undefined;
+}): string | null;
+export declare function buildCommandNotFoundHint(scriptName: string, scripts?: PackageScripts | undefined): string;
+export declare function getNearestScript(scriptName: string, scripts?: PackageScripts | undefined): string | null;
+export declare function getNearest(name: string, list: readonly string[]): string | null;

package/lib/buildCommandNotFoundHint.js

@@ -0,0 +1,46 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+import didYouMean, { ReturnTypeEnums } from 'didyoumean2';
+export function getNearestProgram({ dir, modulesDir, programName, workspaceDir, }) {
+    try {
+        const binDir = path.join(dir, modulesDir, '.bin');
+        const programList = readProgramsFromDir(binDir);
+        if (workspaceDir && workspaceDir !== dir) {
+            const workspaceBinDir = path.join(workspaceDir, modulesDir, '.bin');
+            programList.push(...readProgramsFromDir(workspaceBinDir));
+        }
+        return getNearest(programName, programList);
+    }
+    catch {
+        return null;
+    }
+}
+function readProgramsFromDir(binDir) {
+    const files = readdirSync(binDir);
+    if (process.platform !== 'win32')
+        return files;
+    const executableExtensions = ['.cmd', '.bat', '.ps1', '.exe', '.com'];
+    return files.map((fullName) => {
+        const { name, ext } = path.parse(fullName);
+        return executableExtensions.includes(ext.toLowerCase()) ? name : fullName;
+    });
+}
+export function buildCommandNotFoundHint(scriptName, scripts) {
+    let hint = `Command "${scriptName}" not found.`;
+    const nearestCommand = getNearestScript(scriptName, scripts);
+    if (nearestCommand) {
+        hint += ` Did you mean "pnpm run ${nearestCommand}"?`;
+    }
+    return hint;
+}
+export function getNearestScript(scriptName, scripts) {
+    return getNearest(scriptName, Object.keys(scripts ?? []));
+}
+export function getNearest(name, list) {
+    if (list == null || list.length === 0)
+        return null;
+    return didYouMean(name, list, {
+        returnType: ReturnTypeEnums.FIRST_CLOSEST_MATCH,
+    });
+}
+//# sourceMappingURL=buildCommandNotFoundHint.js.map

package/lib/create.d.ts

@@ -0,0 +1,8 @@
+import * as dlx from './dlx.js';
+export declare const commandNames: string[];
+export declare function handler(_opts: dlx.DlxCommandOptions, params: string[]): Promise<{
+    exitCode: number;
+} | string>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function help(): string;

package/lib/create.js

@@ -0,0 +1,94 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { renderHelp } from 'render-help';
+import * as dlx from './dlx.js';
+export const commandNames = ['create'];
+export async function handler(_opts, params) {
+    // If the first argument is --help or -h, we show the help message.
+    if (params[0] === '--help' || params[0] === '-h') {
+        return help();
+    }
+    const [packageName, ...packageArgs] = params;
+    if (packageName === undefined) {
+        throw new PnpmError('MISSING_ARGS', 'Missing the template package name.\n' +
+            'The correct usage is `pnpm create <name>` ' +
+            'with <name> substituted for a package name.');
+    }
+    const createPackageName = convertToCreateName(packageName);
+    return dlx.handler(_opts, [createPackageName, ...packageArgs]);
+}
+export function rcOptionsTypes() {
+    return {};
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        'allow-build': [String, Array],
+    };
+}
+export function help() {
+    return renderHelp({
+        description: 'Creates a project from a `create-*` starter kit.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'A list of package names that are allowed to run postinstall scripts during installation',
+                        name: '--allow-build',
+                    },
+                ],
+            },
+        ],
+        url: docsUrl('create'),
+        usages: [
+            'pnpm create <name>',
+            'pnpm create <name-without-create>',
+            'pnpm create <@scope>',
+        ],
+    });
+}
+const CREATE_PREFIX = 'create-';
+/**
+ * Defines the npm's algorithm for resolving a package name
+ * for create-* packages.
+ *
+ * Example:
+ *   - `foo`            -> `create-foo`
+ *   - `@usr/foo`       -> `@usr/create-foo`
+ *   - `@usr`           -> `@usr/create`
+ *   - `@usr@2.0.0`     -> `@usr/create@2.0.0`
+ *   - `@usr/foo@2.0.0` -> `@usr/create-foo@2.0.0`
+ *   - `@usr@latest`    -> `@user/create@latest`
+ *
+ * For more info, see https://docs.npmjs.com/cli/v9/commands/npm-init#description
+ */
+function convertToCreateName(packageName) {
+    if (packageName[0] === '@') {
+        const preferredVersionPosition = packageName.indexOf('@', 1);
+        let preferredVersion = '';
+        if (preferredVersionPosition > -1) {
+            preferredVersion = packageName.substring(preferredVersionPosition);
+            packageName = packageName.substring(0, preferredVersionPosition);
+        }
+        const [scope, scopedPackage = ''] = packageName.split('/');
+        if (scopedPackage === '') {
+            return `${scope}/create${preferredVersion}`;
+        }
+        else {
+            return `${scope}/${ensureCreatePrefixed(scopedPackage)}${preferredVersion}`;
+        }
+    }
+    else {
+        return ensureCreatePrefixed(packageName);
+    }
+}
+function ensureCreatePrefixed(packageName) {
+    if (packageName.startsWith(CREATE_PREFIX)) {
+        return packageName;
+    }
+    else {
+        return `${CREATE_PREFIX}${packageName}`;
+    }
+}
+//# sourceMappingURL=create.js.map

package/lib/dlx.d.ts

@@ -0,0 +1,24 @@
+import { type Config } from '@pnpm/config.reader';
+import { add } from '@pnpm/installing.commands';
+import type { PnpmSettings, SupportedArchitectures } from '@pnpm/types';
+export declare const skipPackageManagerCheck = true;
+export declare const commandNames: string[];
+export declare const shorthands: Record<string, string>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare function help(): string;
+export type DlxCommandOptions = {
+    package?: string[];
+    shellMode?: boolean;
+    allowBuild?: string[];
+} & Pick<Config, 'extraBinPaths' | 'minimumReleaseAgeExclude' | 'registries' | 'reporter' | 'userAgent' | 'cacheDir' | 'dlxCacheMaxAge' | 'symlink'> & Omit<add.AddCommandOptions, 'rootProjectManifestDir'> & PnpmSettings;
+export declare function handler(opts: DlxCommandOptions, [command, ...args]: string[]): Promise<{
+    exitCode: number;
+    output?: string;
+}>;
+export declare function createCacheKey(opts: {
+    packages: string[];
+    registries: Record<string, string>;
+    allowBuild?: string[];
+    supportedArchitectures?: SupportedArchitectures;
+}): string;

package/lib/dlx.js

@@ -0,0 +1,290 @@
+import fs, {} from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { getBinsFromPackageManifest } from '@pnpm/bins.resolver';
+import { resolveFromCatalog, } from '@pnpm/catalogs.resolver';
+import { OUTPUT_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl, readProjectManifestOnly } from '@pnpm/cli.utils';
+import { types } from '@pnpm/config.reader';
+import { createPackageVersionPolicy } from '@pnpm/config.version-policy';
+import { createHexHash } from '@pnpm/crypto.hash';
+import { PnpmError } from '@pnpm/error';
+import { createResolver } from '@pnpm/installing.client';
+import { add } from '@pnpm/installing.commands';
+import { readPackageJsonFromDir } from '@pnpm/pkg-manifest.reader';
+import { parseWantedDependency } from '@pnpm/resolving.parse-wanted-dependency';
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import { safeExeca as execa } from 'execa';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import symlinkDir from 'symlink-dir';
+import { makeEnv } from './makeEnv.js';
+export const skipPackageManagerCheck = true;
+export const commandNames = ['dlx'];
+export const shorthands = {
+    c: '--shell-mode',
+};
+export function rcOptionsTypes() {
+    return {
+        ...pick([
+            'cpu',
+            'libc',
+            'os',
+        ], types),
+        'shell-mode': Boolean,
+    };
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    package: [String, Array],
+    'allow-build': [String, Array],
+});
+export function help() {
+    return renderHelp({
+        description: 'Run a package in a temporary environment.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'The package to install before running the command',
+                        name: '--package',
+                    },
+                    {
+                        description: 'A list of package names that are allowed to run postinstall scripts during installation',
+                        name: '--allow-build',
+                    },
+                    {
+                        description: 'Runs the script inside of a shell. Uses /bin/sh on UNIX and \\cmd.exe on Windows.',
+                        name: '--shell-mode',
+                        shortAlias: '-c',
+                    },
+                ],
+            },
+            OUTPUT_OPTIONS,
+        ],
+        url: docsUrl('dlx'),
+        usages: ['pnpm dlx <command> [args...]'],
+    });
+}
+export async function handler(opts, [command, ...args]) {
+    if (!command && (!opts.package || opts.package.length === 0)) {
+        return { exitCode: 1, output: help() };
+    }
+    const pkgs = opts.package ?? [command];
+    const fullMetadata = ((opts.resolutionMode === 'time-based' ||
+        Boolean(opts.minimumReleaseAge) ||
+        opts.trustPolicy === 'no-downgrade') && !opts.registrySupportsTimeField);
+    const catalogResolver = resolveFromCatalog.bind(null, opts.catalogs ?? {});
+    const { resolve } = createResolver({
+        ...opts,
+        authConfig: opts.rawConfig,
+        fullMetadata,
+        filterMetadata: fullMetadata,
+        retry: {
+            factor: opts.fetchRetryFactor,
+            maxTimeout: opts.fetchRetryMaxtimeout,
+            minTimeout: opts.fetchRetryMintimeout,
+            retries: opts.fetchRetries,
+        },
+        timeout: opts.fetchTimeout,
+    });
+    const resolvedPkgAliases = [];
+    const publishedBy = opts.minimumReleaseAge ? new Date(Date.now() - opts.minimumReleaseAge * 60 * 1000) : undefined;
+    const publishedByExclude = opts.minimumReleaseAgeExclude
+        ? createPackageVersionPolicy(opts.minimumReleaseAgeExclude)
+        : undefined;
+    const resolvedPkgs = await Promise.all(pkgs.map(async (pkg) => {
+        const { alias, bareSpecifier } = parseWantedDependency(pkg) || {};
+        if (alias == null)
+            return pkg;
+        const resolvedBareSpecifier = bareSpecifier != null
+            ? resolveCatalogProtocol(catalogResolver, alias, bareSpecifier)
+            : bareSpecifier;
+        resolvedPkgAliases.push(alias);
+        const resolved = await resolve({ alias, bareSpecifier: resolvedBareSpecifier }, {
+            lockfileDir: opts.lockfileDir ?? opts.dir,
+            preferredVersions: {},
+            projectDir: opts.dir,
+            publishedBy,
+            publishedByExclude,
+        });
+        return resolved.id;
+    }));
+    const { cacheLink, cacheExists, cachedDir } = findCache({
+        packages: resolvedPkgs,
+        dlxCacheMaxAge: opts.dlxCacheMaxAge,
+        cacheDir: opts.cacheDir,
+        registries: opts.registries,
+        allowBuild: opts.allowBuild,
+        supportedArchitectures: opts.supportedArchitectures,
+    });
+    if (!cacheExists) {
+        fs.mkdirSync(cachedDir, { recursive: true });
+        await add.handler({
+            ...opts,
+            enableGlobalVirtualStore: opts.enableGlobalVirtualStore ?? true,
+            bin: path.join(cachedDir, 'node_modules/.bin'),
+            dir: cachedDir,
+            lockfileDir: cachedDir,
+            allowBuilds: Object.fromEntries([...resolvedPkgAliases, ...(opts.allowBuild ?? [])].map(pkg => [pkg, true])),
+            rootProjectManifestDir: cachedDir,
+            saveProd: true, // dlx will be looking for the package in the "dependencies" field!
+            saveDev: false,
+            saveOptional: false,
+            savePeer: false,
+            symlink: true,
+            workspaceDir: undefined,
+        }, resolvedPkgs);
+        try {
+            await symlinkDir(cachedDir, cacheLink, { overwrite: true });
+        }
+        catch (error) {
+            // EBUSY/EEXIST/EPERM means that there is another dlx process running in parallel that has acquired the cache link first.
+            // EPERM can happen on Windows when another process has the symlink open while this process tries to unlink it.
+            // The link created by the other process is just as up-to-date as the link the current process was attempting
+            // to create. Therefore, instead of re-attempting to create the current link again, it is just as good to let
+            // the other link stay. The current process should yield.
+            if (!util.types.isNativeError(error) || !('code' in error) || (error.code !== 'EBUSY' && error.code !== 'EEXIST' && error.code !== 'EPERM')) {
+                throw error;
+            }
+        }
+    }
+    const binsDir = path.join(cachedDir, 'node_modules/.bin');
+    const env = makeEnv({
+        userAgent: opts.userAgent,
+        prependPaths: [binsDir, ...opts.extraBinPaths],
+    });
+    const binName = opts.package
+        ? command
+        : await getBinName(cachedDir, opts);
+    try {
+        await execa(binName, args, {
+            cwd: process.cwd(),
+            env,
+            stdio: 'inherit',
+            shell: opts.shellMode ?? false,
+        });
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'exitCode' in err && err.exitCode != null) {
+            return {
+                exitCode: err.exitCode,
+            };
+        }
+        throw err;
+    }
+    return { exitCode: 0 };
+}
+async function getPkgName(pkgDir) {
+    const manifest = await readPackageJsonFromDir(pkgDir);
+    const dependencyNames = Object.keys(manifest.dependencies ?? {});
+    if (dependencyNames.length === 0) {
+        throw new PnpmError('DLX_NO_DEP', 'dlx was unable to find the installed dependency in "dependencies"');
+    }
+    return dependencyNames[0];
+}
+async function getBinName(cachedDir, opts) {
+    const pkgName = await getPkgName(cachedDir);
+    const pkgDir = path.join(cachedDir, 'node_modules', pkgName);
+    const manifest = await readProjectManifestOnly(pkgDir, opts);
+    const bins = await getBinsFromPackageManifest(manifest, pkgDir);
+    if (bins.length === 0) {
+        throw new PnpmError('DLX_NO_BIN', `No binaries found in ${pkgName}`);
+    }
+    if (bins.length === 1) {
+        return bins[0].name;
+    }
+    const scopelessPkgName = scopeless(manifest.name);
+    const defaultBin = bins.find(({ name }) => name === scopelessPkgName);
+    if (defaultBin)
+        return defaultBin.name;
+    const binNames = bins.map(({ name }) => name);
+    throw new PnpmError('DLX_MULTIPLE_BINS', `Could not determine executable to run. ${pkgName} has multiple binaries: ${binNames.join(', ')}`, {
+        hint: `Try one of the following:
+${binNames.map(name => `pnpm --package=${pkgName} dlx ${name}`).join('\n')}
+`,
+    });
+}
+function scopeless(pkgName) {
+    if (pkgName[0] === '@') {
+        return pkgName.split('/')[1];
+    }
+    return pkgName;
+}
+function findCache(opts) {
+    const dlxCommandCacheDir = createDlxCommandCacheDir(opts);
+    const cacheLink = path.join(dlxCommandCacheDir, 'pkg');
+    const cachedDir = getValidCacheDir(cacheLink, opts.dlxCacheMaxAge);
+    return {
+        cacheLink,
+        cachedDir: cachedDir ?? getPrepareDir(dlxCommandCacheDir),
+        cacheExists: cachedDir != null,
+    };
+}
+function createDlxCommandCacheDir(opts) {
+    const dlxCacheDir = path.resolve(opts.cacheDir, 'dlx');
+    const cacheKey = createCacheKey(opts);
+    const cachePath = path.join(dlxCacheDir, cacheKey);
+    fs.mkdirSync(cachePath, { recursive: true });
+    return cachePath;
+}
+export function createCacheKey(opts) {
+    const sortedPkgs = [...opts.packages].sort(lexCompare);
+    const sortedRegistries = Object.entries(opts.registries).sort(([k1], [k2]) => lexCompare(k1, k2));
+    const args = [sortedPkgs, sortedRegistries];
+    if (opts.allowBuild?.length) {
+        args.push({ allowBuild: opts.allowBuild.sort(lexCompare) });
+    }
+    if (opts.supportedArchitectures) {
+        const supportedArchitecturesKeys = ['cpu', 'libc', 'os'];
+        for (const key of supportedArchitecturesKeys) {
+            const value = opts.supportedArchitectures[key];
+            if (!value?.length)
+                continue;
+            args.push({
+                supportedArchitectures: {
+                    [key]: [...new Set(value)].sort(lexCompare),
+                },
+            });
+        }
+    }
+    const hashStr = JSON.stringify(args);
+    return createHexHash(hashStr);
+}
+function getValidCacheDir(cacheLink, dlxCacheMaxAge) {
+    let stats;
+    let target;
+    try {
+        stats = fs.lstatSync(cacheLink);
+        if (stats.isSymbolicLink()) {
+            target = fs.realpathSync(cacheLink);
+            if (!target)
+                return undefined;
+        }
+        else {
+            return undefined;
+        }
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return undefined;
+        }
+        throw err;
+    }
+    const isValid = stats.mtime.getTime() + dlxCacheMaxAge * 60_000 >= new Date().getTime();
+    return isValid ? target : undefined;
+}
+function getPrepareDir(cachePath) {
+    const name = `${new Date().getTime().toString(16)}-${process.pid.toString(16)}`;
+    return path.join(cachePath, name);
+}
+function resolveCatalogProtocol(catalogResolver, alias, bareSpecifier) {
+    const result = catalogResolver({ alias, bareSpecifier });
+    switch (result.type) {
+        case 'found': return result.resolution.specifier;
+        case 'unused': return bareSpecifier;
+        case 'misconfiguration': throw result.error;
+    }
+}
+//# sourceMappingURL=dlx.js.map

package/lib/exec.d.ts

@@ -0,0 +1,34 @@
+import { type RecursiveSummary } from '@pnpm/cli.utils';
+import { type Config } from '@pnpm/config.reader';
+import type { CheckDepsStatusOptions } from '@pnpm/deps.status';
+import type { ProjectRootDir, ProjectsGraph } from '@pnpm/types';
+export declare const shorthands: Record<string, string | string[]>;
+export declare const commandNames: string[];
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare function help(): string;
+export declare function getResumedPackageChunks({ resumeFrom, chunks, selectedProjectsGraph }: {
+    resumeFrom: string;
+    chunks: ProjectRootDir[][];
+    selectedProjectsGraph: ProjectsGraph;
+}): ProjectRootDir[][];
+export declare function writeRecursiveSummary(opts: {
+    dir: string;
+    summary: RecursiveSummary;
+}): Promise<void>;
+export declare function createEmptyRecursiveSummary(chunks: string[][]): RecursiveSummary;
+export declare function getExecutionDuration(start: [number, number]): number;
+export type ExecOpts = Required<Pick<Config, 'selectedProjectsGraph'>> & {
+    bail?: boolean;
+    unsafePerm?: boolean;
+    reverse?: boolean;
+    sort?: boolean;
+    workspaceConcurrency?: number;
+    shellMode?: boolean;
+    resumeFrom?: string;
+    reportSummary?: boolean;
+    implicitlyFellbackFromRun?: boolean;
+} & Pick<Config, 'bin' | 'cliOptions' | 'dir' | 'extraBinPaths' | 'extraEnv' | 'lockfileDir' | 'modulesDir' | 'nodeOptions' | 'pnpmHomeDir' | 'rawConfig' | 'recursive' | 'reporterHidePrefix' | 'userAgent' | 'verifyDepsBeforeRun' | 'workspaceDir'> & CheckDepsStatusOptions;
+export declare function handler(opts: ExecOpts, params: string[]): Promise<{
+    exitCode: number;
+}>;