concurrently 8.2.2 → 9.0.0

package/dist/src/command.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { ChildProcess as BaseChildProcess, SpawnOptions } from 'child_process';
+import { ChildProcess as BaseChildProcess, MessageOptions, SendHandle, SpawnOptions } from 'child_process';
 import * as Rx from 'rxjs';
 import { EventEmitter, Writable } from 'stream';
 /**
@@ -30,6 +30,13 @@ export interface CommandInfo {
      * Color to use on prefix of the command.
      */
     prefixColor?: string;
+    /**
+     * Whether sending of messages to/from this command (also known as "inter-process communication")
+     * should be enabled, and using which file descriptor number.
+     *
+     * If set, must be > 2.
+     */
+    ipc?: number;
     /**
      * Output command in raw format.
      */
@@ -59,10 +66,18 @@ export interface TimerEvent {
     startDate: Date;
     endDate?: Date;
 }
+export interface MessageEvent {
+    message: object;
+    handle?: SendHandle;
+}
+interface OutgoingMessageEvent extends MessageEvent {
+    options?: MessageOptions;
+    onSent(error?: unknown): void;
+}
 /**
  * Subtype of NodeJS's child_process including only what's actually needed for a command to work.
  */
-export type ChildProcess = EventEmitter & Pick<BaseChildProcess, 'pid' | 'stdin' | 'stdout' | 'stderr'>;
+export type ChildProcess = EventEmitter & Pick<BaseChildProcess, 'pid' | 'stdin' | 'stdout' | 'stderr' | 'send'>;
 /**
  * Interface for a function that must kill the process with `pid`, optionally sending `signal` to it.
  */
@@ -71,6 +86,15 @@ export type KillProcess = (pid: number, signal?: string) => void;
  * Interface for a function that spawns a command and returns its child process instance.
  */
 export type SpawnCommand = (command: string, options: SpawnOptions) => ChildProcess;
