concurrently 3.6.0 → 4.1.0

package/.travis.yml

@@ -1,11 +1,10 @@
 language: node_js
 node_js:
+  - 10
   - 8
   - 6
-  - 4
 script:
   - npm test
   - npm run lint
-notifications:
-  email:
-    - kimmobrunfeldt+concurrent@gmail.com
+after_success:
+  - npm run report-coverage

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "eslint.enable": true,
+    "jest.autoEnable": true,
+    "jest.showCoverageOnLoad": true
+}

package/CONTRIBUTING.md

@@ -6,7 +6,6 @@ updated.
 
 **Pull requests:** You don't need to bump version numbers or modify anything related to releasing. That stuff is fully automated, just write the functionality.
 
-
 # Maintaining
 
 ## Test
@@ -14,11 +13,9 @@ updated.
 Tests can be run with command:
 
 ```bash
-mocha
+npm run test
 ```
 
-You need to have *mocha* installed globally with `npm install -g mocha`.
-
 ## Release
 
 * Commit all changes

package/README.md

@@ -9,6 +9,24 @@ Like `npm run watch-js & npm run watch-less` but better.
 
 ![](docs/demo.gif)
 
+**Table of contents**
+- [Why](#why)
+- [Install](#install)
+- [Usage](#usage)
+- [Programmatic Usage](#programmatic-usage)
+- [FAQ](#faq)
+
+## 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**.
+
 **Features:**
 
 * Cross platform (including Windows)
@@ -92,65 +110,70 @@ Help:
 
 ```
 
-Usage: concurrently [options] <command ...>
+concurrently [options] <command ...>
+
+General
+  -n, --names       List of custom names to be used in prefix template.
+                    Example names: "main,browser,server"                [string]
+  --name-separator  The character to split <names> on. Example usage:
+                    concurrently -n "styles|scripts|server" --name-separator "|"
+                                                                  [default: ","]
+  -r, --raw         Output only raw output of processes, disables prettifying
+                    and concurrently coloring.                         [boolean]
+  -s, --success     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.
+                              [choices: "first", "last", "all"] [default: "all"]
+  --no-color        Disables colors from logging                       [boolean]
+
+Prefix styling
+  -p, --prefix            Prefix used in logging for each process.
+                          Possible values: index, pid, time, command, name,
+                          none, or a template. Example template: "{time}-{pid}"
+                         [string] [default: index or name (when --names is set)]
+  -c, --prefix-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.            [string] [default: "gray.dim"]
+  -l, --prefix-length     Limit how many characters of the command is displayed
+                          in prefix. The option can be used to shorten the
+                          prefix when it is set to "command"
+                                                          [number] [default: 10]
+  -t, --timestamp-format  Specify the timestamp in moment/date-fns format.
+                                   [string] [default: "YYYY-MM-DD HH:mm:ss.SSS"]
+
+Input handling
+  -i, --handle-input      Whether input should be forwarded to the child
+                          processes. See examples for more information.[boolean]
+  --default-input-target  Identifier for child process to which input on stdin
+                          should be sent if not specified at start of input.
+                          Can be either the index or the name of the process.
+                                                                    [default: 0]
+
+Killing other processes
+  -k, --kill-others      kill other processes if one exits or dies     [boolean]
+  --kill-others-on-fail  kill other processes if one exits with non zero status
+                         code                                          [boolean]
+
+Restarting
+  --restart-tries  How many times a process that died should restart.
+                                                           [number] [default: 0]
+  --restart-after  Delay time to respawn the process, in milliseconds.
+                                                           [number] [default: 0]
 
 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
-
-  --default-input-target <identifier> identifier for child process to which input on stdin should be sent if not specified at start of input. Can be either the index or the name of the process. Default: 0
-
-Input:
-
-Input can be sent to any of the child processes using either the name or index
-of the command followed by a colon. If no child identifier is specified then the
-input will be sent to the child specified by the `--default-input-target`
-option, which defaults to index 0.
+  -h, --help         Show help                                         [boolean]
+  -v, -V, --version  Show version number                               [boolean]
 
 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"
@@ -165,50 +188,26 @@ Examples:
 
  - Custom names and colored prefixes
 
-     $ concurrently --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "http-server" "npm run watch"
-     
+     $ concurrently --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold"
+     "http-server" "npm run watch"
+
  - Shortened NPM run commands
 
      $ concurrently npm:watch-node npm:watch-js npm:watch-css
 
  - Send input to default
 
-     $ concurrently "nodemon" "npm run watch-js"
+     $ concurrently --handle-input "nodemon" "npm run watch-js"
      rs  # Sends rs command to nodemon process
 
- - Specify a default-input-target
-
-     $ concurrently --default-input-target 1 "npm run watch-js" nodemon
-     rs
-
- - Send input to specific child identified by index
-
-     $ concurrently "npm run watch-js" nodemon
-     1:rs
-
- - Send input to specific child identified by name
-
-     $ concurrently -n js,srv "npm run watch-js" nodemon
-     srv:rs
-
- - Send input to default
-
-     $ concurrently "nodemon" "npm run watch-js"
-     rs  # Sends rs command to nodemon process
-
- - Specify a default-input-target
-
-     $ concurrently --default-input-target 1 "npm run watch-js" nodemon
-     rs
-
  - Send input to specific child identified by index
 
-     $ concurrently "npm run watch-js" nodemon
+     $ concurrently --handle-input "npm run watch-js" nodemon
      1:rs
 
  - Send input to specific child identified by name
 
-     $ concurrently -n js,srv "npm run watch-js" nodemon
+     $ concurrently --handle-input -n js,srv "npm run watch-js" nodemon
      srv:rs
 
  - Shortened NPM run commands
@@ -222,6 +221,52 @@ Examples:
 For more details, visit https://github.com/kimmobrunfeldt/concurrently
 ```
 
+## Programmatic Usage
+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 }`.
+- `options` (optional): an object containing any of the below:
+    - `defaultInputTarget`: the default input target when reading from `inputStream`.
+    Default: `0`.
+    - `inputStream`: a [`Readable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_readable_streams)
+    to read the input from, eg `process.stdin`.
+    - `killOthers`: an array of exitting conditions that will cause a process to kill others.
+    Can contain any of `success` or `failure`.
+    - `outputStream`: a [`Writable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_writable_streams)
+    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.
+    - `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, colouring or extra stuff.
+    - `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 [date-fns/moment format](https://date-fns.org/v1.29.0/docs/format)
+    to use when prefixing with `time`. Default: `YYYY-MM-DD HH:mm:ss.ZZZ`
+
+> Returns: a `Promise` that resolves if the run was successful (according to `successCondition` option),
+> or rejects otherwise.
+
+Example:
+
+```js
+const concurrently = require('concurrently');
+concurrently([
+    'npm:watch-*',
+    { command: 'nodemon', name: 'server' }
+], {
+    prefix: 'name',
+    killOthers: ['failure', 'success'],
+    restartTries: 3,
+}).then(success, failure);
+```
+
 ## FAQ
 
 * Process exited with code *null*?
@@ -237,14 +282,6 @@ For more details, visit https://github.com/kimmobrunfeldt/concurrently
     So *null* means the process didn't terminate normally. This will make **concurrent**
     to return non-zero exit code too.
 
+* Does this work with the npm-replacement [yarn](https://github.com/yarnpkg/yarn)?
 
-## 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**.
+    Yes! In all examples above, you may replace "`npm`" with "`yarn`".

package/appveyor.yml

@@ -1,8 +1,8 @@
 environment:
   matrix:
+    - nodejs_version: '10'
     - nodejs_version: '8'
     - nodejs_version: '6'
-    - nodejs_version: '4'
 install:
   - ps: Install-Product node $env:nodejs_version
   - set CI=true

package/bin/concurrently.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const yargs = require('yargs');
+const defaults = require('../src/defaults');
+const concurrently = require('../index');
+
+const args = yargs
+    .usage('$0 [options] <command ...>')
+    .help('h')
+    .alias('h', 'help')
+    .version('v', require('../package.json').version)
+    .alias('v', 'V')
+    .alias('v', 'version')
+    .options({
+        // General
+        'n': {
+            alias: 'names',
+            describe:
+                'List of custom names to be used in prefix template.\n' +
+                'Example names: "main,browser,server"',
+            type: 'string'
+        },
+        'name-separator': {
+            describe:
+                'The character to split <names> on. Example usage:\n' +
+                'concurrently -n "styles|scripts|server" --name-separator "|"',
+            default: defaults.nameSeparator,
+        },
+        's': {
+            alias: 'success',
+            describe:
+                '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.',
+            choices: ['first', 'last', 'all'],
+            default: defaults.success
+        },
+        'r': {
+            alias: 'raw',
+            describe:
+                'Output only raw output of processes, disables prettifying ' +
+                'and concurrently coloring.',
+            type: 'boolean'
+        },
+        // This one is provided for free. Chalk reads this itself and removes colours.
+        // https://www.npmjs.com/package/chalk#chalksupportscolor
+        'no-color': {
+            describe: 'Disables colors from logging',
+            type: 'boolean'
+        },
+
+        // Kill others
+        'k': {
+            alias: 'kill-others',
+            describe: 'kill other processes if one exits or dies',
+            type: 'boolean'
+        },
+        'kill-others-on-fail': {
+            describe: 'kill other processes if one exits with non zero status code',
+            type: 'boolean'
+        },
+
+        // Prefix
+        'p': {
+            alias: 'prefix',
+            describe:
+                'Prefix used in logging for each process.\n' +
+                'Possible values: index, pid, time, command, name, none, or a template. ' +
+                'Example template: "{time}-{pid}"',
+            defaultDescription: 'index or name (when --names is set)',
+            type: 'string'
+        },
+        'c': {
+            alias: 'prefix-colors',
+            describe:
+                'Comma-separated list of chalk colors to use on prefixes. ' +
+                'If there are more commands than colors, the last color will be repeated.\n' +
+                '- Available modifiers: reset, bold, dim, italic, underline, inverse, hidden, strikethrough\n' +
+                '- Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray\n' +
+                '- Available background colors: bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite\n' +
+                'See https://www.npmjs.com/package/chalk for more information.',
+            default: defaults.prefixColors,
+            type: 'string'
+        },
+        'l': {
+            alias: 'prefix-length',
+            describe:
+                'Limit how many characters of the command is displayed in prefix. ' +
+                'The option can be used to shorten the prefix when it is set to "command"',
+            default: defaults.prefixLength,
+            type: 'number'
+        },
+        't': {
+            alias: 'timestamp-format',
+            describe: 'Specify the timestamp in moment/date-fns format.',
+            default: defaults.timestampFormat,
+            type: 'string'
+        },
+
+        // Restarting
+        'restart-tries': {
+            describe: 'How many times a process that died should restart.',
+            default: defaults.restartTries,
+            type: 'number'
+        },
+        'restart-after': {
+            describe: 'Delay time to respawn the process, in milliseconds.',
+            default: defaults.restartDelay,
+            type: 'number'
+        },
+
+        // Input
+        'i': {
+            alias: 'handle-input',
+            describe:
+                'Whether input should be forwarded to the child processes. ' +
+                'See examples for more information.',
+            type: 'boolean'
+        },
+        'default-input-target': {
+            default: defaults.defaultInputTarget,
+            describe:
+                'Identifier for child process to which input on stdin ' +
+                'should be sent if not specified at start of input.\n' +
+                'Can be either the index or the name of the process.'
+        }
+    })
+    .group(['n', 'name-separator', 'raw', 's', 'no-color'], 'General')
+    .group(['p', 'c', 'l', 't'], 'Prefix styling')
+    .group(['i', 'default-input-target'], 'Input handling')
+    .group(['k', 'kill-others-on-fail'], 'Killing other processes')
+    .group(['restart-tries', 'restart-after'], 'Restarting')
+    // Too much text to write as JS strings, .txt file is better
+    .epilogue(fs.readFileSync(__dirname + '/epilogue.txt', { encoding: 'utf8' }))
+    .argv;
+
+const prefixColors = args.prefixColors.split(',');
+const names = (args.names || '').split(args.nameSeparator);
+
+let lastColor;
+concurrently(args._.map((command, index) => {
+    // Use documented behaviour of repeating last colour when specifying more commands than colours
+    lastColor = prefixColors[index] || lastColor;
+    return {
+        command,
+        prefixColor: lastColor,
+        name: names[index]
+    };
+}), {
+    inputStream: args.handleInput && process.stdin,
+    defaultInputTarget: args.defaultInputTarget,
+    killOthers: args.killOthers
+        ? ['success', 'failure']
+        : (args.killOthersOnFail ? ['failure'] : []),
+    raw: args.raw,
+    prefix: args.prefix,
+    restartDelay: args.restartAfter,
+    restartTries: args.restartTries,
+    successCondition: args.success,
+    timestampFormat: args.timestampFormat
+}).then(
+    () => process.exit(0),
+    () => process.exit(1)
+);