concurrently 8.2.1 → 9.0.0

package/dist/src/flow-control/teardown.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Teardown = void 0;
+const Rx = __importStar(require("rxjs"));
+const spawn_1 = require("../spawn");
+class Teardown {
+    logger;
+    spawn;
+    teardown;
+    constructor({ logger, spawn, commands, }) {
+        this.logger = logger;
+        this.spawn = spawn || spawn_1.spawn;
+        this.teardown = commands;
+    }
+    handle(commands) {
+        const { logger, teardown, spawn } = this;
+        const onFinish = async () => {
+            if (!teardown.length) {
+                return;
+            }
+            for (const command of teardown) {
+                logger.logGlobalEvent(`Running teardown command "${command}"`);
+                const child = spawn(command, (0, spawn_1.getSpawnOpts)({ stdio: 'raw' }));
+                const error = Rx.fromEvent(child, 'error');
+                const close = Rx.fromEvent(child, 'close');
+                try {
+                    const [exitCode, signal] = await Promise.race([
+                        Rx.firstValueFrom(error).then((event) => {
+                            throw event;
+                        }),
+                        Rx.firstValueFrom(close).then((event) => event),
+                    ]);
+                    logger.logGlobalEvent(`Teardown command "${command}" exited with code ${exitCode ?? signal}`);
+                    if (signal === 'SIGINT') {
+                        break;
+                    }
+                }
+                catch (error) {
+                    const errorText = String(error instanceof Error ? error.stack || error : error);
+                    logger.logGlobalEvent(`Teardown command "${command}" errored:`);
+                    logger.logGlobalEvent(errorText);
+                    return Promise.reject();
+                }
+            }
+        };
+        return { commands, onFinish };
+    }
+}
+exports.Teardown = Teardown;

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Readable } from 'stream';
 import { CloseEvent, Command, CommandIdentifier, TimerEvent } from './command';
-import { concurrently, ConcurrentlyCommandInput, ConcurrentlyOptions as BaseConcurrentlyOptions, ConcurrentlyResult } from './concurrently';
+import { concurrently as createConcurrently, ConcurrentlyCommandInput, ConcurrentlyOptions as BaseConcurrentlyOptions, ConcurrentlyResult } from './concurrently';
 import { FlowController } from './flow-control/flow-controller';
 import { InputHandler } from './flow-control/input-handler';
 import { KillOnSignal } from './flow-control/kill-on-signal';
@@ -10,9 +10,9 @@ import { LogError } from './flow-control/log-error';
 import { LogExit } from './flow-control/log-exit';
 import { LogOutput } from './flow-control/log-output';
 import { LogTimings } from './flow-control/log-timings';
-import { RestartProcess } from './flow-control/restart-process';
+import { RestartDelay, RestartProcess } from './flow-control/restart-process';
 import { Logger } from './logger';
