GitHub image
execa
⌘K
execa logo

Coverage Status

Process execution for humans





Why

This package improves child_process methods with:

Install

npm install execa

Usage

Promise interface

import {execa} from 'execa'; const {stdout} = await execa('echo', ['unicorns']); console.log(stdout); //=> 'unicorns'

Scripts interface

For more information about Execa scripts, please see this page.

Basic

import {$} from 'execa'; const branch = await $`git branch --show-current`; await $`dep deploy --branch=${branch}`;

Multiple arguments

import {$} from 'execa'; const args = ['unicorns', '&', 'rainbows!']; const {stdout} = await $`echo ${args}`; console.log(stdout); //=> 'unicorns & rainbows!'

With options

import {$} from 'execa'; await $({stdio: 'inherit'})`echo unicorns`; //=> 'unicorns'

Global/shared options

import {$ as $_} from 'execa'; const $ = $_({stdio: 'inherit'}); await $`echo unicorns`; //=> 'unicorns' await $`echo rainbows`; //=> 'rainbows'

Piping

import {$} from 'execa'; await $`npm run build` .pipe`sort` .pipe`head -n2`;

Verbose mode

> node file.js unicorns rainbows > NODE_DEBUG=execa node file.js [19:49:00.360] [0] $ echo unicorns unicorns [19:49:00.383] [0] √ (done in 23ms) [19:49:00.383] [1] $ echo rainbows rainbows [19:49:00.404] [1] √ (done in 21ms)

Input/output

Redirect output to a file

import {execa} from 'execa'; // Similar to `echo unicorns > stdout.txt` in Bash await execa('echo', ['unicorns'], {stdout: {file: 'stdout.txt'}}); // Similar to `echo unicorns 2> stdout.txt` in Bash await execa('echo', ['unicorns'], {stderr: {file: 'stderr.txt'}}); // Similar to `echo unicorns &> stdout.txt` in Bash await execa('echo', ['unicorns'], {stdout: {file: 'all.txt'}, stderr: {file: 'all.txt'}});

Redirect input from a file

import {execa} from 'execa'; // Similar to `cat < stdin.txt` in Bash const {stdout} = await execa('cat', {inputFile: 'stdin.txt'}); console.log(stdout); //=> 'unicorns'

Save and pipe output from a subprocess

import {execa} from 'execa'; const {stdout} = await execa('echo', ['unicorns'], {stdout: ['pipe', 'inherit']}); // Prints `unicorns` console.log(stdout); // Also returns 'unicorns'

Pipe multiple subprocesses

import {execa} from 'execa'; // Similar to `npm run build | sort | head -n2` in Bash const {stdout, pipedFrom} = await execa('npm', ['run', 'build']) .pipe('sort') .pipe('head', ['-n2']); console.log(stdout); // Result of `head -n2` console.log(pipedFrom[0]); // Result of `sort` console.log(pipedFrom[0].pipedFrom[0]); // Result of `npm run build`

Handling Errors

import {execa} from 'execa'; // Catching an error try { await execa('unknown', ['command']); } catch (error) { console.log(error); /* { message: 'Command failed with ENOENT: unknown command\nspawn unknown ENOENT', errno: -2, code: 'ENOENT', syscall: 'spawn unknown', path: 'unknown', spawnargs: ['command'], shortMessage: 'Command failed with ENOENT: unknown command\nspawn unknown ENOENT', originalMessage: 'spawn unknown ENOENT', command: 'unknown command', escapedCommand: 'unknown command', cwd: '/path/to/cwd', durationMs: 28.217566, failed: true, timedOut: false, isCanceled: false, isTerminated: false, stdout: '', stderr: '', stdio: [undefined, '', ''], pipedFrom: [] } */ }

API

Methods

execa(file, arguments?, options?)

file: string | URL
arguments: string[]
options: Options
Returns: Subprocess

Executes a command using file ...arguments.

Arguments are automatically escaped. They can contain any character, including spaces.

This is the preferred method when executing single commands.

$`command`

$(options)`command`

command: string
options: Options
Returns: Subprocess

Executes a command. The command string includes both the file and its arguments.

Arguments are automatically escaped. They can contain any character, but spaces, tabs and newlines must use ${} like $`echo ${'has space'}`.

