@pnpm/exec.commands 1001.0.15

package/lib/run.js

@@ -0,0 +1,336 @@
+import path from 'node:path';
+import { FILTERING, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl, readProjectManifestOnly, tryReadProjectManifest, } from '@pnpm/cli.utils';
+import { getWorkspaceConcurrency, types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { makeNodeRequireOption, runLifecycleHook, } from '@pnpm/exec.lifecycle';
+import { syncInjectedDeps } from '@pnpm/workspace.injected-deps-syncer';
+import pLimit from 'p-limit';
+import { pick } from 'ramda';
+import { realpathMissing } from 'realpath-missing';
+import { renderHelp } from 'render-help';
+import { buildCommandNotFoundHint } from './buildCommandNotFoundHint.js';
+import { handler as exec } from './exec.js';
+import { existsInDir } from './existsInDir.js';
+import { runDepsStatusCheck } from './runDepsStatusCheck.js';
+import { getSpecifiedScripts as getSpecifiedScriptWithoutStartCommand, runRecursive } from './runRecursive.js';
+export const IF_PRESENT_OPTION = {
+    'if-present': Boolean,
+};
+export const IF_PRESENT_OPTION_HELP = {
+    description: 'Avoid exiting with a non-zero exit code when the script is undefined',
+    name: '--if-present',
+};
+export const PARALLEL_OPTION_HELP = {
+    description: 'Completely disregard concurrency and topological sorting, \
+running a given script immediately in all matching packages \
+with prefixed streaming output. This is the preferred flag \
+for long-running processes such as watch run over many packages.',
+    name: '--parallel',
+};
+export const RESUME_FROM_OPTION_HELP = {
+    description: 'Command executed from given package',
+    name: '--resume-from',
+};
+export const SEQUENTIAL_OPTION_HELP = {
+    description: 'Run the specified scripts one by one',
+    name: '--sequential',
+};
+export const REPORT_SUMMARY_OPTION_HELP = {
+    description: 'Save the execution results of every package to "pnpm-exec-summary.json". Useful to inspect the execution time and status of each package.',
+    name: '--report-summary',
+};
+export const REPORTER_HIDE_PREFIX_HELP = {
+    description: 'Hide project name prefix from output of running scripts. Useful when running in CI like GitHub Actions and the output from a script may create an annotation.',
+    name: '--reporter-hide-prefix',
+};
+export const shorthands = {
+    parallel: [
+        '--workspace-concurrency=Infinity',
+        '--no-sort',
+        '--stream',
+        '--recursive',
+    ],
+    sequential: [
+        '--workspace-concurrency=1',
+    ],
+};
+export function rcOptionsTypes() {
+    return {
+        ...pick([
+            'npm-path',
+        ], allTypes),
+    };
+}
+export function cliOptionsTypes() {
+    return {
+        ...pick([
+            'bail',
+            'sort',
+            'unsafe-perm',
+            'workspace-concurrency',
+            'scripts-prepend-node-path',
+        ], allTypes),
+        ...IF_PRESENT_OPTION,
+        recursive: Boolean,
+        reverse: Boolean,
+        'resume-from': String,
+        'report-summary': Boolean,
+        'reporter-hide-prefix': Boolean,
+    };
+}
+export const completion = async (cliOpts, params) => {
+    if (params.length > 0) {
+        return [];
+    }
+    const manifest = await readProjectManifestOnly(cliOpts.dir ?? process.cwd(), cliOpts);
+    return Object.keys(manifest.scripts ?? {}).map((name) => ({ name }));
+};
+export const commandNames = ['run', 'run-script'];
+export function help() {
+    return renderHelp({
+        aliases: ['run-script'],
+        description: 'Runs a defined package script.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Run the defined package script 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: 'The command will exit with a 0 exit code even if the script fails',
+                        name: '--no-bail',
+                    },
+                    IF_PRESENT_OPTION_HELP,
+                    PARALLEL_OPTION_HELP,
+                    RESUME_FROM_OPTION_HELP,
+                    ...UNIVERSAL_OPTIONS,
+                    SEQUENTIAL_OPTION_HELP,
+                    REPORT_SUMMARY_OPTION_HELP,
+                    REPORTER_HIDE_PREFIX_HELP,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('run'),
+        usages: ['pnpm run <command> [<args>...]'],
+    });
+}
+export async function handler(opts, params) {
+    let dir;
+    if (opts.fallbackCommandUsed && (params[0] === 't' || params[0] === 'tst')) {
+        params[0] = 'test';
+    }
+    const [scriptName, ...passedThruArgs] = params;
+    if (opts.verifyDepsBeforeRun) {
+        await runDepsStatusCheck(opts);
+    }
+    if (opts.nodeOptions) {
+        opts.extraEnv = {
+            ...opts.extraEnv,
+            NODE_OPTIONS: opts.nodeOptions,
+        };
+    }
+    if (opts.recursive) {
+        if (scriptName || Object.keys(opts.selectedProjectsGraph).length > 1) {
+            return runRecursive(params, opts);
+        }
+        dir = Object.keys(opts.selectedProjectsGraph)[0];
+    }
+    else {
+        dir = opts.dir;
+    }
+    const manifest = await readProjectManifestOnly(dir, opts);
+    if (!scriptName) {
+        const rootManifest = opts.workspaceDir && opts.workspaceDir !== dir
+            ? (await tryReadProjectManifest(opts.workspaceDir, opts)).manifest
+            : undefined;
+        return printProjectCommands(manifest, rootManifest ?? undefined);
+    }
+    const specifiedScripts = getSpecifiedScripts(manifest.scripts ?? {}, scriptName);
+    if (specifiedScripts.length < 1) {
+        if (opts.ifPresent)
+            return;
+        if (opts.fallbackCommandUsed) {
+            if (opts.argv == null)
+                throw new Error('Could not fallback because opts.argv.original was not passed to the script runner');
+            const params = opts.argv.original.slice(1);
+            while (params.length > 0 && params[0][0] === '-' && params[0] !== '--') {
+                params.shift();
+            }
+            if (params.length > 0 && params[0] === '--') {
+                params.shift();
+            }
+            if (params.length === 0) {
+                throw new PnpmError('UNEXPECTED_BEHAVIOR', 'Params should not be an empty array', {
+                    hint: 'This was a bug caused by programmer error. Please report it',
+                });
+            }
+            return exec({
+                selectedProjectsGraph: {},
+                implicitlyFellbackFromRun: true,
+                ...opts,
+            }, params);
+        }
+        if (opts.workspaceDir) {
+            const { manifest: rootManifest } = await tryReadProjectManifest(opts.workspaceDir, opts);
+            if (getSpecifiedScripts(rootManifest?.scripts ?? {}, scriptName).length > 0 && specifiedScripts.length < 1) {
+                throw new PnpmError('NO_SCRIPT', `Missing script: ${scriptName}`, {
+                    hint: `But script matched with ${scriptName} is present in the root of the workspace,
+so you may run "pnpm -w run ${scriptName}"`,
+                });
+            }
+        }
+        throw new PnpmError('NO_SCRIPT', `Missing script: ${scriptName}`, {
+            hint: buildCommandNotFoundHint(scriptName, manifest.scripts),
+        });
+    }
+    const concurrency = getWorkspaceConcurrency(opts.workspaceConcurrency);
+    const lifecycleOpts = {
+        depPath: dir,
+        extraBinPaths: opts.extraBinPaths,
+        extraEnv: opts.extraEnv,
+        pkgRoot: dir,
+        rawConfig: opts.rawConfig,
+        rootModulesDir: await realpathMissing(path.join(dir, 'node_modules')),
+        scriptsPrependNodePath: opts.scriptsPrependNodePath,
+        scriptShell: opts.scriptShell,
+        silent: opts.reporter === 'silent',
+        shellEmulator: opts.shellEmulator,
+        stdio: (specifiedScripts.length > 1 && concurrency > 1) ? 'pipe' : 'inherit',
+        unsafePerm: true, // when running scripts explicitly, assume that they're trusted.
+    };
+    const existsPnp = existsInDir.bind(null, '.pnp.cjs');
+    const pnpPath = (opts.workspaceDir && existsPnp(opts.workspaceDir)) ?? existsPnp(dir);
+    if (pnpPath) {
+        lifecycleOpts.extraEnv = {
+            ...lifecycleOpts.extraEnv,
+            ...makeNodeRequireOption(pnpPath),
+        };
+    }
+    try {
+        const limitRun = pLimit(concurrency);
+        const runScriptOptions = {
+            enablePrePostScripts: opts.enablePrePostScripts ?? false,
+            syncInjectedDepsAfterScripts: opts.syncInjectedDepsAfterScripts,
+            workspaceDir: opts.workspaceDir,
+        };
+        const _runScript = runScript.bind(null, { manifest, lifecycleOpts, runScriptOptions, passedThruArgs });
+        await Promise.all(specifiedScripts.map(script => limitRun(() => _runScript(script))));
+    }
+    catch (err) {
+        if (opts.bail !== false) {
+            throw err;
+        }
+    }
+    return undefined;
+}
+const ALL_LIFECYCLE_SCRIPTS = new Set([
+    'prepublish',
+    'prepare',
+    'prepublishOnly',
+    'prepack',
+    'postpack',
+    'publish',
+    'postpublish',
+    'preinstall',
+    'install',
+    'postinstall',
+    'preuninstall',
+    'uninstall',
+    'postuninstall',
+    'preversion',
+    'version',
+    'postversion',
+    'pretest',
+    'test',
+    'posttest',
+    'prestop',
+    'stop',
+    'poststop',
+    'prestart',
+    'start',
+    'poststart',
+    'prerestart',
+    'restart',
+    'postrestart',
+    'preshrinkwrap',
+    'shrinkwrap',
+    'postshrinkwrap',
+]);
+function printProjectCommands(manifest, rootManifest) {
+    const lifecycleScripts = [];
+    const otherScripts = [];
+    for (const [scriptName, script] of Object.entries(manifest.scripts ?? {})) {
+        if (ALL_LIFECYCLE_SCRIPTS.has(scriptName)) {
+            lifecycleScripts.push([scriptName, script]);
+        }
+        else {
+            otherScripts.push([scriptName, script]);
+        }
+    }
+    if (lifecycleScripts.length === 0 && otherScripts.length === 0) {
+        return 'There are no scripts specified.';
+    }
+    let output = '';
+    if (lifecycleScripts.length > 0) {
+        output += `Lifecycle scripts:\n${renderCommands(lifecycleScripts)}`;
+    }
+    if (otherScripts.length > 0) {
+        if (output !== '')
+            output += '\n\n';
+        output += `Commands available via "pnpm run":\n${renderCommands(otherScripts)}`;
+    }
+    if ((rootManifest?.scripts) == null) {
+        return output;
+    }
+    const rootScripts = Object.entries(rootManifest.scripts);
+    if (rootScripts.length === 0) {
+        return output;
+    }
+    if (output !== '')
+        output += '\n\n';
+    output += `Commands of the root workspace project (to run them, use "pnpm -w run"):
+${renderCommands(rootScripts)}`;
+    return output;
+}
+export async function runScript(opts, scriptName) {
+    if (opts.runScriptOptions.enablePrePostScripts &&
+        opts.manifest.scripts?.[`pre${scriptName}`] &&
+        !opts.manifest.scripts[scriptName].includes(`pre${scriptName}`)) {
+        await runLifecycleHook(`pre${scriptName}`, opts.manifest, opts.lifecycleOpts);
+    }
+    await runLifecycleHook(scriptName, opts.manifest, { ...opts.lifecycleOpts, args: opts.passedThruArgs });
+    if (opts.runScriptOptions.enablePrePostScripts &&
+        opts.manifest.scripts?.[`post${scriptName}`] &&
+        !opts.manifest.scripts[scriptName].includes(`post${scriptName}`)) {
+        await runLifecycleHook(`post${scriptName}`, opts.manifest, opts.lifecycleOpts);
+    }
+    if (opts.runScriptOptions.syncInjectedDepsAfterScripts?.includes(scriptName)) {
+        await syncInjectedDeps({
+            pkgName: opts.manifest.name,
+            pkgRootDir: opts.lifecycleOpts.pkgRoot,
+            workspaceDir: opts.runScriptOptions.workspaceDir,
+        });
+    }
+}
+function renderCommands(commands) {
+    return commands.map(([scriptName, script]) => `  ${scriptName}\n    ${script}`).join('\n');
+}
+function getSpecifiedScripts(scripts, scriptName) {
+    const specifiedSelector = getSpecifiedScriptWithoutStartCommand(scripts, scriptName);
+    if (specifiedSelector.length > 0) {
+        return specifiedSelector;
+    }
+    // if a user passes start command as scriptName, `node server.js` will be executed as a fallback, so return start command even if start command is not defined in package.json
+    if (scriptName === 'start') {
+        return [scriptName];
+    }
+    return [];
+}
+//# sourceMappingURL=run.js.map

