concurrently 3.2.0 → 3.5.1

package/.travis.yml

@@ -1,10 +1,8 @@
 language: node_js
 node_js:
-  - 7
+  - 8
   - 6
   - 4
-before_script:
-  - npm install -g mocha
 notifications:
   email:
     - kimmobrunfeldt+concurrent@gmail.com

package/README.md

@@ -11,10 +11,10 @@ Like `npm run watch-js & npm run watch-less` but better.
 
 **Features:**
 
-* Cross platform, works also in Windows
+* Cross platform (including Windows)
 * Output is easy to follow with prefixes
 * With `--kill-others` switch, all commands are killed if one dies
-* Spawns commands with [spawn-default-shell](https://github.com/kimmobrunfeldt/spawn-default-shell)
+* Spawns commands with [spawn-command](https://github.com/mmalecki/spawn-command)
 
 ## Install
 
@@ -32,7 +32,7 @@ npm install concurrently --save
 
 ## Usage
 
-Remember to surround separate commands with quotes, like this:
+Remember to surround separate commands with quotes:
 ```bash
 concurrently "command1 arg" "command2 arg"
 ```
@@ -59,9 +59,10 @@ 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. Example template: "{time}-{pid}"
+  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"
@@ -85,12 +86,21 @@ Options:
   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
 
@@ -106,7 +116,7 @@ Examples:
 
  - 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"
 
 For more details, visit https://github.com/kimmobrunfeldt/concurrently
 ```
@@ -137,31 +147,3 @@ 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**.
-
-### NPM Issue
-
-Previously I thought this could fix some problems I had with watching scripts and this readme said:
-
-> When running watch or serve tasks, I'd recommend to use `--kill-others` option:
->
-> ```bash
-> concurrently --kill-others "npm run watch-js" "npm run watch-less"
-> ```
->
-> That way, if for some reason e.g. your `watch-less` died, you would notice it easier.
-
-However NPM didn't work as I hoped it would. See [this issue](https://github.com/kimmobrunfeldt/concurrently/issues/4).
-
-
-## Debugging
-
-A few common debugging commands.
-
-### spawn-default-shell
-
-Which shell and flag does [spawn-default-shell](https://github.com/kimmobrunfeldt/spawn-default-shell/)
-use?
-
-```bash
-npm i spawn-default-shell && node -e "console.log(require('spawn-default-shell/src/get-shell')())"
-```

package/appveyor.yml

@@ -1,13 +1,12 @@
 environment:
   matrix:
-    - nodejs_version: '7'
+    - nodejs_version: '8'
     - nodejs_version: '6'
     - nodejs_version: '4'
 install:
   - ps: Install-Product node $env:nodejs_version
   - set CI=true
   - npm -g install npm@latest
-  - npm install -g mocha
   - set PATH=%APPDATA%\npm;%PATH%
   - npm install
 build: off

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concurrently",
-  "version": "3.2.0",
+  "version": "3.5.1",
   "description": "Run commands concurrently",
   "main": "src/main.js",
   "bin": {
@@ -37,7 +37,7 @@
     "date-fns": "^1.23.0",
     "lodash": "^4.5.1",
     "rx": "2.3.24",
-    "spawn-default-shell": "^2.0.0",
+    "spawn-command": "^0.0.2-1",
     "supports-color": "^3.2.3",
     "tree-kill": "^1.1.0"
   },

package/src/main.js

@@ -7,7 +7,7 @@ var program = require('commander');
 var _ = require('lodash');
 var treeKill = require('tree-kill');
 var chalk = require('chalk');
-var defaultShell = require('spawn-default-shell');
+var spawn = require('spawn-command');
 var supportsColor = require('supports-color');
 var IS_WINDOWS = /^win/.test(process.platform);
 
@@ -15,8 +15,8 @@ var config = {
     // Kill other processes if one dies
     killOthers: false,
 
-    // How much in ms we wait before killing other processes
-    killDelay: 1000,
+    // Kill other processes if one exits with non zero status code
+    killOthersOnFail: false,
 
     // Return success or failure of the 'first' child to terminate, the 'last' child,
     // or succeed only if 'all' children succeed
@@ -24,7 +24,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,7 +46,16 @@ 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
 };
 
 function main() {
@@ -58,6 +67,8 @@ function main() {
 
     parseArgs();
     config = mergeDefaultsWithArgs(config);
+    applyDynamicDefaults(config)
+
     run(program.args);
 }
 
@@ -69,6 +80,10 @@ function parseArgs() {
             '-k, --kill-others',
             'kill other processes if one exits or dies'
         )
+        .option(
+            '--kill-others-on-fail',
+            'kill other processes if one exits with non zero status code'
+        )
         .option(
             '--no-color',
             'disable colors from logging'
@@ -77,7 +92,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>',
@@ -122,6 +137,21 @@ 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'
         );
 
     program.on('--help', function() {
@@ -132,6 +162,10 @@ function parseArgs() {
             '',
             '       $ 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"',
@@ -146,7 +180,7 @@ 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"',
             ''
         ];
         console.log(help.join('\n'));
@@ -164,6 +198,12 @@ function mergeDefaultsWithArgs(config) {
     return _.merge(config, program);
 }
 
+function applyDynamicDefaults(config) {
+    if (!config.prefix) {
+        config.prefix = config.names ? 'name' : 'index';
+    }
+}
+
 function stripCmdQuotes(cmd) {
     // Removes the quotes surrounding a command.
     if (cmd[0] === '"' || cmd[0] === '\'') {
@@ -190,14 +230,7 @@ function run(commands) {
           spawnOpts.env = Object.assign({FORCE_COLOR: supportsColor.level}, process.env)
         }
 
-        var child;
-        try {
-            child = defaultShell.spawn(cmd, spawnOpts);
-        } catch (e) {
-            logError('', chalk.gray.dim, 'Error occured when executing command: ' + cmd);
-            logError('', chalk.gray.dim, e.stack);
-            process.exit(1);
-        }
+        var child = spawnChild(cmd, spawnOpts);
 
         if (index < prefixColors.length) {
             var prefixColorPath = prefixColors[index];
@@ -209,13 +242,41 @@ function run(commands) {
             command: cmd,
             index: index,
             name: name,
+            options: spawnOpts,
+            restartTries: config.restartTries,
             prefixColor: lastPrefixColor
         };
         return child;
     });
 
+    var streams = toStreams(children);
+
+    handleChildEvents(streams, children, childrenInfo);
+
+    ['SIGINT', 'SIGTERM'].forEach(function(signal) {
+      process.on(signal, function() {
+        children.forEach(function(child) {
+          treeKill(child.pid, signal);
+        });
+      });
+    });
+}
+
+function spawnChild(cmd, options) {
+    var 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) {
+    return _.map(children, function(child) {
         var childStreams = {
             error: Rx.Node.fromEvent(child, 'error'),
             close: Rx.Node.fromEvent(child, 'close')
@@ -233,21 +294,15 @@ 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) {
@@ -266,39 +321,68 @@ function handleClose(streams, children, childrenInfo) {
     var exitCodes = [];
     var closeStreams = _.map(streams, 'close');
     var closeStream = Rx.Observable.merge.apply(this, closeStreams);
+    var 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;
         exitCodes.push(exitCode);
 
         var prefix = getPrefix(childrenInfo, event.child);
-        var prefixColor = childrenInfo[event.child.pid].prefixColor;
-        var command = childrenInfo[event.child.pid].command;
+        var childInfo = childrenInfo[event.child.pid];
+        var prefixColor = childInfo.prefixColor;
+        var 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) {
-        // Give other processes some time to stop cleanly before killing them
-        var delayedExit = closeStream.delay(config.killDelay);
+function respawnChild(event, childrenInfo) {
+    setTimeout(function() {
+        var childInfo = childrenInfo[event.child.pid];
+        var prefix = getPrefix(childrenInfo, event.child);
+        var prefixColor = childInfo.prefixColor;
+        logEvent(prefix, prefixColor, childInfo.command + ' restarted');
+        var newChild = spawnChild(childInfo.command, childInfo.options);
 
-        delayedExit.subscribe(function() {
-            logEvent('--> ', chalk.gray.dim, 'Sending SIGTERM to other processes..');
+        childrenInfo[newChild.pid] = childrenInfo[event.child.pid];
+        delete childrenInfo[event.child.pid];
 
-            // Send SIGTERM to alive children
-            _.each(aliveChildren, function(child) {
-                treeKill(child.pid, 'SIGTERM');
-            });
-        });
-    }
+        var children = [newChild];
+        var streams = toStreams(children);
+        handleChildEvents(streams, children, childrenInfo);
+    }, config.restartAfter);
+}
+
+function killOtherProcesses(processes) {
+    logEvent('--> ', chalk.gray.dim, 'Sending SIGTERM to other processes..');
+
+    // Send SIGTERM to alive children
+    _.each(processes, function(child) {
+        treeKill(child.pid, 'SIGTERM');
+    });
 }
 
 function exit(childExitCodes) {
@@ -385,7 +469,7 @@ function log(prefix, prefixColor, text) {
 function logEvent(prefix, prefixColor, text) {
     if (config.raw) return;
 
-    logWithPrefix(prefix, prefixColor, text, chalk.gray.dim);
+    logWithPrefix(prefix, prefixColor, text + '\n', chalk.gray.dim);
 }
 
 function logError(prefix, prefixColor, text) {
@@ -394,31 +478,35 @@ function logError(prefix, prefixColor, text) {
     logWithPrefix(prefix, prefixColor, text, chalk.red.bold);
 }
 
+var 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');
     // Do not bgColor trailing space
     var coloredPrefix = colorText(prefix.replace(/ $/, ''), prefixColor) + ' ';
-    var paddedLines = _.map(lines, function(line, i) {
+    var paddedLines = _.map(lines, function(line, index) {
         var coloredLine = color ? colorText(line, color) : line;
-        return coloredPrefix + coloredLine;
+        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/test/test-functional.js

@@ -5,8 +5,8 @@ var assert = require('assert');
 var run = require('./utils').run;
 var IS_WINDOWS = /^win/.test(process.platform);
 
-// If true, output of commands are shown
-var DEBUG_TESTS = process.env.DEBUG_TESTS === 'true';
+// Note: Set the DEBUG_TESTS environment variable to `true` to see output of test commands.
+
 var TEST_DIR = 'dir/';
 
 // Abs path to test directory
@@ -17,7 +17,7 @@ describe('concurrently', function() {
     this.timeout(5000);
 
     it('help should be successful', () => {
-        return run('node ./src/main.js --help', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js --help')
             .then(function(exitCode) {
                 // exit code 0 means success
                 assert.strictEqual(exitCode, 0);
@@ -25,36 +25,69 @@ describe('concurrently', function() {
     });
 
     it('version should be successful', () => {
-        return run('node ./src/main.js -V', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -V')
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
             });
     });
 
     it('two successful commands should exit 0', () => {
-        return run('node ./src/main.js "echo test" "echo test"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js "echo test" "echo test"')
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
             });
     });
 
     it('at least one unsuccessful commands should exit non-zero', () => {
-        return run('node ./src/main.js "echo test" "nosuchcmd" "echo test"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js "echo test" "nosuchcmd" "echo test"')
             .then(function(exitCode) {
                 assert.notStrictEqual(exitCode, 0);
             });
     });
 
     it('--kill-others should kill other commands if one dies', () => {
-        // This test would timeout if kill others option does not work
-        return run('node ./src/main.js --kill-others "sleep 1000" "echo test" "sleep 1000"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js --kill-others "sleep 1" "echo test" "sleep 0.1 && nosuchcmd"')
+            .then(function(exitCode) {
+                assert.notStrictEqual(exitCode, 0);
+            });
+    });
+
+    it('--kill-others-on-fail should kill other commands if one exits with non-zero status code', () => {
+        return run('node ./src/main.js --kill-others-on-fail "sleep 1" "exit 1" "sleep 1"')
             .then(function(exitCode) {
                 assert.notStrictEqual(exitCode, 0);
             });
     });
 
+    it('--kill-others-on-fail should NOT kill other commands if none of them exits with non-zero status code', (done) => {
+        var readline = require('readline');
+        var exits = 0;
+        var sigtermInOutput = false;
+
+        run('node ./src/main.js --kill-others-on-fail "echo killTest1" "echo killTest2" "echo killTest3"', {
+            onOutputLine: function(line) {
+                if (/SIGTERM/.test(line)) {
+                    sigtermInOutput = true;
+                }
+
+                // waiting for exits
+                if (/killTest\d$/.test(line)) {
+                    exits++;
+                }
+            }
+        }).then(function() {
+            if(sigtermInOutput) {
+                done(new Error('There was a "SIGTERM" in console output'));
+            } else if (exits !== 3) {
+                done(new Error('There was wrong number of echoes(' + exits + ') from executed commands'));
+            } else {
+                done();
+            }
+        });
+    });
+
     it('--success=first should return first exit code', () => {
-        return run('node ./src/main.js -k --success first "echo test" "sleep 1000" ', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -k --success first "echo test" "sleep 0.1 && nosuchcmd"')
             // When killed, sleep returns null exit code
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
@@ -63,26 +96,138 @@ describe('concurrently', function() {
 
     it('--success=last should return last exit code', () => {
         // When killed, sleep returns null exit code
-        return run('node ./src/main.js -k --success last "echo test" "sleep 1000" ', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -k --success last "echo test" "sleep 0.1 && nosuchcmd"')
             .then(function(exitCode) {
                 assert.notStrictEqual(exitCode, 0);
             });
     });
 
     it('&& nosuchcmd should return non-zero exit code', () => {
-        return run('node ./src/main.js "echo 1 && nosuchcmd" "echo 1 && nosuchcmd" ', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js "echo 1 && nosuchcmd" "echo 1 && nosuchcmd" ')
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 1);
             });
     });
 
     it('--prefix-colors should handle non-existent colors without failing', () => {
-        return run('node ./src/main.js -c "not.a.color" "echo colors"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -c "not.a.color" "echo colors"')
+            .then(function(exitCode) {
+                assert.strictEqual(exitCode, 0);
+            });
+    });
+
+    it('--prefix should default to "index"', () => {
+        var collectedLines = []
+
+        return run('node ./src/main.js "echo one" "echo two"', {
+            onOutputLine: (line) => {
+                if (/(one|two)$/.exec(line)) {
+                    collectedLines.push(line)
+                }
+            }
+        })
+            .then(function(exitCode) {
+                assert.strictEqual(exitCode, 0);
+
+                collectedLines.sort()
+                assert.deepEqual(collectedLines, [
+                    '[0] one',
+                    '[1] two'
+                ])
+            });
+    });
+
+    it('--names should set a different default prefix', () => {
+        var collectedLines = []
+
+        return run('node ./src/main.js -n aa,bb "echo one" "echo two"', {
+            onOutputLine: (line) => {
+                if (/(one|two)$/.exec(line)) {
+                    collectedLines.push(line)
+                }
+            }
+        })
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
+
+                collectedLines.sort()
+                assert.deepEqual(collectedLines, [
+                    '[aa] one',
+                    '[bb] two'
+                ])
             });
     });
 
+    it('--allow-restart should restart a proccess with non-zero exit code', (done) => {
+        var readline = require('readline');
+        var exitedWithOne = false;
+        var restarted = false;
+
+        run('node ./src/main.js --allow-restart "sleep 0.1 && exit 1" "sleep 1"', {
+            pipe: false,
+            onOutputLine: (line) => {
+                var re = /exited with code (.+)/.exec(line);
+                if (re && re[1] === '1') {
+                    exitedWithOne = true
+                }
+
+                if (/restarted/.test(line)) {
+                    restarted = true;
+                }
+            }
+        }).then(function() {
+            if (exitedWithOne && restarted) {
+                done();
+            } else {
+                done(new Error('No restarted process exited with code 1'));
+            }
+        });
+    });
+
+    it('--restart-after=n should restart a proccess after n miliseconds', (done) => {
+        var readline = require('readline');
+        var start, end;
+
+        run('node ./src/main.js --allow-restart --restart-after 300 "exit 1" "sleep 1"', {
+            pipe: false,
+            onOutputLine: (line) => {
+                if (!start && /exited with code (.+)/.test(line)) {
+                    start = new Date().getTime();
+                }
+
+                if (!end && /restarted/.test(line)) {
+                    end = new Date().getTime();
+                }
+            }
+        }).then(function() {
+            // we accept 100 miliseconds of error
+            if (end - start >= 300 && end - start < 400) {
+                done();
+            } else {
+                done(new Error('No restarted process after 300 miliseconds'));
+            }
+        });
+    });
+    it('--restart-tries=n should restart a proccess at most n times', (done) => {
+        var readline = require('readline');
+        var restartedTimes = 0;
+
+        run('node ./src/main.js --allow-restart --restart-tries 2 "exit 1" "sleep 1"', {
+            pipe: false,
+            onOutputLine: (line) => {
+                if (/restarted/.test(line)) {
+                    restartedTimes++;
+                }
+            }
+        }).then(function() {
+            if (restartedTimes == 2) {
+                done();
+            } else {
+                done(new Error('No restarted process twice'));
+            }
+        });
+    });
+
     ['SIGINT', 'SIGTERM'].forEach((signal) => {
       if (IS_WINDOWS) {
           console.log('IS_WINDOWS=true');
@@ -104,32 +249,20 @@ describe('concurrently', function() {
         }
 
         run('node ./src/main.js "node ./test/support/signal.js" "node ./test/support/signal.js"', {
-          pipe: false,
-          callback: function(child) {
-            var rl = readline.createInterface({
-              input: child.stdout,
-              output: null
-            });
+          onOutputLine: function(line, child) {
+            // waiting for startup
+            if (/STARTED/.test(line)) {
+              waitingStart--;
+            }
+            if (!waitingStart) {
+              // both processes are started
+              child.kill(signal);
+            }
 
-            rl.on('line', function(line) {
-              if (DEBUG_TESTS) {
-                console.log(line);
-              }
-
-              // waiting for startup
-              if (/STARTED/.test(line)) {
-                waitingStart--;
-              }
-              if (!waitingStart) {
-                // both processes are started
-                child.kill(signal);
-              }
-
-              // waiting for signal
-              if (new RegExp(signal).test(line)) {
-                waitingSignal--;
-              }
-            });
+            // waiting for signal
+            if (new RegExp(signal).test(line)) {
+              waitingSignal--;
+            }
           }
         }).then(function() {
           waitForSignal(done);

package/test/utils.js

@@ -1,31 +1,31 @@
 var childProcess = require('child_process');
 var _ = require('lodash');
+var readline = require('readline')
 var shellQuote = require('shell-quote');
 
+// If true, output of commands are shown
+var DEBUG_TESTS = process.env.DEBUG_TESTS === 'true';
+
 function run(cmd, opts) {
     opts = _.merge({
-        pipe: true,
-        cwd: undefined,
-        callback: function(child) {
-            // Since we return promise, we need to provide
-            // this callback if one wants to access the child
-            // process reference
-            // Called immediately after successful child process
-            // spawn
-        }
+        // If set to a function, it will be called for each line
+        // written to the child process's stdout as (line, child)
+        onOutputLine: undefined,
     }, opts);
 
     var child;
     var parts = shellQuote.parse(cmd);
     try {
         child = childProcess.spawn(_.head(parts), _.tail(parts), {
-            cwd: opts.cwd,
-            stdio: opts.pipe ? "inherit" : null
+            stdio: DEBUG_TESTS && !opts.onOutputLine ? 'inherit': null,
         });
     } catch (e) {
         return Promise.reject(e);
     }
-    opts.callback(child);
+
+    if (opts.onOutputLine) {
+        readLines(child, opts.onOutputLine);
+    }
 
     return new Promise(function(resolve, reject) {
         child.on('error', function(err) {
@@ -38,6 +38,21 @@ function run(cmd, opts) {
     });
 }
 
+function readLines(child, callback) {
+    var rl = readline.createInterface({
+        input: child.stdout,
+        output: null
+    });
+
+    rl.on('line', function(line) {
+        if (DEBUG_TESTS) {
+            console.log(line);
+        }
+
+        callback(line, child)
+    });
+}
+
 module.exports = {
     run: run
 };

package/.npmignore

@@ -1,31 +0,0 @@
-# Logs
-logs
-*.log
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directory
-# Deployed apps should consider commenting this line out:
-# see https://npmjs.org/doc/faq.html#Should-I-check-my-node_modules-folder-into-git
-node_modules
-
-# OS X
-.DS_Store
-
-# Vagrant directory
-.vagrant