concurrently 6.5.0 → 7.1.0

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

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.InputHandler = void 0;
+const Rx = __importStar(require("rxjs"));
+const operators_1 = require("rxjs/operators");
+const defaults = __importStar(require("../defaults"));
+/**
+ * Sends input from concurrently through to commands.
+ *
+ * Input can start with a command identifier, in which case it will be sent to that specific command.
+ * For instance, `0:bla` will send `bla` to command at index `0`, and `server:stop` will send `stop`
+ * to command with name `server`.
+ *
+ * If the input doesn't start with a command identifier, it is then always sent to the default target.
+ */
+class InputHandler {
+    constructor({ defaultInputTarget, inputStream, pauseInputStreamOnFinish, logger }) {
+        this.logger = logger;
+        this.defaultInputTarget = defaultInputTarget || defaults.defaultInputTarget;
+        this.inputStream = inputStream;
+        this.pauseInputStreamOnFinish = pauseInputStreamOnFinish !== false;
+    }
+    handle(commands) {
+        if (!this.inputStream) {
+            return { commands };
+        }
+        Rx.fromEvent(this.inputStream, 'data')
+            .pipe((0, operators_1.map)(data => data.toString()))
+            .subscribe(data => {
+            const dataParts = data.split(/:(.+)/);
+            const targetId = dataParts.length > 1 ? dataParts[0] : this.defaultInputTarget;
+            const input = dataParts[1] || data;
+            const command = commands.find(command => (command.name === targetId ||
+                command.index.toString() === targetId.toString()));
+            if (command && command.stdin) {
+                command.stdin.write(input);
+            }
+            else {
+                this.logger.logGlobalEvent(`Unable to find command ${targetId}, or it has no stdin open\n`);
+            }
+        });
+        return {
+            commands,
+            onFinish: () => {
+                if (this.pauseInputStreamOnFinish) {
+                    // https://github.com/kimmobrunfeldt/concurrently/issues/252
+                    this.inputStream.pause();
+                }
+            },
+        };
+    }
+}
+exports.InputHandler = InputHandler;
+;

package/dist/src/flow-control/kill-on-signal.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Command } from '../command';
+import { FlowController } from './flow-controller';
+/**
+ * Watches the main concurrently process for signals and sends the same signal down to each spawned
+ * command.
+ */
+export declare class KillOnSignal implements FlowController {
+    private readonly process;
+    constructor({ process }: {
+        process: EventEmitter;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+    };
+}

package/{src → dist/src}/flow-control/kill-on-signal.js

@@ -1,14 +1,15 @@
-const { map } = require('rxjs/operators');
-
-const BaseHandler = require('./base-handler');
-
-module.exports = class KillOnSignal extends BaseHandler {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KillOnSignal = void 0;
+const operators_1 = require("rxjs/operators");
+/**
+ * Watches the main concurrently process for signals and sends the same signal down to each spawned
+ * command.
+ */
+class KillOnSignal {
     constructor({ process }) {
-        super();
-
         this.process = process;
     }
-
     handle(commands) {
         let caughtSignal;
         ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach(signal => {
@@ -17,10 +18,9 @@ module.exports = class KillOnSignal extends BaseHandler {
                 commands.forEach(command => command.kill(signal));
             });
         });
-
         return {
             commands: commands.map(command => {
-                const closeStream = command.close.pipe(map(exitInfo => {
+                const closeStream = command.close.pipe((0, operators_1.map)(exitInfo => {
                     const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
                     return Object.assign({}, exitInfo, { exitCode });
                 }));
@@ -32,4 +32,6 @@ module.exports = class KillOnSignal extends BaseHandler {
             })
         };
     }
-};
+}
+exports.KillOnSignal = KillOnSignal;
+;

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KillOthers = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const operators_1 = require("rxjs/operators");
+/**
+ * Sends a SIGTERM signal to all commands when one of the exits with a matching condition.
+ */
+class KillOthers {
+    constructor({ logger, conditions }) {
+        this.logger = logger;
+        this.conditions = lodash_1.default.castArray(conditions);
+    }
+    handle(commands) {
+        const conditions = this.conditions.filter(condition => (condition === 'failure' ||
+            condition === 'success'));
+        if (!conditions.length) {
+            return { commands };
+        }
+        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);
+            if (killableCommands.length) {
+                this.logger.logGlobalEvent('Sending SIGTERM to other processes..');
+                killableCommands.forEach(command => command.kill());
+            }
+        }));
+        return { commands };
+    }
+}
+exports.KillOthers = KillOthers;
+;

