Package - execa

Process execution for humans

One of the maintainers @ehmicky is looking for a remote full-time position as a Node.js back-end lead. Feel free to contact him!

Why

This package improves child_process methods with:

Promise interface.
Strips the final newline from the output so you don't have to do stdout.trim().
Supports shebang binaries cross-platform.
Improved Windows support.
Higher max buffer. 100 MB instead of 200 KB.
Executes locally installed binaries by name.
Cleans up spawned processes when the parent process dies.
Get interleaved output from stdout and stderr similar to what is printed on the terminal. (Async only)
Can specify file and arguments as a single string without a shell
More descriptive errors.

Install

$ npm install execa

Usage

const execa = require('execa');

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

Additional examples:

const execa = require('execa');

(async () => {
	// Pipe the child process stdout to the current stdout
	execa('echo', ['unicorns']).stdout.pipe(process.stdout);


	// Catching an error
	try {
		await execa('wrong', ['command']);
	} catch (error) {
		console.log(error);
		/*
		{
			message: 'Command failed with exit code 2 (ENOENT): wrong command spawn wrong ENOENT',
			errno: 'ENOENT',
			syscall: 'spawn wrong',
			path: 'wrong',
			spawnargs: ['command'],
			command: 'wrong command',
			exitCode: 2,
			exitCodeName: 'ENOENT',
			stdout: '',
			stderr: '',
			all: '',
			failed: true,
			timedOut: false,
			isCanceled: false,
			killed: false
		}
		*/
	}

	// Cancelling a spawned process
	const subprocess = execa('node');
	setTimeout(() => {
		subprocess.cancel();
	}, 1000);
	try {
		await subprocess;
	} catch (error) {
		console.log(subprocess.killed); // true
		console.log(error.isCanceled); // true
	}
})();

// Catching an error with a sync method
try {
	execa.sync('wrong', ['command']);
} catch (error) {
	console.log(error);
	/*
	{
		message: 'Command failed with exit code 2 (ENOENT): wrong command spawnSync wrong ENOENT',
		errno: 'ENOENT',
		syscall: 'spawnSync wrong',
		path: 'wrong',
		spawnargs: ['command'],
		command: 'wrong command',
		exitCode: 2,
		exitCodeName: 'ENOENT',
		stdout: '',
		stderr: '',
		failed: true,
		timedOut: false,
		isCanceled: false,
		killed: false
	}
	*/
}

// Kill a process with SIGTERM, and after 2 seconds, kill it with SIGKILL
const subprocess = execa('node');
setTimeout(() => {
	subprocess.kill('SIGTERM', {
		forceKillAfterTimeout: 2000
	});
}, 1000);

API

execa(file, arguments, [options])

Execute a file. Think of this as a mix of child_process.execFile() and child_process.spawn().

No escaping/quoting is needed.

Unless the shell option is used, no shell interpreter (Bash, cmd.exe, etc.) is used, so shell features such as variables substitution (echo $PATH) are not allowed.

Returns a child_process instance which:

is also a Promise resolving or rejecting with a childProcessResult.
exposes the following additional methods and properties.

kill([signal], [options])

Same as the original child_process#kill() except: if signal is SIGTERM (the default value) and the child process is not terminated after 5 seconds, force it by sending SIGKILL.

options.forceKillAfterTimeout

Type: number | false
Default: 5000

Milliseconds to wait for the child process to terminate before sending SIGKILL.

Can be disabled with false.

cancel()

Similar to childProcess.kill(). This is preferred when cancelling the child process execution as the error is more descriptive and childProcessResult.isCanceled is set to true.

all

Stream combining/interleaving stdout and stderr.

execa.sync(file, [arguments], [options])

Execute a file synchronously.

Returns or throws a childProcessResult.

execa.command(command, [options])

Same as execa() except both file and arguments are specified in a single command string. For example, execa('echo', ['unicorns']) is the same as execa.command('echo unicorns').

If the file or an argument contains spaces, they must be escaped with backslashes. This matters especially if command is not a constant but a variable, for example with __dirname or process.cwd(). Except for spaces, no escaping/quoting is needed.

execa.commandSync(command, [options])

Same as execa.command() but synchronous.

Returns or throws a childProcessResult.

execa.node(scriptPath, [arguments], [options])

Execute a Node.js script as a child process.

