@pnpm/exec.commands 1001.0.15

package/lib/exec.js

@@ -0,0 +1,328 @@
+import path from 'node:path';
+import { FILTERING, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl, readProjectManifestOnly, throwOnCommandFail } from '@pnpm/cli.utils';
+import { getWorkspaceConcurrency, types } from '@pnpm/config.reader';
+import { lifecycleLogger } from '@pnpm/core-loggers';
+import { PnpmError } from '@pnpm/error';
+import { makeNodeRequireOption } from '@pnpm/exec.lifecycle';
+import { logger } from '@pnpm/logger';
+import { prependDirsToPath } from '@pnpm/shell.path';
+import { tryReadProjectManifest } from '@pnpm/workspace.project-manifest-reader';
+import { sortProjects } from '@pnpm/workspace.projects-sorter';
+import { safeExeca as execa } from 'execa';
+import pLimit from 'p-limit';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import which from 'which';
+import { writeJsonFile } from 'write-json-file';
+import { getNearestProgram, getNearestScript } from './buildCommandNotFoundHint.js';
+import { existsInDir } from './existsInDir.js';
+import { makeEnv } from './makeEnv.js';
+import { PARALLEL_OPTION_HELP, REPORT_SUMMARY_OPTION_HELP, RESUME_FROM_OPTION_HELP, shorthands as runShorthands, } from './run.js';
+import { runDepsStatusCheck } from './runDepsStatusCheck.js';
+export const shorthands = {
+    parallel: runShorthands.parallel,
+    c: '--shell-mode',
+};
+export const commandNames = ['exec'];
+export function rcOptionsTypes() {
+    return {
+        ...pick([
+            'bail',
+            'sort',
+            'unsafe-perm',
+            'workspace-concurrency',
+            'reporter-hide-prefix',
+        ], types),
+        'shell-mode': Boolean,
+        'resume-from': String,
+        'report-summary': Boolean,
+    };
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    recursive: Boolean,
+    reverse: Boolean,
+});
+export function help() {
+    return renderHelp({
+        description: 'Run a shell command in the context of a project.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Do not hide project name prefix from output of recursively running command.',
+                        name: '--no-reporter-hide-prefix',
+                    },
+                    PARALLEL_OPTION_HELP,
+                    {
+                        description: 'Run the shell command in every package found in subdirectories \
+or every workspace package, when executed inside a workspace. \
+For options that may be used with `-r`, see "pnpm help recursive"',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    {
+                        description: 'If exist, runs file inside of a shell. \
+Uses /bin/sh on UNIX and \\cmd.exe on Windows. \
+The shell should understand the -c switch on UNIX or /d /s /c on Windows.',
+                        name: '--shell-mode',
+                        shortAlias: '-c',
+                    },
+                    RESUME_FROM_OPTION_HELP,
+                    REPORT_SUMMARY_OPTION_HELP,
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('exec'),
+        usages: ['pnpm [-r] [-c] exec <command> [args...]'],
+    });
+}
+export function getResumedPackageChunks({ resumeFrom, chunks, selectedProjectsGraph, }) {
+    const resumeFromPackagePrefix = Object.keys(selectedProjectsGraph)
+        .find((prefix) => selectedProjectsGraph[prefix]?.package.manifest.name === resumeFrom);
+    if (!resumeFromPackagePrefix) {
+        throw new PnpmError('RESUME_FROM_NOT_FOUND', `Cannot find package ${resumeFrom}. Could not determine where to resume from.`);
+    }
+    const chunkPosition = chunks.findIndex(chunk => chunk.includes(resumeFromPackagePrefix));
+    return chunks.slice(chunkPosition);
+}
+export async function writeRecursiveSummary(opts) {
+    await writeJsonFile(path.join(opts.dir, 'pnpm-exec-summary.json'), {
+        executionStatus: opts.summary,
+    });
+}
+export function createEmptyRecursiveSummary(chunks) {
+    const acc = {};
+    for (const prefix of chunks.flat()) {
+        acc[prefix] = { status: 'queued' };
+    }
+    return acc;
+}
+export function getExecutionDuration(start) {
+    const end = process.hrtime(start);
+    return (end[0] * 1e9 + end[1]) / 1e6;
+}
+export async function handler(opts, params) {
+    // For backward compatibility
+    if (params[0] === '--') {
+        params.shift();
+    }
+    if (!params[0]) {
+        throw new PnpmError('EXEC_MISSING_COMMAND', '\'pnpm exec\' requires a command to run');
+    }
+    const limitRun = pLimit(getWorkspaceConcurrency(opts.workspaceConcurrency));
+    if (opts.verifyDepsBeforeRun) {
+        await runDepsStatusCheck(opts);
+    }
+    let chunks;
+    if (opts.recursive) {
+        chunks = opts.sort
+            ? sortProjects(opts.selectedProjectsGraph)
+            : [Object.keys(opts.selectedProjectsGraph).sort()];
+        if (opts.reverse) {
+            chunks = chunks.reverse();
+        }
+    }
+    else {
+        chunks = [[(opts.cliOptions.dir ?? process.cwd())]];
+        const project = await tryReadProjectManifest(opts.dir);
+        if (project.manifest != null) {
+            opts.selectedProjectsGraph = {
+                [opts.dir]: {
+                    dependencies: [],
+                    package: {
+                        ...project,
+                        rootDir: opts.dir,
+                        rootDirRealPath: opts.dir,
+                    },
+                },
+            };
+        }
+    }
+    if (!opts.selectedProjectsGraph) {
+        throw new PnpmError('RECURSIVE_EXEC_NO_PACKAGE', 'No package found in this workspace');
+    }
+    if (opts.resumeFrom) {
+        chunks = getResumedPackageChunks({
+            resumeFrom: opts.resumeFrom,
+            chunks,
+            selectedProjectsGraph: opts.selectedProjectsGraph,
+        });
+    }
+    const result = createEmptyRecursiveSummary(chunks);
+    const existsPnp = existsInDir.bind(null, '.pnp.cjs');
+    const workspacePnpPath = opts.workspaceDir && existsPnp(opts.workspaceDir);
+    let exitCode = 0;
+    const prependPaths = [
+        './node_modules/.bin',
+        ...(opts.extraBinPaths ?? []),
+    ];
+    const reporterShowPrefix = opts.recursive && opts.reporterHidePrefix === false;
+    for (const chunk of chunks) {
+        // eslint-disable-next-line no-await-in-loop
+        await Promise.all(chunk.map(async (prefix) => limitRun(async () => {
+            result[prefix].status = 'running';
+            const startTime = process.hrtime();
+            try {
+                const pnpPath = workspacePnpPath ?? existsPnp(prefix);
+                const extraEnv = {
+                    ...opts.extraEnv,
+                    ...(pnpPath ? makeNodeRequireOption(pnpPath) : {}),
+                };
+                const env = makeEnv({
+                    extraEnv: {
+                        ...extraEnv,
+                        PNPM_PACKAGE_NAME: opts.selectedProjectsGraph[prefix]?.package.manifest.name,
+                        ...(opts.nodeOptions ? { NODE_OPTIONS: opts.nodeOptions } : {}),
+                    },
+                    prependPaths,
+                    userAgent: opts.userAgent,
+                });
+                const [cmd, ...args] = params;
+                if (reporterShowPrefix) {
+                    const manifest = await readProjectManifestOnly(prefix);
+                    const child = execa(cmd, args, {
+                        cwd: prefix,
+                        env,
+                        stdio: 'pipe',
+                        shell: opts.shellMode ?? false,
+                    });
+                    const lifecycleOpts = {
+                        wd: prefix,
+                        depPath: manifest.name ?? path.relative(opts.dir, prefix),
+                        stage: '(exec)',
+                    };
+                    const logFn = (stdio) => (data) => {
+                        for (const line of String(data).split('\n')) {
+                            lifecycleLogger.debug({
+                                ...lifecycleOpts,
+                                stdio,
+                                line,
+                            });
+                        }
+                    };
+                    child.stdout.on('data', logFn('stdout'));
+                    child.stderr.on('data', logFn('stderr'));
+                    await new Promise((resolve) => {
+                        void child.once('close', exitCode => {
+                            lifecycleLogger.debug({
+                                ...lifecycleOpts,
+                                exitCode: exitCode ?? 1,
+                                optional: false,
+                            });
+                            resolve();
+                        });
+                    });
+                    await child;
+                }
+                else {
+                    await execa(cmd, args, {
+                        cwd: prefix,
+                        env,
+                        stdio: 'inherit',
+                        shell: opts.shellMode ?? false,
+                    });
+                }
+                result[prefix].status = 'passed';
+                result[prefix].duration = getExecutionDuration(startTime);
+            }
+            catch (err) { // eslint-disable-line
+                if (isErrorCommandNotFound(params[0], err, prependPaths)) {
+                    err.message = `Command "${params[0]}" not found`;
+                    err.hint = await createExecCommandNotFoundHint(params[0], {
+                        implicitlyFellbackFromRun: opts.implicitlyFellbackFromRun ?? false,
+                        dir: opts.dir,
+                        workspaceDir: opts.workspaceDir,
+                        modulesDir: opts.modulesDir ?? 'node_modules',
+                    });
+                }
+                else if (!opts.recursive && typeof err.exitCode === 'number') {
+                    exitCode = err.exitCode;
+                    return;
+                }
+                logger.info(err);
+                result[prefix] = {
+                    status: 'failure',
+                    duration: getExecutionDuration(startTime),
+                    error: err,
+                    message: err.message,
+                    prefix,
+                };
+                if (!opts.bail) {
+                    return;
+                }
+                if (!err['code']?.startsWith('ERR_PNPM_')) {
+                    err['code'] = 'ERR_PNPM_RECURSIVE_EXEC_FIRST_FAIL';
+                }
+                err['prefix'] = prefix;
+                if (opts.reportSummary) {
+                    await writeRecursiveSummary({
+                        dir: opts.lockfileDir ?? opts.dir,
+                        summary: result,
+                    });
+                }
+                throw err;
+            }
+        })));
+    }
+    if (opts.reportSummary) {
+        await writeRecursiveSummary({
+            dir: opts.lockfileDir ?? opts.dir,
+            summary: result,
+        });
+    }
+    throwOnCommandFail('pnpm recursive exec', result);
+    return { exitCode };
+}
+async function createExecCommandNotFoundHint(programName, opts) {
+    if (opts.implicitlyFellbackFromRun) {
+        let nearestScript;
+        try {
+            nearestScript = getNearestScript(programName, (await readProjectManifestOnly(opts.dir)).scripts);
+        }
+        catch { }
+        if (nearestScript) {
+            return `Did you mean "pnpm ${nearestScript}"?`;
+        }
+        const nearestProgram = getNearestProgram({
+            programName,
+            dir: opts.dir,
+            workspaceDir: opts.workspaceDir,
+            modulesDir: opts.modulesDir,
+        });
+        if (nearestProgram) {
+            return `Did you mean "pnpm ${nearestProgram}"?`;
+        }
+        return undefined;
+    }
+    const nearestProgram = getNearestProgram({
+        programName,
+        dir: opts.dir,
+        workspaceDir: opts.workspaceDir,
+        modulesDir: opts.modulesDir,
+    });
+    if (nearestProgram) {
+        return `Did you mean "pnpm exec ${nearestProgram}"?`;
+    }
+    return undefined;
+}
+function isErrorCommandNotFound(command, error, prependPaths) {
+    // Mac/Linux
+    if (process.platform === 'linux' || process.platform === 'darwin') {
+        return error.originalMessage === `spawn ${command} ENOENT`;
+    }
+    // Windows
+    if (process.platform === 'win32') {
+        const { value: path } = prependDirsToPath(prependPaths);
+        return !which.sync(command, {
+            nothrow: true,
+            path,
+        });
+    }
+    return false;
+}
+//# sourceMappingURL=exec.js.map

