concurrently 6.0.1 → 6.2.1

package/README.md

@@ -1,6 +1,6 @@
 # Concurrently
 
-[![Travis Build Status](https://travis-ci.org/kimmobrunfeldt/concurrently.svg)](https://travis-ci.org/kimmobrunfeldt/concurrently) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/kimmobrunfeldt/concurrently?branch=master&svg=true)](https://ci.appveyor.com/project/kimmobrunfeldt/concurrently) *master branch status*
+[![Build Status](https://github.com/open-cli-tools/concurrently/workflows/Tests/badge.svg)](https://github.com/open-cli-tools/concurrently/actions?workflow=Tests) *master branch status*
 
 [![NPM Badge](https://nodei.co/npm/concurrently.png?downloads=true)](https://www.npmjs.com/package/concurrently)
 
@@ -20,7 +20,7 @@ Like `npm run watch-js & npm run watch-less` but better.
 
 ## Why
 
-I like [task automation with npm](http://substack.net/task_automation_with_npm_run)
+I like [task automation with npm](https://github.com/substack/blog/blob/master/npm_run.markdown)
 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
@@ -147,7 +147,7 @@ Prefix styling
                           - 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"]
+                          information.            [string] [default: "reset"]
   -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"
@@ -169,9 +169,10 @@ Killing other processes
                          code                                          [boolean]
 
 Restarting
-  --restart-tries  How many times a process that died should restart.
+      --restart-tries  How many times a process that died should restart.
+                       Negative numbers will make the process restart forever.
                                                            [number] [default: 0]
-  --restart-after  Delay time to respawn the process, in milliseconds.
+      --restart-after  Delay time to respawn the process, in milliseconds.
                                                            [number] [default: 0]
 
 Options:
@@ -220,22 +221,26 @@ Examples:
 
      $ concurrently npm:watch-*
 
-For more details, visit https://github.com/kimmobrunfeldt/concurrently
+For more details, visit https://github.com/open-cli-tools/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, 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`.
+    - `handleInput`: when `true`, reads input from `process.stdin`.
     - `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`.
+    to read the input from. Should only be used in the rare instance you would like to stream anything other than `process.stdin`. Overrides `handleInput`.
+    - `pauseInputStreamOnFinish`: by default, pauses the input stream (`process.stdin` when `handleInput` is enabled, or `inputStream` if provided) when all of the processes have finished. If you need to read from the input stream after `concurrently` has finished, set this to `false`. ([#252](https://github.com/kimmobrunfeldt/concurrently/issues/252)).
     - `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.
@@ -257,9 +262,9 @@ concurrently can be used programmatically by using the API documented below:
 
 > Returns: a `Promise` that resolves if the run was successful (according to `successCondition` option),
 > 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.
+> that the commands terminated. The objects have the shape `{ command, index, exitCode, killed }`, where `command` is the object
+> passed in the `commands` array, `index` its index there and `killed` indicates if the process was killed as a result of
+> `killOthers`. Default values (empty strings or objects) are returned for the fields that were not specified.
 
 Example:
 

package/bin/concurrently.js

@@ -107,7 +107,9 @@ const args = yargs
 
         // Restarting
         'restart-tries': {
-            describe: 'How many times a process that died should restart.',
+            describe:
+                'How many times a process that died should restart.\n' +
+                'Negative numbers will make the process restart forever.',
             default: defaults.restartTries,
             type: 'number'
         },
@@ -155,7 +157,7 @@ concurrently(args._.map((command, index) => {
         name: names[index]
     };
 }), {
-    inputStream: args.handleInput && process.stdin,
+    handleInput: args.handleInput,
     defaultInputTarget: args.defaultInputTarget,
     killOthers: args.killOthers
         ? ['success', 'failure']

package/bin/concurrently.spec.js

@@ -0,0 +1,365 @@
+const readline = require('readline');
+const _ = require('lodash');
+const Rx = require('rxjs');
+const { buffer, map } = require('rxjs/operators');
+const spawn = require('spawn-command');
+
+const isWindows = process.platform === 'win32';
+const createKillMessage = prefix => new RegExp(
+    _.escapeRegExp(prefix) +
+    ' exited with code ' +
+    (isWindows ? 1 : '(SIGTERM|143)')
+);
+
+const run = args => {
+    const child = spawn('node ./concurrently.js ' + args, {
+        cwd: __dirname,
+        env: Object.assign({}, process.env, {
+            // When upgrading from jest 23 -> 24, colors started printing in the test output.
+            // They are forcibly disabled here
+            FORCE_COLOR: 0
+        }),
+    });
+
+    const stdout = readline.createInterface({
+        input: child.stdout,
+        output: null
+    });
+
+    const stderr = readline.createInterface({
+        input: child.stderr,
+        output: null
+    });
+
+    const close = Rx.fromEvent(child, 'close');
+    const log = Rx.merge(
+        Rx.fromEvent(stdout, 'line'),
+        Rx.fromEvent(stderr, 'line')
+    ).pipe(map(data => data.toString()));
+
+    return {
+        close,
+        log,
+        stdin: child.stdin,
+        pid: child.pid
+    };
+};
+
+it('has help command', done => {
+    run('--help').close.subscribe(event => {
+        expect(event[0]).toBe(0);
+        done();
+    }, done);
+});
+
+it('has version command', done => {
+    Rx.combineLatest(
+        run('--version').close,
+        run('-V').close,
+        run('-v').close
+    ).subscribe(events => {
+        expect(events[0][0]).toBe(0);
+        expect(events[1][0]).toBe(0);
+        expect(events[2][0]).toBe(0);
+        done();
+    }, done);
+});
+
+describe('exiting conditions', () => {
+    it('is of success by default when running successful commands', done => {
+        run('"echo foo" "echo bar"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+
+    it('is of failure by default when one of the command fails', done => {
+        run('"echo foo" "exit 1"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBeGreaterThan(0);
+                done();
+            }, done);
+    });
+
+    it('is of success when --success=first and first command to exit succeeds', done => {
+        run('--success=first "echo foo" "sleep 0.5 && exit 1"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+
+    it('is of failure when --success=first and first command to exit fails', done => {
+        run('--success=first "exit 1" "sleep 0.5 && echo foo"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBeGreaterThan(0);
+                done();
+            }, done);
+    });
+
+    it('is of success when --success=last and last command to exit succeeds', done => {
+        run('--success=last "exit 1" "sleep 0.5 && echo foo"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+
+    it('is of failure when --success=last and last command to exit fails', done => {
+        run('--success=last "echo foo" "sleep 0.5 && exit 1"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBeGreaterThan(0);
+                done();
+            }, done);
+    });
+
+    it.skip('is of success when a SIGINT is sent', done => {
+        const child = run('"node fixtures/read-echo.js"');
+        child.close.subscribe(exit => {
+            // TODO This is null within Node, but should be 0 outside (eg from real terminal)
+            expect(exit[0]).toBe(0);
+            done();
+        }, done);
+
+        process.kill(child.pid, 'SIGINT');
+    });
+
+    it('is aliased to -s', done => {
+        run('-s last "exit 1" "sleep 0.5 && echo foo"')
+            .close
+            .subscribe(exit => {
+                expect(exit[0]).toBe(0);
+                done();
+            }, done);
+    });
+});
+
+describe('--raw', () => {
+    it('is aliased to -r', done => {
+        const child = run('-r "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toHaveLength(2);
+            expect(lines).toContainEqual(expect.stringContaining('foo'));
+            expect(lines).toContainEqual(expect.stringContaining('bar'));
+            done();
+        }, done);
+    });
+
+    it('does not log any extra output', done => {
+        const child = run('--raw "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toHaveLength(2);
+            expect(lines).toContainEqual(expect.stringContaining('foo'));
+            expect(lines).toContainEqual(expect.stringContaining('bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--names', () => {
+    it('is aliased to -n', done => {
+        const child = run('-n foo,bar "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+            done();
+        }, done);
+    });
+
+    it('prefixes with names', done => {
+        const child = run('--names foo,bar "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+            done();
+        }, done);
+    });
+
+    it('is split using --name-separator arg', done => {
+        const child = run('--names "foo|bar" --name-separator "|" "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--prefix', () => {
+    it('is aliased to -p', done => {
+        const child = run('-p command "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[echo foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[echo bar] bar'));
+            done();
+        }, done);
+    });
+
+    it('specifies custom prefix', done => {
+        const child = run('--prefix command "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[echo foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[echo bar] bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--prefix-length', () => {
+    it('is aliased to -l', done => {
+        const child = run('-p command -l 5 "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[ec..o] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[ec..r] bar'));
+            done();
+        }, done);
+    });
+
+    it('specifies custom prefix length', done => {
+        const child = run('--prefix command --prefix-length 5 "echo foo" "echo bar"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[ec..o] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[ec..r] bar'));
+            done();
+        }, done);
+    });
+});
+
+describe('--restart-tries', () => {
+    it('changes how many times a command will restart', done => {
+        const child = run('--restart-tries 1 "exit 1"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toEqual([
+                expect.stringContaining('[0] exit 1 exited with code 1'),
+                expect.stringContaining('[0] exit 1 restarted'),
+                expect.stringContaining('[0] exit 1 exited with code 1'),
+            ]);
+            done();
+        }, done);
+    });
+});
+
+describe('--kill-others', () => {
+    it('is aliased to -k', done => {
+        const child = run('-k "sleep 10" "exit 0"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+
+    it('kills on success', done => {
+        const child = run('--kill-others "sleep 10" "exit 0"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+
+    it('kills on failure', done => {
+        const child = run('--kill-others "sleep 10" "exit 1"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 1 exited with code 1'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+});
+
+describe('--kill-others-on-fail', () => {
+    it('does not kill on success', done => {
+        const child = run('--kill-others-on-fail "sleep 0.5" "exit 0"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('[0] sleep 0.5 exited with code 0'));
+            done();
+        }, done);
+    });
+
+    it('kills on failure', done => {
+        const child = run('--kill-others-on-fail "sleep 10" "exit 1"');
+        child.log.pipe(buffer(child.close)).subscribe(lines => {
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 1 exited with code 1'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] sleep 10')));
+            done();
+        }, done);
+    });
+});
+
+describe('--handle-input', () => {
+    it('is aliased to -i', done => {
+        const child = run('-i "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            if (/READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+
+            if (/\[0\] stop/.test(line)) {
+                done();
+            }
+        }, done);
+    });
+
+    it('forwards input to first process by default', done => {
+        const child = run('--handle-input "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            if (/READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+
+            if (/\[0\] stop/.test(line)) {
+                done();
+            }
+        }, done);
+    });
+
+
+    it('forwards input to process --default-input-target', done => {
+        const lines = [];
+        const child = run('-ki --default-input-target 1 "node fixtures/read-echo.js" "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            lines.push(line);
+            if (/\[1\] READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+        }, done);
+
+        child.close.subscribe(exit => {
+            expect(exit[0]).toBeGreaterThan(0);
+            expect(lines).toContainEqual(expect.stringContaining('[1] stop'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node fixtures/read-echo.js')));
+            done();
+        }, done);
+    });
+
+    it('forwards input to specified process', done => {
+        const lines = [];
+        const child = run('-ki "node fixtures/read-echo.js" "node fixtures/read-echo.js"');
+        child.log.subscribe(line => {
+            lines.push(line);
+            if (/\[1\] READING/.test(line)) {
+                child.stdin.write('1:stop\n');
+            }
+        }, done);
+
+        child.close.subscribe(exit => {
+            expect(exit[0]).toBeGreaterThan(0);
+            expect(lines).toContainEqual(expect.stringContaining('[1] stop'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node fixtures/read-echo.js')));
+            done();
+        }, done);
+    });
+});

package/bin/epilogue.txt

@@ -39,4 +39,4 @@ Examples:
 
      $ $0 npm:watch-*
 
-For more details, visit https://github.com/kimmobrunfeldt/concurrently
+For more details, visit https://github.com/open-cli-tools/concurrently

package/index.js

@@ -9,7 +9,7 @@ const RestartProcess = require('./src/flow-control/restart-process');
 const concurrently = require('./src/concurrently');
 const Logger = require('./src/logger');
 
-module.exports = (commands, options = {}) => {
+module.exports = exports = (commands, options = {}) => {
     const logger = new Logger({
         outputStream: options.outputStream || process.stdout,
         prefixFormat: options.prefix,
@@ -30,7 +30,8 @@ module.exports = (commands, options = {}) => {
             new InputHandler({
                 logger,
                 defaultInputTarget: options.defaultInputTarget,
-                inputStream: options.inputStream,
+                inputStream: options.inputStream || (options.handleInput && process.stdin),
+                pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
             }),
             new KillOnSignal({ process }),
             new RestartProcess({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concurrently",
-  "version": "6.0.1",
+  "version": "6.2.1",
   "description": "Run commands concurrently",
   "main": "index.js",
   "bin": {
@@ -16,7 +16,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/kimmobrunfeldt/concurrently.git"
+    "url": "https://github.com/open-cli-tools/concurrently.git"
   },
   "keywords": [
     "bash",
@@ -31,7 +31,7 @@
   "dependencies": {
     "chalk": "^4.1.0",
     "date-fns": "^2.16.1",
-    "lodash": "^4.17.20",
+    "lodash": "^4.17.21",
     "read-pkg": "^5.2.0",
     "rxjs": "^6.6.3",
     "spawn-command": "^0.0.2-1",

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

@@ -0,0 +1,36 @@
+const ExpandNpmShortcut = require('./expand-npm-shortcut');
+const parser = new ExpandNpmShortcut();
+
+it('returns same command if no npm: prefix is present', () => {
+    const commandInfo = {
+        name: 'echo',
+        command: 'echo foo'
+    };
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+for (const npmCmd of ['npm', 'yarn', 'pnpm']) {
+    describe(`with ${npmCmd}: prefix`, () => {
+        it(`expands to "${npmCmd} run <script> <args>"`, () => {
+            const commandInfo = {
+                name: 'echo',
+                command: `${npmCmd}:foo -- bar`
+            };
+            expect(parser.parse(commandInfo)).toEqual({
+                name: 'echo',
+                command: `${npmCmd} run foo -- bar`
+            });
+        });
+
+        it('sets name to script name if none', () => {
+            const commandInfo = {
+                command: `${npmCmd}:foo -- bar`
+            };
+            expect(parser.parse(commandInfo)).toEqual({
+                name: 'foo',
+                command: `${npmCmd} run foo -- bar`
+            });
+        });
+    });
+
+}

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

@@ -0,0 +1,58 @@
+const ExpandNpmWildcard = require('./expand-npm-wildcard');
+
+let parser, readPkg;
+
+beforeEach(() => {
+    readPkg = jest.fn();
+    parser = new ExpandNpmWildcard(readPkg);
+});
+
+it('returns same command if not an npm run command', () => {
+    const commandInfo = {
+        command: 'npm test'
+    };
+
+    expect(readPkg).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('returns same command if no wildcard present', () => {
+    const commandInfo = {
+        command: 'npm run foo bar'
+    };
+
+    expect(readPkg).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('expands to nothing if no scripts exist in package.json', () => {
+    readPkg.mockReturnValue({});
+
+    expect(parser.parse({ command: 'npm run foo-*-baz qux' })).toEqual([]);
+});
+
+for (const npmCmd of ['npm', 'yarn', 'pnpm']) {
+    describe(`with an ${npmCmd}: prefix`, () => {
+        it('expands to all scripts matching pattern', () => {
+            readPkg.mockReturnValue({
+                scripts: {
+                    'foo-bar-baz': '',
+                    'foo--baz': '',
+                }
+            });
+
+            expect(parser.parse({ command: `${npmCmd} run foo-*-baz qux` })).toEqual([
+                { name: 'foo-bar-baz', command: `${npmCmd} run foo-bar-baz qux` },
+                { name: 'foo--baz', command: `${npmCmd} run foo--baz qux` },
+            ]);
+        });
+
+        it('caches scripts upon calls', () => {
+            readPkg.mockReturnValue({});
+            parser.parse({ command: `${npmCmd} run foo-*-baz qux` });
+            parser.parse({ command: `${npmCmd} run foo-*-baz qux` });
+
+            expect(readPkg).toHaveBeenCalledTimes(1);
+        });
+    });
+}

package/src/command-parser/strip-quotes.spec.js

@@ -0,0 +1,20 @@
+const StripQuotes = require('./strip-quotes');
+const parser = new StripQuotes();
+
+it('returns command as is if no single/double quote at the beginning', () => {
+    expect(parser.parse({ command: 'echo foo' })).toEqual({ command: 'echo foo' });
+});
+
+it('strips single quotes', () => {
+    expect(parser.parse({ command: '\'echo foo\'' })).toEqual({ command: 'echo foo' });
+});
+
+it('strips double quotes', () => {
+    expect(parser.parse({ command: '"echo foo"' })).toEqual({ command: 'echo foo' });
+});
+
+it('does not remove quotes if they are impaired', () => {
+    expect(parser.parse({ command: '"echo foo' })).toEqual({ command: '"echo foo' });
+    expect(parser.parse({ command: 'echo foo\'' })).toEqual({ command: 'echo foo\'' });
+    expect(parser.parse({ command: '"echo foo\'' })).toEqual({ command: '"echo foo\'' });
+});

package/src/command.js

@@ -14,6 +14,7 @@ module.exports = class Command {
         this.killProcess = killProcess;
         this.spawn = spawn;
         this.spawnOpts = spawnOpts;
+        this.killed = false;
 
         this.error = new Rx.Subject();
         this.close = new Rx.Subject();
@@ -41,6 +42,7 @@ module.exports = class Command {
                 },
                 index: this.index,
                 exitCode: exitCode === null ? signal : exitCode,
+                killed: this.killed,
             });
         });
         child.stdout && pipeTo(Rx.fromEvent(child.stdout, 'data'), this.stdout);
@@ -50,6 +52,7 @@ module.exports = class Command {
 
     kill(code) {
         if (this.killable) {
+            this.killed = true;
             this.killProcess(this.pid, code);
         }
     }