concurrently 6.5.1 → 7.2.0

package/dist/src/concurrently.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrently = void 0;
+const assert_1 = __importDefault(require("assert"));
+const lodash_1 = __importDefault(require("lodash"));
+const spawn_command_1 = __importDefault(require("spawn-command"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const command_1 = require("./command");
+const expand_arguments_1 = require("./command-parser/expand-arguments");
+const expand_npm_shortcut_1 = require("./command-parser/expand-npm-shortcut");
+const expand_npm_wildcard_1 = require("./command-parser/expand-npm-wildcard");
+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 defaults = {
+    spawn: spawn_command_1.default,
+    kill: tree_kill_1.default,
+    raw: false,
+    controllers: [],
+    cwd: undefined,
+};
+/**
+ * Core concurrently functionality -- spawns the given commands concurrently and
+ * returns the commands themselves + the result according to the specified success condition.
+ *
+ * @see CompletionListener
+ */
+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 commandParsers = [
+        new strip_quotes_1.StripQuotes(),
+        new expand_npm_shortcut_1.ExpandNpmShortcut(),
+        new expand_npm_wildcard_1.ExpandNpmWildcard(),
+    ];
+    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(Object.assign({
+            index,
+            prefixColor: lastColor,
+        }, command), (0, get_spawn_opts_1.getSpawnOpts)({
+            raw: options.raw,
+            env: command.env,
+            cwd: command.cwd || options.cwd,
+        }), options.spawn, options.kill);
+    })
+        .value();
+    const handleResult = options.controllers.reduce(({ commands: prevCommands, onFinishCallbacks }, controller) => {
+        const { commands, onFinish } = controller.handle(prevCommands);
+        return {
+            commands,
+            onFinishCallbacks: lodash_1.default.concat(onFinishCallbacks, onFinish ? [onFinish] : []),
+        };
+    }, { commands, onFinishCallbacks: [] });
+    commands = handleResult.commands;
+    if (options.logger) {
+        const outputWriter = new output_writer_1.OutputWriter({
+            outputStream: options.outputStream,
+            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);
+    for (let i = 0; i < maxProcesses; i++) {
+        maybeRunMore(commandsLeft);
+    }
+    const result = new completion_listener_1.CompletionListener({ successCondition: options.successCondition })
+        .listen(commands)
+        .finally(() => {
+        handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());
+    });
+    return {
+        result,
+        commands,
+    };
+}
+exports.concurrently = concurrently;
+;
+function mapToCommandInfo(command) {
+    if (typeof command === 'string') {
+        return {
+            command,
+            name: '',
+            env: {},
+            cwd: '',
+        };
+    }
+    return Object.assign({
+        command: command.command,
+        name: command.name || '',
+        env: command.env || {},
+        cwd: command.cwd || '',
+    }, command.prefixColor ? {
+        prefixColor: command.prefixColor,
+    } : {});
+}
+function parseCommand(command, parsers) {
+    return parsers.reduce((commands, parser) => lodash_1.default.flatMap(commands, command => parser.parse(command)), lodash_1.default.castArray(command));
+}
+function maybeRunMore(commandsLeft) {
+    const command = commandsLeft.shift();
+    if (!command) {
+        return;
+    }
+    command.start();
+    command.close.subscribe(() => {
+        maybeRunMore(commandsLeft);
+    });
+}

package/dist/src/defaults.d.ts

@@ -0,0 +1,62 @@
+import { SuccessCondition } from './completion-listener';
+export declare const defaultInputTarget = 0;
+/**
+ * Whether process.stdin should be forwarded to child processes.
+ */
+export declare const handleInput = false;
+/**
+ * How many processes to run at once.
+ */
+export declare const maxProcesses = 0;
+/**
+ * Indices and names of commands whose output are not to be logged.
+ */
+export declare const hide = "";
+/**
+ * The character to split <names> on.
+ */
+export declare const nameSeparator = ",";
+/**
+ * Which prefix style to use when logging processes output.
+ */
+export declare const prefix = "";
+/**
+ * Default prefix color.
+ * @see https://www.npmjs.com/package/chalk
+ */
+export declare const prefixColors = "reset";
+/**
+ * How many bytes we'll show on the command prefix.
+ */
+export declare const prefixLength = 10;
+export declare const raw = false;
+/**
+ * Number of attempts of restarting a process, if it exits with non-0 code.
+ */
+export declare const restartTries = 0;
+/**
+ * How many milliseconds concurrently should wait before restarting a process.
+ */
+export declare const restartDelay = 0;
+/**
+ * Condition of success for concurrently itself.
+ */
+export declare const success: SuccessCondition;
+/**
+ * Date format used when logging date/time.
+ * @see https://date-fns.org/v2.0.1/docs/format
+ */
+export declare const timestampFormat = "yyyy-MM-dd HH:mm:ss.SSS";
+/**
+ * Current working dir passed as option to spawn command.
+ * Defaults to process.cwd()
+ */
+export declare const cwd: string | undefined;
+/**
+ * Whether to show timing information for processes in console output.
+ */
+export declare const timings = false;
+/**
+ * Passthrough additional arguments to commands (accessible via placeholders) instead of treating them as commands.
+ */
+export declare const passthroughArguments = false;