package/dist/src/flow-control/log-error.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+/**
+ * Logs when commands failed executing, e.g. due to the executable not existing in the system.
+ */
+export declare class LogError implements FlowController {
+    private readonly logger;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+    };
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogError = void 0;
+/**
+ * Logs when commands failed executing, e.g. due to the executable not existing in the system.
+ */
+class LogError {
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+    handle(commands) {
+        commands.forEach(command => command.error.subscribe(event => {
+            this.logger.logCommandEvent(`Error occurred when executing command: ${command.command}`, command);
+            const errorText = String(event instanceof Error ? (event.stack || event) : event);
+            this.logger.logCommandEvent(errorText, command);
+        }));
+        return { commands };
+    }
+}
+exports.LogError = LogError;
+;

package/dist/src/flow-control/log-exit.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+/**
+ * Logs the exit code/signal of commands.
+ */
+export declare class LogExit implements FlowController {
+    private readonly logger;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+    };
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogExit = void 0;
+/**
+ * Logs the exit code/signal of commands.
+ */
+class LogExit {
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+    handle(commands) {
+        commands.forEach(command => command.close.subscribe(({ exitCode }) => {
+            this.logger.logCommandEvent(`${command.command} exited with code ${exitCode}`, command);
+        }));
+        return { commands };
+    }
+}
+exports.LogExit = LogExit;
+;

package/dist/src/flow-control/log-output.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+/**
+ * Logs the stdout and stderr output of commands.
+ */
+export declare class LogOutput implements FlowController {
+    private readonly logger;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+    };
+}

package/{src → dist/src}/flow-control/log-output.js

@@ -1,12 +1,20 @@
-const BaseHandler = require('./base-handler');
-
-module.exports = class LogOutput extends BaseHandler {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogOutput = void 0;
+/**
+ * Logs the stdout and stderr output of commands.
+ */
+class LogOutput {
+    constructor({ logger }) {
+        this.logger = logger;
+    }
     handle(commands) {
         commands.forEach(command => {
             command.stdout.subscribe(text => this.logger.logCommandText(text.toString(), command));
             command.stderr.subscribe(text => this.logger.logCommandText(text.toString(), command));
         });
-
         return { commands };
     }
-};
+}
+exports.LogOutput = LogOutput;
+;

package/dist/src/flow-control/log-timings.d.ts