package/lib/existsInDir.d.ts

@@ -0,0 +1 @@
+export declare function existsInDir(entityName: string, dir: string): string | undefined;

package/lib/existsInDir.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function existsInDir(entityName, dir) {
+    const entityPath = path.join(dir, entityName);
+    if (fs.existsSync(entityPath))
+        return entityPath;
+    return undefined;
+}
+//# sourceMappingURL=existsInDir.js.map

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import * as create from './create.js';
+import * as dlx from './dlx.js';
+import * as exec from './exec.js';
+import * as restart from './restart.js';
+import * as run from './run.js';
+export { create, dlx, exec, restart, run };

package/lib/index.js

@@ -0,0 +1,7 @@
+import * as create from './create.js';
+import * as dlx from './dlx.js';
+import * as exec from './exec.js';
+import * as restart from './restart.js';
+import * as run from './run.js';
+export { create, dlx, exec, restart, run };
+//# sourceMappingURL=index.js.map

package/lib/makeEnv.d.ts

@@ -0,0 +1,10 @@
+export interface Env extends NodeJS.ProcessEnv {
+    npm_config_user_agent: string;
+    PATH?: string;
+    Path?: string;
+}
+export declare function makeEnv(opts: {
+    extraEnv?: NodeJS.ProcessEnv;
+    userAgent?: string;
+    prependPaths: string[];
+}): Env;