This is the preferred method when executing multiple commands in a script file.

The command string can inject any ${value} with the following types: string, number, subprocess or an array of those types. For example: $`echo one ${'two'} ${3} ${['four', 'five']}`. For ${subprocess}, the subprocess's stdout is used.

The command string can use multiple lines and indentation.

For more information, please see this section and this page.

$(options)

options: Options
Returns: $

Returns a new instance of $ but with different default options. Consecutive calls are merged to previous ones.

This can be used to either:

  • Set options for a specific command: $(options)`command`
  • Share options for multiple commands: const $$ = $(options); $$`command`; $$`otherCommand`;

execaCommand(command, options?)

command: string
options: Options
Returns: Subprocess

Executes a command. The command string includes both the file and its arguments.

Arguments are automatically escaped. They can contain any character, but spaces must be escaped with a backslash like execaCommand('echo has\\ space').

This is the preferred method when executing a user-supplied command string, such as in a REPL.

execaNode(scriptPath, arguments?, options?)

file: string | URL
arguments: string[]
options: Options
Returns: Subprocess

Same as execa() but using the node option.

Executes a Node.js file using node scriptPath ...arguments.

This is the preferred method when executing Node.js files.

execaSync(file, arguments?, options?)

execaCommandSync(command, options?)

$.sync`command`

$.s`command`

$.sync(options)`command`

$.s(options)`command`

Same as execa(), execaCommand(), $`command` but synchronous.

Cannot use the following options: all, cleanup, buffer, detached, ipc, serialization, cancelSignal, lines and verbose: 'full'. Also, the stdin, stdout, stderr, stdio and input options cannot be an array, an iterable, a transform or a web stream. Node.js streams must have a file descriptor unless the input option is used.

Returns or throws a subprocessResult. The subprocess is not returned: its methods and properties are not available. This includes .kill(), .pid, .pipe() and the .stdin/.stdout/.stderr streams.

Shell syntax

For all the methods above, no shell interpreter (Bash, cmd.exe, etc.) is used unless the shell option is set. This means shell-specific characters and expressions ($variable, &&, ||, ;, |, etc.) have no special meaning and do not need to be escaped.

subprocess

The return value of all asynchronous methods is both:

all

Type: ReadableStream | undefined

Stream combining/interleaving stdout and stderr.

This is undefined if either:

pipe(file, arguments?, options?)

file: string | URL
arguments: string[]
options: Options and PipeOptions
Returns: Promise<SubprocessResult>

Pipe the subprocess' stdout to a second Execa subprocess' stdin. This resolves with that second subprocess' result. If either subprocess is rejected, this is rejected with that subprocess' error instead.

This follows the same syntax as execa(file, arguments?, options?) except both regular options and pipe-specific options can be specified.

This can be called multiple times to chain a series of subprocesses.

Multiple subprocesses can be piped to the same subprocess. Conversely, the same subprocess can be piped to multiple other subprocesses.

This is usually the preferred method to pipe subprocesses.

pipe`command`

pipe(options)`command`

command: string
options: Options and PipeOptions
Returns: Promise<SubprocessResult>

Like .pipe(file, arguments?, options?) but using a command template string instead. This follows the same syntax as $.

This is the preferred method to pipe subprocesses when using $.

pipe(secondSubprocess, pipeOptions?)

secondSubprocess: execa() return value
pipeOptions: PipeOptions
Returns: Promise<SubprocessResult>

Like .pipe(file, arguments?, options?) but using the return value of another execa() call instead.

This is the most advanced method to pipe subprocesses. It is useful in specific cases, such as piping multiple subprocesses to the same subprocess.

pipeOptions

Type: object

pipeOptions.from

Type: "stdout" | "stderr" | "all" | number
Default: "stdout"

Which stream to pipe from the source subprocess. A file descriptor number can also be passed.

"all" pipes both stdout and stderr. This requires the all option to be true.

pipeOptions.to

Type: "stdin" | number
Default: "stdin"

Which stream to pipe to the destination subprocess. A file descriptor number can also be passed.

pipeOptions.unpipeSignal

Type: AbortSignal

Unpipe the subprocess when the signal aborts.

The .pipe() method will be rejected with a cancellation error.

kill(signal, error?)