-export type ConcurrentlyOptions = BaseConcurrentlyOptions & {
+export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' | 'hide'> & {
     /**
      * Which command(s) should have their output hidden.
      */
@@ -26,13 +26,17 @@ export type ConcurrentlyOptions = BaseConcurrentlyOptions & {
      * How many characters should a prefix have at most, used when the prefix format is `command`.
      */
     prefixLength?: number;
+    /**
+     * Pads short prefixes with spaces so that all prefixes have the same length.
+     */
+    padPrefix?: boolean;
     /**
      * Whether output should be formatted to include prefixes and whether "event" logs will be logged.
      */
     raw?: boolean;
     /**
      * Date format used when logging date/time.
-     * @see https://date-fns.org/v2.0.1/docs/format
+     * @see https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
      */
     timestampFormat?: string;
     defaultInputTarget?: CommandIdentifier;
@@ -44,7 +48,7 @@ export type ConcurrentlyOptions = BaseConcurrentlyOptions & {
      *
      * @see RestartProcess
      */
-    restartDelay?: number;
+    restartDelay?: RestartDelay;
     /**
      * How many times commands should be restarted when they exit with a failure.
      *
@@ -63,12 +67,18 @@ export type ConcurrentlyOptions = BaseConcurrentlyOptions & {
      * @see LogTimings
      */
     timings?: boolean;
+    /**
+     * Clean up command(s) to execute before exiting concurrently.
+     * These won't be prefixed and don't affect concurrently's exit code.
+     */
+    teardown?: readonly string[];
     /**
      * List of additional arguments passed that will get replaced in each command.
      * If not defined, no argument replacing will happen.
      */
     additionalArguments?: string[];
 };
-declare const _default: (commands: ConcurrentlyCommandInput[], options?: Partial<ConcurrentlyOptions>) => ConcurrentlyResult;
-export default _default;
-export { CloseEvent, Command, CommandIdentifier, concurrently, ConcurrentlyCommandInput, ConcurrentlyResult, FlowController, InputHandler, KillOnSignal, KillOthers, LogError, LogExit, Logger, LogOutput, LogTimings, RestartProcess, TimerEvent, };
+export declare function concurrently(commands: ConcurrentlyCommandInput[], options?: Partial<ConcurrentlyOptions>): ConcurrentlyResult;
+export { ConcurrentlyCommandInput, ConcurrentlyResult, createConcurrently, Logger };
+export { CloseEvent, Command, CommandIdentifier, TimerEvent };
+export { FlowController, InputHandler, KillOnSignal, KillOthers, LogError, LogExit, LogOutput, LogTimings, RestartProcess, };

package/dist/src/index.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestartProcess = exports.LogTimings = exports.LogOutput = exports.Logger = exports.LogExit = exports.LogError = exports.KillOthers = exports.KillOnSignal = exports.InputHandler = exports.concurrently = exports.Command = void 0;
+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 command_1 = require("./command");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
 const concurrently_1 = require("./concurrently");
-Object.defineProperty(exports, "concurrently", { enumerable: true, get: function () { return concurrently_1.concurrently; } });
+Object.defineProperty(exports, "createConcurrently", { enumerable: true, get: function () { return concurrently_1.concurrently; } });
 const input_handler_1 = require("./flow-control/input-handler");
 Object.defineProperty(exports, "InputHandler", { enumerable: true, get: function () { return input_handler_1.InputHandler; } });
 const kill_on_signal_1 = require("./flow-control/kill-on-signal");
@@ -19,27 +23,41 @@ const log_output_1 = require("./flow-control/log-output");
 Object.defineProperty(exports, "LogOutput", { enumerable: true, get: function () { return log_output_1.LogOutput; } });
 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 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; } });
-exports.default = (commands, options = {}) => {
+function concurrently(commands, options = {}) {
+    // 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: options.hide,
+        hide,
         prefixFormat: options.prefix,
-        prefixLength: options.prefixLength,
+        commandLength: options.prefixLength,
         raw: options.raw,
         timestampFormat: options.timestampFormat,
     });
+    if (options.prefixColors === false) {
+        logger.toggleColors(false);
+    }
+    const abortController = new AbortController();
     return (0, concurrently_1.concurrently)(commands, {
         maxProcesses: options.maxProcesses,
         raw: options.raw,
         successCondition: options.successCondition,
         cwd: options.cwd,
+        hide,
         logger,
         outputStream: options.outputStream || process.stdout,
         group: options.group,
+        abortSignal: abortController.signal,
         controllers: [
+            // LoggerPadding needs to run before any other controllers that might output something
+            ...(options.padPrefix ? [new logger_padding_1.LoggerPadding({ logger })] : []),
             new log_error_1.LogError({ logger }),
             new log_output_1.LogOutput({ logger }),
             new log_exit_1.LogExit({ logger }),
@@ -49,7 +67,7 @@ exports.default = (commands, options = {}) => {
                 inputStream: options.inputStream || (options.handleInput ? process.stdin : undefined),
                 pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
             }),
-            new kill_on_signal_1.KillOnSignal({ process }),
+            new kill_on_signal_1.KillOnSignal({ process, abortController }),
             new restart_process_1.RestartProcess({
                 logger,
                 delay: options.restartDelay,
@@ -59,13 +77,16 @@ exports.default = (commands, options = {}) => {
                 logger,
                 conditions: options.killOthers || [],
                 killSignal: options.killSignal,
+                abortController,
             }),
             new log_timings_1.LogTimings({
                 logger: options.timings ? logger : undefined,
                 timestampFormat: options.timestampFormat,
             }),
+            new teardown_1.Teardown({ logger, spawn: options.spawn, commands: options.teardown || [] }),
         ],
         prefixColors: options.prefixColors || [],
         additionalArguments: options.additionalArguments,
     });