Same as execa('node', [file, ...arguments], options) except (like child_process#fork()):

the nodePath and nodeArguments options can be used
the shell option cannot be used
an extra channel ipc is passed to stdio

childProcessResult

Type: object

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

command

Type: string

The file and arguments that were run.

exitCode

Type: number

The numeric exit code of the process that was run.

exitCodeName

Type: string

The textual exit code of the process that was run.

stdout

Type: string | Buffer

The output of the process on stdout.

stderr

Type: string | Buffer

The output of the process on stderr.

all

Type: string | Buffer

The output of the process on both stdout and stderr. undefined if execa.sync() was used.

failed

Type: boolean

Whether the process failed to run.

timedOut

Type: boolean

Whether the process timed out.

isCanceled

Type: boolean

Whether the process was canceled.

killed

Type: boolean

Whether the process was killed.

signal

Type: string | undefined

The signal that was used to terminate the process.

options

Type: object

cleanup

Type: boolean
Default: true

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

preferLocal

Type: boolean
Default: true

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

localDir

Type: string
Default: process.cwd()

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

buffer

Type: boolean
Default: true

Buffer the output from the spawned process. When buffering is disabled you must consume the output of the stdout and stderr streams because the promise will not be resolved/rejected until they have completed.

If the spawned process fails, error.stdout, error.stderr, and error.all will contain the buffered data.

input

Type: string | Buffer | stream.Readable

Write some input to the stdin of your binary.
Streams are not allowed when using the synchronous methods.

stdin

Type: string | number | Stream | undefined
Default: pipe

Same options as stdio.

stdout

Type: string | number | Stream | undefined
Default: pipe

Same options as stdio.

stderr

Type: string | number | Stream | undefined
Default: pipe

Same options as stdio.

reject

Type: boolean
Default: true

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

stripFinalNewline

Type: boolean
Default: true

Strip the final newline character from the output.

extendEnv

Type: boolean
Default: true

Set to false if you don't want to extend the environment variables when providing the env property.

Execa also accepts the below options which are the same as the options for child_process#spawn()/child_process#exec()

cwd

Type: string
Default: process.cwd()

Current working directory of the child process.

env

Type: object
Default: process.env

Environment key-value pairs. Extends automatically from process.env. Set extendEnv to false if you don't want this.

argv0

Type: string

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

stdio

Type: string | string[]
Default: pipe

Child's stdio configuration.

detached

Type: boolean

Prepare child to run independently of its parent process. Specific behavior depends on the platform.

uid

Type: number

Sets the user identity of the process.

gid

Type: number

Sets the group identity of the process.

shell

Type: boolean | string
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.

encoding

Type: string | null
Default: utf8

Specify the character encoding used to decode the stdout and stderr output. If set to null, then stdout and stderr will be a Buffer instead of a string.

timeout

Type: number
Default: 0

If timeout is greater than 0, the parent will send the signal identified by the killSignal property (the default is SIGTERM) if the child runs longer than timeout milliseconds.

maxBuffer

Type: number
Default: 100_000_000 (100 MB)

Largest amount of data in bytes allowed on stdout or stderr.

killSignal

Type: string | number
Default: SIGTERM

Signal value to be used when the spawned process will be killed.

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.

nodePath (for `.node()` only)

Type: string
Default: process.execPath

Node.js executable used to create the child process.

nodeArguments (for `.node()` only)

Type: string[]
Default: process.execArgv

List of string arguments passed to the Node.js executable.

Tips

Save and pipe output from a child process

Let's say you want to show the output of a child process in real-time while also saving it to a variable.

const execa = require('execa');

const subprocess = execa('echo', ['foo']);
subprocess.stdout.pipe(process.stdout);

(async () => {
	const {stdout} = await subprocess;
	console.log('child output:', stdout);
})();

Redirect output to a file

const execa = require('execa');

const subprocess = execa('echo', ['foo'])
subprocess.stdout.pipe(fs.createWriteStream('stdout.txt'))

Redirect input from a file

const execa = require('execa');

const subprocess = execa('cat')
fs.createReadStream('stdin.txt').pipe(subprocess.stdin)

gulp-execa - Gulp plugin for execa

Maintainers

Get professional support for this package with a Tidelift subscription
_{Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies.}

Current Tags

9.5.2 ... latest (18 days ago)
2.0.0-alpha.0 ... next (6 years ago)

Why

Install

Usage

API

execa(file, arguments, [options])

kill([signal], [options])

options.forceKillAfterTimeout

cancel()

all

execa.sync(file, [arguments], [options])

execa.command(command, [options])

execa.commandSync(command, [options])

execa.node(scriptPath, [arguments], [options])

childProcessResult

command

exitCode

exitCodeName

stdout

stderr

all

failed

timedOut

isCanceled

killed

signal

options

cleanup

preferLocal

localDir

buffer

input

stdin

stdout

stderr

reject

stripFinalNewline

extendEnv

cwd

env

argv0

stdio

detached

uid

gid

shell

encoding

timeout

maxBuffer

killSignal

windowsVerbatimArguments

nodePath (for .node() only)

nodeArguments (for .node() only)

Tips

Save and pipe output from a child process

Redirect output to a file

Redirect input from a file

Related

Maintainers

Current Tags

61 Versions

nodePath (for `.node()` only)

nodeArguments (for `.node()` only)