package/lib/makeEnv.js

@@ -0,0 +1,20 @@
+import path from 'node:path';
+import { PnpmError } from '@pnpm/error';
+import { prependDirsToPath } from '@pnpm/shell.path';
+export function makeEnv(opts) {
+    for (const prependPath of opts.prependPaths) {
+        if (prependPath.includes(path.delimiter)) {
+            // Unfortunately, there is no way to escape the PATH delimiter,
+            // so directories added to the PATH should not contain it.
+            throw new PnpmError('BAD_PATH_DIR', `Cannot add ${prependPath} to PATH because it contains the path delimiter character (${path.delimiter})`);
+        }
+    }
+    const pathEnv = prependDirsToPath(opts.prependPaths);
+    return {
+        ...process.env,
+        ...opts.extraEnv,
+        npm_config_user_agent: opts.userAgent ?? 'pnpm',
+        [pathEnv.name]: pathEnv.value,
+    };
+}
+//# sourceMappingURL=makeEnv.js.map

package/lib/regexpCommand.d.ts

@@ -0,0 +1 @@
+export declare function tryBuildRegExpFromCommand(command: string): RegExp | null;

package/lib/regexpCommand.js

@@ -0,0 +1,21 @@
+import { PnpmError } from '@pnpm/error';
+export function tryBuildRegExpFromCommand(command) {
+    // https://github.com/stdlib-js/regexp-regexp/blob/6428051ac9ef7c9d03468b19bdbb1dc6fc2a5509/lib/regexp.js
+    const regExpDetectRegExpScriptCommand = /^\/((?:\\\/|[^/])+)\/([dgimuvys]*)$/;
+    const match = command.match(regExpDetectRegExpScriptCommand);
+    // if the passed script selector is not in the format of RegExp literal like /build:.*/, return null and handle it as a string script command
+    if (!match) {
+        return null;
+    }
+    // if the passed RegExp script selector includes flag, report the error because RegExp flag is not useful for script selector and pnpm does not support this.
+    if (match[2]) {
+        throw new PnpmError('UNSUPPORTED_SCRIPT_COMMAND_FORMAT', 'RegExp flags are not supported in script command selector');
+    }
+    try {
+        return new RegExp(match[1]);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=regexpCommand.js.map

package/lib/restart.d.ts

@@ -0,0 +1,6 @@
+import { type RunOpts } from './run.js';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: RunOpts, params: string[]): Promise<void>;

package/lib/restart.js

@@ -0,0 +1,35 @@
+import { types as allTypes } from '@pnpm/config.reader';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { handler as run, IF_PRESENT_OPTION, IF_PRESENT_OPTION_HELP, } from './run.js';
+export function rcOptionsTypes() {
+    return {
+        ...pick([
+            'npm-path',
+        ], allTypes),
+    };
+}
+export function cliOptionsTypes() {
+    return IF_PRESENT_OPTION;
+}
+export const commandNames = ['restart'];
+export function help() {
+    return renderHelp({
+        description: 'Restarts a package. Runs a package\'s "stop", "restart", and "start" scripts, and associated pre- and post- scripts.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    IF_PRESENT_OPTION_HELP,
+                ],
+            },
+        ],
+        usages: ['pnpm restart [-- <args>...]'],
+    });
+}
+export async function handler(opts, params) {
+    await run(opts, ['stop', ...params]);
+    await run(opts, ['restart', ...params]);
+    await run(opts, ['start', ...params]);
+}
+//# sourceMappingURL=restart.js.map