+/**
+ * The state of a command.
+ *
+ * - `stopped`: command was never started
+ * - `started`: command is currently running
+ * - `errored`: command failed spawning
+ * - `exited`: command is not running anymore, e.g. it received a close event
+ */
+type CommandState = 'stopped' | 'started' | 'errored' | 'exited';
 export declare class Command implements CommandInfo {
     private readonly killProcess;
     private readonly spawn;
@@ -86,29 +110,45 @@ export declare class Command implements CommandInfo {
     readonly env: Record<string, unknown>;
     /** @inheritdoc */
     readonly cwd?: string;
+    /** @inheritdoc */
+    readonly ipc?: number;
     readonly close: Rx.Subject<CloseEvent>;
     readonly error: Rx.Subject<unknown>;
     readonly stdout: Rx.Subject<Buffer>;
     readonly stderr: Rx.Subject<Buffer>;
     readonly timer: Rx.Subject<TimerEvent>;
+    readonly messages: {
+        incoming: Rx.Subject<MessageEvent>;
+        outgoing: Rx.ReplaySubject<OutgoingMessageEvent>;
+    };
     process?: ChildProcess;
+    private subscriptions;
     stdin?: Writable;
     pid?: number;
     killed: boolean;
     exited: boolean;
-    /** @deprecated */
-    get killable(): boolean;
-    constructor({ index, name, command, prefixColor, env, cwd }: CommandInfo & {
+    state: CommandState;
+    constructor({ index, name, command, prefixColor, env, cwd, ipc }: CommandInfo & {
         index: number;
     }, spawnOpts: SpawnOptions, spawn: SpawnCommand, killProcess: KillProcess);
     /**
      * Starts this command, piping output, error and close events onto the corresponding observables.
      */
     start(): void;
+    private maybeSetupIPC;
+    /**
+     * Sends a message to the underlying process once it starts.
+     *
+     * @throws  If the command doesn't have an IPC channel enabled
+     * @returns Promise that resolves when the message is sent,
+     *          or rejects if it fails to deliver the message.
+     */
+    send(message: object, handle?: SendHandle, options?: MessageOptions): Promise<void>;
     /**
      * Kills this command, optionally specifying a signal to send to it.
      */
     kill(code?: string): void;
+    private cleanUp;
     /**
      * Detects whether a command can be killed.
      *
@@ -119,3 +159,4 @@ export declare class Command implements CommandInfo {
         process: ChildProcess;
     };
 }
+export {};

package/dist/src/command.js

@@ -26,24 +26,47 @@ 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();
-        this.stdout = new Rx.Subject();
-        this.stderr = new Rx.Subject();
-        this.timer = new Rx.Subject();
-        this.killed = false;
-        this.exited = false;
+    killProcess;
+    spawn;
+    spawnOpts;
+    index;
+    /** @inheritdoc */
+    name;
+    /** @inheritdoc */
+    command;
+    /** @inheritdoc */
+    prefixColor;
+    /** @inheritdoc */
+    env;
+    /** @inheritdoc */
+    cwd;
+    /** @inheritdoc */
+    ipc;
+    close = new Rx.Subject();
+    error = new Rx.Subject();
+    stdout = new Rx.Subject();
+    stderr = new Rx.Subject();
+    timer = new Rx.Subject();
+    messages = {
+        incoming: new Rx.Subject(),
+        outgoing: new Rx.ReplaySubject(),
+    };
+    process;
+    // TODO: Should exit/error/stdio subscriptions be added here?
+    subscriptions = [];
+    stdin;
+    pid;
+    killed = false;
+    exited = false;
+    state = 'stopped';
+    constructor({ index, name, command, prefixColor, env, cwd, ipc }, spawnOpts, spawn, killProcess) {
         this.index = index;
         this.name = name;
         this.command = command;
         this.prefixColor = prefixColor;
         this.env = env || {};
         this.cwd = cwd;
+        this.ipc = ipc;
         this.killProcess = killProcess;
         this.spawn = spawn;
         this.spawnOpts = spawnOpts;
@@ -53,22 +76,28 @@ class Command {
      */
     start() {
         const child = this.spawn(this.command, this.spawnOpts);
+        this.state = 'started';
         this.process = child;
         this.pid = child.pid;
         const startDate = new Date(Date.now());
         const highResStartTime = process.hrtime();
         this.timer.next({ startDate });
+        this.subscriptions = [...this.maybeSetupIPC(child)];
         Rx.fromEvent(child, 'error').subscribe((event) => {
-            this.process = undefined;
+            this.cleanUp();
             const endDate = new Date(Date.now());
             this.timer.next({ startDate, endDate });
             this.error.next(event);
+            this.state = 'errored';
         });
         Rx.fromEvent(child, 'close')
             .pipe(Rx.map((event) => event))
             .subscribe(([exitCode, signal]) => {
-            this.process = undefined;
-            this.exited = true;
+            this.cleanUp();
+            // Don't override error event
+            if (this.state !== 'errored') {
+                this.state = 'exited';
+            }
             const endDate = new Date(Date.now());
             this.timer.next({ startDate, endDate });
             const [durationSeconds, durationNanoSeconds] = process.hrtime(highResStartTime);
@@ -90,6 +119,47 @@ class Command {
             pipeTo(Rx.fromEvent(child.stderr, 'data').pipe(Rx.map((event) => event)), this.stderr);
         this.stdin = child.stdin || undefined;
     }
+    maybeSetupIPC(child) {
+        if (!this.ipc) {
+            return [];
+        }
+        return [
+            pipeTo(Rx.fromEvent(child, 'message').pipe(Rx.map((event) => {
+                const [message, handle] = event;
+                return { message, handle };
+            })), this.messages.incoming),
+            this.messages.outgoing.subscribe((message) => {
+                if (!child.send) {
+                    return message.onSent(new Error('Command does not have an IPC channel'));
+                }
+                child.send(message.message, message.handle, message.options, (error) => {
+                    message.onSent(error);
+                });
+            }),
+        ];
+    }
+    /**
+     * Sends a message to the underlying process once it starts.
+     *
+     * @throws  If the command doesn't have an IPC channel enabled
+     * @returns Promise that resolves when the message is sent,
+     *          or rejects if it fails to deliver the message.
+     */
+    send(message, handle, options) {
+        if (this.ipc == null) {
+            throw new Error('Command IPC is disabled');
+        }
+        return new Promise((resolve, reject) => {
+            this.messages.outgoing.next({
+                message,
+                handle,
+                options,
+                onSent(error) {
+                    error ? reject(error) : resolve();
+                },
+            });
+        });
+    }
     /**
      * Kills this command, optionally specifying a signal to send to it.
      */
@@ -99,6 +169,11 @@ class Command {
             this.killProcess(this.pid, code);
         }
     }
+    cleanUp() {
+        this.subscriptions?.forEach((sub) => sub.unsubscribe());
+        this.messages.outgoing = new Rx.ReplaySubject();
+        this.process = undefined;
+    }
     /**
      * Detects whether a command can be killed.
      *
@@ -113,5 +188,5 @@ exports.Command = Command;
  * Pipes all events emitted by `stream` into `subject`.
  */
 function pipeTo(stream, subject) {
-    stream.subscribe((event) => subject.next(event));
+    return stream.subscribe((event) => subject.next(event));
 }

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import * as Rx from 'rxjs';
 import { CloseEvent, Command } from './command';
 /**
@@ -34,7 +35,9 @@ export declare class CompletionListener {
      * Given a list of commands, wait for all of them to exit and then evaluate their exit codes.
      *
      * @returns A Promise that resolves if the success condition is met, or rejects otherwise.
+     *          In either case, the value is a list of close events for commands that spawned.
+     *          Commands that didn't spawn are filtered out.
      */
-    listen(commands: Command[]): Promise<CloseEvent[]>;
+    listen(commands: Command[], abortSignal?: AbortSignal): Promise<CloseEvent[]>;
     private emitWithScheduler;
 }

package/dist/src/completion-listener.js

@@ -30,11 +30,17 @@ const operators_1 = require("rxjs/operators");
  * Provides logic to determine whether lists of commands ran successfully.
  */
 class CompletionListener {
+    successCondition;
+    scheduler;
     constructor({ successCondition = 'all', scheduler, }) {
         this.successCondition = successCondition;
         this.scheduler = scheduler;
     }
     isSuccess(events) {
+        if (!events.length) {
+            // When every command was aborted, consider a success.
+            return true;
+        }
         if (this.successCondition === 'first') {
             return events[0].exitCode === 0;
         }
@@ -52,7 +58,7 @@ class CompletionListener {
         const nameOrIndex = commandSyntaxMatch[1];
         const targetCommandsEvents = events.filter(({ command, index }) => command.name === nameOrIndex || index === Number(nameOrIndex));
         if (this.successCondition.startsWith('!')) {
-            // All commands except the specified ones must exit succesfully
+            // All commands except the specified ones must exit successfully
             return events.every((event) => targetCommandsEvents.includes(event) || event.exitCode === 0);
         }
         // Only the specified commands must exit succesfully
@@ -63,12 +69,27 @@ class CompletionListener {
      * Given a list of commands, wait for all of them to exit and then evaluate their exit codes.
      *
      * @returns A Promise that resolves if the success condition is met, or rejects otherwise.
+     *          In either case, the value is a list of close events for commands that spawned.
+     *          Commands that didn't spawn are filtered out.
      */
-    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)
-            ? this.emitWithScheduler(Rx.of(exitInfos))
-            : this.emitWithScheduler(Rx.throwError(() => exitInfos))), (0, operators_1.take)(1)));
+    listen(commands, abortSignal) {
+        const abort = abortSignal &&
+            Rx.fromEvent(abortSignal, 'abort', { once: true }).pipe(
+            // The abort signal must happen before commands are killed, otherwise new commands
+            // might spawn. Because of this, it's not be possible to capture the close events
+            // without an immediate delay
+            (0, operators_1.delay)(0, this.scheduler), (0, operators_1.map)(() => undefined));
+        const closeStreams = commands.map((command) => abort
+            ? // Commands that have been started must close.
+                Rx.race(command.close, abort.pipe((0, operators_1.filter)(() => command.state === 'stopped')))
+            : command.close);
+        return Rx.lastValueFrom(Rx.combineLatest(closeStreams).pipe((0, operators_1.filter)(() => commands.every((command) => command.state !== 'started')), (0, operators_1.map)((events) => events
+            // Filter out aborts, since they cannot be sorted and are considered success condition anyways
+            .filter((event) => event != null)
+            // Sort according to exit time
+            .sort((first, second) => first.timings.endDate.getTime() - second.timings.endDate.getTime())), (0, operators_1.switchMap)((events) => this.isSuccess(events)
+            ? this.emitWithScheduler(Rx.of(events))
+            : this.emitWithScheduler(Rx.throwError(() => events))), (0, operators_1.take)(1)));
     }
     emitWithScheduler(input) {
         return this.scheduler ? input.pipe(Rx.observeOn(this.scheduler)) : input;

package/dist/src/concurrently.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Writable } from 'stream';
-import { CloseEvent, Command, CommandInfo, KillProcess, SpawnCommand } from './command';
+import { CloseEvent, Command, CommandIdentifier, CommandInfo, KillProcess, SpawnCommand } from './command';
 import { SuccessCondition } from './completion-listener';
 import { FlowController } from './flow-control/flow-controller';
 import { Logger } from './logger';
@@ -21,7 +22,8 @@ export type ConcurrentlyResult = {
      * A promise that resolves when concurrently ran successfully according to the specified
      * success condition, or reject otherwise.
      *
-     * Both the resolved and rejected value is the list of all command's close events.
+     * Both the resolved and rejected value is a list of all the close events for commands that
+     * spawned; commands that didn't spawn are filtered out.
      */
     result: Promise<CloseEvent[]>;
 };
@@ -49,9 +51,11 @@ export type ConcurrentlyOptions = {
      * Available background colors:
      * - `bgBlack`, `bgRed`, `bgGreen`, `bgYellow`, `bgBlue`, `bgMagenta`, `bgCyan`, `bgWhite`
      *
+     * Set to `false` to disable colors.
+     *
      * @see {@link https://www.npmjs.com/package/chalk} for more information.
      */
-    prefixColors?: string | string[];
+    prefixColors?: string | string[] | false;
     /**
      * Maximum number of commands to run at once.
      * Exact number or a percent of CPUs available (for example "50%").
@@ -65,6 +69,10 @@ export type ConcurrentlyOptions = {
      * Defaults to false.
      */
     raw?: boolean;
+    /**
+     * Which commands should have their output hidden.
+     */
+    hide?: CommandIdentifier[];
     /**
      * The current working directory of commands which didn't specify one.
      * Defaults to `process.cwd()`.
@@ -74,6 +82,10 @@ export type ConcurrentlyOptions = {
      * @see CompletionListener
      */
     successCondition?: SuccessCondition;
+    /**
+     * A signal to stop spawning further processes.
+     */
+    abortSignal?: AbortSignal;
     /**
      * Which flow controllers should be applied on commands spawned by concurrently.
      * Defaults to an empty array.
@@ -81,7 +93,7 @@ export type ConcurrentlyOptions = {
     controllers: FlowController[];
     /**
      * A function that will spawn commands.
-     * Defaults to the `spawn-command` module.
+     * Defaults to a function that spawns using either `cmd.exe` or `/bin/sh`.
      */
     spawn: SpawnCommand;
     /**

package/dist/src/concurrently.js

@@ -7,7 +7,6 @@ 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");
 const expand_arguments_1 = require("./command-parser/expand-arguments");
@@ -15,11 +14,11 @@ 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 prefix_color_selector_1 = require("./prefix-color-selector");
+const spawn_1 = require("./spawn");
 const defaults = {
-    spawn: spawn_command_1.default,
+    spawn: spawn_1.spawn,
     kill: tree_kill_1.default,
     raw: false,
     controllers: [],
@@ -35,7 +34,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 prefixColorSelector = new prefix_color_selector_1.PrefixColorSelector(options.prefixColors || []);
     const commandParsers = [
         new strip_quotes_1.StripQuotes(),
         new expand_npm_shortcut_1.ExpandNpmShortcut(),
@@ -44,16 +43,19 @@ function concurrently(baseCommands, baseOptions) {
     if (options.additionalArguments) {
         commandParsers.push(new expand_arguments_1.ExpandArguments(options.additionalArguments));
     }
+    const hide = (options.hide || []).map(String);
     let commands = (0, lodash_1.default)(baseCommands)
         .map(mapToCommandInfo)
         .flatMap((command) => parseCommand(command, commandParsers))
         .map((command, index) => {
+        const hidden = hide.includes(command.name) || hide.includes(String(index));
         return new command_1.Command({
             index,
             prefixColor: prefixColorSelector.getNextColor(),
             ...command,
-        }, (0, get_spawn_opts_1.getSpawnOpts)({
-            raw: command.raw ?? options.raw,
+        }, (0, spawn_1.getSpawnOpts)({
+            ipc: command.ipc,
+            stdio: hidden ? 'hidden' : command.raw ?? options.raw ? 'raw' : 'normal',
             env: command.env,
             cwd: command.cwd || options.cwd,
         }), options.spawn, options.kill);
@@ -80,13 +82,11 @@ function concurrently(baseCommands, baseOptions) {
         ? 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);
+        maybeRunMore(commandsLeft, options.abortSignal);
     }
     const result = new completion_listener_1.CompletionListener({ successCondition: options.successCondition })
-        .listen(commands)
-        .finally(() => {
-        handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());
-    });
+        .listen(commands, options.abortSignal)
+        .finally(() => Promise.all(handleResult.onFinishCallbacks.map((onFinish) => onFinish())));
     return {
         result,
         commands,
@@ -103,6 +103,7 @@ function mapToCommandInfo(command) {
         name: command.name || '',
         env: command.env || {},
         cwd: command.cwd || '',
+        ipc: command.ipc,
         ...(command.prefixColor
             ? {
                 prefixColor: command.prefixColor,
@@ -118,13 +119,13 @@ function mapToCommandInfo(command) {
 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) {
+function maybeRunMore(commandsLeft, abortSignal) {
     const command = commandsLeft.shift();
-    if (!command) {
+    if (!command || abortSignal?.aborted) {
         return;
     }
     command.start();
     command.close.subscribe(() => {
-        maybeRunMore(commandsLeft);
+        maybeRunMore(commandsLeft, abortSignal);
     });
 }

package/dist/src/date-format.d.ts

@@ -0,0 +1,19 @@
+export type FormatterOptions = {
+    locale?: string;
+    calendar?: string;
+};
+/**
+ * Unicode-compliant date/time formatter.
+ *
+ * @see https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
+ */
+export declare class DateFormatter {
+    private readonly options;
+    private static tokenRegex;
+    private readonly parts;
+    constructor(pattern: string, options?: FormatterOptions);
+    private compileLiteral;
+    private compileOther;
+    private compileToken;
+    format(date: Date): string;
+}