@@ -0,0 +1,27 @@
+import { CloseEvent, Command } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+interface TimingInfo {
+    name: string;
+    duration: string;
+    'exit code': string | number;
+    killed: boolean;
+    command: string;
+}
+/**
+ * Logs timing information about commands as they start/stop and then a summary when all commands finish.
+ */
+export declare class LogTimings implements FlowController {
+    static mapCloseEventToTimingInfo({ command, timings, killed, exitCode }: CloseEvent): TimingInfo;
+    private readonly logger?;
+    private readonly timestampFormat;
+    constructor({ logger, timestampFormat }: {
+        logger?: Logger;
+        timestampFormat?: string;
+    });
+    printExitInfoTimingTable(exitInfos: CloseEvent[]): CloseEvent[];
+    handle(commands: Command[]): {
+        commands: Command[];
+    };
+}
+export {};

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

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogTimings = void 0;
+const format_1 = __importDefault(require("date-fns/format"));
+const lodash_1 = __importDefault(require("lodash"));
+const Rx = __importStar(require("rxjs"));
+const operators_1 = require("rxjs/operators");
+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 {
+            name: command.name,
+            duration: readableDurationMs,
+            'exit code': exitCode,
+            killed,
+            command: command.command,
+        };
+    }
+    printExitInfoTimingTable(exitInfos) {
+        var _a, _b;
+        const exitInfoTable = (0, lodash_1.default)(exitInfos)
+            .sortBy(({ timings }) => timings.durationSeconds)
+            .reverse()
+            .map(LogTimings.mapCloseEventToTimingInfo)
+            .value();
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.logGlobalEvent('Timings:');
+        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.logTable(exitInfoTable);
+        return exitInfos;
+    }
+    ;
+    handle(commands) {
+        if (!this.logger) {
+            return { commands };
+        }
+        // individual process timings
+        commands.forEach(command => {
+            command.timer.subscribe(({ startDate, endDate }) => {
+                var _a, _b;
+                if (!endDate) {
+                    const formattedStartDate = (0, format_1.default)(startDate, this.timestampFormat);
+                    (_a = this.logger) === null || _a === void 0 ? void 0 : _a.logCommandEvent(`${command.command} started at ${formattedStartDate}`, command);
+                }
+                else {
+                    const durationMs = endDate.getTime() - startDate.getTime();
+                    const formattedEndDate = (0, format_1.default)(endDate, this.timestampFormat);
+                    (_b = this.logger) === null || _b === void 0 ? void 0 : _b.logCommandEvent(`${command.command} stopped at ${formattedEndDate} after ${durationMs.toLocaleString()}ms`, command);
+                }
+            });
+        });
+        // overall summary timings
+        const closeStreams = commands.map(command => command.close);
+        const allProcessesClosed = Rx.merge(...closeStreams).pipe((0, operators_1.bufferCount)(closeStreams.length), (0, operators_1.take)(1));
+        allProcessesClosed.subscribe((exitInfos) => this.printExitInfoTimingTable(exitInfos));
+        return { commands };
+    }
+}
+exports.LogTimings = LogTimings;
+;

package/dist/src/flow-control/restart-process.d.ts

