concurrently 7.4.0 → 7.6.0

package/README.md

@@ -3,7 +3,7 @@
 [![Latest Release](https://img.shields.io/github/v/release/open-cli-tools/concurrently?label=Release)](https://github.com/open-cli-tools/concurrently/releases)
 [![License](https://img.shields.io/github/license/open-cli-tools/concurrently?label=License)](https://github.com/open-cli-tools/concurrently/blob/main/LICENSE)
 [![Weekly Downloads on NPM](https://img.shields.io/npm/dw/concurrently?label=Downloads&logo=npm)](https://www.npmjs.com/package/concurrently)
-[![CI Status](https://img.shields.io/github/workflow/status/open-cli-tools/concurrently/CI?label=CI&logo=github)](https://github.com/open-cli-tools/concurrently/actions/workflows/ci.yml)
+[![CI Status](https://img.shields.io/github/workflow/status/open-cli-tools/concurrently/Test?label=CI&logo=github)](https://github.com/open-cli-tools/concurrently/actions/workflows/test.yml)
 [![Coverage Status](https://img.shields.io/coveralls/github/open-cli-tools/concurrently/main?label=Coverage&logo=coveralls)](https://coveralls.io/github/open-cli-tools/concurrently?branch=main)
 
 Run multiple commands concurrently.
@@ -15,7 +15,7 @@ Like `npm run watch-js & npm run watch-less` but better.
 
 - [concurrently](#concurrently)
   - [Why](#why)
-  - [Install](#install)
+  - [Installation](#installation)
   - [Usage](#usage)
   - [API](#api)
     - [`concurrently(commands[, options])`](#concurrentlycommands-options)
@@ -41,25 +41,24 @@ tired of opening terminals and made **concurrently**.
 - With `--kill-others` switch, all commands are killed if one dies
 - Spawns commands with [spawn-command](https://github.com/mmalecki/spawn-command)
 
-## Install
+## Installation
 
-The tool is written in Node.js, but you can use it to run **any** commands.
-
-```bash
-npm install -g concurrently
-```
+**concurrently** can be installed in the global scope (if you'd like to have it available and use it on the whole system) or locally for a specific package (for example if you'd like to use it in the `scripts` section of your package):
 
-or if you are using it from npm scripts:
+|             | npm                     | Yarn                           | pnpm                       |
+| ----------- | ----------------------- | ------------------------------ | -------------------------- |
+| **Global**  | `npm i -g concurrently` | `yarn global add concurrently` | `pnpm add -g concurrently` |
+| **Local**\* | `npm i concurrently -D` | `yarn add concurrently -D`     | `pnpm add -D concurrently` |
 
-```bash
-npm install concurrently --save
-```
+<sub>\* It's recommended to add **concurrently** as `devDependencies` as it's usually used for developing purposes. Please change this flag if this doesn't apply in your case.</sub>
 
 ## Usage
 
 > **Note**
 > The `concurrently` command is now also available under the shorthand alias `conc`.
 
+The tool is written in Node.js, but you can use it to run **any** commands.
+
 Remember to surround separate commands with quotes:
 
 ```bash
@@ -146,8 +145,9 @@ concurrently [options] <command ...>
 
 General
   -m, --max-processes          How many processes should run at once.
+                               Exact number or a percent of CPUs available (for example "50%").
                                New processes only spawn after all restart tries
-                               of a process.                            [number]
+                               of a process.                            [string]
   -n, --names                  List of custom names to be used in prefix
                                template.
                                Example names: "main,browser,server"     [string]
@@ -191,8 +191,9 @@ Prefix styling
                           - Available modifiers: reset, bold, dim, italic,
                           underline, inverse, hidden, strikethrough
                           - Available colors: black, red, green, yellow, blue,
-                          magenta, cyan, white, gray
-                          or any hex values for colors, eg #23de43
+                          magenta, cyan, white, gray,
+                          any hex values for colors (e.g. #23de43) or auto for
+                          an automatically picked color
                           - Available background colors: bgBlack, bgRed,
                           bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
                           See https://www.npmjs.com/package/chalk for more
@@ -250,6 +251,14 @@ Examples:
      $ concurrently --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold"
      "http-server" "npm run watch"
 
+ - Auto varying colored prefixes
+
+     $ concurrently -c "auto" "npm run watch" "http-server"
+
+ - Mixing auto and manual colored prefixes
+
+     $ concurrently -c "red,auto" "npm run watch" "http-server" "echo hello"
+
  - Configuring via environment variables with CONCURRENTLY_ prefix
 
      $ CONCURRENTLY_RAW=true CONCURRENTLY_KILL_OTHERS=true concurrently "echo
@@ -324,12 +333,12 @@ For more details, visit https://github.com/open-cli-tools/concurrently
   - `prefix`: the prefix type to use when logging processes output.
     Possible values: `index`, `pid`, `time`, `command`, `name`, `none`, or a template (eg `[{time} process: {pid}]`).
     Default: the name of the process, or its index if no name is set.
-  - `prefixColors`: a list of colors as supported by [chalk](https://www.npmjs.com/package/chalk).
-    If concurrently would run more commands than there are colors, the last color is repeated.
+  - `prefixColors`: a list of colors as supported by [chalk](https://www.npmjs.com/package/chalk) or `auto` for an automatically picked color.
+    If concurrently would run more commands than there are colors, the last color is repeated, unless if the last color value is `auto` which means following colors are automatically picked to vary.
     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, colouring or extra stuff.
+    be logged, without any prefixes, coloring or extra stuff.
   - `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.

package/dist/bin/concurrently.js

@@ -54,8 +54,9 @@ const args = (0, yargs_1.default)(argsBeforeSep)
     'max-processes': {
         alias: 'm',
         describe: 'How many processes should run at once.\n' +
-            'New processes only spawn after all restart tries of a process.',
-        type: 'number',
+            'New processes only spawn after all restart tries of a process.\n' +
+            'Exact number or a percent of CPUs available (for example "50%")',
+        type: 'string',
     },
     names: {
         alias: 'n',
@@ -87,7 +88,7 @@ const args = (0, yargs_1.default)(argsBeforeSep)
             'and concurrently coloring.',
         type: 'boolean',
     },
-    // This one is provided for free. Chalk reads this itself and removes colours.
+    // This one is provided for free. Chalk reads this itself and removes colors.
     // https://www.npmjs.com/package/chalk#chalksupportscolor
     'no-color': {
         describe: 'Disables colors from logging',
@@ -140,8 +141,8 @@ const args = (0, yargs_1.default)(argsBeforeSep)
         describe: 'Comma-separated list of chalk colors to use on prefixes. ' +
             'If there are more commands than colors, the last color will be repeated.\n' +
             '- Available modifiers: reset, bold, dim, italic, underline, inverse, hidden, strikethrough\n' +
-            '- Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray \n' +
-            'or any hex values for colors, eg #23de43\n' +
+            '- Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray, \n' +
+            'any hex values for colors (e.g. #23de43) or auto for an automatically picked color\n' +
             '- Available background colors: bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite\n' +
             'See https://www.npmjs.com/package/chalk for more information.',
         default: defaults.prefixColors,

package/dist/bin/epilogue.js

@@ -20,6 +20,14 @@ const examples = [
         description: 'Custom names and colored prefixes',
         example: '$ $0 --names "HTTP,WATCH" -c "bgBlue.bold,bgMagenta.bold" "http-server" "npm run watch"',
     },
+    {
+        description: 'Auto varying colored prefixes',
+        example: '$ $0 -c "auto" "npm run watch" "http-server"',
+    },
+    {
+        description: 'Mixing auto and manual colored prefixes',
+        example: '$ $0 -c "red,auto" "npm run watch" "http-server" "echo hello"',
+    },
     {
         description: 'Configuring via environment variables with CONCURRENTLY_ prefix',
         example: '$ CONCURRENTLY_RAW=true CONCURRENTLY_KILL_OTHERS=true $0 "echo hello" "echo world"',

package/dist/src/command-parser/expand-arguments.d.ts

@@ -9,8 +9,8 @@ export declare class ExpandArguments implements CommandParser {
     parse(commandInfo: CommandInfo): {
         command: string;
         name: string;
-        env?: Record<string, unknown>;
-        cwd?: string;
-        prefixColor?: string;
+        env?: Record<string, unknown> | undefined;
+        cwd?: string | undefined;
+        prefixColor?: string | undefined;
     };
 }

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

@@ -12,9 +12,6 @@ const OMISSION = /\(!([^)]+)\)/;
  * `package.json` file of the current directory.
  */
 class ExpandNpmWildcard {
-    constructor(readPackage = ExpandNpmWildcard.readPackage) {
-        this.readPackage = readPackage;
-    }
     static readPackage() {
         try {
             const json = fs_1.default.readFileSync('package.json', { encoding: 'utf-8' });
@@ -24,6 +21,9 @@ class ExpandNpmWildcard {
             return {};
         }
     }
+    constructor(readPackage = ExpandNpmWildcard.readPackage) {
+        this.readPackage = readPackage;
+    }
     parse(commandInfo) {
         const [, npmCmd, cmdName, args] = commandInfo.command.match(/(npm|yarn|pnpm) run (\S+)([^&]*)/) || [];
         const wildcardPosition = (cmdName || '').indexOf('*');
@@ -40,7 +40,9 @@ class ExpandNpmWildcard {
         const preWildcard = lodash_1.default.escapeRegExp(cmdNameSansOmission.slice(0, wildcardPosition));
         const postWildcard = lodash_1.default.escapeRegExp(cmdNameSansOmission.slice(wildcardPosition + 1));
         const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
-        const currentName = commandInfo.name || '';
+        // If 'commandInfo.name' doesn't match 'cmdName', this means a custom name
+        // has been specified and thus becomes the prefix (as described in the README).
+        const prefix = commandInfo.name !== cmdName ? commandInfo.name : '';
         return this.scripts
             .map((script) => {
             const match = script.match(wildcardRegex);
@@ -54,9 +56,9 @@ class ExpandNpmWildcard {
                 return {
                     ...commandInfo,
                     command: `${npmCmd} run ${script}${args}`,
-                    // Will use an empty command name if command has no name and the wildcard match is empty,
-                    // e.g. if `npm:watch-*` matches `npm run watch-`.
-                    name: currentName + match[1],
+                    // Will use an empty command name if no prefix has been specified and
+                    // the wildcard match is empty, e.g. if `npm:watch-*` matches `npm run watch-`.
+                    name: prefix + match[1],
                 };
             }
         })

package/dist/src/command-parser/strip-quotes.d.ts

@@ -7,8 +7,8 @@ export declare class StripQuotes implements CommandParser {
     parse(commandInfo: CommandInfo): {
         command: string;
         name: string;
-        env?: Record<string, unknown>;
-        cwd?: string;
-        prefixColor?: string;
+        env?: Record<string, unknown> | undefined;
+        cwd?: string | undefined;
+        prefixColor?: string | undefined;
     };
 }

package/dist/src/command.d.ts

@@ -8,7 +8,7 @@ import { EventEmitter, Writable } from 'stream';
 /**
  * Identifier for a command; if string, it's the command's name, if number, it's the index.
  */
-export declare type CommandIdentifier = string | number;
+export type CommandIdentifier = string | number;
 export interface CommandInfo {
     /**
      * Command's name.
@@ -27,7 +27,7 @@ export interface CommandInfo {
      */
     cwd?: string;
     /**
-     * Color to use on prefix of command.
+     * Color to use on prefix of the command.
      */
     prefixColor?: string;
 }
@@ -58,15 +58,15 @@ export interface TimerEvent {
 /**
  * Subtype of NodeJS's child_process including only what's actually needed for a command to work.
  */
-export declare type ChildProcess = EventEmitter & Pick<BaseChildProcess, 'pid' | 'stdin' | 'stdout' | 'stderr'>;
+export type ChildProcess = EventEmitter & Pick<BaseChildProcess, 'pid' | 'stdin' | 'stdout' | 'stderr'>;
 /**
  * Interface for a function that must kill the process with `pid`, optionally sending `signal` to it.
  */
-export declare type KillProcess = (pid: number, signal?: string) => void;
+export type KillProcess = (pid: number, signal?: string) => void;
 /**
  * Interface for a function that spawns a command and returns its child process instance.
  */
-export declare type SpawnCommand = (command: string, options: SpawnOptions) => ChildProcess;
+export type SpawnCommand = (command: string, options: SpawnOptions) => ChildProcess;
 export declare class Command implements CommandInfo {
     private readonly killProcess;
     private readonly spawn;
@@ -77,7 +77,7 @@ export declare class Command implements CommandInfo {
     /** @inheritdoc */
     readonly command: string;
     /** @inheritdoc */
-    readonly prefixColor: string;
+    readonly prefixColor?: string;
     /** @inheritdoc */
     readonly env: Record<string, unknown>;
     /** @inheritdoc */
@@ -92,6 +92,7 @@ export declare class Command implements CommandInfo {
     pid?: number;
     killed: boolean;
     exited: boolean;
+    /** @deprecated */
     get killable(): boolean;
     constructor({ index, name, command, prefixColor, env, cwd }: CommandInfo & {
         index: number;
@@ -104,4 +105,13 @@ export declare class Command implements CommandInfo {
      * Kills this command, optionally specifying a signal to send to it.
      */
     kill(code?: string): void;
+    /**
+     * Detects whether a command can be killed.
+     *
+     * Also works as a type guard on the input `command`.
+     */
+    static canKill(command: Command): command is Command & {
+        pid: number;
+        process: ChildProcess;
+    };
 }

package/dist/src/command.js

@@ -26,6 +26,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
 const Rx = __importStar(require("rxjs"));
 class Command {
+    /** @deprecated */
+    get killable() {
+        return Command.canKill(this);
+    }
     constructor({ index, name, command, prefixColor, env, cwd }, spawnOpts, spawn, killProcess) {
         this.close = new Rx.Subject();
         this.error = new Rx.Subject();
@@ -38,15 +42,12 @@ class Command {
         this.name = name;
         this.command = command;
         this.prefixColor = prefixColor;
-        this.env = env;
+        this.env = env || {};
         this.cwd = cwd;
         this.killProcess = killProcess;
         this.spawn = spawn;
         this.spawnOpts = spawnOpts;
     }
-    get killable() {
-        return !!this.process;
-    }
     /**
      * Starts this command, piping output, error and close events onto the corresponding observables.
      */
@@ -72,7 +73,7 @@ class Command {
             this.close.next({
                 command: this,
                 index: this.index,
-                exitCode: exitCode === null ? signal : exitCode,
+                exitCode: exitCode !== null && exitCode !== void 0 ? exitCode : String(signal),
                 killed: this.killed,
                 timings: {
                     startDate,
@@ -83,17 +84,25 @@ class Command {
         });
         child.stdout && pipeTo(Rx.fromEvent(child.stdout, 'data'), this.stdout);
         child.stderr && pipeTo(Rx.fromEvent(child.stderr, 'data'), this.stderr);
-        this.stdin = child.stdin;
+        this.stdin = child.stdin || undefined;
     }
     /**
      * Kills this command, optionally specifying a signal to send to it.
      */
     kill(code) {
-        if (this.killable) {
+        if (Command.canKill(this)) {
             this.killed = true;
             this.killProcess(this.pid, code);
         }
     }
+    /**
+     * Detects whether a command can be killed.
+     *
+     * Also works as a type guard on the input `command`.
+     */
+    static canKill(command) {
+        return !!command.pid && !!command.process;
+    }
 }
 exports.Command = Command;
 /**

package/dist/src/completion-listener.d.ts

@@ -9,7 +9,7 @@ import { CloseEvent, Command } from './command';
  * - `command-{name|index}`: only the commands with the specified names or index.
  * - `!command-{name|index}`: all commands but the ones with the specified names or index.
  */
-export declare type SuccessCondition = 'first' | 'last' | 'all' | `command-${string | number}` | `!command-${string | number}`;
+export type SuccessCondition = 'first' | 'last' | 'all' | `command-${string | number}` | `!command-${string | number}`;
 /**
  * Provides logic to determine whether lists of commands ran successfully.
  */
@@ -36,4 +36,5 @@ export declare class CompletionListener {
      * @returns A Promise that resolves if the success condition is met, or rejects otherwise.
      */
     listen(commands: Command[]): Promise<CloseEvent[]>;
+    private emitWithScheduler;
 }

package/dist/src/completion-listener.js

@@ -67,8 +67,11 @@ class CompletionListener {
     listen(commands) {
         const closeStreams = commands.map((command) => command.close);
         return Rx.lastValueFrom(Rx.merge(...closeStreams).pipe((0, operators_1.bufferCount)(closeStreams.length), (0, operators_1.switchMap)((exitInfos) => this.isSuccess(exitInfos)
-            ? Rx.of(exitInfos, this.scheduler)
-            : Rx.throwError(exitInfos, this.scheduler)), (0, operators_1.take)(1)));
+            ? this.emitWithScheduler(Rx.of(exitInfos))
+            : this.emitWithScheduler(Rx.throwError(exitInfos))), (0, operators_1.take)(1)));
+    }
+    emitWithScheduler(input) {
+        return this.scheduler ? input.pipe(Rx.observeOn(this.scheduler)) : input;
     }
 }
 exports.CompletionListener = CompletionListener;

package/dist/src/concurrently.d.ts

@@ -9,8 +9,10 @@ import { Logger } from './logger';
  * If value is a string, then that's the command's command line.
  * Fine grained options can be defined by using the object format.
  */
-export declare type ConcurrentlyCommandInput = string | Partial<CommandInfo>;
-export declare type ConcurrentlyResult = {
+export type ConcurrentlyCommandInput = string | ({
+    command: string;
+} & Partial<CommandInfo>);
+export type ConcurrentlyResult = {
     /**
      * All commands created and ran by concurrently.
      */
@@ -23,7 +25,7 @@ export declare type ConcurrentlyResult = {
      */
     result: Promise<CloseEvent[]>;
 };
-export declare type ConcurrentlyOptions = {
+export type ConcurrentlyOptions = {
     logger?: Logger;
     /**
      * Which stream should the commands output be written to.
@@ -39,11 +41,12 @@ export declare type ConcurrentlyOptions = {
     prefixColors?: string[];
     /**
      * Maximum number of commands to run at once.
+     * Exact number or a percent of CPUs available (for example "50%").
      *
      * If undefined, then all processes will start in parallel.
      * Setting this value to 1 will achieve sequential running.
      */
-    maxProcesses?: number;
+    maxProcesses?: number | string;
     /**
      * Whether commands should be spawned in raw mode.
      * Defaults to false.

package/dist/src/concurrently.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.concurrently = void 0;
 const assert_1 = __importDefault(require("assert"));
 const lodash_1 = __importDefault(require("lodash"));
+const os_1 = require("os");
 const spawn_command_1 = __importDefault(require("spawn-command"));
 const tree_kill_1 = __importDefault(require("tree-kill"));
 const command_1 = require("./command");
@@ -16,6 +17,7 @@ const strip_quotes_1 = require("./command-parser/strip-quotes");
 const completion_listener_1 = require("./completion-listener");
 const get_spawn_opts_1 = require("./get-spawn-opts");
 const output_writer_1 = require("./output-writer");
+const prefix_color_selector_1 = require("./prefix-color-selector");
 const defaults = {
     spawn: spawn_command_1.default,
     kill: tree_kill_1.default,
@@ -33,6 +35,7 @@ function concurrently(baseCommands, baseOptions) {
     assert_1.default.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');
     assert_1.default.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');
     const options = lodash_1.default.defaults(baseOptions, defaults);
+    const prefixColorSelector = new prefix_color_selector_1.PrefixColorSelector(options.prefixColors);
     const commandParsers = [
         new strip_quotes_1.StripQuotes(),
         new expand_npm_shortcut_1.ExpandNpmShortcut(),
@@ -41,16 +44,13 @@ function concurrently(baseCommands, baseOptions) {
     if (options.additionalArguments) {
         commandParsers.push(new expand_arguments_1.ExpandArguments(options.additionalArguments));
     }
-    let lastColor = '';
     let commands = (0, lodash_1.default)(baseCommands)
         .map(mapToCommandInfo)
         .flatMap((command) => parseCommand(command, commandParsers))
         .map((command, index) => {
-        // Use documented behaviour of repeating last color when specifying more commands than colors
-        lastColor = (options.prefixColors && options.prefixColors[index]) || lastColor;
         return new command_1.Command({
             index,
-            prefixColor: lastColor,
+            prefixColor: prefixColorSelector.getNextColor(),
             ...command,
         }, (0, get_spawn_opts_1.getSpawnOpts)({
             raw: options.raw,
@@ -70,13 +70,15 @@ function concurrently(baseCommands, baseOptions) {
     if (options.logger && options.outputStream) {
         const outputWriter = new output_writer_1.OutputWriter({
             outputStream: options.outputStream,
-            group: options.group,
+            group: !!options.group,
             commands,
         });
         options.logger.output.subscribe(({ command, text }) => outputWriter.write(command, text));
     }
     const commandsLeft = commands.slice();
-    const maxProcesses = Math.max(1, Number(options.maxProcesses) || commandsLeft.length);
+    const maxProcesses = Math.max(1, (typeof options.maxProcesses === 'string' && options.maxProcesses.endsWith('%')
+        ? Math.round(((0, os_1.cpus)().length * Number(options.maxProcesses.slice(0, -1))) / 100)
+        : Number(options.maxProcesses)) || commandsLeft.length);
     for (let i = 0; i < maxProcesses; i++) {
         maybeRunMore(commandsLeft);
     }
@@ -93,13 +95,9 @@ function concurrently(baseCommands, baseOptions) {
 exports.concurrently = concurrently;
 function mapToCommandInfo(command) {
     if (typeof command === 'string') {
-        return {
-            command,
-            name: '',
-            env: {},
-            cwd: '',
-        };
+        return mapToCommandInfo({ command });
     }
+    assert_1.default.ok(command.command, '[concurrently] command cannot be empty');
     return {
         command: command.command,
         name: command.name || '',

package/dist/src/flow-control/input-handler.d.ts

@@ -15,19 +15,16 @@ import { FlowController } from './flow-controller';
 export declare class InputHandler implements FlowController {
     private readonly logger;
     private readonly defaultInputTarget;
-    private readonly inputStream;
+    private readonly inputStream?;
     private readonly pauseInputStreamOnFinish;
     constructor({ defaultInputTarget, inputStream, pauseInputStreamOnFinish, logger, }: {
-        inputStream: Readable;
+        inputStream?: Readable;
         logger: Logger;
         defaultInputTarget?: CommandIdentifier;
         pauseInputStreamOnFinish?: boolean;
     });
     handle(commands: Command[]): {
         commands: Command[];
-        onFinish?: undefined;
-    } | {
-        commands: Command[];
-        onFinish: () => void;
+        onFinish?: () => void | undefined;
     };
 }

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

@@ -44,11 +44,12 @@ class InputHandler {
         this.pauseInputStreamOnFinish = pauseInputStreamOnFinish !== false;
     }
     handle(commands) {
-        if (!this.inputStream) {
+        const { inputStream } = this;
+        if (!inputStream) {
             return { commands };
         }
-        Rx.fromEvent(this.inputStream, 'data')
-            .pipe((0, operators_1.map)((data) => data.toString()))
+        Rx.fromEvent(inputStream, 'data')
+            .pipe((0, operators_1.map)((data) => String(data)))
             .subscribe((data) => {
             const dataParts = data.split(/:(.+)/);
             const targetId = dataParts.length > 1 ? dataParts[0] : this.defaultInputTarget;
@@ -67,7 +68,7 @@ class InputHandler {
             onFinish: () => {
                 if (this.pauseInputStreamOnFinish) {
                     // https://github.com/kimmobrunfeldt/concurrently/issues/252
-                    this.inputStream.pause();
+                    inputStream.pause();
                 }
             },
         };

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

@@ -1,9 +1,9 @@
 import { Command } from '../command';
 import { Logger } from '../logger';
 import { FlowController } from './flow-controller';
-export declare type ProcessCloseCondition = 'failure' | 'success';
+export type ProcessCloseCondition = 'failure' | 'success';
 /**
- * Sends a SIGTERM signal to all commands when one of the exits with a matching condition.
+ * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.
  */
 export declare class KillOthers implements FlowController {
     private readonly logger;

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

@@ -6,8 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KillOthers = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const operators_1 = require("rxjs/operators");
+const command_1 = require("../command");
 /**
- * Sends a SIGTERM signal to all commands when one of the exits with a matching condition.
+ * Sends a SIGTERM signal to all commands when one of the commands exits with a matching condition.
  */
 class KillOthers {
     constructor({ logger, conditions, }) {
@@ -21,7 +22,7 @@ class KillOthers {
         }
         const closeStates = commands.map((command) => command.close.pipe((0, operators_1.map)(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'), (0, operators_1.filter)((state) => conditions.includes(state))));
         closeStates.forEach((closeState) => closeState.subscribe(() => {
-            const killableCommands = commands.filter((command) => command.killable);
+            const killableCommands = commands.filter((command) => command_1.Command.canKill(command));
             if (killableCommands.length) {
                 this.logger.logGlobalEvent('Sending SIGTERM to other processes..');
                 killableCommands.forEach((command) => command.kill());

package/dist/src/flow-control/log-timings.js

@@ -27,6 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogTimings = void 0;
+const assert = __importStar(require("assert"));
 const format_1 = __importDefault(require("date-fns/format"));
 const lodash_1 = __importDefault(require("lodash"));
 const Rx = __importStar(require("rxjs"));
@@ -36,10 +37,6 @@ const defaults = __importStar(require("../defaults"));
  * Logs timing information about commands as they start/stop and then a summary when all commands finish.
  */
 class LogTimings {
-    constructor({ logger, timestampFormat = defaults.timestampFormat, }) {
-        this.logger = logger;
-        this.timestampFormat = timestampFormat;
-    }
     static mapCloseEventToTimingInfo({ command, timings, killed, exitCode, }) {
         const readableDurationMs = (timings.endDate.getTime() - timings.startDate.getTime()).toLocaleString();
         return {
@@ -50,7 +47,12 @@ class LogTimings {
             command: command.command,
         };
     }
+    constructor({ logger, timestampFormat = defaults.timestampFormat, }) {
+        this.logger = logger;
+        this.timestampFormat = timestampFormat;
+    }
     printExitInfoTimingTable(exitInfos) {
+        assert.ok(this.logger);
         const exitInfoTable = (0, lodash_1.default)(exitInfos)
             .sortBy(({ timings }) => timings.durationSeconds)
             .reverse()
@@ -61,7 +63,8 @@ class LogTimings {
         return exitInfos;
     }
     handle(commands) {
-        if (!this.logger) {
+        const { logger } = this;
+        if (!logger) {
             return { commands };
         }
         // individual process timings
@@ -69,12 +72,12 @@ class LogTimings {
             command.timer.subscribe(({ startDate, endDate }) => {
                 if (!endDate) {
                     const formattedStartDate = (0, format_1.default)(startDate, this.timestampFormat);
-                    this.logger.logCommandEvent(`${command.command} started at ${formattedStartDate}`, command);
+                    logger.logCommandEvent(`${command.command} started at ${formattedStartDate}`, command);
                 }
                 else {
                     const durationMs = endDate.getTime() - startDate.getTime();
                     const formattedEndDate = (0, format_1.default)(endDate, this.timestampFormat);
-                    this.logger.logCommandEvent(`${command.command} stopped at ${formattedEndDate} after ${durationMs.toLocaleString()}ms`, command);
+                    logger.logCommandEvent(`${command.command} stopped at ${formattedEndDate} after ${durationMs.toLocaleString()}ms`, command);
                 }
             });
         });

package/dist/src/get-spawn-opts.d.ts

@@ -11,23 +11,23 @@ export declare const getSpawnOpts: ({ colorSupport, cwd, process, raw, env, }: {
      *
      * Defaults to whatever the terminal's stdout support is.
      */
-    colorSupport?: Pick<supportsColor.supportsColor.Level, 'level'> | false;
+    colorSupport?: false | Pick<supportsColor.supportsColor.Level, "level"> | undefined;
     /**
      * The NodeJS process.
      */
-    process?: Pick<NodeJS.Process, 'cwd' | 'platform' | 'env'>;
+    process?: Pick<NodeJS.Process, "cwd" | "env" | "platform"> | undefined;
     /**
      * A custom working directory to spawn processes in.
      * Defaults to `process.cwd()`.
      */
-    cwd?: string;
+    cwd?: string | undefined;
     /**
      * Whether to customize the options for spawning processes in raw mode.
      * Defaults to false.
      */
-    raw?: boolean;
+    raw?: boolean | undefined;
     /**
      * Map of custom environment variables to include in the spawn options.
      */
-    env?: Record<string, unknown>;
+    env?: Record<string, unknown> | undefined;
 }) => SpawnOptions;

package/dist/src/index.d.ts

@@ -12,7 +12,7 @@ import { LogOutput } from './flow-control/log-output';
 import { LogTimings } from './flow-control/log-timings';
 import { RestartProcess } from './flow-control/restart-process';
 import { Logger } from './logger';
-export declare type ConcurrentlyOptions = BaseConcurrentlyOptions & {
+export type ConcurrentlyOptions = BaseConcurrentlyOptions & {
     /**
      * Which command(s) should have their output hidden.
      */

package/dist/src/index.js

@@ -46,7 +46,7 @@ exports.default = (commands, options = {}) => {
             new input_handler_1.InputHandler({
                 logger,
                 defaultInputTarget: options.defaultInputTarget,
-                inputStream: options.inputStream || (options.handleInput && process.stdin),
+                inputStream: options.inputStream || (options.handleInput ? process.stdin : undefined),
                 pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
             }),
             new kill_on_signal_1.KillOnSignal({ process }),
@@ -57,10 +57,10 @@ exports.default = (commands, options = {}) => {
             }),
             new kill_others_1.KillOthers({
                 logger,
-                conditions: options.killOthers,
+                conditions: options.killOthers || [],
             }),
             new log_timings_1.LogTimings({
-                logger: options.timings ? logger : null,
+                logger: options.timings ? logger : undefined,
                 timestampFormat: options.timestampFormat,
             }),
         ],

package/dist/src/logger.js

@@ -86,13 +86,14 @@ class Logger {
         }, prefix);
     }
     colorText(command, text) {
+        var _a;
         let color;
         if (command.prefixColor && command.prefixColor.startsWith('#')) {
             color = chalk_1.default.hex(command.prefixColor);
         }
         else {
             const defaultColor = lodash_1.default.get(chalk_1.default, defaults.prefixColors, chalk_1.default.reset);
-            color = lodash_1.default.get(chalk_1.default, command.prefixColor, defaultColor);
+            color = lodash_1.default.get(chalk_1.default, (_a = command.prefixColor) !== null && _a !== void 0 ? _a : '', defaultColor);
         }
         return color(text);
     }

package/dist/src/prefix-color-selector.d.ts

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+export declare class PrefixColorSelector {
+    private colorGenerator;
+    constructor(customColors?: string[]);
+    /** A list of colors that are readable in a terminal. */
+    static get ACCEPTABLE_CONSOLE_COLORS(): ("stderr" | keyof chalk.Chalk | "supportsColor" | "Level" | "Color" | "ForegroundColor" | "BackgroundColor" | "Modifiers")[];
+    /**
+     * @returns The given custom colors then a set of acceptable console colors indefinitely.
+     */
+    getNextColor(): string;
+}

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrefixColorSelector = void 0;
+function getConsoleColorsWithoutCustomColors(customColors) {
+    return PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS.filter(
+    // Consider the "Bright" variants of colors to be the same as the plain color to avoid similar colors
+    (color) => !customColors.includes(color.replace(/Bright$/, '')));
+}
+/**
+ * Creates a generator that yields an infinite stream of colors.
+ */
+function* createColorGenerator(customColors) {
+    // Custom colors should be used as is, except for "auto"
+    const nextAutoColors = getConsoleColorsWithoutCustomColors(customColors);
+    let lastColor;
+    for (const customColor of customColors) {
+        let currentColor = customColor;
+        if (currentColor !== 'auto') {
+            yield currentColor; // Manual color
+        }
+        else {
+            // Find the first auto color that is not the same as the last color
+            while (currentColor === 'auto' || lastColor === currentColor) {
+                if (!nextAutoColors.length) {
+                    // There could be more "auto" values than auto colors so this needs to be able to refill
+                    nextAutoColors.push(...PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS);
+                }
+                currentColor = String(nextAutoColors.shift());
+            }
+            yield currentColor; // Auto color
+        }
+        lastColor = currentColor;
+    }
+    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
+        }
+    }
+    // Finish the initial set(s) of auto colors to avoid repetition
+    for (const color of nextAutoColors) {
+        yield color;
+    }
+    // Yield an infinite stream of acceptable console colors
+    //
+    // If the given custom colors use every ACCEPTABLE_CONSOLE_COLORS except one then there is a chance a color will be repeated,
+    // however its highly unlikely and low consequence so not worth the extra complexity to account for it
+    while (true) {
+        for (const color of PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS) {
+            yield color; // Repeat colors forever
+        }
+    }
+}
+class PrefixColorSelector {
+    constructor(customColors = []) {
+        this.colorGenerator = createColorGenerator(customColors);
+    }
+    /** A list of colors that are readable in a terminal. */
+    static get ACCEPTABLE_CONSOLE_COLORS() {
+        // Colors picked randomly, can be amended if required
+        return [
+            // Prevent duplicates, in case the list becomes significantly large
+            ...new Set([
+                // Text colors
+                'cyan',
+                'yellow',
+                'greenBright',
+                'blueBright',
+                'magentaBright',
+                'white',
+                'grey',
+                'red',
+                // Background colors
+                'bgCyan',
+                'bgYellow',
+                'bgGreenBright',
+                'bgBlueBright',
+                'bgMagenta',
+                'bgWhiteBright',
+                'bgGrey',
+                'bgRed',
+            ]),
+        ];
+    }
+    /**
+     * @returns The given custom colors then a set of acceptable console colors indefinitely.
+     */
+    getNextColor() {
+        return this.colorGenerator.next().value;
+    }
+}
+exports.PrefixColorSelector = PrefixColorSelector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concurrently",
-  "version": "7.4.0",
+  "version": "7.6.0",
   "description": "Run commands concurrently",
   "main": "index.js",
   "types": "dist/src/index.d.ts",
@@ -25,9 +25,9 @@
     "build": "tsc --build",
     "postbuild": "chmod +x dist/bin/concurrently.js",
     "clean": "tsc --build --clean",
-    "format": "prettier --ignore-path .gitignore --check '**/{!(package-lock).json,*.y?(a)ml,*.md}'",
+    "format": "prettier --check '**/*.{json,y?(a)ml,md}'",
     "format:fix": "npm run format -- --write",
-    "lint": "eslint . --ext mjs,js,ts --ignore-path .gitignore",
+    "lint": "eslint --ignore-path .gitignore --ext mjs,js,ts .",
     "lint:fix": "npm run lint -- --fix",
     "prepublishOnly": "npm run build",
     "report-coverage": "cat coverage/lcov.info | coveralls",
@@ -63,7 +63,7 @@
     "@hirez_io/observer-spy": "^2.2.0",
     "@swc/core": "^1.2.224",
     "@swc/jest": "^0.2.21",
-    "@types/jest": "^28.1.6",
+    "@types/jest": "^28.1.8",
     "@types/lodash": "^4.14.178",
     "@types/node": "^16.11.47",
     "@types/shell-quote": "^1.7.1",
@@ -77,16 +77,16 @@
     "eslint": "^8.21.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^26.8.2",
+    "eslint-plugin-jest": "^27.0.4",
     "eslint-plugin-prettier": "^4.0.0",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
+    "eslint-plugin-simple-import-sort": "^8.0.0",
     "jest": "^28.1.3",
     "jest-create-mock-instance": "^2.0.0",
     "lint-staged": "^12.4.1",
     "prettier": "^2.6.2",
     "simple-git-hooks": "^2.7.0",
     "string-argv": "^0.3.1",
-    "typescript": "^4.5.4"
+    "typescript": "~4.9.3"
   },
   "files": [
     "dist",
@@ -101,6 +101,6 @@
   },
   "lint-staged": {
     "*.m?{js,ts}": "eslint --fix",
-    "{!(package-lock).json,*.{y?(a)ml,md}}": "prettier --write"
+    "*.{json,y?(a)ml,md}": "prettier --write"
   }
 }