-};
+}
+exports.concurrently = concurrently;

package/dist/src/logger.d.ts

@@ -4,13 +4,19 @@ export declare class Logger {
     private readonly hide;
     private readonly raw;
     private readonly prefixFormat?;
-    private readonly prefixLength;
-    private readonly timestampFormat;
+    private readonly commandLength;
+    private readonly dateFormatter;
+    private chalk;
     /**
-     * Last character emitted.
+     * How many characters should a prefix have.
+     * Prefixes shorter than this will be padded with spaces to the right.
+     */
+    private prefixLength;
+    /**
+     * Last character emitted, and from which command.
      * If `undefined`, then nothing has been logged yet.
      */
-    private lastChar?;
+    private lastWrite?;
     /**
      * Observable that emits when there's been output logged.
      * If `command` is is `undefined`, then the log is for a global event.
@@ -19,11 +25,11 @@ export declare class Logger {
         command: Command | undefined;
         text: string;
     }>;
-    constructor({ hide, prefixFormat, prefixLength, raw, timestampFormat, }: {
+    constructor({ hide, prefixFormat, commandLength, raw, timestampFormat, }: {
         /**
-         * Which command(s) should have their output hidden.
+         * Which commands should have their output hidden.
          */
-        hide?: CommandIdentifier | CommandIdentifier[];
+        hide?: CommandIdentifier[];
         /**
          * Whether output should be formatted to include prefixes and whether "event" logs will be
          * logged.
@@ -35,18 +41,27 @@ export declare class Logger {
          */
         prefixFormat?: string;
         /**
-         * How many characters should a prefix have at most, used when the prefix format is `command`.
+         * How many characters should a prefix have at most when the format is `command`.
          */
-        prefixLength?: number;
+        commandLength?: number;
         /**
          * Date format used when logging date/time.
-         * @see https://date-fns.org/v2.0.1/docs/format
+         * @see https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
          */
         timestampFormat?: string;
     });
+    /**
+     * Toggles colors on/off globally.
+     */
+    toggleColors(on: boolean): void;
     private shortenText;
     private getPrefixesFor;
+    getPrefixContent(command: Command): {
+        type: 'default' | 'template';
+        value: string;
+    } | undefined;
     getPrefix(command: Command): string;