@@ -0,0 +1,22 @@
+import * as Rx from 'rxjs';
+import { Command } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+/**
+ * Restarts commands that fail up to a defined number of times.
+ */
+export declare class RestartProcess implements FlowController {
+    private readonly logger;
+    private readonly scheduler?;
+    readonly delay: number;
+    readonly tries: number;
+    constructor({ delay, tries, logger, scheduler }: {
+        delay?: number;
+        tries?: number;
+        logger: Logger;
+        scheduler?: Rx.SchedulerLike;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+    };
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.RestartProcess = void 0;
+const Rx = __importStar(require("rxjs"));
+const operators_1 = require("rxjs/operators");
+const defaults = __importStar(require("../defaults"));
+/**
+ * Restarts commands that fail up to a defined number of times.
+ */
+class RestartProcess {
+    constructor({ delay, tries, logger, scheduler }) {
+        this.logger = logger;
+        this.delay = delay != null ? +delay : defaults.restartDelay;
+        this.tries = tries != null ? +tries : defaults.restartTries;
+        this.tries = this.tries < 0 ? Infinity : this.tries;
+        this.scheduler = scheduler;
+    }
+    handle(commands) {
+        if (this.tries === 0) {
+            return { commands };
+        }
+        commands.map(command => command.close.pipe((0, operators_1.take)(this.tries), (0, operators_1.takeWhile)(({ exitCode }) => exitCode !== 0))).map((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((0, operators_1.delay)(this.delay, this.scheduler), (0, operators_1.mapTo)(true)), 
+        // Skip the first N emissions (as these would be duplicates of the above),
+        // meaning it will be empty because of success, or failed all N times,
+        // and no more restarts should be attempted.
+        failure.pipe((0, operators_1.skip)(this.tries), (0, operators_1.mapTo)(false), (0, operators_1.defaultIfEmpty)(false))).subscribe(restart => {
+            const command = commands[index];
+            if (restart) {
+                this.logger.logCommandEvent(`${command.command} restarted`, command);
+                command.start();
+            }
+        }));
+        return {
+            commands: commands.map(command => {
+                const closeStream = command.close.pipe((0, operators_1.filter)(({ exitCode }, emission) => {
+                    // We let all success codes pass, and failures only after restarting won't happen again
+                    return exitCode === 0 || emission >= this.tries;
+                }));
+                return new Proxy(command, {
+                    get(target, prop) {
+                        return prop === 'close' ? closeStream : target[prop];
+                    }
+                });
+            })
+        };
+    }
+}
+exports.RestartProcess = RestartProcess;
+;

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

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { SpawnOptions } from 'child_process';
+import supportsColor from 'supports-color';
+export declare const getSpawnOpts: ({ colorSupport, cwd, process, raw, env, }: {
+    /**
+     * What the color support of the spawned processes should be.
+     * If set to `false`, then no colors should be output.
+     *
+     * Defaults to whatever the terminal's stdout support is.
+     */
+    colorSupport?: Pick<supportsColor.supportsColor.Level, 'level'> | false;
+    /**
+     * The NodeJS process.
+     */
+    process?: Pick<NodeJS.Process, 'cwd' | 'platform' | 'env'>;
+    /**
+     * A custom working directory to spawn processes in.
+     * Defaults to `process.cwd()`.
+     */
+    cwd?: string;
+    /**
+     * Whether to customize the options for spawning processes in raw mode.
+     * Defaults to false.
+     */
+    raw?: boolean;
+    /**
+     * Map of custom environment variables to include in the spawn options.
+     */
+    env?: Record<string, any>;
+}) => SpawnOptions;

package/dist/src/get-spawn-opts.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpawnOpts = void 0;
+const supports_color_1 = __importDefault(require("supports-color"));
+const getSpawnOpts = ({ colorSupport = supports_color_1.default.stdout, cwd, process = global.process, raw = false, env = {}, }) => Object.assign({
+    cwd: cwd || process.cwd(),
+}, raw && { stdio: 'inherit' }, /^win/.test(process.platform) && { detached: false }, { env: Object.assign(colorSupport ? { FORCE_COLOR: colorSupport.level } : {}, process.env, env) });
+exports.getSpawnOpts = getSpawnOpts;

package/dist/src/index.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { CloseEvent, Command, CommandIdentifier, TimerEvent } from './command';
+import { concurrently, 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';
+import { KillOthers, ProcessCloseCondition } from './flow-control/kill-others';
+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 { Logger } from './logger';
+export declare type ConcurrentlyOptions = BaseConcurrentlyOptions & {
+    /**
+     * Which command(s) should have their output hidden.
+     */
+    hide?: CommandIdentifier | CommandIdentifier[];
+    /**
+     * The prefix format to use when logging a command's output.
+     * Defaults to the command's index.
+     */
+    prefix?: string;
+    /**
+     * How many characters should a prefix have at most, used when the prefix format is `command`.
+     */
+    prefixLength?: number;
+    /**
+     * 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
+     */
+    timestampFormat?: string;
+    defaultInputTarget?: CommandIdentifier;
+    inputStream?: Readable;
+    handleInput?: boolean;
+    pauseInputStreamOnFinish?: boolean;
+    /**
+     * How much time in milliseconds to wait before restarting a command.
+     *
+     * @see RestartProcess
+     */
+    restartDelay?: number;
+    /**
+     * How many times commands should be restarted when they exit with a failure.
+     *
+     * @see RestartProcess
+     */
+    restartTries?: number;
+    /**
+     * Under which condition(s) should other commands be killed when the first one exits.
+     *
+     * @see KillOthers
+     */
+    killOthers?: ProcessCloseCondition | ProcessCloseCondition[];
+    /**
+     * Whether to output timing information for processes.
+     *
+     * @see LogTimings
+     */
+    timings?: boolean;
+};
+declare const _default: (commands: ConcurrentlyCommandInput[], options?: Partial<ConcurrentlyOptions>) => ConcurrentlyResult;
+export default _default;
+export { concurrently, ConcurrentlyCommandInput, ConcurrentlyResult, Logger, Command, CloseEvent, TimerEvent, CommandIdentifier, FlowController, InputHandler, KillOnSignal, KillOthers, LogError, LogExit, LogOutput, LogTimings, RestartProcess, };