@lerna-lite/exec

(lerna exec) - Exec command [optional] 👷

Optional package extracted from Lerna exec command that will give us the ability to execute an arbitrary command in each package.

This package was added mainly because NPM Workspaces don't yet support executing commands in parallel and in topological order (they do have this RFC, so perhaps someday this package would become irrelevant :)).

Installation

npm install @lerna-lite/exec -D

# then use it (see usage below)
lerna exec <command>
# or via pnpm
pnpm exec lerna exec <command>

Usage

$ lerna exec -- <command> [..args] # runs the command in all packages
$ lerna exec -- rm -rf ./node_modules
$ lerna exec -- protractor conf.js

Run an arbitrary command in each package. A double-dash (--) is necessary to pass dashed flags to the spawned command, but is not necessary when all the arguments are positional.

The name of the current package is available through the environment variable LERNA_PACKAGE_NAME:

$ lerna exec -- npm view \$LERNA_PACKAGE_NAME

You may also run a script located in the root dir, in a complicated dir structure through the environment variable LERNA_ROOT_PATH:

$ lerna exec -- node \$LERNA_ROOT_PATH/scripts/some-script.js

Options

lerna exec accepts all filter flags.

$ lerna exec --scope my-component -- ls -la

Note When executing the command in the shell, you will need to surround the command provided to lerna exec in quotes (what comes after double-dash --). Without this, the entire line is interpreted by your shell before lerna ever sees it and causes command flags to be returned as unknown. For example lerna exec -- 'git log -p -2'. This is not required when used as an npm script.

• @lerna/exec
  • Usage
  • Options
    • --dry-run
    • --stream
    • --parallel
    • --no-bail
    • --no-prefix
    • --no-shell
    • --profile
    • --profile-location <location>

The commands are spawned in parallel, using the concurrency given (except with --parallel). The output is piped through, so not deterministic. If you want to run the command in one package after another, use it like this:

$ lerna exec --concurrency 1 -- ls -la

--dry-run

Displays the execution command that would be performed without actually executing it. This could be helpful for troubleshooting.

$ lerna exec echo hello world --dry-run

--stream

Stream output from child processes immediately, prefixed with the originating package name. This allows output from different packages to be interleaved.

$ lerna exec --stream -- babel src -d lib

--parallel

Similar to --stream, but completely disregards concurrency and topological sorting, running a given command or script immediately in all matching packages with prefixed streaming output. This is the preferred flag for long-running processes such as babel src -d lib -w run over many packages.

$ lerna exec --parallel -- babel src -d lib -w

Note: It is advised to constrain the scope of this command when using the --parallel flag, as spawning dozens of subprocesses may be harmful to your shell's equanimity (or maximum file descriptor limit, for example). YMMV

--no-bail

# Run a command, ignoring non-zero (error) exit codes
$ lerna exec --no-bail <command>

By default, lerna exec will exit with an error if any execution returns a non-zero exit code. Pass --no-bail to disable this behavior, executing in all packages regardless of exit code.

--no-prefix

Disable package name prefixing when output is streaming (--stream or --parallel). This option can be useful when piping results to other processes, such as editor plugins.

--no-shell

By default, lerna exec runs the given command within a system shell (e.g., /bin/sh on Unix or cmd.exe on Windows). Pass --no-shell to disable this behavior and spawn the process directly.

# Execute cross-env-shell without the overhead of an extra system shell
$ lerna exec --no-shell -- cross-env-shell 'echo hello from $LERNA_PACKAGE_NAME'

This option is particularly useful for:

• Silencing DEP0190 Warnings: Modern Node.js versions (v20+) emit the DEP0190 DeprecationWarning when passing raw strings containing environment variables to a shell. Disabling the shell wrapper resolves this warning.
• Cross-Platform Reliability: When using shell-agnostic tools like cross-env-shell, bypassing the system shell prevents inconsistent variable expansion or escaping issues between different environments (e.g., Bash vs. Dash on Linux).

Note: When --no-shell is active, native shell operators such as &&, |, and > will not work, as no shell is present to interpret them.

--profile

Profiles the command executions and produces a performance profile which can be analyzed using DevTools in a Chromium-based browser (direct url: devtools://devtools/bundled/devtools_app.html). The profile shows a timeline of the command executions where each execution is assigned to an open slot. The number of slots is determined by the --concurrency option and the number of open slots is determined by --concurrency minus the number of ongoing operations. The end result is a visualization of the parallel execution of your commands.

The default location of the performance profile output is at the root of your project.

$ lerna exec --profile -- <command>

Note: Lerna will only profile when topological sorting is enabled (i.e. without --parallel and --no-sort).

--profile-location <location>

You can provide a custom location for the performance profile output. The path provided will be resolved relative to the current working directory.

$ lerna exec --profile --profile-location=logs/profile/ -- <command>