+    setPrefixLength(length: number): void;
     colorText(command: Command, text: string): string;
     /**
      * Logs an event for a command (e.g. start, stop).

package/dist/src/logger.js

@@ -28,34 +28,53 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const format_1 = __importDefault(require("date-fns/format"));
 const lodash_1 = __importDefault(require("lodash"));
 const Rx = __importStar(require("rxjs"));
+const date_format_1 = require("./date-format");
 const defaults = __importStar(require("./defaults"));
+const defaultChalk = chalk_1.default;
+const noColorChalk = new chalk_1.default.Instance({ level: 0 });
 class Logger {
-    constructor({ hide, prefixFormat, prefixLength, raw = false, timestampFormat, }) {
-        /**
-         * Observable that emits when there's been output logged.
-         * If `command` is is `undefined`, then the log is for a global event.
-         */
-        this.output = new Rx.Subject();
-        // 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.
-        this.hide = lodash_1.default.castArray(hide)
-            .filter((name) => name || name === 0)
-            .map(String);
+    hide;
+    raw;
+    prefixFormat;
+    commandLength;
+    dateFormatter;
+    chalk = defaultChalk;
+    /**
+     * How many characters should a prefix have.
+     * Prefixes shorter than this will be padded with spaces to the right.
+     */
+    prefixLength = 0;
+    /**
+     * Last character emitted, and from which command.
+     * If `undefined`, then nothing has been logged yet.
+     */
+    lastWrite;
+    /**
+     * Observable that emits when there's been output logged.
+     * If `command` is is `undefined`, then the log is for a global event.
+     */
+    output = new Rx.Subject();
+    constructor({ hide, prefixFormat, commandLength, raw = false, timestampFormat, }) {
+        this.hide = (hide || []).map(String);
         this.raw = raw;
         this.prefixFormat = prefixFormat;
-        this.prefixLength = prefixLength || defaults.prefixLength;
-        this.timestampFormat = timestampFormat || defaults.timestampFormat;
+        this.commandLength = commandLength || defaults.prefixLength;
+        this.dateFormatter = new date_format_1.DateFormatter(timestampFormat || defaults.timestampFormat);
+    }
+    /**
+     * Toggles colors on/off globally.
+     */
+    toggleColors(on) {
+        this.chalk = on ? defaultChalk : noColorChalk;
     }
     shortenText(text) {
-        if (!text || text.length <= this.prefixLength) {
+        if (!text || text.length <= this.commandLength) {
             return text;
         }
         const ellipsis = '..';
-        const prefixLength = this.prefixLength - ellipsis.length;
+        const prefixLength = this.commandLength - ellipsis.length;
         const endLength = Math.floor(prefixLength / 2);
         const beginningLength = prefixLength - endLength;
         const beginnning = text.slice(0, beginningLength);
@@ -64,35 +83,50 @@ class Logger {
     }
     getPrefixesFor(command) {
         return {
-            pid: String(command.pid),
+            // When there's limited concurrency, the PID might not be immediately available,
+            // so avoid the string 'undefined' from becoming a prefix
+            pid: command.pid != null ? String(command.pid) : '',
             index: String(command.index),
             name: command.name,
             command: this.shortenText(command.command),
-            time: (0, format_1.default)(Date.now(), this.timestampFormat),
+            time: this.dateFormatter.format(new Date()),
         };
     }
-    getPrefix(command) {
+    getPrefixContent(command) {
         const prefix = this.prefixFormat || (command.name ? 'name' : 'index');
         if (prefix === 'none') {
-            return '';
+            return;
         }
         const prefixes = this.getPrefixesFor(command);
         if (Object.keys(prefixes).includes(prefix)) {
-            return `[${prefixes[prefix]}]`;
+            return { type: 'default', value: prefixes[prefix] };
         }
-        return lodash_1.default.reduce(prefixes, (prev, val, key) => {
+        const value = lodash_1.default.reduce(prefixes, (prev, val, key) => {
             const keyRegex = new RegExp(lodash_1.default.escapeRegExp(`{${key}}`), 'g');
             return prev.replace(keyRegex, String(val));
         }, prefix);
+        return { type: 'template', value };
+    }
+    getPrefix(command) {
+        const content = this.getPrefixContent(command);
+        if (!content) {
+            return '';
+        }
+        return content.type === 'template'
+            ? content.value.padEnd(this.prefixLength, ' ')
+            : `[${content.value.padEnd(this.prefixLength, ' ')}]`;
+    }
+    setPrefixLength(length) {
+        this.prefixLength = length;
     }
     colorText(command, text) {
         let color;
         if (command.prefixColor && command.prefixColor.startsWith('#')) {
-            color = chalk_1.default.hex(command.prefixColor);
+            color = this.chalk.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);
+            const defaultColor = lodash_1.default.get(this.chalk, defaults.prefixColors, this.chalk.reset);
+            color = lodash_1.default.get(this.chalk, command.prefixColor ?? '', defaultColor);
         }
         return color(text);
     }
@@ -105,7 +139,14 @@ class Logger {
         if (this.raw) {
             return;
         }
-        this.logCommandText(chalk_1.default.reset(text) + '\n', command);
+        // Last write was from this command, but it didn't end with a line feed.
+        // Prepend one, otherwise the event's text will be concatenated to that write.
+        // A line feed is otherwise inserted anyway.
+        let prefix = '';
+        if (this.lastWrite?.command === command && this.lastWrite.char !== '\n') {
+            prefix = '\n';
+        }
+        this.logCommandText(prefix + this.chalk.reset(text) + '\n', command);
     }
     logCommandText(text, command) {
         if (this.hide.includes(String(command.index)) || this.hide.includes(command.name)) {
@@ -123,7 +164,7 @@ class Logger {
         if (this.raw) {
             return;
         }
-        this.log(chalk_1.default.reset('-->') + ' ', chalk_1.default.reset(text) + '\n');
+        this.log(this.chalk.reset('-->') + ' ', this.chalk.reset(text) + '\n');
     }
     /**
      * Logs a table from an input object array, like `console.table`.
@@ -181,21 +222,19 @@ class Logger {
         }
         // #70 - replace some ANSI code that would impact clearing lines
         text = text.replace(/\u2026/g, '...');
-        const lines = text.split('\n').map((line, index, lines) => {
-            // First line will write prefix only if we finished the last write with a LF.
-            // Last line won't write prefix because it should be empty.
-            if (index === 0 || index === lines.length - 1) {
-                return line;
-            }
-            return prefix + line;
-        });
-        if (!this.lastChar || this.lastChar === '\n') {
+        // This write's interrupting another command, emit a line feed to start clean.
+        if (this.lastWrite && this.lastWrite.command !== command && this.lastWrite.char !== '\n') {
+            this.emit(this.lastWrite.command, '\n');
+        }
+        // Clean lines should emit a prefix
+        if (!this.lastWrite || this.lastWrite.char === '\n') {
             this.emit(command, prefix);
         }
-        this.lastChar = text[text.length - 1];
-        this.emit(command, lines.join('\n'));
+        const textToWrite = text.replaceAll('\n', (lf, i) => lf + (text[i + 1] ? prefix : ''));
+        this.emit(command, textToWrite);
     }
     emit(command, text) {
+        this.lastWrite = { command, char: text[text.length - 1] };
         this.output.next({ command, text });
     }
 }

package/dist/src/output-writer.js

@@ -29,8 +29,11 @@ const Rx = __importStar(require("rxjs"));
  * Class responsible for actually writing output onto a writable stream.
  */
 class OutputWriter {
+    outputStream;
+    group;
+    buffers;
+    activeCommandIndex = 0;
     constructor({ outputStream, group, commands, }) {
-        this.activeCommandIndex = 0;
         this.outputStream = outputStream;
         this.group = group;
         this.buffers = commands.map(() => []);
@@ -42,7 +45,8 @@ class OutputWriter {
                 for (let i = command.index + 1; i < commands.length; i++) {
                     this.activeCommandIndex = i;
                     this.flushBuffer(i);
-                    if (!commands[i].exited) {
+                    // TODO: Should errored commands also flush buffer?
+                    if (commands[i].state !== 'exited') {
                         break;
                     }
                 }

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

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 export declare class PrefixColorSelector {
     private colorGenerator;
-    constructor(customColors?: string[]);
+    constructor(customColors?: string | 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")[];
     /**

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

@@ -52,8 +52,10 @@ function* createColorGenerator(customColors) {
     }
 }
 class PrefixColorSelector {
+    colorGenerator;
     constructor(customColors = []) {
-        this.colorGenerator = createColorGenerator(customColors);
+        const normalizedColors = typeof customColors === 'string' ? [customColors] : customColors;
+        this.colorGenerator = createColorGenerator(normalizedColors);
     }
     /** A list of colors that are readable in a terminal. */
     static get ACCEPTABLE_CONSOLE_COLORS() {

package/dist/src/{get-spawn-opts.d.ts → spawn.d.ts}

@@ -3,9 +3,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { SpawnOptions } from 'child_process';
+/// <reference types="node" />
+import { ChildProcess, SpawnOptions } from 'child_process';
 import supportsColor from 'supports-color';
-export declare const getSpawnOpts: ({ colorSupport, cwd, process, raw, env, }: {
+/**
+ * Spawns a command using `cmd.exe` on Windows, or `/bin/sh` elsewhere.
+ */
+export declare function spawn(command: string, options: SpawnOptions, spawn?: (command: string, args: string[], options: SpawnOptions) => ChildProcess, process?: Pick<NodeJS.Process, 'platform'>): ChildProcess;
+export declare const getSpawnOpts: ({ colorSupport, cwd, process, ipc, stdio, env, }: {
     /**
      * What the color support of the spawned processes should be.
      * If set to `false`, then no colors should be output.
@@ -23,10 +28,20 @@ export declare const getSpawnOpts: ({ colorSupport, cwd, process, raw, env, }: {
      */
     cwd?: string | undefined;
     /**
-     * Whether to customize the options for spawning processes in raw mode.
-     * Defaults to false.
+     * The file descriptor number at which the channel for inter-process communication
+     * should be set up.
+     */
+    ipc?: number | undefined;
+    /**
+     * Which stdio mode to use. Raw implies inheriting the parent process' stdio.
+     *
+     * - `normal`: all of stdout, stderr and stdin are piped
+     * - `hidden`: stdin is piped, stdout/stderr outputs are ignored
+     * - `raw`: all of stdout, stderr and stdin are inherited from the main process
+     *
+     * Defaults to `normal`.
      */
-    raw?: boolean | undefined;
+    stdio?: "raw" | "hidden" | "normal" | undefined;
     /**
      * Map of custom environment variables to include in the spawn options.
      */

package/dist/src/spawn.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpawnOpts = exports.spawn = void 0;
+const assert_1 = __importDefault(require("assert"));
+const child_process_1 = require("child_process");
+const supports_color_1 = __importDefault(require("supports-color"));
+/**
+ * Spawns a command using `cmd.exe` on Windows, or `/bin/sh` elsewhere.
+ */
+// Implementation based off of https://github.com/mmalecki/spawn-command/blob/v0.0.2-1/lib/spawn-command.js
+function spawn(command, options, 
+// For testing
+spawn = child_process_1.spawn, process = global.process) {
+    let file = '/bin/sh';
+    let args = ['-c', command];
+    if (process.platform === 'win32') {
+        file = 'cmd.exe';
+        args = ['/s', '/c', `"${command}"`];
+        options.windowsVerbatimArguments = true;
+    }
+    return spawn(file, args, options);
+}
+exports.spawn = spawn;
+const getSpawnOpts = ({ colorSupport = supports_color_1.default.stdout, cwd, process = global.process, ipc, stdio = 'normal', env = {}, }) => {
+    const stdioValues = stdio === 'normal'
+        ? ['pipe', 'pipe', 'pipe']
+        : stdio === 'raw'
+            ? ['inherit', 'inherit', 'inherit']
+            : ['pipe', 'ignore', 'ignore'];
+    if (ipc != null) {
+        // Avoid overriding the stdout/stderr/stdin
+        assert_1.default.ok(ipc > 2, '[concurrently] the IPC channel number should be > 2');
+        stdioValues[ipc] = 'ipc';
+    }
+    return {
+        cwd: cwd || process.cwd(),
+        stdio: stdioValues,
+        ...(/^win/.test(process.platform) && { detached: false }),
+        env: {
+            ...(colorSupport ? { FORCE_COLOR: colorSupport.level.toString() } : {}),
+            ...process.env,
+            ...env,
+        },
+    };
+};
+exports.getSpawnOpts = getSpawnOpts;

package/docs/README.md

@@ -0,0 +1,13 @@
+# Concurrently Documentation
+
+## CLI
+
+These articles cover using concurrently through CLI:
+
+- [Prefixing](./cli/prefixing.md)
+- [Output Control](./cli/output-control.md)
+- [Shortcuts](./cli/shortcuts.md)
+- [Restarting Commands](./cli/restarting.md)
+- [Input Handling](./cli/input-handling.md)
+- [Passthrough Arguments](./cli/passthrough-arguments.md)
+- [Configuration](./cli/configuration.md)

package/docs/cli/configuration.md

@@ -0,0 +1,11 @@
+# Configuration
+
+You might want to configure concurrently to always have certain flags on.
+Any of concurrently's flags can be set via environment variables that are prefixed with `CONCURRENTLY_`.
+
+```bash
+$ export CONCURRENTLY_KILL_OTHERS=true
+$ export CONCURRENTLY_HANDLE_INPUT=true
+# Equivalent to passing --kill-others and --handle-input
+$ concurrently nodemon "echo 'hey nodemon, you won't last long'"
+```