package/lib/runDepsStatusCheck.d.ts

@@ -0,0 +1,8 @@
+import type { VerifyDepsBeforeRun } from '@pnpm/config.reader';
+import { type CheckDepsStatusOptions, type WorkspaceStateSettings } from '@pnpm/deps.status';
+export interface RunDepsStatusCheckOptions extends CheckDepsStatusOptions {
+    dir: string;
+    verifyDepsBeforeRun?: VerifyDepsBeforeRun;
+}
+export declare function runDepsStatusCheck(opts: RunDepsStatusCheckOptions): Promise<void>;
+export declare function createInstallArgs(opts: Pick<WorkspaceStateSettings, 'dev' | 'optional' | 'production'> | undefined): string[];

package/lib/runDepsStatusCheck.js

@@ -0,0 +1,74 @@
+import { checkDepsStatus } from '@pnpm/deps.status';
+import { PnpmError } from '@pnpm/error';
+import { runPnpmCli } from '@pnpm/exec.pnpm-cli-runner';
+import { globalWarn } from '@pnpm/logger';
+import enquirer from 'enquirer';
+export async function runDepsStatusCheck(opts) {
+    // the following flags are always the default values during `pnpm run` and `pnpm exec`,
+    // so they may not match the workspace state after `pnpm install --production|--no-optional`
+    const ignoredWorkspaceStateSettings = ['dev', 'optional', 'production'];
+    opts.ignoredWorkspaceStateSettings = ignoredWorkspaceStateSettings;
+    const { upToDate, issue, workspaceState } = await checkDepsStatus(opts);
+    if (upToDate)
+        return;
+    const command = ['install', ...createInstallArgs(workspaceState?.settings)];
+    const install = runPnpmCli.bind(null, command, { cwd: opts.dir });
+    switch (opts.verifyDepsBeforeRun) {
+        case 'install':
+            install();
+            break;
+        case 'prompt': {
+            // In non-TTY environments (like CI), we can't prompt the user
+            // Exit with error to alert users that node_modules are out of sync
+            if (!process.stdin.isTTY) {
+                throw new PnpmError('VERIFY_DEPS_BEFORE_RUN', issue ?? 'Your node_modules are out of sync with your lockfile', {
+                    hint: 'Run "pnpm install" before running scripts. The "verifyDepsBeforeRun: prompt" setting cannot prompt for confirmation in non-interactive environments.',
+                });
+            }
+            let confirmed;
+            try {
+                confirmed = await enquirer.prompt({
+                    type: 'confirm',
+                    name: 'runInstall',
+                    message: `Your "node_modules" directory is out of sync with the "pnpm-lock.yaml" file. This can lead to issues during scripts execution.
+
+Would you like to run "pnpm ${command.join(' ')}" to update your "node_modules"?`,
+                    initial: true,
+                });
+            }
+            catch {
+                // User cancelled the prompt (e.g. Ctrl+C) — exit immediately
+                // so the caller doesn't proceed to run the script.
+                process.exit(1);
+            }
+            if (confirmed.runInstall) {
+                install();
+            }
+            break;
+        }
+        case 'error':
+            throw new PnpmError('VERIFY_DEPS_BEFORE_RUN', issue ?? 'Your node_modules are out of sync with your lockfile', {
+                hint: 'Run "pnpm install"',
+            });
+        case 'warn':
+            globalWarn(`Your node_modules are out of sync with your lockfile. ${issue}`);
+            break;
+    }
+}
+export function createInstallArgs(opts) {
+    const args = [];
+    if (!opts)
+        return args;
+    const { dev, optional, production } = opts;
+    if (production && !dev) {
+        args.push('--production');
+    }
+    else if (dev && !production) {
+        args.push('--dev');
+    }
+    if (!optional) {
+        args.push('--no-optional');
+    }
+    return args;
+}
+//# sourceMappingURL=runDepsStatusCheck.js.map