kill(error?)

signal: string | number
error: Error
Returns: boolean

Sends a signal to the subprocess. The default signal is the killSignal option. killSignal defaults to SIGTERM, which terminates the subprocess.

This returns false when the signal could not be sent, for example when the subprocess has already exited.

When an error is passed as argument, its message and stack trace are kept in the subprocess' error. The subprocess is then terminated with the default signal. This does not emit the error event.

More info.

SubprocessResult

Type: object

Result of a subprocess execution. On success this is a plain object. On failure this is also an Error instance.

The subprocess fails when:

command

Type: string

The file and arguments that were run, for logging purposes.

This is not escaped and should not be executed directly as a subprocess, including using execa() or execaCommand().

escapedCommand

Type: string

Same as command but escaped.

Unlike command, control characters are escaped, which makes it safe to print in a terminal.

This can also be copied and pasted into a shell, for debugging purposes. Since the escaping is fairly basic, this should not be executed directly as a subprocess, including using execa() or execaCommand().

cwd

Type: string

The current directory in which the command was run.

durationMs

Type: number

Duration of the subprocess, in milliseconds.

stdout

Type: string | Uint8Array | string[] | Uint8Array[] | unknown[] | undefined

The output of the subprocess on stdout.

This is undefined if the stdout option is set to only 'inherit', 'ignore', Stream or integer. This is an array if the lines option is true, or if the stdout option is a transform in object mode.

stderr

Type: string | Uint8Array | string[] | Uint8Array[] | unknown[] | undefined

The output of the subprocess on stderr.

This is undefined if the stderr option is set to only 'inherit', 'ignore', Stream or integer. This is an array if the lines option is true, or if the stderr option is a transform in object mode.

all

Type: string | Uint8Array | string[] | Uint8Array[] | unknown[] | undefined

The output of the subprocess with stdout and stderr interleaved.

This is undefined if either:

This is an array if the lines option is true, or if either the stdout or stderr option is a transform in object mode.

stdio

Type: Array<string | Uint8Array | string[] | Uint8Array[] | unknown[] | undefined>

The output of the subprocess on stdin, stdout, stderr and other file descriptors.

Items are undefined when their corresponding stdio option is set to 'inherit', 'ignore', Stream or integer. Items are arrays when their corresponding stdio option is a transform in object mode.

message

Type: string

Error message when the subprocess failed to run. In addition to the underlying error message, it also contains some information related to why the subprocess errored.

The subprocess stderr, stdout and other file descriptors' output are appended to the end, separated with newlines and not interleaved.

shortMessage

Type: string

This is the same as the message property except it does not include the subprocess stdout/stderr/stdio.

originalMessage

Type: string | undefined

Original error message. This is the same as the message property excluding the subprocess stdout/stderr/stdio and some additional information added by Execa.

This is undefined unless the subprocess exited due to an error event or a timeout.

failed

Type: boolean

Whether the subprocess failed to run.

timedOut

Type: boolean

Whether the subprocess timed out.

isCanceled

Type: boolean

Whether the subprocess was canceled using the cancelSignal option.

isTerminated

Type: boolean

Whether the subprocess was terminated by a signal (like SIGTERM) sent by either:

exitCode

Type: number | undefined

The numeric exit code of the subprocess that was run.

This is undefined when the subprocess could not be spawned or was terminated by a signal.

signal

Type: string | undefined

The name of the signal (like SIGTERM) that terminated the subprocess, sent by either:

If a signal terminated the subprocess, this property is defined and included in the error message. Otherwise it is undefined.

signalDescription

Type: string | undefined

A human-friendly description of the signal that was used to terminate the subprocess. For example, Floating point arithmetic error.

If a signal terminated the subprocess, this property is defined and included in the error message. Otherwise it is undefined. It is also undefined when the signal is very uncommon which should seldomly happen.

pipedFrom

Type: SubprocessResult[]

Results of the other subprocesses that were piped into this subprocess. This is useful to inspect a series of subprocesses piped with each other.

This array is initially empty and is populated each time the .pipe() method resolves.

options

Type: object

This lists all Execa options, including some options which are the same as for child_process#spawn()/child_process#exec().

reject

Type: boolean
Default: true

