concurrently 5.0.2 → 6.0.0

package/README.md

@@ -10,11 +10,13 @@ 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)
+- [Concurrently](#concurrently)
+  - [Why](#why)
+  - [Install](#install)
+  - [Usage](#usage)
+  - [Programmatic Usage](#programmatic-usage)
+    - [`concurrently(commands[, options])`](#concurrentlycommands-options)
+  - [FAQ](#faq)
 
 ## Why
 
@@ -113,18 +115,21 @@ Help:
 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.
+  -m, --max-processes  How many processes should run at once.
+                       New processes only spawn after all restart tries of a
+                       process.                                         [number]
+  -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]
+  --no-color           Disables colors from logging                    [boolean]
 
 Prefix styling
   -p, --prefix            Prefix used in logging for each process.
@@ -137,7 +142,8 @@ Prefix styling
                           - Available modifiers: reset, bold, dim, italic,
                           underline, inverse, hidden, strikethrough
                           - Available colors: black, red, green, yellow, blue,
-                          magenta, cyan, white, gray
+                          magenta, cyan, white, gray, or any hex values for
+                          colors, eg #23de43
                           - Available background colors: bgBlack, bgRed,
                           bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
                           See https://www.npmjs.com/package/chalk for more
@@ -222,14 +228,17 @@ 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 }`.
+  with the shape `{ command, name, prefixColor, env, cwd }`.
 - `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`.
     - `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`.
+    - `maxProcesses`: how many processes should run at once.
     - `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.
@@ -247,7 +256,10 @@ concurrently can be used programmatically by using the API documented below:
     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.
+> or rejects, containing an array of objects with information for each command that has been run, in the order
+> that the commands terminated. The objects have the shape `{ command, index, exitCode }`, where `command` is the object
+> passed in the `commands` array and `index` its index there. Default values (empty strings or objects) are returned for
+> the fields that were not specified.
 
 Example:
 
@@ -255,11 +267,14 @@ Example:
 const concurrently = require('concurrently');
 concurrently([
     'npm:watch-*',
-    { command: 'nodemon', name: 'server' }
+    { 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'),
 }).then(success, failure);
 ```
 
@@ -278,6 +293,6 @@ 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)?
+* Does this work with the npm-replacements [yarn](https://github.com/yarnpkg/yarn) or [pnpm](https://pnpm.js.org/)?
 
-    Yes! In all examples above, you may replace "`npm`" with "`yarn`".
+    Yes! In all examples above, you may replace "`npm`" with "`yarn`" or "`pnpm`".

package/bin/concurrently.js

@@ -13,6 +13,13 @@ const args = yargs
     .alias('v', 'version')
     .options({
         // General
+        'm': {
+            alias: 'max-processes',
+            describe:
+                'How many processes should run at once.\n' +
+                'New processes only spawn after all restart tries of a process.',
+            type: 'number'
+        },
         'n': {
             alias: 'names',
             describe:
@@ -76,7 +83,8 @@ const args = yargs
                 '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 colors: black, red, green, yellow, blue, magenta, cyan, white, gray \n' +
+                'or any hex values for colors, eg #23de43\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,
@@ -125,7 +133,7 @@ const args = yargs
                 'Can be either the index or the name of the process.'
         }
     })
-    .group(['n', 'name-separator', 'raw', 's', 'no-color'], 'General')
+    .group(['m', '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')
@@ -152,6 +160,7 @@ concurrently(args._.map((command, index) => {
     killOthers: args.killOthers
         ? ['success', 'failure']
         : (args.killOthersOnFail ? ['failure'] : []),
+    maxProcesses: args.maxProcesses,
     raw: args.raw,
     prefix: args.prefix,
     prefixLength: args.prefixLength,

package/index.js

@@ -19,8 +19,10 @@ module.exports = (commands, options = {}) => {
     });
 
     return concurrently(commands, {
+        maxProcesses: options.maxProcesses,
         raw: options.raw,
         successCondition: options.successCondition,
+        cwd: options.cwd,
         controllers: [
             new LogError({ logger }),
             new LogOutput({ logger }),
@@ -30,7 +32,7 @@ module.exports = (commands, options = {}) => {
                 defaultInputTarget: options.defaultInputTarget,
                 inputStream: options.inputStream,
             }),
-            new KillOnSignal(),
+            new KillOnSignal({ process }),
             new RestartProcess({
                 logger,
                 delay: options.restartDelay,
@@ -47,6 +49,7 @@ module.exports = (commands, options = {}) => {
 // Export all flow controllers and the main concurrently function,
 // so that 3rd-parties can use them however they want
 exports.concurrently = concurrently;
+exports.Logger = Logger;
 exports.InputHandler = InputHandler;
 exports.KillOnSignal = KillOnSignal;
 exports.KillOthers = KillOthers;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "concurrently",
-  "version": "5.0.2",
+  "version": "6.0.0",
   "description": "Run commands concurrently",
   "main": "index.js",
   "bin": {
     "concurrently": "./bin/concurrently.js"
   },
   "engines": {
-    "node": ">=6.0.0"
+    "node": ">=10.0.0"
   },
   "scripts": {
     "lint": "eslint . --ignore-path .gitignore",
@@ -29,20 +29,20 @@
   "author": "Kimmo Brunfeldt",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^2.4.2",
-    "date-fns": "^2.0.1",
-    "lodash": "^4.17.15",
-    "read-pkg": "^4.0.1",
-    "rxjs": "^6.5.2",
+    "chalk": "^4.1.0",
+    "date-fns": "^2.16.1",
+    "lodash": "^4.17.20",
+    "read-pkg": "^5.2.0",
+    "rxjs": "^6.6.3",
     "spawn-command": "^0.0.2-1",
-    "supports-color": "^6.1.0",
+    "supports-color": "^8.1.0",
     "tree-kill": "^1.2.2",
-    "yargs": "^13.3.0"
+    "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "coveralls": "^3.0.4",
-    "eslint": "^5.16.0",
-    "jest": "^24.8.0",
+    "coveralls": "^3.1.0",
+    "eslint": "^7.17.0",
+    "jest": "^26.6.3",
     "jest-create-mock-instance": "^1.1.0"
   },
   "files": [

package/src/command-parser/expand-npm-shortcut.js

@@ -1,6 +1,6 @@
 module.exports = class ExpandNpmShortcut {
     parse(commandInfo) {
-        const [, npmCmd, cmdName, args] = commandInfo.command.match(/^(npm|yarn):(\S+)(.*)/) || [];
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/^(npm|yarn|pnpm):(\S+)(.*)/) || [];
         if (!cmdName) {
             return commandInfo;
         }

package/src/command-parser/expand-npm-wildcard.js

@@ -7,7 +7,7 @@ module.exports = class ExpandNpmWildcard {
     }
 
     parse(commandInfo) {
-        const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn) run (\S+)([^&]*)/) || [];
+        const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn|pnpm) run (\S+)([^&]*)/) || [];
         const wildcardPosition = (cmdName || '').indexOf('*');
 
         // If the regex didn't match an npm script, or it has no wildcard,

package/src/command.js

@@ -5,11 +5,12 @@ module.exports = class Command {
         return !!this.process;
     }
 
-    constructor({ index, name, command, prefixColor, killProcess, spawn, spawnOpts }) {
+    constructor({ index, name, command, prefixColor, env, killProcess, spawn, spawnOpts }) {
         this.index = index;
         this.name = name;
         this.command = command;
         this.prefixColor = prefixColor;
+        this.env = env;
         this.killProcess = killProcess;
         this.spawn = spawn;
         this.spawnOpts = spawnOpts;
@@ -31,7 +32,16 @@ module.exports = class Command {
         });
         Rx.fromEvent(child, 'close').subscribe(([exitCode, signal]) => {
             this.process = undefined;
-            this.close.next(exitCode === null ? signal : exitCode);
+            this.close.next({
+                command: {
+                    command: this.command,
+                    name: this.name,
+                    prefixColor: this.prefixColor,
+                    env: this.env,
+                },
+                index: this.index,
+                exitCode: exitCode === null ? signal : exitCode,
+            });
         });
         child.stdout && pipeTo(Rx.fromEvent(child.stdout, 'data'), this.stdout);
         child.stderr && pipeTo(Rx.fromEvent(child.stderr, 'data'), this.stderr);

package/src/completion-listener.js

@@ -7,29 +7,33 @@ module.exports = class CompletionListener {
         this.scheduler = scheduler;
     }
 
-    listen(commands) {
-        const closeStreams = commands.map(command => command.close);
-        const allClosed = Rx.zip(...closeStreams);
-        return Rx.merge(...closeStreams).pipe(
-            bufferCount(closeStreams.length),
-            map(exitCodes => {
-                switch (this.successCondition) {
-                /* eslint-disable indent */
-                    case 'first':
-                        return exitCodes[0] === 0;
+    isSuccess(exitCodes) {
+        switch (this.successCondition) {
+        /* eslint-disable indent */
+            case 'first':
+                return exitCodes[0] === 0;
+
+            case 'last':
+                return exitCodes[exitCodes.length - 1] === 0;
 
-                    case 'last':
-                        return exitCodes[exitCodes.length - 1] === 0;
+            default:
+                return exitCodes.every(exitCode => exitCode === 0);
+            /* eslint-enable indent */
+        }
+    }
 
-                    default:
-                        return exitCodes.every(exitCode => exitCode === 0);
-                /* eslint-enable indent */
-                }
-            }),
-            switchMap(success => success
-                ? Rx.of(null, this.scheduler)
-                : Rx.throwError(new Error(), this.scheduler)),
-            take(1)
-        ).toPromise();
+    listen(commands) {
+        const closeStreams = commands.map(command => command.close);
+        return Rx.merge(...closeStreams)
+            .pipe(
+                bufferCount(closeStreams.length),
+                switchMap(exitInfos =>
+                    this.isSuccess(exitInfos.map(({ exitCode }) => exitCode))
+                        ? Rx.of(exitInfos, this.scheduler)
+                        : Rx.throwError(exitInfos, this.scheduler)
+                ),
+                take(1)
+            )
+            .toPromise();
     }
 };

package/src/concurrently.js

@@ -16,7 +16,8 @@ const defaults = {
     spawn,
     kill: treeKill,
     raw: false,
-    controllers: []
+    controllers: [],
+    cwd: undefined,
 };
 
 module.exports = (commands, options) => {
@@ -31,17 +32,21 @@ module.exports = (commands, options) => {
         new ExpandNpmWildcard()
     ];
 
-    const spawnOpts = getSpawnOpts({ raw: options.raw });
-
     commands = _(commands)
         .map(mapToCommandInfo)
         .flatMap(command => parseCommand(command, commandParsers))
-        .map((command, index) => new Command(Object.assign({
-            index,
-            spawnOpts,
-            killProcess: options.kill,
-            spawn: options.spawn,
-        }, command)))
+        .map((command, index) => new Command(
+            Object.assign({
+                index,
+                spawnOpts: getSpawnOpts({
+                    raw: options.raw,
+                    env: command.env,
+                    cwd: command.cwd || options.cwd,
+                }),
+                killProcess: options.kill,
+                spawn: options.spawn,
+            }, command)
+        ))
         .value();
 
     commands = options.controllers.reduce(
@@ -49,7 +54,12 @@ module.exports = (commands, options) => {
         commands
     );
 
-    commands.forEach(command => command.start());
+    const commandsLeft = commands.slice();
+    const maxProcesses = Math.max(1, Number(options.maxProcesses) || commandsLeft.length);
+    for (let i = 0; i < maxProcesses; i++) {
+        maybeRunMore(commandsLeft);
+    }
+
     return new CompletionListener({ successCondition: options.successCondition }).listen(commands);
 };
 
@@ -58,6 +68,7 @@ function mapToCommandInfo(command) {
         command: command.command || command,
         name: command.name || '',
         prefixColor: command.prefixColor || '',
+        env: command.env || {},
     };
 }
 
@@ -67,3 +78,15 @@ function parseCommand(command, parsers) {
         _.castArray(command)
     );
 }
+
+function maybeRunMore(commandsLeft) {
+    const command = commandsLeft.shift();
+    if (!command) {
+        return;
+    }
+
+    command.start();
+    command.close.subscribe(() => {
+        maybeRunMore(commandsLeft);
+    });
+}

package/src/defaults.js

@@ -8,6 +8,8 @@ module.exports = {
     defaultInputTarget: 0,
     // Whether process.stdin should be forwarded to child processes
     handleInput: false,
+    // How many processes to run at once
+    maxProcesses: 0,
     nameSeparator: ',',
     // Which prefix style to use when logging processes output.
     prefix: '',
@@ -23,5 +25,7 @@ module.exports = {
     // Condition of success for concurrently itself.
     success: 'all',
     // Refer to https://date-fns.org/v2.0.1/docs/format
-    timestampFormat: 'yyyy-MM-dd HH:mm:ss.SSS'
+    timestampFormat: 'yyyy-MM-dd HH:mm:ss.SSS',
+    // Current working dir passed as option to spawn command. Default: process.cwd()
+    cwd: undefined
 };

package/src/flow-control/kill-on-signal.js

@@ -2,7 +2,7 @@ const { map } = require('rxjs/operators');
 
 
 module.exports = class KillOnSignal {
-    constructor({ process = global.process } = {}) {
+    constructor({ process }) {
         this.process = process;
     }
 
@@ -16,8 +16,9 @@ module.exports = class KillOnSignal {
         });
 
         return commands.map(command => {
-            const closeStream = command.close.pipe(map(value => {
-                return caughtSignal === 'SIGINT' ? 0 : value;
+            const closeStream = command.close.pipe(map(exitInfo => {
+                const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
+                return Object.assign({}, exitInfo, { exitCode });
             }));
             return new Proxy(command, {
                 get(target, prop) {

package/src/flow-control/kill-others.js

@@ -18,7 +18,7 @@ module.exports = class KillOthers {
         }
 
         const closeStates = commands.map(command => command.close.pipe(
-            map(exitCode => exitCode === 0 ? 'success' : 'failure'),
+            map(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'),
             filter(state => conditions.includes(state))
         ));
 

package/src/flow-control/log-exit.js

@@ -4,8 +4,8 @@ module.exports = class LogExit {
     }
 
     handle(commands) {
-        commands.forEach(command => command.close.subscribe(code => {
-            this.logger.logCommandEvent(`${command.command} exited with code ${code}`, command);
+        commands.forEach(command => command.close.subscribe(({ exitCode }) => {
+            this.logger.logCommandEvent(`${command.command} exited with code ${exitCode}`, command);
         }));
 
         return commands;

package/src/flow-control/restart-process.js

@@ -18,7 +18,7 @@ module.exports = class RestartProcess {
 
         commands.map(command => command.close.pipe(
             take(this.tries),
-            takeWhile(code => code !== 0)
+            takeWhile(({ exitCode }) => exitCode !== 0)
         )).map((failure, index) => Rx.merge(
             // Delay the emission (so that the restarts happen on time),
             // explicitly telling the subscriber that a restart is needed
@@ -36,9 +36,9 @@ module.exports = class RestartProcess {
         }));
 
         return commands.map(command => {
-            const closeStream = command.close.pipe(filter((value, emission) => {
+            const closeStream = command.close.pipe(filter(({ exitCode }, emission) => {
                 // We let all success codes pass, and failures only after restarting won't happen again
-                return value === 0 || emission >= this.tries;
+                return exitCode === 0 || emission >= this.tries;
             }));
 
             return new Proxy(command, {

package/src/get-spawn-opts.js

@@ -2,11 +2,15 @@ const supportsColor = require('supports-color');
 
 module.exports = ({
     colorSupport = supportsColor.stdout,
+    cwd,
     process = global.process,
-    raw = false
-} = {}) => Object.assign(
-    {},
+    raw = false,
+    env = {},
+}) => Object.assign(
+    {
+        cwd: cwd || process.cwd(),
+    },
     raw && { stdio: 'inherit' },
     /^win/.test(process.platform) && { detached: false },
-    colorSupport && { env: Object.assign({ FORCE_COLOR: colorSupport.level }, process.env) }
+    { env: Object.assign(colorSupport ? { FORCE_COLOR: colorSupport.level } : {}, process.env, env) }
 );

package/src/logger.js

@@ -53,11 +53,16 @@ module.exports = class Logger {
         return _.reduce(prefixes, (prev, val, key) => {
             const keyRegex = new RegExp(_.escapeRegExp(`{${key}}`), 'g');
             return prev.replace(keyRegex, val);
-        }, prefix).trim();
+        }, prefix);
     }
 
     colorText(command, text) {
-        const color = _.get(chalk, command.prefixColor, chalk.gray.dim);
+        let color;
+        if (command.prefixColor && command.prefixColor.startsWith('#')) {
+            color = chalk.hex(command.prefixColor);
+        } else {
+            color = _.get(chalk, command.prefixColor, chalk.gray.dim);
+        }
         return color(text);
     }