concurrently 9.2.1 → 10.0.1

package/dist/lib/index.js

@@ -0,0 +1,98 @@
+import process from 'node:process';
+import { assertNotRuntime } from './assert.js';
+import { Command } from './command.js';
+import { concurrently as createConcurrently, } from './concurrently.js';
+import { InputHandler } from './flow-control/input-handler.js';
+import { KillOnSignal } from './flow-control/kill-on-signal.js';
+import { KillOthers } from './flow-control/kill-others.js';
+import { LogError } from './flow-control/log-error.js';
+import { LogExit } from './flow-control/log-exit.js';
+import { LogOutput } from './flow-control/log-output.js';
+import { LogTimings } from './flow-control/log-timings.js';
+import { LoggerPadding } from './flow-control/logger-padding.js';
+import { OutputErrorHandler } from './flow-control/output-error-handler.js';
+import { RestartProcess } from './flow-control/restart-process.js';
+import { Teardown } from './flow-control/teardown.js';
+import { Logger } from './logger.js';
+import { createSpawn } from './spawn.js';
+import { castArray } from './utils.js';
+export function concurrently(commands, options = {}) {
+    assertNotRuntime(
+    // When run via /snap/bin/node, process.execPath maps to the actual snap path, but it also sets
+    // several SNAP_* env variables. If the snap is run directly via e.g. /snap/node/current/bin/node,
+    // the issues don't happen and no env variables are set.
+    !String(process.env.SNAP).startsWith('/snap'), 'Snap', 'Snap confinement can interfere with spawning child processes. See issue #584');
+    // 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 = castArray(options.hide).filter((id) => id || id === 0);
+    const logger = options.logger ||
+        new Logger({
+            hide,
+            prefixFormat: options.prefix,
+            commandLength: options.prefixLength,
+            raw: options.raw,
+            timestampFormat: options.timestampFormat,
+        });
+    if (options.prefixColors === false) {
+        logger.toggleColors(false);
+    }
+    const abortController = new AbortController();
+    const outputStream = options.outputStream || process.stdout;
+    const spawn = createSpawn(options.shell);
+    return createConcurrently(commands, {
+        maxProcesses: options.maxProcesses,
+        raw: options.raw,
+        successCondition: options.successCondition,
+        cwd: options.cwd,
+        spawn,
+        hide,
+        logger,
+        outputStream,
+        group: options.group,
+        abortSignal: abortController.signal,
+        controllers: [
+            // LoggerPadding needs to run before any other controllers that might output something
+            ...(options.padPrefix ? [new LoggerPadding({ logger })] : []),
+            new LogError({ logger }),
+            new LogOutput({ logger }),
+            new LogExit({ logger }),
+            new InputHandler({
+                logger,
+                defaultInputTarget: options.defaultInputTarget,
+                inputStream: options.inputStream || (options.handleInput ? process.stdin : undefined),
+                pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
+            }),
+            new KillOnSignal({ process, abortController }),
+            new RestartProcess({
+                logger,
+                delay: options.restartDelay,
+                tries: options.restartTries,
+            }),
+            new KillOthers({
+                logger,
+                conditions: options.killOthersOn || [],
+                timeoutMs: options.killTimeout,
+                killSignal: options.killSignal,
+                abortController,
+            }),
+            new OutputErrorHandler({ abortController, outputStream }),
+            new LogTimings({
+                logger: options.timings ? logger : undefined,
+                timestampFormat: options.timestampFormat,
+            }),
+            new Teardown({ logger, spawn, commands: options.teardown || [] }),
+        ],
+        prefixColors: options.prefixColors || [],
+        additionalArguments: options.additionalArguments,
+    });
+}
+// Export all flow controllers, types, and the main concurrently function,
+// so that 3rd-parties can use them however they want
+// Main
+export default concurrently;
+export { createConcurrently, Logger };
+// Command specific
+export { Command };
+// Flow controllers
+export { InputHandler, KillOnSignal, KillOthers, LogError, LogExit, LogOutput, LogTimings, RestartProcess, };

package/dist/{src → lib}/jsonc.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
 ORIGINAL https://www.npmjs.com/package/tiny-jsonc
 BY Fabio Spampinato