Setting this to false resolves the promise with the error instead of rejecting it.

shell

Type: boolean | string | URL
Default: false

If true, runs file inside of a shell. Uses /bin/sh on UNIX and cmd.exe on Windows. A different shell can be specified as a string. The shell should understand the -c switch on UNIX or /d /s /c on Windows.

We recommend against using this option since it is:

  • not cross-platform, encouraging shell-specific syntax.
  • slower, because of the additional shell interpretation.
  • unsafe, potentially allowing command injection.

cwd

Type: string | URL
Default: process.cwd()

Current working directory of the subprocess.

This is also used to resolve the nodePath option when it is a relative path.

env

Type: object
Default: process.env

Environment key-value pairs.

Unless the extendEnv option is false, the subprocess also uses the current process' environment variables (process.env).

extendEnv

Type: boolean
Default: true

If true, the subprocess uses both the env option and the current process' environment variables (process.env). If false, only the env option is used, not process.env.

preferLocal

Type: boolean
Default: true with $, false otherwise

Prefer locally installed binaries when looking for a binary to execute.
If you $ npm install foo, you can then execa('foo').

localDir

Type: string | URL
Default: process.cwd()

Preferred path to find locally installed binaries in (use with preferLocal).

node

Type: boolean
Default: true with execaNode(), false otherwise

If true, runs with Node.js. The first argument must be a Node.js file.

nodeOptions

Type: string[]
Default: process.execArgv (current Node.js CLI options)

List of CLI options passed to the Node.js executable.

Requires the node option to be true.

nodePath

Type: string | URL
Default: process.execPath (current Node.js executable)

Path to the Node.js executable.

For example, this can be used together with get-node to run a specific Node.js version.

Requires the node option to be true.

verbose

Type: 'none' | 'short' | 'full'
Default: 'none'

If verbose is 'short' or 'full', prints each command on stderr before executing it. When the command completes, prints its duration and (if it failed) its error.

If verbose is 'full', the command's stdout and stderr are printed too, unless either:

This can also be set to 'full' by setting the NODE_DEBUG=execa environment variable in the current process.

buffer

Type: boolean
Default: true

Whether to return the subprocess' output using the result.stdout, result.stderr, result.all and result.stdio properties.

On failure, the error.stdout, error.stderr, error.all and error.stdio properties are used instead.

When buffer is false, the output can still be read using the subprocess.stdout, subprocess.stderr, subprocess.stdio and subprocess.all streams. If the output is read, this should be done right away to avoid missing any data.

input

Type: string | Uint8Array | stream.Readable

Write some input to the subprocess' stdin.

See also the inputFile and stdin options.

inputFile

Type: string | URL

Use a file as input to the subprocess' stdin.

See also the input and stdin options.

stdin

Type: string | number | stream.Readable | ReadableStream | URL | Uint8Array | Iterable<string> | Iterable<Uint8Array> | Iterable<unknown> | AsyncIterable<string> | AsyncIterable<Uint8Array> | AsyncIterable<unknown> | GeneratorFunction<string> | GeneratorFunction<Uint8Array> | GeneratorFunction<unknown>| AsyncGeneratorFunction<string> | AsyncGeneratorFunction<Uint8Array> | AsyncGeneratorFunction<unknown> (or a tuple of those types)
Default: inherit with $, pipe otherwise

How to setup the subprocess' standard input. This can be:

  • 'pipe': Sets subprocess.stdin stream.
  • 'overlapped': Like 'pipe' but asynchronous on Windows.
  • 'ignore': Do not use stdin.
  • 'inherit': Re-use the current process' stdin.
  • an integer: Re-use a specific file descriptor from the current process.
  • a Node.js Readable stream.
  • { file: 'path' } object.
  • a file URL.
  • a web ReadableStream.
  • an Iterable or an AsyncIterable
  • an Uint8Array.

This can be an array of values such as ['inherit', 'pipe'] or [filePath, 'pipe'].

This can also be a generator function to transform the input. Learn more.

stdout

Type: string | number | stream.Writable | WritableStream | URL | GeneratorFunction<string> | GeneratorFunction<Uint8Array> | GeneratorFunction<unknown>| AsyncGeneratorFunction<string> | AsyncGeneratorFunction<Uint8Array> | AsyncGeneratorFunction<unknown> (or a tuple of those types)
Default: pipe

