concurrently 9.1.1 → 9.2.0

package/README.md

@@ -61,7 +61,7 @@ The tool is written in Node.js, but you can use it to run **any** commands.
 Remember to surround separate commands with quotes:
 
 ```bash
-concurrently "command1 arg" "command2 arg"
+concurrently 'command1 arg' 'command2 arg'
 ```
 
 Otherwise **concurrently** would try to run 4 separate commands:
@@ -70,7 +70,7 @@ Otherwise **concurrently** would try to run 4 separate commands:
 In package.json, escape quotes:
 
 ```bash
-"start": "concurrently \"command1 arg\" \"command2 arg\""
+"start": "concurrently 'command1 arg' 'command2 arg'"
 ```
 
 You can always check concurrently's flag list by running `concurrently --help`.
@@ -88,7 +88,7 @@ Check out documentation and other usage examples in the [`docs` directory](./doc
   with the shape `{ command, name, prefixColor, env, cwd, ipc }`.
 
 - `options` (optional): an object containing any of the below:
-  - `cwd`: the working directory to be used by all commands. Can be overriden per command.
+  - `cwd`: the working directory to be used by all commands. Can be overridden per command.
     Default: `process.cwd()`.
   - `defaultInputTarget`: the default input target when reading from `inputStream`.
     Default: `0`.
@@ -96,8 +96,8 @@ Check out documentation and other usage examples in the [`docs` directory](./doc
   - `inputStream`: a [`Readable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_readable_streams)
     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`.
+  - `killOthersOn`: once the first command exits with one of these statuses, kill other commands.
+    Can be an array containing the strings `success` (status code zero) and/or `failure` (non-zero exit status).
   - `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`.
@@ -109,14 +109,14 @@ Check out documentation and other usage examples in the [`docs` directory](./doc
     Prefix colors specified per-command take precedence over this list.
   - `prefixLength`: how many characters to show when prefixing with `command`. Default: `10`
   - `raw`: whether raw mode should be used, meaning strictly process output will
-    be logged, without any prefixes, coloring or extra stuff. Can be overriden per command.
+    be logged, without any prefixes, coloring or extra stuff. Can be overridden per command.
   - `successCondition`: the condition to consider the run was successful.
     If `first`, only the first process to exit will make up the success of the run; if `last`, the last process that exits will determine whether the run succeeds.
     Anything else means all processes should exit successfully.
   - `restartTries`: how many attempts to restart a process that dies will be made. Default: `0`.
   - `restartDelay`: how many milliseconds to wait between process restarts. Default: `0`.
   - `timestampFormat`: a [Unicode format](https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
-    to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.ZZZ`
+    to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.SSS`
   - `additionalArguments`: list of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.
 
 > **Returns:** an object in the shape `{ result, commands }`.
@@ -172,6 +172,7 @@ It has the following properties:
 - `stderr`: an RxJS observable to the command's `stderr`.
 - `error`: an RxJS observable to the command's error events (e.g. when it fails to spawn).
 - `timer`: an RxJS observable to the command's timing events (e.g. starting, stopping).
+- `stateChange`: an RxJS observable for changes to the command's `state` property.
 - `messages`: an object with the following properties:
 
   - `incoming`: an RxJS observable for the IPC messages received from the underlying process.

package/dist/bin/concurrently.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const lodash_1 = __importDefault(require("lodash"));
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
+const assert_1 = require("../src/assert");
 const defaults = __importStar(require("../src/defaults"));
 const index_1 = require("../src/index");
 const read_package_1 = require("./read-package");
@@ -128,7 +129,7 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     // Kill others
     'kill-others': {
         alias: 'k',
-        describe: 'Kill other processes if one exits or dies.',
+        describe: 'Kill other processes once the first exits.',
         type: 'boolean',
     },
     'kill-others-on-fail': {
@@ -141,6 +142,10 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
         type: 'string',
         default: defaults.killSignal,
     },
+    'kill-timeout': {
+        describe: 'How many milliseconds to wait before forcing process terminating.',
+        type: 'number',
+    },
     // Prefix
     prefix: {
         alias: 'p',
@@ -209,10 +214,11 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .group(['m', 'n', 'name-separator', 's', 'r', 'no-color', 'hide', 'g', 'timings', 'P', 'teardown'], 'General')
     .group(['p', 'c', 'l', 't', 'pad-prefix'], 'Prefix styling')
     .group(['i', 'default-input-target'], 'Input handling')
-    .group(['k', 'kill-others-on-fail', 'kill-signal'], 'Killing other processes')
+    .group(['k', 'kill-others-on-fail', 'kill-signal', 'kill-timeout'], 'Killing other processes')
     .group(['restart-tries', 'restart-after'], 'Restarting')
     .epilogue(epilogue);
 const args = program.parseSync();
+(0, assert_1.assertDeprecated)(args.nameSeparator === defaults.nameSeparator, 'name-separator', 'Use commas as name separators instead.');
 // Get names of commands by the specified separator
 const names = (args.names || '').split(args.nameSeparator);
 const additionalArguments = lodash_1.default.castArray(args['--'] ?? []).map(String);
@@ -227,12 +233,13 @@ if (!commands.length) {
 })), {
     handleInput: args.handleInput,
     defaultInputTarget: args.defaultInputTarget,
-    killOthers: args.killOthers
+    killOthersOn: args.killOthers
         ? ['success', 'failure']
         : args.killOthersOnFail
             ? ['failure']
             : [],
     killSignal: args.killSignal,
+    killTimeout: args.killTimeout,
     maxProcesses: args.maxProcesses,
     raw: args.raw,
     hide: args.hide.split(','),

package/dist/src/assert.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Asserts that some condition is true, and if not, prints a warning about it being deprecated.
+ * The message is printed only once.
+ */
+export declare function assertDeprecated(check: boolean, name: string, message: string): void;

package/dist/src/assert.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertDeprecated = void 0;
+const deprecations = new Set();
+/**
+ * Asserts that some condition is true, and if not, prints a warning about it being deprecated.
+ * The message is printed only once.
+ */
+function assertDeprecated(check, name, message) {
+    if (!check) {
+        // eslint-disable-next-line no-console
+        console.warn(`[concurrently] ${name} is deprecated. ${message}`);
+        deprecations.add(name);
+    }
+}
+exports.assertDeprecated = assertDeprecated;

package/dist/src/command.d.ts

@@ -117,6 +117,13 @@ export declare class Command implements CommandInfo {
     readonly stdout: Rx.Subject<Buffer>;
     readonly stderr: Rx.Subject<Buffer>;
     readonly timer: Rx.Subject<TimerEvent>;
+    /**
+     * A stream of changes to the `#state` property.
+     *
+     * Note that the command never goes back to the `stopped` state, therefore it's not a value
+     * that's emitted by this stream.
+     */
+    readonly stateChange: Rx.Subject<"started" | "errored" | "exited">;
     readonly messages: {
         incoming: Rx.Subject<MessageEvent>;
         outgoing: Rx.ReplaySubject<OutgoingMessageEvent>;
@@ -135,6 +142,7 @@ export declare class Command implements CommandInfo {
      * Starts this command, piping output, error and close events onto the corresponding observables.
      */
     start(): void;
+    private changeState;
     private maybeSetupIPC;
     /**
      * Sends a message to the underlying process once it starts.

package/dist/src/command.js

@@ -47,6 +47,13 @@ class Command {
     stdout = new Rx.Subject();
     stderr = new Rx.Subject();
     timer = new Rx.Subject();
+    /**
+     * A stream of changes to the `#state` property.
+     *
+     * Note that the command never goes back to the `stopped` state, therefore it's not a value
+     * that's emitted by this stream.
+     */
+    stateChange = new Rx.Subject();
     messages = {
         incoming: new Rx.Subject(),
         outgoing: new Rx.ReplaySubject(),
@@ -76,7 +83,7 @@ class Command {
      */
     start() {
         const child = this.spawn(this.command, this.spawnOpts);
-        this.state = 'started';
+        this.changeState('started');
         this.process = child;
         this.pid = child.pid;
         const startDate = new Date(Date.now());
@@ -88,7 +95,7 @@ class Command {
             const endDate = new Date(Date.now());
             this.timer.next({ startDate, endDate });
             this.error.next(event);
-            this.state = 'errored';
+            this.changeState('errored');
         });
         Rx.fromEvent(child, 'close')
             .pipe(Rx.map((event) => event))
@@ -96,7 +103,7 @@ class Command {
             this.cleanUp();
             // Don't override error event
             if (this.state !== 'errored') {
-                this.state = 'exited';
+                this.changeState('exited');
             }
             const endDate = new Date(Date.now());
             this.timer.next({ startDate, endDate });
@@ -119,6 +126,10 @@ class Command {
             pipeTo(Rx.fromEvent(child.stderr, 'data').pipe(Rx.map((event) => event)), this.stderr);
         this.stdin = child.stdin || undefined;
     }
+    changeState(state) {
+        this.state = state;
+        this.stateChange.next(state);
+    }
     maybeSetupIPC(child) {
         if (!this.ipc) {
             return [];

package/dist/src/completion-listener.js

@@ -61,7 +61,7 @@ class CompletionListener {
             // All commands except the specified ones must exit successfully
             return events.every((event) => targetCommandsEvents.includes(event) || event.exitCode === 0);
         }
-        // Only the specified commands must exit succesfully
+        // Only the specified commands must exit successfully
         return (targetCommandsEvents.length > 0 &&
             targetCommandsEvents.every((event) => event.exitCode === 0));
     }
@@ -73,6 +73,9 @@ class CompletionListener {
      *          Commands that didn't spawn are filtered out.
      */
     listen(commands, abortSignal) {
+        if (!commands.length) {
+            return Promise.resolve([]);
+        }
         const abort = abortSignal &&
             Rx.fromEvent(abortSignal, 'abort', { once: true }).pipe(
             // The abort signal must happen before commands are killed, otherwise new commands

package/dist/src/concurrently.d.ts

@@ -101,10 +101,6 @@ export type ConcurrentlyOptions = {
      * Defaults to the `tree-kill` module.
      */
     kill: KillProcess;
-    /**
-     * Signal to send to killed processes.
-     */
-    killSignal?: string;
     /**
      * List of additional arguments passed that will get replaced in each command.
      * If not defined, no argument replacing will happen.

package/dist/src/concurrently.js

@@ -7,6 +7,7 @@ exports.concurrently = void 0;
 const assert_1 = __importDefault(require("assert"));
 const lodash_1 = __importDefault(require("lodash"));
 const os_1 = require("os");
+const rxjs_1 = require("rxjs");
 const tree_kill_1 = __importDefault(require("tree-kill"));
 const command_1 = require("./command");
 const expand_arguments_1 = require("./command-parser/expand-arguments");
@@ -75,7 +76,10 @@ function concurrently(baseCommands, baseOptions) {
             group: !!options.group,
             commands,
         });
-        options.logger.output.subscribe(({ command, text }) => outputWriter.write(command, text));
+        options.logger.output
+            // Stop trying to write after there's been an error.
+            .pipe((0, rxjs_1.takeUntil)(outputWriter.error))
+            .subscribe(({ command, text }) => outputWriter.write(command, text));
     }
     const commandsLeft = commands.slice();
     const maxProcesses = Math.max(1, (typeof options.maxProcesses === 'string' && options.maxProcesses.endsWith('%')

package/dist/src/flow-control/input-handler.js

@@ -73,7 +73,7 @@ class InputHandler {
                 command = commandsMap.get(target);
                 input = data;
             }
-            if (command && command.stdin) {
+            if (command?.stdin) {
                 command.stdin.write(input);
             }
             else {

package/dist/src/flow-control/kill-others.d.ts

@@ -11,13 +11,16 @@ export declare class KillOthers implements FlowController {
     private readonly abortController?;
     private readonly conditions;
     private readonly killSignal;
-    constructor({ logger, abortController, conditions, killSignal, }: {
+    private readonly timeoutMs?;
+    constructor({ logger, abortController, conditions, killSignal, timeoutMs, }: {
         logger: Logger;
         abortController?: AbortController;
         conditions: ProcessCloseCondition | ProcessCloseCondition[];
         killSignal: string | undefined;
+        timeoutMs?: number;
     });
     handle(commands: Command[]): {
         commands: Command[];
     };
+    private maybeForceKill;
 }

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

@@ -15,11 +15,13 @@ class KillOthers {
     abortController;
     conditions;
     killSignal;
-    constructor({ logger, abortController, conditions, killSignal, }) {
+    timeoutMs;
+    constructor({ logger, abortController, conditions, killSignal, timeoutMs, }) {
         this.logger = logger;
         this.abortController = abortController;
         this.conditions = lodash_1.default.castArray(conditions);
         this.killSignal = killSignal;
+        this.timeoutMs = timeoutMs;
     }
     handle(commands) {
         const conditions = this.conditions.filter((condition) => condition === 'failure' || condition === 'success');
@@ -33,9 +35,23 @@ class KillOthers {
             if (killableCommands.length) {
                 this.logger.logGlobalEvent(`Sending ${this.killSignal || 'SIGTERM'} to other processes..`);
                 killableCommands.forEach((command) => command.kill(this.killSignal));
+                this.maybeForceKill(killableCommands);
             }
         }));
         return { commands };
     }
+    maybeForceKill(commands) {
+        // No need to force kill when the signal already is SIGKILL.
+        if (!this.timeoutMs || this.killSignal === 'SIGKILL') {
+            return;
+        }
+        setTimeout(() => {
+            const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
+            if (killableCommands) {
+                this.logger.logGlobalEvent(`Sending SIGKILL to ${killableCommands.length} processes..`);
+                killableCommands.forEach((command) => command.kill('SIGKILL'));
+            }
+        }, this.timeoutMs);
+    }
 }
 exports.KillOthers = KillOthers;

package/dist/src/flow-control/output-error-handler.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { Command } from '../command';
+import { FlowController } from './flow-controller';
+/**
+ * Kills processes and aborts further command spawning on output stream error (namely, SIGPIPE).
+ */
+export declare class OutputErrorHandler implements FlowController {
+    private readonly outputStream;
+    private readonly abortController;
+    constructor({ abortController, outputStream, }: {
+        abortController: AbortController;
+        outputStream: Writable;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+        onFinish(): void;
+    };
+}

package/dist/src/flow-control/output-error-handler.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputErrorHandler = void 0;
+const observables_1 = require("../observables");
+/**
+ * Kills processes and aborts further command spawning on output stream error (namely, SIGPIPE).
+ */
+class OutputErrorHandler {
+    outputStream;
+    abortController;
+    constructor({ abortController, outputStream, }) {
+        this.abortController = abortController;
+        this.outputStream = outputStream;
+    }
+    handle(commands) {
+        const subscription = (0, observables_1.fromSharedEvent)(this.outputStream, 'error').subscribe(() => {
+            commands.forEach((command) => command.kill());
+            // Avoid further commands from spawning, e.g. if `RestartProcess` is used.
+            this.abortController.abort();
+        });
+        return {
+            commands,
+            onFinish: () => subscription.unsubscribe(),
+        };
+    }
+}
+exports.OutputErrorHandler = OutputErrorHandler;

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

@@ -53,7 +53,7 @@ class RestartProcess {
         });
         commands
             .map((command) => command.close.pipe((0, operators_1.take)(this.tries), (0, operators_1.takeWhile)(({ exitCode }) => exitCode !== 0)))
-            .map((failure, index) => Rx.merge(
+            .forEach((failure, index) => Rx.merge(
         // Delay the emission (so that the restarts happen on time),
         // explicitly telling the subscriber that a restart is needed
         failure.pipe(delayOperator, (0, operators_1.map)(() => true)), 

package/dist/src/index.d.ts

@@ -56,11 +56,23 @@ export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' |
      */
     restartTries?: number;
     /**
-     * Under which condition(s) should other commands be killed when the first one exits.
-     *
+     * @deprecated Use `killOthersOn` instead.
      * @see KillOthers
      */
     killOthers?: ProcessCloseCondition | ProcessCloseCondition[];
+    /**
+     * Once the first command exits with one of these statuses, kill other commands.
+     * @see KillOthers
+     */
+    killOthersOn?: ProcessCloseCondition | ProcessCloseCondition[];
+    /**
+     * Signal to send to killed processes.
+     */
+    killSignal?: string;
+    /**
+     * How many milliseconds to wait before killing processes.
+     */
+    killTimeout?: number;
     /**
      * Whether to output timing information for processes.
      *

package/dist/src/index.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestartProcess = exports.LogTimings = exports.LogOutput = exports.LogExit = exports.LogError = exports.KillOthers = exports.KillOnSignal = exports.InputHandler = exports.Command = exports.Logger = exports.createConcurrently = exports.concurrently = void 0;
 const lodash_1 = __importDefault(require("lodash"));
+const assert_1 = require("./assert");
 const command_1 = require("./command");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
 const concurrently_1 = require("./concurrently");
@@ -24,27 +25,31 @@ Object.defineProperty(exports, "LogOutput", { enumerable: true, get: function ()
 const log_timings_1 = require("./flow-control/log-timings");
 Object.defineProperty(exports, "LogTimings", { enumerable: true, get: function () { return log_timings_1.LogTimings; } });
 const logger_padding_1 = require("./flow-control/logger-padding");
+const output_error_handler_1 = require("./flow-control/output-error-handler");
 const restart_process_1 = require("./flow-control/restart-process");
 Object.defineProperty(exports, "RestartProcess", { enumerable: true, get: function () { return restart_process_1.RestartProcess; } });
 const teardown_1 = require("./flow-control/teardown");
 const logger_1 = require("./logger");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
 function concurrently(commands, options = {}) {
+    (0, assert_1.assertDeprecated)(options.killOthers === undefined, 'killOthers', 'Use killOthersOn instead.');
     // To avoid empty strings from hiding the output of commands that don't have a name,
     // keep in the list of commands to hide only strings with some length.
     // This might happen through the CLI when no `--hide` argument is specified, for example.
     const hide = lodash_1.default.castArray(options.hide).filter((id) => id || id === 0);
-    const logger = new logger_1.Logger({
-        hide,
-        prefixFormat: options.prefix,
-        commandLength: options.prefixLength,
-        raw: options.raw,
-        timestampFormat: options.timestampFormat,
-    });
+    const logger = options.logger ||
+        new logger_1.Logger({
+            hide,
+            prefixFormat: options.prefix,
+            commandLength: options.prefixLength,
+            raw: options.raw,
+            timestampFormat: options.timestampFormat,
+        });
     if (options.prefixColors === false) {
         logger.toggleColors(false);
     }
     const abortController = new AbortController();
+    const outputStream = options.outputStream || process.stdout;
     return (0, concurrently_1.concurrently)(commands, {
         maxProcesses: options.maxProcesses,
         raw: options.raw,
@@ -52,7 +57,7 @@ function concurrently(commands, options = {}) {
         cwd: options.cwd,
         hide,
         logger,
-        outputStream: options.outputStream || process.stdout,
+        outputStream,
         group: options.group,
         abortSignal: abortController.signal,
         controllers: [
@@ -75,10 +80,12 @@ function concurrently(commands, options = {}) {
             }),
             new kill_others_1.KillOthers({
                 logger,
-                conditions: options.killOthers || [],
+                conditions: options.killOthersOn || options.killOthers || [],
+                timeoutMs: options.killTimeout,
                 killSignal: options.killSignal,
                 abortController,
             }),
+            new output_error_handler_1.OutputErrorHandler({ abortController, outputStream }),
             new log_timings_1.LogTimings({
                 logger: options.timings ? logger : undefined,
                 timestampFormat: options.timestampFormat,

package/dist/src/logger.js

@@ -77,9 +77,9 @@ class Logger {
         const prefixLength = this.commandLength - ellipsis.length;
         const endLength = Math.floor(prefixLength / 2);
         const beginningLength = prefixLength - endLength;
-        const beginnning = text.slice(0, beginningLength);
+        const beginning = text.slice(0, beginningLength);
         const end = text.slice(text.length - endLength, text.length);
-        return beginnning + ellipsis + end;
+        return beginning + ellipsis + end;
     }
     getPrefixesFor(command) {
         return {
@@ -121,7 +121,7 @@ class Logger {
     }
     colorText(command, text) {
         let color;
-        if (command.prefixColor && command.prefixColor.startsWith('#')) {
+        if (command.prefixColor?.startsWith('#')) {
             color = this.chalk.hex(command.prefixColor);
         }
         else {

package/dist/src/observables.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Observable } from 'rxjs';
+/**
+ * Creates an observable for a specific event of an `EventEmitter` instance.
+ *
+ * The underlying event listener is set up only once across the application for that event emitter/name pair.
+ */
+export declare function fromSharedEvent(emitter: EventEmitter, event: string): Observable<unknown>;

package/dist/src/observables.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromSharedEvent = void 0;
+const rxjs_1 = require("rxjs");
+const sharedEvents = new WeakMap();
+/**
+ * Creates an observable for a specific event of an `EventEmitter` instance.
+ *
+ * The underlying event listener is set up only once across the application for that event emitter/name pair.
+ */
+function fromSharedEvent(emitter, event) {
+    let emitterEvents = sharedEvents.get(emitter);
+    if (!emitterEvents) {
+        emitterEvents = new Map();
+        sharedEvents.set(emitter, emitterEvents);
+    }
+    let observable = emitterEvents.get(event);
+    if (!observable) {
+        observable = (0, rxjs_1.fromEvent)(emitter, event).pipe((0, rxjs_1.share)());
+        emitterEvents.set(event, observable);
+    }
+    return observable;
+}
+exports.fromSharedEvent = fromSharedEvent;

package/dist/src/output-writer.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import * as Rx from 'rxjs';
 import { Writable } from 'stream';
 import { Command } from './command';
 /**
@@ -9,11 +10,14 @@ export declare class OutputWriter {
     private readonly group;
     readonly buffers: string[][];
     activeCommandIndex: number;
+    readonly error: Rx.Observable<unknown>;
+    private get errored();
     constructor({ outputStream, group, commands, }: {
         outputStream: Writable;
         group: boolean;
         commands: Command[];
     });
+    private ensureWritable;
     write(command: Command | undefined, text: string): void;
     private flushBuffer;
 }

package/dist/src/output-writer.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OutputWriter = void 0;
 const Rx = __importStar(require("rxjs"));
+const observables_1 = require("./observables");
 /**
  * Class responsible for actually writing output onto a writable stream.
  */
@@ -33,8 +34,14 @@ class OutputWriter {
     group;
     buffers;
     activeCommandIndex = 0;
+    error;
+    get errored() {
+        return this.outputStream.errored;
+    }
     constructor({ outputStream, group, commands, }) {
         this.outputStream = outputStream;
+        this.ensureWritable();
+        this.error = (0, observables_1.fromSharedEvent)(this.outputStream, 'error');
         this.group = group;
         this.buffers = commands.map(() => []);
         if (this.group) {
@@ -53,7 +60,13 @@ class OutputWriter {
             });
         }
     }
+    ensureWritable() {
+        if (this.errored) {
+            throw new TypeError('outputStream is in errored state', { cause: this.errored });
+        }
+    }
     write(command, text) {
+        this.ensureWritable();
         if (this.group && command) {
             if (command.index <= this.activeCommandIndex) {
                 this.outputStream.write(text);
@@ -68,7 +81,9 @@ class OutputWriter {
         }
     }
     flushBuffer(index) {
-        this.buffers[index].forEach((t) => this.outputStream.write(t));
+        if (!this.errored) {
+            this.buffers[index].forEach((t) => this.outputStream.write(t));
+        }
         this.buffers[index] = [];
     }
 }

package/dist/src/prefix-color-selector.js

@@ -34,7 +34,7 @@ function* createColorGenerator(customColors) {
     const lastCustomColor = customColors[customColors.length - 1] || '';
     if (lastCustomColor !== 'auto') {
         while (true) {
-            yield lastCustomColor; // If last custom color was not "auto" then return same color forever, to maintain existing behaviour
+            yield lastCustomColor; // If last custom color was not "auto" then return same color forever, to maintain existing behavior
         }
     }
     // Finish the initial set(s) of auto colors to avoid repetition

package/dist/src/spawn.js

@@ -38,7 +38,7 @@ const getSpawnOpts = ({ colorSupport = supports_color_1.default.stdout, cwd, pro
     return {
         cwd: cwd || process.cwd(),
         stdio: stdioValues,
-        ...(/^win/.test(process.platform) && { detached: false }),
+        ...(process.platform.startsWith('win') && { detached: false }),
         env: {
             ...(colorSupport ? { FORCE_COLOR: colorSupport.level.toString() } : {}),
             ...process.env,

package/docs/README.md

@@ -6,7 +6,9 @@ These articles cover using concurrently through CLI:
 
 - [Prefixing](./cli/prefixing.md)
 - [Output Control](./cli/output-control.md)
+- [Success Conditions](./cli/success.md)
 - [Shortcuts](./cli/shortcuts.md)
+- [Terminating Commands](./cli/terminating.md)
 - [Restarting Commands](./cli/restarting.md)
 - [Input Handling](./cli/input-handling.md)
 - [Passthrough Arguments](./cli/passthrough-arguments.md)

package/docs/cli/input-handling.md

@@ -4,7 +4,7 @@ By default, concurrently doesn't send input to any commands it spawns.<br/>
 In the below example, typing `rs` to manually restart [nodemon](https://nodemon.io/) does nothing:
 
 ```bash
-$ concurrently "nodemon" "npm run watch-js"
+$ concurrently 'nodemon' 'npm run watch-js'
 rs
 ```
 
@@ -12,7 +12,7 @@ To turn on input handling, it's necessary to set the `--handle-input`/`-i` flag.
 This will send `rs` to the first command:
 
 ```bash
-$ concurrently --handle-input "nodemon" "npm run watch-js"
+$ concurrently --handle-input 'nodemon' 'npm run watch-js'
 rs
 ```
 
@@ -20,14 +20,14 @@ To send input to a different command instead, it's possible to prefix the input
 For example, the below sends `rs` to the second command:
 
 ```bash
-$ concurrently --handle-input "npm run watch-js" "nodemon"
+$ concurrently --handle-input 'npm run watch-js' 'nodemon'
 1:rs
 ```
 
 If the command has a name, it's also possible to target it using that command's name:
 
 ```bash
-$ concurrently --handle-input --names js,server "npm run watch-js" "nodemon"
+$ concurrently --handle-input --names js,server 'npm run watch-js' 'nodemon'
 server:rs
 ```
 
@@ -35,6 +35,6 @@ It's also possible to change the default command that receives input.<br/>
 To do this, set the `--default-input-target` flag to a command's index or name.
 
 ```bash
-$ concurrently --handle-input --default-input-target 1 "npm run watch-js" "nodemon"
+$ concurrently --handle-input --default-input-target 1 'npm run watch-js' 'nodemon'
 rs
 ```

package/docs/cli/output-control.md

@@ -7,7 +7,7 @@ concurrently offers a few ways to control a command's output.
 A command's outputs (and all its events) can be hidden by using the `--hide` flag.
 
 ```bash
-$ concurrently --hide 0 "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently --hide 0 'echo Hello there' 'echo General Kenobi!'
 [1] General Kenobi!
 [1] echo 'General Kenobi!' exited with code 0
 ```
@@ -18,7 +18,7 @@ It might be useful at times to make sure that the commands outputs are grouped t
 This can be done with the `--group` flag.
 
 ```bash
-$ concurrently --group "echo Hello there && sleep 2 && echo 'General Kenobi!'" "echo hi Star Wars fans"
+$ concurrently --group 'echo Hello there && sleep 2 && echo General Kenobi!' 'echo hi Star Wars fans'
 [0] Hello there
 [0] General Kenobi!
 [0] echo Hello there && sleep 2 && echo 'General Kenobi!' exited with code 0
@@ -31,5 +31,5 @@ $ concurrently --group "echo Hello there && sleep 2 && echo 'General Kenobi!'" "
 When piping concurrently's outputs to another command or file, you might want to force it to not use colors, as these can break the other command's parsing, or reduce the legibility of the output in non-terminal environments.
 
 ```bash
-$ concurrently -c red,blue --no-color "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently -c red,blue --no-color 'echo Hello there' 'echo General Kenobi!'
 ```

package/docs/cli/prefixing.md

@@ -5,7 +5,7 @@
 concurrently will by default prefix each command's outputs with a zero-based index, wrapped in square brackets:
 
 ```bash
-$ concurrently "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently 'echo Hello there' "echo 'General Kenobi!'"
 [0] Hello there
 [1] General Kenobi!
 [0] echo Hello there exited with code 0
@@ -15,7 +15,7 @@ $ concurrently "echo Hello there" "echo 'General Kenobi!'"
 If you've given the commands names, they are used instead:
 
 ```bash
-$ concurrently --names one,two "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently --names one,two 'echo Hello there' "echo 'General Kenobi!'"
 [one] Hello there
 [two] General Kenobi!
 [one] echo Hello there exited with code 0
@@ -36,7 +36,7 @@ There are other prefix styles available too:
 Any of these can be used by setting the `--prefix`/`-p` flag. For example:
 
 ```bash
-$ concurrently --prefix pid "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently --prefix pid 'echo Hello there' 'echo General Kenobi!'
 [2222] Hello there
 [2223] General Kenobi!
 [2222] echo Hello there exited with code 0
@@ -47,7 +47,7 @@ It's also possible to have a prefix based on a template. Any of the styles liste
 Doing so will also remove the square brackets:
 
 ```bash
-$ concurrently --prefix "{index}-{pid}" "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently --prefix '{index}-{pid}' 'echo Hello there' 'echo General Kenobi!'
 0-2222 Hello there
 1-2223 General Kenobi!
 0-2222 echo Hello there exited with code 0
@@ -62,7 +62,7 @@ This can be changed by using the `--prefix-colors`/`-c` flag, which takes a comm
 The available values are color names (e.g. `green`, `magenta`, `gray`, etc), a hex value (such as `#23de43`), or `auto`, to automatically select a color.
 
 ```bash
-$ concurrently -c red,blue "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently -c red,blue 'echo Hello there' 'echo General Kenobi!'
 ```
 
 <details>
@@ -82,7 +82,7 @@ $ concurrently -c red,blue "echo Hello there" "echo 'General Kenobi!'"
 Colors can take modifiers too. Several can be applied at once by prepending `.<modifier 1>.<modifier 2>` and so on.
 
 ```bash
-$ concurrently -c red,bold.blue.dim "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently -c red,bold.blue.dim 'echo Hello there' 'echo General Kenobi!'
 ```
 
 <details>
@@ -98,10 +98,10 @@ $ concurrently -c red,bold.blue.dim "echo Hello there" "echo 'General Kenobi!'"
 - `underline`
 </details>
 
-A background color can be set in a similary fashion.
+A background color can be set in a similarly fashion.
 
 ```bash
-$ concurrently -c bgGray,red.bgBlack "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently -c bgGray,red.bgBlack 'echo Hello there' 'echo General Kenobi!'
 ```
 
 <details>
@@ -124,7 +124,7 @@ When using the `command` prefix style, it's possible that it'll be too long.<br/
 It can be limited by setting the `--prefix-length`/`-l` flag:
 
 ```bash
-$ concurrently -p command -l 10 "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently -p command -l 10 'echo Hello there' 'echo General Kenobi!'
 [echo..here] Hello there
 [echo..bi!'] General Kenobi!
 [echo..here] echo Hello there exited with code 0
@@ -135,7 +135,7 @@ It's also possible that some prefixes are too short, and you want all of them to
 This can be done by setting the `--pad-prefix` flag:
 
 ```bash
-$ concurrently -n foo,barbaz --pad-prefix "echo Hello there" "echo 'General Kenobi!'"
+$ concurrently -n foo,barbaz --pad-prefix 'echo Hello there' 'echo General Kenobi!'
 [foo   ] Hello there
 [foo   ] echo Hello there exited with code 0
 [barbaz] General Kenobi!

package/docs/cli/restarting.md

@@ -4,7 +4,7 @@ Sometimes it's useful to have commands that exited with a non-zero status to res
 concurrently lets you configure how many times you wish for such a command to restart through the `--restart-tries` flag:
 
 ```bash
-$ concurrently --restart-tries 2 "exit 1"
+$ concurrently --restart-tries 2 'exit 1'
 [0] exit 1 exited with code 1
 [0] exit 1 restarted
 [0] exit 1 exited with code 1
@@ -16,7 +16,7 @@ Sometimes, it might be interesting to have commands wait before restarting.<br/>
 To do this, simply set `--restart-after` to a the number of milliseconds you'd like to delay restarting.
 
 ```bash
-$ concurrently -p time --restart-tries 1 --restart-after 3000 "exit 1"
+$ concurrently -p time --restart-tries 1 --restart-after 3000 'exit 1'
 [2024-09-01 23:43:55.871] exit 1 exited with code 1
 [2024-09-01 23:43:58.874] exit 1 restarted
 [2024-09-01 23:43:58.891] exit 1 exited with code 1
@@ -26,7 +26,7 @@ If a command is not having success spawning, you might want to instead apply an
 Set `--restart-after exponential` to have commands respawn with a `2^N` seconds delay.
 
 ```bash
-$ concurrently -p time --restart-tries 3 --restart-after exponential "exit 1"
+$ concurrently -p time --restart-tries 3 --restart-after exponential 'exit 1'
 
 [2024-09-01 23:49:01.124] exit 1 exited with code 1
 [2024-09-01 23:49:02.127] exit 1 restarted

package/docs/cli/shortcuts.md

@@ -35,9 +35,9 @@ For example, given the following `package.json` contents:
 It's possible to run some of these with the following command line:
 
 ```bash
-$ concurrently "pnpm:lint:js"
+$ concurrently 'pnpm:lint:js'
 # Is equivalent to
-$ concurrently -n lint:js "pnpm run lint:js"
+$ concurrently -n lint:js 'pnpm run lint:js'
 ```
 
 Note that the command automatically receives a name equal to the script name.
@@ -46,17 +46,17 @@ If you have several scripts with similar name patterns, you can use the `*` wild
 The spawned commands will receive names set to whatever the `*` wildcard matched.
 
 ```bash
-$ concurrently "npm:lint:fix:*"
+$ concurrently 'npm:lint:fix:*'
 # is equivalent to
-$ concurrently -n js,ts "npm run lint:fix:js" "npm run lint:fix:ts"
+$ concurrently -n js,ts 'npm run lint:fix:js' 'npm run lint:fix:ts'
 ```
 
 If you specify a command name when using wildcards, it'll be a prefix of what the `*` wildcard matched:
 
 ```bash
-$ concurrently -n fix: "npm:lint:fix:*"
+$ concurrently -n fix: 'npm:lint:fix:*'
 # is equivalent to
-$ concurrently -n fix:js,fix:ts "npm run lint:fix:js" "npm run lint:fix:ts"
+$ concurrently -n fix:js,fix:ts 'npm run lint:fix:js' 'npm run lint:fix:ts'
 ```
 
 Filtering out commands matched by wildcard is also possible. Do this with by including `(!<some pattern>)` in the command line:
@@ -64,7 +64,7 @@ Filtering out commands matched by wildcard is also possible. Do this with by inc
 ```bash
 $ concurrently 'yarn:lint:*(!fix)'
 # is equivalent to
-$ concurrently -n js,ts "yarn run lint:js" "yarn run lint:ts"
+$ concurrently -n js,ts 'yarn run lint:js' 'yarn run lint:ts'
 ```
 
 > [!NOTE]

package/docs/cli/success.md

@@ -0,0 +1,73 @@
+# Success Conditions
+
+When you're using concurrently in shell scripts or CI pipelines, the exit code matters.  
+It determines whether the next step runs, or if the script stops with a failure.
+
+You can control concurrently's exit code using the `--success` flag.  
+This tells it **which command(s)** must succeed (exit with code `0`) for concurrently to return success overall.
+
+There are several possible values:
+
+## `all`
+
+All commands must exit with code `0`.
+This is the default value.
+
+## `first`
+
+The first command to exit must do so with code `0`.
+
+```bash
+# ✅ Exits with code 0 — second command exits first and succeeds
+$ concurrently --success first 'sleep 1 && exit 1' 'exit 0'
+
+# ❌ Exits with a non-zero code — second command exits first, but with code 1
+$ concurrently --success first 'sleep 1 && exit 0' 'exit 1'
+```
+
+## `last`
+
+The last command to exit must do so with code `0`.
+
+```bash
+# ✅ Exits with code 0 - first command exits last and succeeds
+$ concurrently --success last 'sleep 1 && exit 0' 'exit 1'
+
+# ❌ Exits with a non-zero code — first command exits last, but with code 1
+$ concurrently --success last 'sleep 1 && exit 1' 'exit 0'
+```
+
+## `command-{name}` or `command-{index}`
+
+A specific command, by name or index, must exit with code `0`.
+
+```bash
+# Exits with code 0 only if 'npm test' (index 1) passes.
+$ concurrently --success command-1 --kill-others 'npm run server' 'npm test'
+
+# Exits with code 0 only if 'test' command passes.
+$ concurrently --success command-test --names server,test --kill-others \
+    'npm start' \
+    'npm test'
+```
+
+> [!TIP]
+> Use `--kill-others` to kill a long-running process, such as a server, once tests pass.
+
+## `!command-{name}` or `!command-{index}`
+
+All but a specific command, by name or index, must exit with code `0`.
+
+```bash
+# Ignores 'npm start'; all others must succeed
+$ concurrently --success '!command-2' --kill-others \
+    'npm test' \
+    'npm build' \
+    'npm start'
+
+# Ignores 'server'; all others must succeed
+$ concurrently --success '!command-server' --names test,build,server --kill-others \
+    'npm test' \
+    'npm build' \
+    'npm start'
+```

package/docs/cli/terminating.md

@@ -0,0 +1,52 @@
+# Terminating Commands
+
+It's possible to have concurrently terminate other commands when one of them exits.<br/>
+This can be done in the following ways:
+
+## Terminating on either success or error
+
+By using the `--kill-others` flag, concurrently will terminate other commands once the first one exits,
+no matter the exit code.<br/>
+This is useful to terminate the server process once the test is done.
+
+```bash
+$ concurrently --kill-others --names server,test 'npm start' 'npm test'
+```
+
+## Terminating on error only
+
+By using the `--kill-others-on-fail` flag, concurrently will terminate other commands any command
+exits with a non-zero code.<br/>
+This is useful if you're building multiple applications, and you want to abort the others once you know
+that any of them is broken.
+
+```bash
+$ concurrently --kill-others-on-fail 'npm run app1:build' 'npm run app2:build'
+```
+
+## Configuring termination
+
+### Kill Signal
+
+It's possible to configure which signal you want to send when terminating commands with the `--kill-signal` flag.
+The default is `SIGTERM`, but it's also possible to send `SIGKILL`.
+
+```bash
+$ concurrently --kill-others --kill-signal SIGKILL 'npm start' 'npm test'
+```
+
+### Timeout
+
+In case you have a misbehaving process that ignores the kill signal, you can force kill it after some
+timeout (in milliseconds) by using the `--kill-timeout` flag.
+This sends a `SIGKILL`, which cannot be caught.
+
+```bash
+$ concurrently --kill-others --kill-timeout 1000 'sleep 1 && echo bye' './misbehaving'
+[0] bye
+[0] sleep 1 && echo bye exited with code 0
+--> Sending SIGTERM to other processes..
+[1] IGNORING SIGNAL
+--> Sending SIGKILL to 1 processes..
+[1] ./misbehaving exited with code SIGKILL
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concurrently",
-  "version": "9.1.1",
+  "version": "9.2.0",
   "description": "Run commands concurrently",
   "packageManager": "pnpm@8.15.9+sha256.daa27a0b541bc635323ff96c2ded995467ff9fe6d69ff67021558aa9ad9dcc36",
   "main": "index.js",
@@ -52,10 +52,10 @@
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "@jest/types": "^29.6.3",
+    "@jest/types": "^30.0.0",
     "@swc/core": "^1.7.23",
     "@swc/jest": "^0.2.36",
-    "@types/jest": "^29.5.6",
+    "@types/jest": "^30.0.0",
     "@types/lodash": "^4.17.7",
     "@types/node": "^18.19.50",
     "@types/shell-quote": "^1.7.5",
@@ -65,7 +65,7 @@
     "@typescript-eslint/parser": "^7.18.0",
     "coveralls-next": "^4.2.1",
     "ctrlc-wrapper": "^0.0.4",
-    "esbuild": "~0.23.1",
+    "esbuild": "~0.25.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.30.0",
@@ -73,7 +73,7 @@
     "eslint-plugin-prettier": "^5.2.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "husky": "^9.1.5",
-    "jest": "^29.7.0",
+    "jest": "^30.0.0",
     "jest-create-mock-instance": "^2.0.0",
     "lint-staged": "^15.2.10",
     "prettier": "^3.0.3",