package/dist/src/defaults.js

@@ -0,0 +1,67 @@
+"use strict";
+// This file is meant to be a shared place for default configs.
+// It's read by the flow controllers, the executable, etc.
+// Refer to tests for the meaning of the different possible values.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passthroughArguments = exports.timings = exports.cwd = exports.timestampFormat = exports.success = exports.restartDelay = exports.restartTries = exports.raw = exports.prefixLength = exports.prefixColors = exports.prefix = exports.nameSeparator = exports.hide = exports.maxProcesses = exports.handleInput = exports.defaultInputTarget = void 0;
+exports.defaultInputTarget = 0;
+/**
+ * Whether process.stdin should be forwarded to child processes.
+ */
+exports.handleInput = false;
+/**
+ * How many processes to run at once.
+ */
+exports.maxProcesses = 0;
+/**
+ * Indices and names of commands whose output are not to be logged.
+ */
+exports.hide = '';
+/**
+ * The character to split <names> on.
+ */
+exports.nameSeparator = ',';
+/**
+ * Which prefix style to use when logging processes output.
+ */
+exports.prefix = '';
+/**
+ * Default prefix color.
+ * @see https://www.npmjs.com/package/chalk
+ */
+exports.prefixColors = 'reset';
+/**
+ * How many bytes we'll show on the command prefix.
+ */
+exports.prefixLength = 10;
+exports.raw = false;
+/**
+ * Number of attempts of restarting a process, if it exits with non-0 code.
+ */
+exports.restartTries = 0;
+/**
+ * How many milliseconds concurrently should wait before restarting a process.
+ */
+exports.restartDelay = 0;
+/**
+ * Condition of success for concurrently itself.
+ */
+exports.success = 'all';
+/**
+ * Date format used when logging date/time.
+ * @see https://date-fns.org/v2.0.1/docs/format
+ */
+exports.timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
+/**
+ * Current working dir passed as option to spawn command.
+ * Defaults to process.cwd()
+ */
+exports.cwd = undefined;
+/**
+ * Whether to show timing information for processes in console output.
+ */
+exports.timings = false;
+/**
+ * Passthrough additional arguments to commands (accessible via placeholders) instead of treating them as commands.
+ */
+exports.passthroughArguments = false;

package/dist/src/flow-control/flow-controller.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../command';
+/**
+ * Interface for a class that controls and/or watches the behavior of commands.
+ *
+ * This may include logging their output, creating interactions between them, or changing when they
+ * actually finish.
+ */
+export interface FlowController {
+    handle(commands: Command[]): {
+        commands: Command[];
+        onFinish?: () => void;
+    };
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Command, CommandIdentifier } from '../command';
+import { Logger } from '../logger';
+import { FlowController } from './flow-controller';
+/**
+ * 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.
+ */
+export declare class InputHandler implements FlowController {
+    private readonly logger;
+    private readonly defaultInputTarget;
+    private readonly inputStream;
+    private readonly pauseInputStreamOnFinish;
+    constructor({ defaultInputTarget, inputStream, pauseInputStreamOnFinish, logger }: {
+        inputStream: Readable;
+        logger: Logger;
+        defaultInputTarget?: CommandIdentifier;
+        pauseInputStreamOnFinish?: boolean;
+    });
+    handle(commands: Command[]): {
+        commands: Command[];
+        onFinish?: undefined;
+    } | {
+        commands: Command[];
+        onFinish: () => void;
+    };
+}

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,19 +18,20 @@ 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 });
                 }));
                 return new Proxy(command, {
                     get(target, prop) {
                         return prop === 'close' ? closeStream : target[prop];
-                    }
+                    },
                 });
-            })
+            }),
         };
     }
-};
+}
+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 {};