package/lib/run.d.ts

@@ -0,0 +1,50 @@
+import type { CompletionFunc } from '@pnpm/cli.command';
+import { type Config } from '@pnpm/config.reader';
+import type { CheckDepsStatusOptions } from '@pnpm/deps.status';
+import { type RunLifecycleHookOptions } from '@pnpm/exec.lifecycle';
+import type { ProjectManifest } from '@pnpm/types';
+import { type RecursiveRunOpts } from './runRecursive.js';
+export declare const IF_PRESENT_OPTION: Record<string, unknown>;
+export interface DescriptionItem {
+    shortAlias?: string;
+    name: string;
+    description?: string;
+}
+export declare const IF_PRESENT_OPTION_HELP: DescriptionItem;
+export declare const PARALLEL_OPTION_HELP: DescriptionItem;
+export declare const RESUME_FROM_OPTION_HELP: DescriptionItem;
+export declare const SEQUENTIAL_OPTION_HELP: DescriptionItem;
+export declare const REPORT_SUMMARY_OPTION_HELP: DescriptionItem;
+export declare const REPORTER_HIDE_PREFIX_HELP: DescriptionItem;
+export declare const shorthands: Record<string, string[]>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const completion: CompletionFunc;
+export declare const commandNames: string[];
+export declare function help(): string;
+export type RunOpts = Omit<RecursiveRunOpts, 'allProjects' | 'selectedProjectsGraph' | 'workspaceDir'> & {
+    recursive?: boolean;
+} & Pick<Config, 'bin' | 'cliOptions' | 'verifyDepsBeforeRun' | 'dir' | 'enablePrePostScripts' | 'engineStrict' | 'extraBinPaths' | 'extraEnv' | 'nodeOptions' | 'pnpmHomeDir' | 'reporter' | 'scriptShell' | 'scriptsPrependNodePath' | 'shellEmulator' | 'syncInjectedDepsAfterScripts' | 'userAgent'> & (({
+    recursive?: false;
+} & Partial<Pick<Config, 'allProjects' | 'selectedProjectsGraph' | 'workspaceDir'>>) | ({
+    recursive: true;
+} & Required<Pick<Config, 'allProjects' | 'selectedProjectsGraph' | 'workspaceDir'>>)) & {
+    argv?: {
+        original: string[];
+    };
+    fallbackCommandUsed?: boolean;
+} & CheckDepsStatusOptions;
+export declare function handler(opts: RunOpts, params: string[]): Promise<string | {
+    exitCode: number;
+} | undefined>;
+export interface RunScriptOptions {
+    enablePrePostScripts: boolean;
+    syncInjectedDepsAfterScripts: string[] | undefined;
+    workspaceDir: string | undefined;
+}
+export declare function runScript(opts: {
+    manifest: ProjectManifest;
+    lifecycleOpts: RunLifecycleHookOptions;
+    runScriptOptions: RunScriptOptions;
+    passedThruArgs: string[];
+}, scriptName: string): Promise<void>;