How to setup the subprocess' standard output. This can be:

  • 'pipe': Sets subprocessResult.stdout (as a string or Uint8Array) and subprocess.stdout (as a stream).
  • 'overlapped': Like 'pipe' but asynchronous on Windows.
  • 'ignore': Do not use stdout.
  • 'inherit': Re-use the current process' stdout.
  • an integer: Re-use a specific file descriptor from the current process.
  • a Node.js Writable stream.
  • { file: 'path' } object.
  • a file URL.
  • a web WritableStream.

This can be an array of values such as ['inherit', 'pipe'] or [filePath, 'pipe'].

This can also be a generator function to transform the output. Learn more.

stderr

Type: string | number | stream.Writable | WritableStream | URL | GeneratorFunction<string> | GeneratorFunction<Uint8Array> | GeneratorFunction<unknown>| AsyncGeneratorFunction<string> | AsyncGeneratorFunction<Uint8Array> | AsyncGeneratorFunction<unknown> (or a tuple of those types)
Default: pipe

How to setup the subprocess' standard error. This can be:

  • 'pipe': Sets subprocessResult.stderr (as a string or Uint8Array) and subprocess.stderr (as a stream).
  • 'overlapped': Like 'pipe' but asynchronous on Windows.
  • 'ignore': Do not use stderr.
  • 'inherit': Re-use the current process' stderr.
  • an integer: Re-use a specific file descriptor from the current process.
  • a Node.js Writable stream.
  • { file: 'path' } object.
  • a file URL.
  • a web WritableStream.

This can be an array of values such as ['inherit', 'pipe'] or [filePath, 'pipe'].

This can also be a generator function to transform the output. Learn more.

stdio

Type: string | Array<string | number | stream.Readable | stream.Writable | ReadableStream | WritableStream | URL | Uint8Array | Iterable<string> | Iterable<Uint8Array> | Iterable<unknown> | AsyncIterable<string> | AsyncIterable<Uint8Array> | AsyncIterable<unknown> | GeneratorFunction<string> | GeneratorFunction<Uint8Array> | GeneratorFunction<unknown>| AsyncGeneratorFunction<string> | AsyncGeneratorFunction<Uint8Array> | AsyncGeneratorFunction<unknown>> (or a tuple of those types)
Default: pipe

Like the stdin, stdout and stderr options but for all file descriptors at once. For example, {stdio: ['ignore', 'pipe', 'pipe']} is the same as {stdin: 'ignore', stdout: 'pipe', stderr: 'pipe'}.

A single string can be used as a shortcut. For example, {stdio: 'pipe'} is the same as {stdin: 'pipe', stdout: 'pipe', stderr: 'pipe'}.

The array can have more than 3 items, to create additional file descriptors beyond stdin/stdout/stderr. For example, {stdio: ['pipe', 'pipe', 'pipe', 'pipe']} sets a fourth file descriptor.

all

Type: boolean
Default: false

Add an .all property on the promise and the resolved value. The property contains the output of the subprocess with stdout and stderr interleaved.

lines

Type: boolean
Default: false

Split stdout and stderr into lines.

encoding

Type: string
Default: utf8

Specify the character encoding used to decode the stdout, stderr and stdio output. If set to 'buffer', then stdout, stderr and stdio will be Uint8Arrays instead of strings.

stripFinalNewline

Type: boolean
Default: true

Strip the final newline character from the output.

maxBuffer

Type: number
Default: 100_000_000 (100 MB)

Largest amount of data in bytes allowed on stdout, stderr and stdio.

ipc

Type: boolean
Default: true if the node option is enabled, false otherwise

Enables exchanging messages with the subprocess using subprocess.send(value) and subprocess.on('message', (value) => {}).

serialization

Type: string
Default: 'advanced'

Specify the kind of serialization used for sending messages between subprocesses when using the ipc option: - json: Uses JSON.stringify() and JSON.parse(). - advanced: Uses v8.serialize()

More info.

detached

Type: boolean
Default: false

Prepare subprocess to run independently of the current process. Specific behavior depends on the platform.

cleanup

Type: boolean
Default: true