@@ -6,11 +5,8 @@ MIT license
 
 Copied due to the dependency not being compatible with CommonJS
 */
-Object.defineProperty(exports, "__esModule", { value: true });
-/* HELPERS */
-const stringOrCommentRe = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g;
-const stringOrTrailingCommaRe = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g;
-/* MAIN */
+const stringOrCommentRe = /("(?:\\?[\s\S])*?")|(\/\/.*)|(\/\*[\s\S]*?\*\/)/g;
+const stringOrTrailingCommaRe = /("(?:\\?[\s\S])*?")|(,\s*)(?=\]|\})/g;
 const JSONC = {
     parse: (text) => {
         text = String(text); // To be extra safe
@@ -25,5 +21,4 @@ const JSONC = {
     },
     stringify: JSON.stringify,
 };
-/* EXPORT */
-exports.default = JSONC;
+export default JSONC;

package/dist/{src → lib}/logger.d.ts

@@ -1,5 +1,6 @@
-import * as Rx from 'rxjs';
-import { Command, CommandIdentifier } from './command';
+import Rx from 'rxjs';
+import { Command, CommandIdentifier } from './command.js';
+export declare const COLOR_MARKER_RE: RegExp;
 export declare class Logger {
     private readonly hide;
     private readonly raw;

package/dist/{src → lib}/logger.js

@@ -1,55 +1,76 @@
-"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]; } };
+import chalk, { Chalk } from 'chalk';
+import Rx from 'rxjs';
+import { DateFormatter } from './date-format.js';
+import * as defaults from './defaults.js';
+import { escapeRegExp, splitOutsideParens } from './utils.js';
+const defaultChalk = chalk;
+const noColorChalk = new Chalk({ level: 0 });
+const HEX_PATTERN = /^#[0-9A-Fa-f]{3,6}$/;
+const COLOR_OPEN = '{color}';
+const COLOR_CLOSE = '{/color}';
+export const COLOR_MARKER_RE = /\{\/?color\}/g;
+/**
+ * Applies a single color segment to a chalk instance.
+ * Handles: function calls (hex, bgHex, rgb, bgRgb, ansi256, bgAnsi256, etc.),
+ * shorthands (#HEX, bg#HEX), and named colors/modifiers.
+ */
+function applySegment(color, segment) {
+    // Function call: name(args) - handles chalk color functions
+    const fnMatch = segment.match(/^(\w+)\((.+)\)$/);
+    if (fnMatch) {
+        const [, fnName, argsStr] = fnMatch;
+        const args = argsStr.split(',').map((a) => {
+            const t = a.trim();
+            return /^\d+$/.test(t) ? parseInt(t, 10) : t;
+        });
+        // Explicit function calls for known chalk color functions
+        switch (fnName) {
+            case 'rgb':
+                return color.rgb(args[0], args[1], args[2]);
+            case 'bgRgb':
+                return color.bgRgb(args[0], args[1], args[2]);
+            case 'hex':
+                if (!HEX_PATTERN.test(args[0]))
+                    return undefined;
+                return color.hex(args[0]);
+            case 'bgHex':
+                if (!HEX_PATTERN.test(args[0]))
+                    return undefined;
+                return color.bgHex(args[0]);
+            case 'ansi256':
+                return color.ansi256(args[0]);
+            case 'bgAnsi256':
+                return color.bgAnsi256(args[0]);
+            default:
+                return undefined;
+        }
     }
-    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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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.Logger = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const Rx = __importStar(require("rxjs"));
-const date_format_1 = require("./date-format");
-const defaults = __importStar(require("./defaults"));
-const utils_1 = require("./utils");
-const defaultChalk = chalk_1.default;
-const noColorChalk = new chalk_1.default.Instance({ level: 0 });
-function getChalkPath(chalk, path) {
-    return path
-        .split('.')
-        .reduce((prev, key) => prev[key], chalk);
+    // Shorthands
+    if (segment.startsWith('bg#'))
+        return color.bgHex(segment.slice(2));
+    if (segment.startsWith('#'))
+        return color.hex(segment);
+    // Property: black, bold, dim, etc.
+    return color[segment] ?? undefined;
 }
-class Logger {
+/**
+ * Applies a color string to chalk, supporting chained colors and modifiers.
+ * Returns undefined if any segment is invalid (triggers fallback to default).
+ */
+function applyColor(chalkInstance, colorString) {
+    const segments = splitOutsideParens(colorString, '.');
+    if (segments.length === 0)
+        return undefined;
+    let color = chalkInstance;
+    for (const segment of segments) {
+        const next = applySegment(color, segment);
+        if (!next)
+            return undefined;
+        color = next;
+    }
+    return color;
+}
+export class Logger {
     hide;
     raw;
     prefixFormat;
@@ -76,7 +97,7 @@ class Logger {
         this.raw = raw;
         this.prefixFormat = prefixFormat;
         this.commandLength = commandLength || defaults.prefixLength;
-        this.dateFormatter = new date_format_1.DateFormatter(timestampFormat || defaults.timestampFormat);
+        this.dateFormatter = new DateFormatter(timestampFormat || defaults.timestampFormat);
     }
     /**
      * Toggles colors on/off globally.
@@ -117,7 +138,7 @@ class Logger {
             return { type: 'default', value: prefixes[prefix] };
         }
         const value = Object.entries(prefixes).reduce((prev, [key, val]) => {
-            const keyRegex = new RegExp((0, utils_1.escapeRegExp)(`{${key}}`), 'g');
+            const keyRegex = new RegExp(escapeRegExp(`{${key}}`), 'g');
             return prev.replace(keyRegex, String(val));
         }, prefix);
         return { type: 'template', value };
@@ -127,23 +148,47 @@ class Logger {
         if (!content) {
             return '';
         }
+        const visibleLength = content.value.replace(COLOR_MARKER_RE, '').length;
+        const padding = ' '.repeat(Math.max(0, this.prefixLength - visibleLength));
         return content.type === 'template'
-            ? content.value.padEnd(this.prefixLength, ' ')
-            : `[${content.value.padEnd(this.prefixLength, ' ')}]`;
+            ? content.value + padding
+            : `[${content.value}${padding}]`;
     }
     setPrefixLength(length) {
         this.prefixLength = length;
     }
     colorText(command, text) {
-        let color;
-        if (command.prefixColor?.startsWith('#')) {
-            color = this.chalk.hex(command.prefixColor);
-        }
-        else {
-            const defaultColor = getChalkPath(this.chalk, defaults.prefixColors);
-            color = getChalkPath(this.chalk, command.prefixColor ?? '') ?? defaultColor;
+        const prefixColor = command.prefixColor ?? '';
+        const defaultColor = applyColor(this.chalk, defaults.prefixColors) ?? this.chalk.reset;
+        const color = applyColor(this.chalk, prefixColor) ?? defaultColor;
+        // Segment the text around `{color}` / `{/color}` markers and only apply `color`
+        // inside opened regions. If either marker is missing, it's implicitly added to
+        // the start or end respectively — so a marker-free input stays fully colored,
+        // preserving backward compatibility.
+        let normalized = text;
+        if (!normalized.includes(COLOR_OPEN))
+            normalized = COLOR_OPEN + normalized;
+        if (!normalized.includes(COLOR_CLOSE))
+            normalized = normalized + COLOR_CLOSE;
+        let output = '';
+        let rest = normalized;
+        let inColorRegion = false;
+        while (rest.length > 0) {
+            const marker = inColorRegion ? COLOR_CLOSE : COLOR_OPEN;
+            const idx = rest.indexOf(marker);
+            if (idx === -1) {
+                // Tail after the last closing marker: normalization guarantees a
+                // `{/color}` exists, so once opened a region always finds its close —
+                // reaching here implies `inColorRegion` is false and the tail is plain.
+                output += rest;
+                break;
+            }
+            const segment = rest.slice(0, idx);
+            output += inColorRegion ? color(segment) : segment;
+            rest = rest.slice(idx + marker.length);
+            inColorRegion = !inColorRegion;
         }
-        return color(text);
+        return output;
     }
     /**
      * Logs an event for a command (e.g. start, stop).
@@ -161,7 +206,7 @@ class Logger {
         if (this.lastWrite?.command === command && this.lastWrite.char !== '\n') {
             prefix = '\n';
         }
-        this.logCommandText(prefix + this.chalk.reset(text) + '\n', command);
+        this.logCommandText(`${prefix}${this.chalk.reset(text)}\n`, command);
     }
     logCommandText(text, command) {
         if (this.hide.includes(String(command.index)) || this.hide.includes(command.name)) {
@@ -179,7 +224,7 @@ class Logger {
         if (this.raw) {
             return;
         }
-        this.log(this.chalk.reset('-->') + ' ', this.chalk.reset(text) + '\n');
+        this.log(`${this.chalk.reset('-->')} `, `${this.chalk.reset(text)}\n`);
     }
     /**
      * Logs a table from an input object array, like `console.table`.
@@ -253,4 +298,3 @@ class Logger {
         this.output.next({ command, text });
     }
 }
-exports.Logger = Logger;

package/dist/{src → lib}/observables.d.ts

@@ -1,4 +1,4 @@
-import EventEmitter from 'events';
+import EventEmitter from 'node:events';
 import { Observable } from 'rxjs';
 /**
  * Creates an observable for a specific event of an `EventEmitter` instance.

package/dist/{src → lib}/observables.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromSharedEvent = fromSharedEvent;
-const rxjs_1 = require("rxjs");
+import { fromEvent, share } from 'rxjs';
 const sharedEvents = new WeakMap();
 /**
  * Creates an observable for a specific event of an `EventEmitter` instance.
  *
  * The underlying event listener is set up only once across the application for that event emitter/name pair.
  */
-function fromSharedEvent(emitter, event) {
+export function fromSharedEvent(emitter, event) {
     let emitterEvents = sharedEvents.get(emitter);
     if (!emitterEvents) {
         emitterEvents = new Map();
@@ -16,7 +13,7 @@ function fromSharedEvent(emitter, event) {
     }
     let observable = emitterEvents.get(event);
     if (!observable) {
-        observable = (0, rxjs_1.fromEvent)(emitter, event).pipe((0, rxjs_1.share)());
+        observable = fromEvent(emitter, event).pipe(share());
         emitterEvents.set(event, observable);
     }
     return observable;

package/dist/{src → lib}/output-writer.d.ts

@@ -1,6 +1,6 @@
-import * as Rx from 'rxjs';
-import { Writable } from 'stream';
-import { Command } from './command';
+import { Writable } from 'node:stream';
+import Rx from 'rxjs';
+import { Command } from './command.js';
 /**
  * Class responsible for actually writing output onto a writable stream.
  */

package/dist/{src → lib}/output-writer.js

@@ -1,45 +1,9 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutputWriter = void 0;
-const Rx = __importStar(require("rxjs"));
-const observables_1 = require("./observables");
+import Rx from 'rxjs';
+import { fromSharedEvent } from './observables.js';
 /**
  * Class responsible for actually writing output onto a writable stream.
  */
-class OutputWriter {
+export class OutputWriter {
     outputStream;
     group;
     buffers;
@@ -51,7 +15,7 @@ class OutputWriter {
     constructor({ outputStream, group, commands, }) {
         this.outputStream = outputStream;
         this.ensureWritable();
-        this.error = (0, observables_1.fromSharedEvent)(this.outputStream, 'error');
+        this.error = fromSharedEvent(this.outputStream, 'error');
         this.group = group;
         this.buffers = commands.map(() => []);
         if (this.group) {
@@ -97,4 +61,3 @@ class OutputWriter {
         this.buffers[index] = [];
     }
 }
-exports.OutputWriter = OutputWriter;

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

@@ -0,0 +1,21 @@
+import { ChalkInstance } from 'chalk';
+export declare class PrefixColorSelector {
+    private colorGenerator;
+    constructor(customColors?: string | string[]);
+    /**
+     * Colors used by `auto` selection and default cycling.
+     *
+     * Each color is chosen to be visually distinct on both dark and light
+     * terminal backgrounds, without carrying semantic meaning (e.g. red
+     * implies errors) or blending into default text (e.g. white/grey).
+     * Background colors are excluded to keep output lightweight.
+     *
+     * This list does NOT restrict manually specified colors — any valid Chalk
+     * color name, hex value, or modifier can be passed via `--prefix-colors`.
+     */
+    static get ACCEPTABLE_CONSOLE_COLORS(): (keyof ChalkInstance)[];
+    /**
+     * @returns The given custom colors then a set of acceptable console colors indefinitely.
+     */
+    getNextColor(): string;
+}

package/dist/{src → lib}/prefix-color-selector.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrefixColorSelector = void 0;
 function getConsoleColorsWithoutCustomColors(customColors) {
     return PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS.filter(
     // Consider the "Bright" variants of colors to be the same as the plain color to avoid similar colors
@@ -51,44 +48,30 @@ function* createColorGenerator(customColors) {
         }
     }
 }
-class PrefixColorSelector {
+export class PrefixColorSelector {
     colorGenerator;
     constructor(customColors = []) {
         const normalizedColors = typeof customColors === 'string' ? [customColors] : customColors;
         this.colorGenerator = createColorGenerator(normalizedColors);
     }
-    /** A list of colors that are readable in a terminal. */
+    /**
+     * Colors used by `auto` selection and default cycling.
+     *
+     * Each color is chosen to be visually distinct on both dark and light
+     * terminal backgrounds, without carrying semantic meaning (e.g. red
+     * implies errors) or blending into default text (e.g. white/grey).
+     * Background colors are excluded to keep output lightweight.
+     *
+     * This list does NOT restrict manually specified colors — any valid Chalk
+     * color name, hex value, or modifier can be passed via `--prefix-colors`.
+     */
     static get ACCEPTABLE_CONSOLE_COLORS() {
-        // Colors picked randomly, can be amended if required
-        return [
-            // Prevent duplicates, in case the list becomes significantly large
-            ...new Set([
-                // Text colors
-                'cyan',
-                'yellow',
-                'greenBright',
-                'blueBright',
-                'magentaBright',
-                'white',
-                'grey',
-                'red',
-                // Background colors
-                'bgCyan',
-                'bgYellow',
-                'bgGreenBright',
-                'bgBlueBright',
-                'bgMagenta',
-                'bgWhiteBright',
-                'bgGrey',
-                'bgRed',
-            ]),
-        ];
+        return [...new Set(['cyan', 'magenta', 'green', 'yellow', 'blue'])];
     }
     /**
      * @returns The given custom colors then a set of acceptable console colors indefinitely.
      */
     getNextColor() {
-        return this.colorGenerator.next().value;
+        return this.colorGenerator.next().value.trim();
     }
 }
-exports.PrefixColorSelector = PrefixColorSelector;

package/dist/{src → lib}/spawn.d.ts

@@ -1,9 +1,18 @@
-import { ChildProcess, SpawnOptions } from 'child_process';
-import supportsColor from 'supports-color';
+import { ChildProcess, SpawnOptions } from 'node:child_process';
+import { ColorSupport } from 'supports-color';
+import { SpawnCommand } from './command.js';
 /**
- * Spawns a command using `cmd.exe` on Windows, or `/bin/sh` elsewhere.
+ * Creates a spawn function that uses the given shell executable.
+ *
+ * The shell is resolved in the following priority order:
+ * 1. explicit shell option
+ * 2. `npm_config_script_shell` env variable
+ * 3. platform default (`cmd.exe` on Windows, `/bin/sh` elsewhere)
+ *
+ * @see https://docs.npmjs.com/cli/v6/using-npm/config#script-shell
  */
-export declare function spawn(command: string, options: SpawnOptions, spawn?: (command: string, args: string[], options: SpawnOptions) => ChildProcess, process?: Pick<NodeJS.Process, 'platform'>): ChildProcess;
+export declare function createSpawn(shell?: string, spawn?: (command: string, args: string[], options: SpawnOptions) => ChildProcess, process?: Pick<NodeJS.Process, 'platform' | 'env'>): SpawnCommand;
+export type ShellKind = 'cmd' | 'posix' | 'powershell';
 export declare const getSpawnOpts: ({ colorSupport, cwd, process, ipc, stdio, env, }: {
     /**
      * What the color support of the spawned processes should be.
@@ -11,7 +20,7 @@ export declare const getSpawnOpts: ({ colorSupport, cwd, process, ipc, stdio, en
      *
      * Defaults to whatever the terminal's stdout support is.
      */
-    colorSupport?: Pick<supportsColor.supportsColor.Level, "level"> | false;
+    colorSupport?: Pick<ColorSupport, "level"> | false;
     /**
      * The NodeJS process.
      */