concurrently 3.4.0 → 3.6.1

package/src/main.js

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
-
-var Rx = require('rx');
-var path = require('path');
-var formatDate = require('date-fns/format');
-var program = require('commander');
-var _ = require('lodash');
-var treeKill = require('tree-kill');
-var chalk = require('chalk');
-var spawn = require('spawn-command');
-var supportsColor = require('supports-color');
-var IS_WINDOWS = /^win/.test(process.platform);
-
-var config = {
+'use strict';
+
+const Rx = require('rx');
+const path = require('path');
+const formatDate = require('date-fns/format');
+const program = require('commander');
+const _ = require('lodash');
+const treeKill = require('tree-kill');
+const chalk = require('chalk');
+const spawn = require('spawn-command');
+const supportsColor = require('supports-color');
+const IS_WINDOWS = /^win/.test(process.platform);
+
+const findChild = require('./findChild.js');
+const parseCmds = require('./parseCmds');
+
+let config = {
     // Kill other processes if one dies
     killOthers: false,
 
@@ -24,7 +28,7 @@ var config = {
 
     // Prefix logging with pid
     // Possible values: 'pid', 'none', 'time', 'command', 'index', 'name'
-    prefix: 'index',
+    prefix: '',
 
     // List of custom names to be used in prefix template
     names: '',
@@ -46,19 +50,33 @@ var config = {
     color: true,
 
     // If true, the output will only be raw output of processes, nothing more
-    raw: false
+    raw: false,
+
+    // If true, the process restart when it exited with status code non-zero
+    allowRestart: false,
+
+    // By default, restart instantly
+    restartAfter: 0,
+
+    // By default, restart once
+    restartTries: 1,
+
+    // Default identifier for child to which input on stdin should be sent.
+    defaultInputTarget: '0'
 };
 
 function main() {
-    var firstBase = path.basename(process.argv[0]);
-    var secondBase = path.basename(process.argv[1]);
+    const firstBase = path.basename(process.argv[0]);
+    const secondBase = path.basename(process.argv[1]);
     if (firstBase === 'concurrent' || secondBase === 'concurrent') {
         console.error('Warning: "concurrent" command is deprecated, use "concurrently" instead.\n');
     }
 
     parseArgs();
     config = mergeDefaultsWithArgs(config);
-    run(program.args);
+
+    const cmds = parseCmds(program.args, config);
+    run(cmds);
 }
 
 function parseArgs() {
@@ -81,7 +99,7 @@ function parseArgs() {
             '-p, --prefix <prefix>',
             'prefix used in logging for each process.\n' +
             'Possible values: index, pid, time, command, name, none, or a template. Default: ' +
-            config.prefix + '. Example template: "{time}-{pid}"\n'
+            'index or name (when --names is set). Example template: "{time}-{pid}"\n'
         )
         .option(
             '-n, --names <names>',
@@ -126,10 +144,40 @@ function parseArgs() {
             'The option can be used to shorten long commands.\n' +
             'Works only if prefix is set to "command". Default: ' +
             config.prefixLength + '\n'
+        )
+        .option(
+            '--allow-restart',
+            'Restart a process which died. Default: ' +
+            config.allowRestart + '\n'
+        )
+        .option(
+            '--restart-after <miliseconds>',
+            'delay time to respawn the process. Default: ' +
+            config.restartAfter + '\n'
+        )
+        .option(
+            '--restart-tries <times>',
+            'limit the number of respawn tries. Default: ' +
+            config.restartTries + '\n'
+
+        )
+        .option(
+            '--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: ' + config.defaultInputTarget + '\n'
         );
 
     program.on('--help', function() {
-        var help = [
+        const help = [
+            '  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.',
+            '',
             '  Examples:',
             '',
             '   - Kill other processes if one exits or dies',
@@ -154,12 +202,40 @@ function parseArgs() {
             '',
             '   - Custom names and colored prefixes',
             '',
-            '       $ concurrently --prefix "[{name}]" --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "npm run watch" "http-server"',
+            '       $ concurrently --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "http-server" "npm run watch"',
+            '',
+            '   - 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',
+            '       1:rs',
+            '',
+            '   - Send input to specific child identified by name',
+            '',
+            '       $ concurrently -n js,srv "npm run watch-js" nodemon',
+            '       srv:rs',
+            '',
+            '   - Shortened NPM run commands',
+            '',
+            '       $ concurrently npm:watch-node npm:watch-js npm:watch-css',
+            '',
+            '   - Shortened NPM run command with wildcard',
+            '',
+            '       $ concurrently npm:watch-*',
             ''
         ];
         console.log(help.join('\n'));
 
-        var url = 'https://github.com/kimmobrunfeldt/concurrently';
+        const url = 'https://github.com/kimmobrunfeldt/concurrently';
         console.log('  For more details, visit ' + url);
         console.log('');
     });
@@ -172,59 +248,84 @@ function mergeDefaultsWithArgs(config) {
     return _.merge(config, program);
 }
 
-function stripCmdQuotes(cmd) {
-    // Removes the quotes surrounding a command.
-    if (cmd[0] === '"' || cmd[0] === '\'') {
-        return cmd.substr(1, cmd.length - 2);
-    } else {
-        return cmd;
-    }
-}
-
 function run(commands) {
-    var childrenInfo = {};
-    var lastPrefixColor = _.get(chalk, chalk.gray.dim);
-    var prefixColors = config.prefixColors.split(',');
-    var names = config.names.split(config.nameSeparator);
-    var children = _.map(commands, function(cmd, index) {
-        // Remove quotes.
-        cmd = stripCmdQuotes(cmd);
-
-        var spawnOpts = config.raw ? {stdio: 'inherit'} : {};
+    const childrenInfo = {};
+    let lastPrefixColor = _.get(chalk, chalk.gray.dim);
+    const children = _.map(commands, function(cmdInfo, index) {
+
+        const spawnOpts = config.raw ? {stdio: 'inherit'} : {};
         if (IS_WINDOWS) {
             spawnOpts.detached = false;
         }
         if (supportsColor) {
-          spawnOpts.env = Object.assign({FORCE_COLOR: supportsColor.level}, process.env)
+            spawnOpts.env = Object.assign({FORCE_COLOR: supportsColor.level}, process.env);
         }
 
-        var child;
-        try {
-            child = spawn(cmd, spawnOpts);
-        } catch (e) {
-            logError('', chalk.gray.dim, 'Error occured when executing command: ' + cmd);
-            logError('', chalk.gray.dim, e.stack);
-            process.exit(1);
-        }
+        const child = spawnChild(cmdInfo.cmd, spawnOpts);
 
-        if (index < prefixColors.length) {
-            var prefixColorPath = prefixColors[index];
+        if (cmdInfo.color) {
+            const prefixColorPath = cmdInfo.color;
             lastPrefixColor = _.get(chalk, prefixColorPath, chalk.gray.dim);
         }
 
-        var name = index < names.length ? names[index] : '';
         childrenInfo[child.pid] = {
-            command: cmd,
+            command: cmdInfo.cmd,
             index: index,
-            name: name,
+            name: cmdInfo.name,
+            options: spawnOpts,
+            restartTries: config.restartTries,
             prefixColor: lastPrefixColor
         };
         return child;
     });
 
+    const streams = toStreams(children);
+
+    handleChildEvents(streams, children, childrenInfo);
+
+    ['SIGINT', 'SIGTERM'].forEach(function(signal) {
+        process.on(signal, function() {
+            children.forEach(function(child) {
+                treeKill(child.pid, signal);
+            });
+        });
+    });
+
+    process.stdin.on('data', (chunk) => {
+        let line = chunk.toString();
+
+        let targetId = config.defaultInputTarget;
+        if (line.indexOf(':') >= 0) {
+            const parts = line.split(':');
+            targetId = parts[0];
+            line = parts[1];
+        }
+
+        const target = findChild(targetId, children, childrenInfo);
+        if (target) {
+            target.stdin.write(line);
+        } else {
+            logError('', chalk.gray.dim, `Unable to find command [${targetId}]\n`);
+        }
+    });
+}
+
+function spawnChild(cmd, options) {
+    let child;
+    try {
+        child = spawn(cmd, options);
+    } catch (e) {
+        logError('', chalk.gray.dim, 'Error occured when executing command: ' + cmd);
+        logError('', chalk.gray.dim, e.stack);
+        process.exit(1);
+    }
+    return child;
+}
+
+function toStreams(children) {
     // Transform all process events to rx streams
-    var streams = _.map(children, function(child) {
-        var childStreams = {
+    return _.map(children, function(child) {
+        const childStreams = {
             error: Rx.Node.fromEvent(child, 'error'),
             close: Rx.Node.fromEvent(child, 'close')
         };
@@ -241,71 +342,88 @@ function run(commands) {
             return memo;
         }, {});
     });
+}
 
+function handleChildEvents(streams, children, childrenInfo) {
     handleClose(streams, children, childrenInfo);
     handleError(streams, childrenInfo);
     if (!config.raw) {
         handleOutput(streams, childrenInfo, 'stdout');
         handleOutput(streams, childrenInfo, 'stderr');
     }
-
-    ['SIGINT', 'SIGTERM'].forEach(function(signal) {
-      process.on(signal, function() {
-        children.forEach(function(child) {
-          treeKill(child.pid, signal);
-        });
-      });
-    });
 }
 
 function handleOutput(streams, childrenInfo, source) {
-    var sourceStreams = _.map(streams, source);
-    var combinedSourceStream = Rx.Observable.merge.apply(this, sourceStreams);
+    const sourceStreams = _.map(streams, source);
+    const combinedSourceStream = Rx.Observable.merge.apply(this, sourceStreams);
 
     combinedSourceStream.subscribe(function(event) {
-        var prefix = getPrefix(childrenInfo, event.child);
-        var prefixColor = childrenInfo[event.child.pid].prefixColor;
+        const prefix = getPrefix(childrenInfo, event.child);
+        const prefixColor = childrenInfo[event.child.pid].prefixColor;
         log(prefix, prefixColor, event.data.toString());
     });
 }
 
 function handleClose(streams, children, childrenInfo) {
-    var aliveChildren = _.clone(children);
-    var exitCodes = [];
-    var closeStreams = _.map(streams, 'close');
-    var closeStream = Rx.Observable.merge.apply(this, closeStreams);
-    var othersKilled = false
+    let aliveChildren = _.clone(children);
+    const exitCodes = [];
+    const closeStreams = _.map(streams, 'close');
+    const closeStream = Rx.Observable.merge.apply(this, closeStreams);
+    let othersKilled = false;
 
     // TODO: Is it possible that amount of close events !== count of spawned?
     closeStream.subscribe(function(event) {
-        var exitCode = event.data;
-        var nonSuccess = exitCode !== 0;
+        const exitCode = event.data;
+        const nonSuccess = exitCode !== 0;
         exitCodes.push(exitCode);
 
-        var prefix = getPrefix(childrenInfo, event.child);
-        var prefixColor = childrenInfo[event.child.pid].prefixColor;
-        var command = childrenInfo[event.child.pid].command;
+        const prefix = getPrefix(childrenInfo, event.child);
+        const childInfo = childrenInfo[event.child.pid];
+        const prefixColor = childInfo.prefixColor;
+        const command = childInfo.command;
         logEvent(prefix, prefixColor, command + ' exited with code ' + exitCode);
 
         aliveChildren = _.filter(aliveChildren, function(child) {
             return child.pid !== event.child.pid;
         });
 
+        if (nonSuccess && config.allowRestart && childInfo.restartTries--) {
+            respawnChild(event, childrenInfo);
+            return;
+        }
+
         if (aliveChildren.length === 0) {
             exit(exitCodes);
         }
         if (!othersKilled) {
-          if (config.killOthers) {
-            killOtherProcesses(aliveChildren);
-            othersKilled = true;
-          } else if (config.killOthersOnFail && nonSuccess) {
-            killOtherProcesses(aliveChildren);
-            othersKilled = true;
-          }
+            if (config.killOthers) {
+                killOtherProcesses(aliveChildren);
+                othersKilled = true;
+            } else if (config.killOthersOnFail && nonSuccess) {
+                killOtherProcesses(aliveChildren);
+                othersKilled = true;
+            }
         }
     });
 }
 
+function respawnChild(event, childrenInfo) {
+    setTimeout(function() {
+        const childInfo = childrenInfo[event.child.pid];
+        const prefix = getPrefix(childrenInfo, event.child);
+        const prefixColor = childInfo.prefixColor;
+        logEvent(prefix, prefixColor, childInfo.command + ' restarted');
+        const newChild = spawnChild(childInfo.command, childInfo.options);
+
+        childrenInfo[newChild.pid] = childrenInfo[event.child.pid];
+        delete childrenInfo[event.child.pid];
+
+        const children = [newChild];
+        const streams = toStreams(children);
+        handleChildEvents(streams, children, childrenInfo);
+    }, config.restartAfter);
+}
+
 function killOtherProcesses(processes) {
     logEvent('--> ', chalk.gray.dim, 'Sending SIGTERM to other processes..');
 
@@ -316,29 +434,29 @@ function killOtherProcesses(processes) {
 }
 
 function exit(childExitCodes) {
-    var success;
+    let success;
     switch (config.success) {
-        case 'first':
-            success = _.first(childExitCodes) === 0;
-            break;
-        case 'last':
-            success = _.last(childExitCodes) === 0;
-            break;
-        default:
-            success = _.every(childExitCodes, function(code) {
-                return code === 0;
-            });
+    case 'first':
+        success = _.first(childExitCodes) === 0;
+        break;
+    case 'last':
+        success = _.last(childExitCodes) === 0;
+        break;
+    default:
+        success = _.every(childExitCodes, function(code) {
+            return code === 0;
+        });
     }
     process.exit(success ? 0 : 1);
 }
 
 function handleError(streams, childrenInfo) {
     // Output emitted errors from child process
-    var errorStreams = _.map(streams, 'error');
-    var processErrorStream = Rx.Observable.merge.apply(this, errorStreams);
+    const errorStreams = _.map(streams, 'error');
+    const processErrorStream = Rx.Observable.merge.apply(this, errorStreams);
 
     processErrorStream.subscribe(function(event) {
-        var command = childrenInfo[event.child.pid].command;
+        const command = childrenInfo[event.child.pid].command;
         logError('', chalk.gray.dim, 'Error occured when executing command: ' + command);
         logError('', chalk.gray.dim, event.data.stack);
     });
@@ -353,19 +471,20 @@ function colorText(text, color) {
 }
 
 function getPrefix(childrenInfo, child) {
-    var prefixes = getPrefixes(childrenInfo, child);
-    if (_.includes(_.keys(prefixes), config.prefix)) {
-        return '[' + prefixes[config.prefix] + '] ';
+    const prefixes = getPrefixes(childrenInfo, child);
+    const prefixType = config.prefix || (prefixes.name ? 'name' : 'index');
+    if (_.includes(_.keys(prefixes), prefixType)) {
+        return '[' + prefixes[prefixType] + '] ';
     }
 
     return _.reduce(prefixes, function(memo, val, key) {
-        var re = new RegExp('{' + key + '}', 'g');
+        const re = new RegExp('{' + key + '}', 'g');
         return memo.replace(re, val);
     }, config.prefix) + ' ';
 }
 
 function getPrefixes(childrenInfo, child) {
-    var prefixes = {};
+    const prefixes = {};
 
     prefixes.none = '';
     prefixes.pid = child.pid;
@@ -373,7 +492,7 @@ function getPrefixes(childrenInfo, child) {
     prefixes.name = childrenInfo[child.pid].name;
     prefixes.time = formatDate(Date.now(), config.timestampFormat);
 
-    var command = childrenInfo[child.pid].command;
+    const command = childrenInfo[child.pid].command;
     prefixes.command = shortenText(command, config.prefixLength);
     return prefixes;
 }
@@ -384,11 +503,11 @@ function shortenText(text, length, cut) {
     }
     cut = _.isString(cut) ? cut : '..';
 
-    var endLength = Math.floor(length / 2);
-    var startLength = length - endLength;
+    const endLength = Math.floor(length / 2);
+    const startLength = length - endLength;
 
-    var first = text.substring(0, startLength);
-    var last = text.substring(text.length - endLength, text.length);
+    const first = text.substring(0, startLength);
+    const last = text.substring(text.length - endLength, text.length);
     return first + cut + last;
 }
 
@@ -397,9 +516,11 @@ function log(prefix, prefixColor, text) {
 }
 
 function logEvent(prefix, prefixColor, text) {
-    if (config.raw) return;
+    if (config.raw) {
+        return;
+    }
 
-    logWithPrefix(prefix, prefixColor, text, chalk.gray.dim);
+    logWithPrefix(prefix, prefixColor, text + '\n', chalk.gray.dim);
 }
 
 function logError(prefix, prefixColor, text) {
@@ -408,31 +529,35 @@ function logError(prefix, prefixColor, text) {
     logWithPrefix(prefix, prefixColor, text, chalk.red.bold);
 }
 
+let lastChar;
+
 function logWithPrefix(prefix, prefixColor, text, color) {
-    var lastChar = text[text.length - 1];
-    if (config.raw) {
-        if (lastChar !== '\n') {
-            text += '\n';
-        }
 
+    if (config.raw) {
         process.stdout.write(text);
         return;
     }
 
-    if (lastChar === '\n') {
-        // Remove extra newline from the end to prevent extra newlines in input
-        text = text.slice(0, text.length - 1);
-    }
+    text = text.replace(/\u2026/g,'...'); // Ellipsis
 
-    var lines = text.split('\n');
+    const lines = text.split('\n');
     // Do not bgColor trailing space
-    var coloredPrefix = colorText(prefix.replace(/ $/, ''), prefixColor) + ' ';
-    var paddedLines = _.map(lines, function(line, i) {
-        var coloredLine = color ? colorText(line, color) : line;
-        return coloredPrefix + coloredLine;
+    const coloredPrefix = colorText(prefix.replace(/ $/, ''), prefixColor) + ' ';
+    const paddedLines = _.map(lines, function(line, index) {
+        let coloredLine = color ? colorText(line, color) : line;
+        if (index !== 0 && index !== (lines.length - 1)) {
+            coloredLine = coloredPrefix + coloredLine;
+        }
+        return coloredLine;
     });
 
-    console.log(paddedLines.join('\n'));
+    if (!lastChar || lastChar === '\n' ) {
+        process.stdout.write(coloredPrefix);
+    }
+
+    lastChar = text[text.length - 1];
+
+    process.stdout.write(paddedLines.join('\n'));
 }
 
 main();

package/src/parseCmds.js

@@ -0,0 +1,65 @@
+'use strict';
+const _ = require('lodash');
+
+const pkgInfo = require('./pkgInfo');
+
+module.exports = function(cmds, config) {
+    config = config || {};
+
+    const names = (config.names || '').split(config.nameSeparator || ',');
+    const prefixColors = config.prefixColors ? config.prefixColors.split(',') : [];
+
+    cmds = cmds.map(stripCmdQuotes);
+
+    cmds = cmds.map((cmd, idx) => ({
+        cmd: cmd,
+        name: names[idx] || ''
+    }));
+
+    cmds = _.flatMap(cmds, expandCmdShortcuts);
+
+    return cmds.map((cmd, idx) => Object.assign(cmd, {
+        color: prefixColors[idx]
+    }));
+};
+
+function stripCmdQuotes(cmd) {
+    // Removes the quotes surrounding a command.
+    if (cmd[0] === '"' || cmd[0] === '\'') {
+        return cmd.substr(1, cmd.length - 2);
+    } else {
+        return cmd;
+    }
+}
+
+function expandCmdShortcuts(cmd) {
+    const shortcut = cmd.cmd.match(/^npm:(\S+)(.*)/);
+    if (shortcut) {
+        const cmdName = shortcut[1];
+        const args = shortcut[2];
+
+        const wildcard = cmdName.indexOf('*');
+        if (wildcard >= 0) {
+            return expandNpmWildcard(cmd, cmdName, wildcard, args);
+        }
+
+        if (!cmd.name) {
+            cmd.name = cmdName;
+        }
+        cmd.cmd = `npm run ${cmdName}${args}`;
+    }
+    return [ cmd ];
+}
+
+function expandNpmWildcard(cmd, cmdName, wildcardPos, args) {
+    const rePre = _.escapeRegExp(cmdName.substr(0, wildcardPos));
+    const reSuf = _.escapeRegExp(cmdName.substr(wildcardPos + 1));
+    const wildcardRe = new RegExp(`^${rePre}(.*?)${reSuf}$`);
+
+    return pkgInfo.getScripts()
+        .filter(script => script.match(wildcardRe))
+        .map(script => Object.assign({}, cmd,  {
+            cmd: `npm run ${script}${args}`,
+            name: cmd.name + script.match(wildcardRe)[1]
+        }));
+}

package/src/pkgInfo.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const readPkg = require('read-pkg');
+
+let pkg;
+
+function getPkg() {
+    if (!pkg) {
+        pkg = readPkg.sync();
+    }
+    return pkg;
+}
+
+exports.getScripts = function() {
+    const pkg = getPkg();
+    return Object.keys(pkg.scripts || {});
+};

package/test/support/read-echo.js

@@ -0,0 +1,12 @@
+'use strict';
+
+process.stdin.on('data', (chunk) => {
+    const line = chunk.toString().trim();
+    console.log(line);
+
+    if (line === 'stop') {
+        process.exit(0);
+    }
+});
+
+console.log('READING');

package/test/support/signal.js

@@ -1,12 +1,12 @@
 ['SIGINT', 'SIGTERM'].forEach(function(signal) {
-  process.on(signal, function() {
-    console.log(signal);
-    process.exit(1);
-  });
+    process.on(signal, function() {
+        console.log(signal);
+        process.exit(1);
+    });
 });
 
 function doNothing() {
-  setTimeout(doNothing, 1000);
+    setTimeout(doNothing, 1000);
 }
 
 doNothing();