Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
# Concurrently
[](https://travis-ci.org/kimmobrunfeldt/concurrently) [](https://ci.appveyor.com/project/kimmobrunfeldt/concurrently) *master branch status*
[](https://www.npmjs.com/package/concurrently)
Run multiple commands concurrently.
Like `npm run watch-js & npm run watch-less` but better.
**Features:**
* Cross platform, works also in Windows
* Output is easy to follow with prefixes
* With `--kill-others` switch, all commands are killed if one dies
* Spawns commands with [spawn-command](https://github.com/mmalecki/spawn-command)
## Install
The tool is written in Node.js, but you can use it to run **any** commands.
```bash
npm install -g concurrently
```
or if you are using it from npm scripts:
```bash
npm install concurrently --save
```
## Usage
Remember to surround separate commands with quotes, like this:
```bash
concurrently "command1 arg" "command2 arg"
```
Otherwise **concurrently** would try to run 4 separate commands:
`command1`, `arg`, `command2`, `arg`.
In package.json, escape quotes:
```bash
"start": "concurrently \"command1 arg\" \"command2 arg\""
```
Good frontend one-liner example [here](https://github.com/kimmobrunfeldt/dont-copy-paste-this-frontend-template/blob/5cd2bde719654941bdfc0a42c6f1b8e69ae79980/package.json#L9).
Help:
```
Usage: concurrently [options] <command ...>
Options:
-h, --help output usage information
-V, --version output the version number
-k, --kill-others kill other processes if one exits or dies
--kill-others-on-fail kill other processes if one exits with non zero status code
--no-color disable colors from logging
-p, --prefix <prefix> prefix used in logging for each process.
Possible values: index, pid, time, command, name, none, or a template. Default: index or name (when --names is set). Example template: "{time}-{pid}"
-n, --names <names> List of custom names to be used in prefix template.
Example names: "main,browser,server"
--name-separator <char> The character to split <names> on.
Default: ",". Example usage: concurrently -n "styles,scripts|server" --name-separator "|" <command ...>
-c, --prefix-colors <colors> Comma-separated list of chalk colors to use on prefixes. If there are more commands than colors, the last color will be repeated.
Available modifiers: reset, bold, dim, italic, underline, inverse, hidden, strikethrough
Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray
Available background colors: bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
See https://www.npmjs.com/package/chalk for more information.
Default: "gray.dim". Example: "black.bgWhite,cyan,gray.dim"
-t, --timestamp-format <format> specify the timestamp in moment/date-fns format. Default: YYYY-MM-DD HH:mm:ss.SSS
-r, --raw output only raw output of processes, disables prettifying and concurrently coloring
-s, --success <first|last|all> Return exit code of zero or one based on the success or failure of the "first" child to terminate, the "last" child, or succeed only if "all" child processes succeed. Default: all
-l, --prefix-length <length> limit how many characters of the command is displayed in prefix.
The option can be used to shorten long commands.
Works only if prefix is set to "command". Default: 10
--allow-restart Restart a process which died. Default: false
--restart-after <miliseconds> delay time to respawn the process. Default: 0
--restart-tries <times> limit the number of respawn tries. Default: 1
Examples:
- Kill other processes if one exits or dies
$ concurrently --kill-others "grunt watch" "http-server"
- Kill other processes if one exits with non zero status code
$ concurrently --kill-others-on-fail "npm run build:client" "npm run build:server"
- Output nothing more than stdout+stderr of child processes
$ concurrently --raw "npm run watch-less" "npm run watch-js"
- Normal output but without colors e.g. when logging to file
$ concurrently --no-color "grunt watch" "http-server" > log
- Custom prefix
$ concurrently --prefix "{time}-{pid}" "npm run watch" "http-server"
- Custom names and colored prefixes
$ concurrently --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "http-server" "npm run watch"
For more details, visit https://github.com/kimmobrunfeldt/concurrently
```
## FAQ
* Process exited with code *null*?
From [Node child_process documentation](http://nodejs.org/api/child_process.html#child_process_event_exit), `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 **concurrent**
to return non-zero exit code too.
## Why
I like [task automation with npm](http://substack.net/task_automation_with_npm_run)
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**.