Security News
ESLint is Now Language-Agnostic: Linting JSON, Markdown, and Beyond
ESLint has added JSON and Markdown linting support with new officially-supported plugins, expanding its versatility beyond JavaScript.
concurrently
Advanced tools
The 'concurrently' npm package is a utility that allows you to run multiple commands concurrently. It is often used to run multiple processes during development, such as a server and a client application at the same time. It can handle the output of these processes, terminate them all together, and more.
Running multiple commands
This feature allows you to run multiple commands at the same time. Each command is quoted and separated by a space.
concurrently "command1 arg" "command2 arg"
Customizing the prefix for command output
This feature allows you to customize the prefix shown in the output for each command. In this example, 'API' and 'UI' are custom prefixes for the two npm scripts.
concurrently --names "API,UI" "npm:api" "npm:start"
Killing all commands when one of them exits
This feature ensures that if one command exits, all other commands are also terminated. This is useful for cleaning up processes if one fails.
concurrently --kill-others "command1" "command2"
Running commands sequentially
This feature allows you to run commands sequentially instead of concurrently. The --success option determines which command's exit code will be used as the exit code for concurrently.
concurrently "command1" "command2" --success first
A CLI tool to run multiple npm-scripts in parallel or sequential. It is similar to concurrently but specifically designed for npm scripts. It provides a simpler interface for running scripts in series or parallel.
PM2 is a production process manager for Node.js applications with a built-in load balancer. It is more feature-rich than concurrently, providing a daemon process that helps keep applications alive forever, facilitates common system admin tasks, and can be used in production environments.
Foreman is a manager for Procfile-based applications. Its focus is on easing the development of applications by allowing you to run multiple processes with a single command. It is not limited to Node.js and can be used with any language or markup.
Run multiple commands concurrently.
Like npm run watch-js & npm run watch-less
but better.
Table of Contents
I like task automation with npm
but the usual way to run multiple commands concurrently is
npm run watch-js & npm run watch-css
. That's fine but it's hard to keep
on track of different outputs. Also if one process fails, others still keep running
and you won't even notice the difference.
Another option would be to just run all commands in separate terminals. I got tired of opening terminals and made concurrently.
Features:
--kill-others
switch, all commands are killed if one diesconcurrently can be installed in the global scope (if you'd like to have it available and use it on the whole system) or locally for a specific package (for example if you'd like to use it in the scripts
section of your package):
npm | Yarn | pnpm | Bun | |
---|---|---|---|---|
Global | npm i -g concurrently | yarn global add concurrently | pnpm add -g concurrently | bun add -g concurrently |
Local* | npm i -D concurrently | yarn add -D concurrently | pnpm add -D concurrently | bun add -d concurrently |
* It's recommended to add concurrently to devDependencies
as it's usually used for developing purposes. Please adjust the command if this doesn't apply in your case.
Note The
concurrently
command is also available under the shorthand aliasconc
.
The tool is written in Node.js, but you can use it to run any commands.
Remember to surround separate commands with quotes:
concurrently "command1 arg" "command2 arg"
Otherwise concurrently would try to run 4 separate commands:
command1
, arg
, command2
, arg
.
In package.json, escape quotes:
"start": "concurrently \"command1 arg\" \"command2 arg\""
You can always check concurrently's flag list by running concurrently --help
.
For the version, run concurrently --version
.
Check out documentation and other usage examples in the docs
directory.
concurrently can be used programmatically by using the API documented below:
concurrently(commands[, options])
commands
: an array of either strings (containing the commands to run) or objects
with the shape { command, name, prefixColor, env, cwd, ipc }
.
options
(optional): an object containing any of the below:
cwd
: the working directory to be used by all commands. Can be overriden per command.
Default: process.cwd()
.defaultInputTarget
: the default input target when reading from inputStream
.
Default: 0
.handleInput
: when true
, reads input from process.stdin
.inputStream
: a Readable
stream
to read the input from. Should only be used in the rare instance you would like to stream anything other than process.stdin
. Overrides handleInput
.pauseInputStreamOnFinish
: by default, pauses the input stream (process.stdin
when handleInput
is enabled, or inputStream
if provided) when all of the processes have finished. If you need to read from the input stream after concurrently
has finished, set this to false
. (#252).killOthers
: an array of exitting conditions that will cause a process to kill others.
Can contain any of success
or failure
.maxProcesses
: how many processes should run at once.outputStream
: a Writable
stream
to write logs to. Default: process.stdout
.prefix
: the prefix type to use when logging processes output.
Possible values: index
, pid
, time
, command
, name
, none
, or a template (eg [{time} process: {pid}]
).
Default: the name of the process, or its index if no name is set.prefixColors
: a list of colors or a string as supported by chalk and additional style auto
for an automatically picked color.
If concurrently would run more commands than there are colors, the last color is repeated, unless if the last color value is auto
which means following colors are automatically picked to vary.
Prefix colors specified per-command take precedence over this list.prefixLength
: how many characters to show when prefixing with command
. Default: 10
raw
: whether raw mode should be used, meaning strictly process output will
be logged, without any prefixes, coloring or extra stuff. Can be overriden per command.successCondition
: the condition to consider the run was successful.
If first
, only the first process to exit will make up the success of the run; if last
, the last process that exits will determine whether the run succeeds.
Anything else means all processes should exit successfully.restartTries
: how many attempts to restart a process that dies will be made. Default: 0
.restartDelay
: how many milliseconds to wait between process restarts. Default: 0
.timestampFormat
: a Unicode format
to use when prefixing with time
. Default: yyyy-MM-dd HH:mm:ss.ZZZ
additionalArguments
: list of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.Returns: an object in the shape
{ result, commands }
.
result
: aPromise
that resolves if the run was successful (according tosuccessCondition
option), or rejects, containing an array ofCloseEvent
, in the order that the commands terminated.commands
: an array of all spawnedCommand
s.
Example:
const concurrently = require('concurrently');
const { result } = concurrently(
[
'npm:watch-*',
{ command: 'nodemon', name: 'server' },
{ command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
{
command: 'watch',
name: 'watch',
cwd: path.resolve(__dirname, 'scripts/watchers'),
},
],
{
prefix: 'name',
killOthers: ['failure', 'success'],
restartTries: 3,
cwd: path.resolve(__dirname, 'scripts'),
},
);
result.then(success, failure);
Command
An object that contains all information about a spawned command, and ways to interact with it.
It has the following properties:
index
: the index of the command among all commands spawned.
command
: the command line of the command.
name
: the name of the command; defaults to an empty string.
cwd
: the current working directory of the command.
env
: an object with all the environment variables that the command will be spawned with.
killed
: whether the command has been killed.
state
: the command's state. Can be one of
stopped
: if the command was never startedstarted
: if the command is currently runningerrored
: if the command failed spawningexited
: if the command is not running anymore, e.g. it received a close eventpid
: the command's process ID.
stdin
: a Writable stream to the command's stdin
.
stdout
: an RxJS observable to the command's stdout
.
stderr
: an RxJS observable to the command's stderr
.
error
: an RxJS observable to the command's error events (e.g. when it fails to spawn).
timer
: an RxJS observable to the command's timing events (e.g. starting, stopping).
messages
: an object with the following properties:
incoming
: an RxJS observable for the IPC messages received from the underlying process.outgoing
: an RxJS observable for the IPC messages sent to the underlying process.Both observables emit MessageEvent
s.
Note that if the command wasn't spawned with IPC support, these won't emit any values.
close
: an RxJS observable to the command's close events.
See CloseEvent
for more information.
start()
: starts the command and sets up all of the above streams
send(message[, handle, options])
: sends a message to the underlying process via IPC channels,
returning a promise that resolves once the message has been sent.
See Node.js docs.
kill([signal])
: kills the command, optionally specifying a signal (e.g. SIGTERM
, SIGKILL
, etc).
MessageEvent
An object that represents a message that was received from/sent to the underlying command process.
It has the following properties:
message
: the message itself.handle
: a net.Socket
,
net.Server
or
dgram.Socket
,
if one was sent, or undefined
.CloseEvent
An object with information about a command's closing event.
It contains the following properties:
command
: a stripped down version of Command
, including only name
, command
, env
and cwd
properties.index
: the index of the command among all commands spawned.killed
: whether the command exited because it was killed.exitCode
: the exit code of the command's process, or the signal which it was killed with.timings
: an object in the shape { startDate, endDate, durationSeconds }
.Process exited with code null?
From Node child_process documentation, exit
event:
This event is emitted after the child process ends. If the process terminated normally, code is the final exit code of the process, otherwise null. If the process terminated due to receipt of a signal, signal is the string name of the signal, otherwise null.
So null means the process didn't terminate normally. This will make concurrently to return non-zero exit code too.
Does this work with the npm-replacements yarn, pnpm, or Bun?
Yes! In all examples above, you may replace "npm
" with "yarn
", "pnpm
", or "bun
".
FAQs
Run commands concurrently
The npm package concurrently receives a total of 4,215,779 weekly downloads. As such, concurrently popularity was classified as popular.
We found that concurrently demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
ESLint has added JSON and Markdown linting support with new officially-supported plugins, expanding its versatility beyond JavaScript.
Security News
Members Hub is conducting large-scale campaigns to artificially boost Discord server metrics, undermining community trust and platform integrity.
Security News
NIST has failed to meet its self-imposed deadline of clearing the NVD's backlog by the end of the fiscal year. Meanwhile, CVE's awaiting analysis have increased by 33% since June.