Kill the subprocess when the current process exits unless either: - the subprocess is detached - the current process is terminated abruptly, for example, with SIGKILL as opposed to SIGTERM or a normal exit

timeout

Type: number
Default: 0

If timeout is greater than 0, the subprocess will be terminated if it runs for longer than that amount of milliseconds.

cancelSignal

Type: AbortSignal

You can abort the subprocess using AbortController.

When AbortController.abort() is called, .isCanceled becomes true.

forceKillAfterDelay

Type: number | false
Default: 5000

If the subprocess is terminated but does not exit, forcefully exit it by sending SIGKILL.

The grace period is 5 seconds by default. This feature can be disabled with false.

This works when the subprocess is terminated by either:

This does not work when the subprocess is terminated by either:

Also, this does not work on Windows, because Windows doesn't support signals: SIGKILL and SIGTERM both terminate the subprocess immediately. Other packages (such as taskkill) can be used to achieve fail-safe termination on Windows.

killSignal

Type: string | number
Default: SIGTERM

Signal used to terminate the subprocess when:

This can be either a name (like "SIGTERM") or a number (like 9).

argv0

Type: string

Explicitly set the value of argv[0] sent to the subprocess. This will be set to file if not specified.

uid

Type: number

Sets the user identity of the subprocess.

gid

Type: number

Sets the group identity of the subprocess.

windowsVerbatimArguments

Type: boolean
Default: false

If true, no quoting or escaping of arguments is done on Windows. Ignored on other platforms. This is set to true automatically when the shell option is true.

windowsHide

Type: boolean
Default: true

On Windows, do not create a new console window. Please note this also prevents CTRL-C from working on Windows.

Tips

Redirect stdin/stdout/stderr to multiple destinations

The stdin, stdout and stderr options can be an array of values. The following example redirects stdout to both the terminal and an output.txt file, while also retrieving its value programmatically.

const {stdout} = await execa('npm', ['install'], {stdout: ['inherit', './output.txt', 'pipe']}); console.log(stdout);

When combining inherit with other values, please note that the subprocess will not be an interactive TTY, even if the current process is one.

Redirect a Node.js stream from/to stdin/stdout/stderr

When passing a Node.js stream to the stdin, stdout or stderr option, Node.js requires that stream to have an underlying file or socket, such as the streams created by the fs, net or http core modules. Otherwise the following error is thrown.

TypeError [ERR_INVALID_ARG_VALUE]: The argument 'stdio' is invalid.

This limitation can be worked around by passing either:

- await execa(..., {stdout: nodeStream}); + await execa(..., {stdout: [nodeStream, 'pipe']});

Retry on error

Safely handle failures by using automatic retries and exponential backoff with the p-retry package:

import pRetry from 'p-retry'; const run = async () => { const results = await execa('curl', ['-sSL', 'https://sindresorhus.com/unicorn']); return results; }; console.log(await pRetry(run, {retries: 5}));

Cancelling a subprocess

import {execa} from 'execa'; const abortController = new AbortController(); const subprocess = execa('node', [], {cancelSignal: abortController.signal}); setTimeout(() => { abortController.abort(); }, 1000); try { await subprocess; } catch (error) { console.log(error.isTerminated); // true console.log(error.isCanceled); // true }

Execute the current package's binary

Execa can be combined with get-bin-path to test the current package's binary. As opposed to hard-coding the path to the binary, this validates that the package.json bin field is correctly set up.

import {getBinPath} from 'get-bin-path'; const binPath = await getBinPath(); await execa(binPath);

Ensuring all output is interleaved

The all stream and string/Uint8Array properties are guaranteed to interleave stdout and stderr.

However, for performance reasons, the subprocess might buffer and merge multiple simultaneous writes to stdout or stderr. This prevents proper interleaving.

For example, this prints 1 3 2 instead of 1 2 3 because both console.log() are merged into a single write.

import {execa} from 'execa'; const {all} = await execa('node', ['example.js'], {all: true}); console.log(all);
// example.js console.log('1'); // writes to stdout console.error('2'); // writes to stderr console.log('3'); // writes to stdout

This can be worked around by using setTimeout().

import {setTimeout} from 'timers/promises'; console.log('1'); console.error('2'); await setTimeout(0); console.log('3');

Related

Maintainers