package/lib/runRecursive.d.ts

@@ -0,0 +1,9 @@
+import { type Config } from '@pnpm/config.reader';
+import type { PackageScripts } from '@pnpm/types';
+export type RecursiveRunOpts = Pick<Config, 'bin' | 'enablePrePostScripts' | 'unsafePerm' | 'pnpmHomeDir' | 'rawConfig' | 'requiredScripts' | 'rootProjectManifest' | 'scriptsPrependNodePath' | 'scriptShell' | 'shellEmulator' | 'stream' | 'syncInjectedDepsAfterScripts' | 'workspaceDir'> & Required<Pick<Config, 'allProjects' | 'selectedProjectsGraph' | 'workspaceDir' | 'dir'>> & Partial<Pick<Config, 'extraBinPaths' | 'extraEnv' | 'bail' | 'reporter' | 'reverse' | 'sort' | 'workspaceConcurrency'>> & {
+    ifPresent?: boolean;
+    resumeFrom?: string;
+    reportSummary?: boolean;
+};
+export declare function runRecursive(params: string[], opts: RecursiveRunOpts): Promise<void>;
+export declare function getSpecifiedScripts(scripts: PackageScripts, scriptName: string): string[];

package/lib/runRecursive.js

@@ -0,0 +1,173 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import util from 'node:util';
+import { throwOnCommandFail } from '@pnpm/cli.utils';
+import { getWorkspaceConcurrency } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { makeNodeRequireOption, } from '@pnpm/exec.lifecycle';
+import { groupStart } from '@pnpm/log.group';
+import { sortProjects } from '@pnpm/workspace.projects-sorter';
+import pLimit from 'p-limit';
+import { realpathMissing } from 'realpath-missing';
+import { createEmptyRecursiveSummary, getExecutionDuration, getResumedPackageChunks, writeRecursiveSummary } from './exec.js';
+import { existsInDir } from './existsInDir.js';
+import { tryBuildRegExpFromCommand } from './regexpCommand.js';
+import { runScript } from './run.js';
+export async function runRecursive(params, opts) {
+    const [scriptName, ...passedThruArgs] = params;
+    if (!scriptName) {
+        throw new PnpmError('SCRIPT_NAME_IS_REQUIRED', 'You must specify the script you want to run');
+    }
+    let hasCommand = 0;
+    const sortedPackageChunks = opts.sort
+        ? sortProjects(opts.selectedProjectsGraph)
+        : [Object.keys(opts.selectedProjectsGraph).sort()];
+    let packageChunks = opts.reverse ? sortedPackageChunks.reverse() : sortedPackageChunks;
+    if (opts.resumeFrom) {
+        packageChunks = getResumedPackageChunks({
+            resumeFrom: opts.resumeFrom,
+            chunks: packageChunks,
+            selectedProjectsGraph: opts.selectedProjectsGraph,
+        });
+    }
+    const limitRun = pLimit(getWorkspaceConcurrency(opts.workspaceConcurrency));
+    const stdio = !opts.stream &&
+        (opts.workspaceConcurrency === 1 ||
+            (packageChunks.length === 1 && packageChunks[0].length === 1))
+        ? 'inherit'
+        : 'pipe';
+    const existsPnp = existsInDir.bind(null, '.pnp.cjs');
+    const workspacePnpPath = opts.workspaceDir && existsPnp(opts.workspaceDir);
+    const requiredScripts = opts.requiredScripts ?? [];
+    if (requiredScripts.includes(scriptName)) {
+        const missingScriptPackages = packageChunks
+            .flat()
+            .map((prefix) => opts.selectedProjectsGraph[prefix])
+            .filter((pkg) => getSpecifiedScripts(pkg.package.manifest.scripts ?? {}, scriptName).length < 1)
+            .map((pkg) => pkg.package.manifest.name ?? pkg.package.rootDir);
+        if (missingScriptPackages.length) {
+            throw new PnpmError('RECURSIVE_RUN_NO_SCRIPT', `Missing script "${scriptName}" in packages: ${missingScriptPackages.join(', ')}`);
+        }
+    }
+    const result = createEmptyRecursiveSummary(packageChunks);
+    for (const chunk of packageChunks) {
+        const selectedScripts = chunk.map(prefix => {
+            const pkg = opts.selectedProjectsGraph[prefix];
+            const specifiedScripts = getSpecifiedScripts(pkg.package.manifest.scripts ?? {}, scriptName);
+            if (!specifiedScripts.length) {
+                result[prefix].status = 'skipped';
+            }
+            return specifiedScripts.map(script => ({ prefix, scriptName: script }));
+        }).flat();
+        // eslint-disable-next-line no-await-in-loop
+        await Promise.all(selectedScripts.map(async ({ prefix, scriptName }) => limitRun(async () => {
+            const pkg = opts.selectedProjectsGraph[prefix];
+            if (!pkg.package.manifest.scripts?.[scriptName] ||
+                process.env.npm_lifecycle_event === scriptName &&
+                    process.env.PNPM_SCRIPT_SRC_DIR === prefix) {
+                return;
+            }
+            result[prefix].status = 'running';
+            const startTime = process.hrtime();
+            hasCommand++;
+            try {
+                const lifecycleOpts = {
+                    depPath: prefix,
+                    extraBinPaths: opts.extraBinPaths,
+                    extraEnv: opts.extraEnv,
+                    pkgRoot: prefix,
+                    rawConfig: opts.rawConfig,
+                    rootModulesDir: await realpathMissing(path.join(prefix, 'node_modules')),
+                    scriptsPrependNodePath: opts.scriptsPrependNodePath,
+                    scriptShell: opts.scriptShell,
+                    silent: opts.reporter === 'silent',
+                    shellEmulator: opts.shellEmulator,
+                    stdio,
+                    unsafePerm: true, // when running scripts explicitly, assume that they're trusted.
+                };
+                const pnpPath = workspacePnpPath ?? existsPnp(prefix);
+                if (pnpPath) {
+                    lifecycleOpts.extraEnv = {
+                        ...lifecycleOpts.extraEnv,
+                        ...makeNodeRequireOption(pnpPath),
+                    };
+                }
+                const runScriptOptions = {
+                    enablePrePostScripts: opts.enablePrePostScripts ?? false,
+                    syncInjectedDepsAfterScripts: opts.syncInjectedDepsAfterScripts,
+                    workspaceDir: opts.workspaceDir,
+                };
+                const _runScript = runScript.bind(null, { manifest: pkg.package.manifest, lifecycleOpts, runScriptOptions, passedThruArgs });
+                const groupEnd = Boolean(lifecycleOpts.silent) || getWorkspaceConcurrency(opts.workspaceConcurrency) > 1
+                    ? undefined
+                    : groupStart(formatSectionName({
+                        name: pkg.package.manifest.name,
+                        script: scriptName,
+                        version: pkg.package.manifest.version,
+                        prefix: path.normalize(path.relative(opts.workspaceDir, prefix)),
+                    }));
+                await _runScript(scriptName);
+                groupEnd?.();
+                result[prefix].status = 'passed';
+                result[prefix].duration = getExecutionDuration(startTime);
+            }
+            catch (err) {
+                assert(util.types.isNativeError(err));
+                result[prefix] = {
+                    status: 'failure',
+                    duration: getExecutionDuration(startTime),
+                    error: err,
+                    message: err.message,
+                    prefix,
+                };
+                if (!opts.bail) {
+                    return;
+                }
+                Object.assign(err, {
+                    code: 'ERR_PNPM_RECURSIVE_RUN_FIRST_FAIL',
+                    prefix,
+                });
+                if (opts.reportSummary) {
+                    await writeRecursiveSummary({
+                        dir: opts.workspaceDir ?? opts.dir,
+                        summary: result,
+                    });
+                }
+                throw err;
+            }
+        })));
+    }
+    if (scriptName !== 'test' && !hasCommand && !opts.ifPresent) {
+        const allPackagesAreSelected = Object.keys(opts.selectedProjectsGraph).length === opts.allProjects.length;
+        if (allPackagesAreSelected) {
+            throw new PnpmError('RECURSIVE_RUN_NO_SCRIPT', `None of the packages has a "${scriptName}" script`);
+        }
+        else {
+            throw new PnpmError('RECURSIVE_RUN_NO_SCRIPT', `None of the selected packages has a "${scriptName}" script`);
+        }
+    }
+    if (opts.reportSummary) {
+        await writeRecursiveSummary({
+            dir: opts.workspaceDir ?? opts.dir,
+            summary: result,
+        });
+    }
+    throwOnCommandFail('pnpm recursive run', result);
+}
+function formatSectionName({ script, name, version, prefix, }) {
+    return `${name ?? 'unknown'}${version ? `@${version}` : ''} ${script ? `: ${script}` : ''} ${prefix}`;
+}
+export function getSpecifiedScripts(scripts, scriptName) {
+    // if scripts in package.json has script which is equal to scriptName a user passes, return it.
+    if (scripts[scriptName]) {
+        return [scriptName];
+    }
+    const scriptSelector = tryBuildRegExpFromCommand(scriptName);
+    // if scriptName which a user passes is RegExp (like /build:.*/), multiple scripts to execute will be selected with RegExp
+    if (scriptSelector) {
+        const scriptKeys = Object.keys(scripts);
+        return scriptKeys.filter(script => script.match(scriptSelector));
+    }
+    return [];
+}
+//# sourceMappingURL=runRecursive.js.map