concurrently 9.2.0 → 10.0.0

package/README.md

@@ -3,7 +3,7 @@
 [![Latest Release](https://img.shields.io/github/v/release/open-cli-tools/concurrently?label=Release)](https://github.com/open-cli-tools/concurrently/releases)
 [![License](https://img.shields.io/github/license/open-cli-tools/concurrently?label=License)](https://github.com/open-cli-tools/concurrently/blob/main/LICENSE)
 [![Weekly Downloads on NPM](https://img.shields.io/npm/dw/concurrently?label=Downloads&logo=npm)](https://www.npmjs.com/package/concurrently)
-[![CI Status](https://img.shields.io/github/actions/workflow/status/open-cli-tools/concurrently/test.yml?label=CI&logo=github)](https://github.com/open-cli-tools/concurrently/actions/workflows/test.yml)
+[![CI Status](https://img.shields.io/github/actions/workflow/status/open-cli-tools/concurrently/ci.yml?label=CI&logo=github)](https://github.com/open-cli-tools/concurrently/actions/workflows/ci.yml)
 [![Coverage Status](https://img.shields.io/coveralls/github/open-cli-tools/concurrently/main?label=Coverage&logo=coveralls)](https://coveralls.io/github/open-cli-tools/concurrently?branch=main)
 
 Run multiple commands concurrently.
@@ -67,11 +67,18 @@ concurrently 'command1 arg' 'command2 arg'
 Otherwise **concurrently** would try to run 4 separate commands:
 `command1`, `arg`, `command2`, `arg`.
 
-In package.json, escape quotes:
-
-```bash
-"start": "concurrently 'command1 arg' 'command2 arg'"
-```
+> [!IMPORTANT]
+> Windows only supports double quotes:
+>
+> ```bash
+> concurrently "command1 arg" "command2 arg"
+> ```
+>
+> Remember to escape the double quotes in your package.json when using Windows:
+>
+> ```json
+> "start": "concurrently \"command1 arg\" \"command2 arg\""
+> ```
 
 You can always check concurrently's flag list by running `concurrently --help`.
 For the version, run `concurrently --version`.
@@ -90,21 +97,25 @@ Check out documentation and other usage examples in the [`docs` directory](./doc
 - `options` (optional): an object containing any of the below:
   - `cwd`: the working directory to be used by all commands. Can be overridden per command.
     Default: `process.cwd()`.
+  - `shell`: shell executable used to run command strings. When unset, uses `npm_config_script_shell` if present (for example when run via `npm run`), otherwise `cmd.exe` on Windows or `/bin/sh` elsewhere. See [shell resolution](./docs/shell-resolution.md).
   - `defaultInputTarget`: the default input target when reading from `inputStream`.
     Default: `0`.
   - `handleInput`: when `true`, reads input from `process.stdin`.
-  - `inputStream`: a [`Readable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_readable_streams)
+  - `inputStream`: a [`Readable` stream](https://nodejs.org/docs/latest/api/stream.html#readable-streams)
     to read the input from. Should only be used in the rare instance you would like to stream anything other than `process.stdin`. Overrides `handleInput`.
   - `pauseInputStreamOnFinish`: by default, pauses the input stream (`process.stdin` when `handleInput` is enabled, or `inputStream` if provided) when all of the processes have finished. If you need to read from the input stream after `concurrently` has finished, set this to `false`. ([#252](https://github.com/kimmobrunfeldt/concurrently/issues/252)).
   - `killOthersOn`: once the first command exits with one of these statuses, kill other commands.
     Can be an array containing the strings `success` (status code zero) and/or `failure` (non-zero exit status).
   - `maxProcesses`: how many processes should run at once.
-  - `outputStream`: a [`Writable` stream](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_writable_streams)
+  - `outputStream`: a [`Writable` stream](https://nodejs.org/docs/latest/api/stream.html#writable-streams)
     to write logs to. Default: `process.stdout`.
   - `prefix`: the prefix type to use when logging processes output.
     Possible values: `index`, `pid`, `time`, `command`, `name`, `none`, or a template (eg `[{time} process: {pid}]`).
     Default: the name of the process, or its index if no name is set.
-  - `prefixColors`: a list of colors or a string as supported by [chalk](https://www.npmjs.com/package/chalk) and additional style `auto` for an automatically picked color.
+    Templates can wrap any portion of the prefix with `{color}` and `{/color}` to restrict coloring to that region (eg `[{color}{name}{/color}]` colors only the name, leaving the brackets uncolored). If either marker is omitted the missing side is implicit, so a template with no markers is colored in full.
+  - `prefixColors`: a list of colors or a string as supported by [Chalk](https://www.npmjs.com/package/chalk) and additional style `auto` for an automatically picked color.
+    Supports all Chalk color functions: `#RRGGBB`, `bg#RRGGBB`, `hex()`, `bgHex()`, `rgb()`, `bgRgb()`, `ansi256()`, `bgAnsi256()`.
+    Functions and modifiers can be chained (e.g., `rgb(255,136,0).bold`, `black.bgHex(#00FF00).dim`).
     If concurrently would run more commands than there are colors, the last color is repeated, unless if the last color value is `auto` which means following colors are automatically picked to vary.
     Prefix colors specified per-command take precedence over this list.
   - `prefixLength`: how many characters to show when prefixing with `command`. Default: `10`
@@ -142,7 +153,7 @@ const { result } = concurrently(
   ],
   {
     prefix: 'name',
-    killOthers: ['failure', 'success'],
+    killOthersOn: ['failure', 'success'],
     restartTries: 3,
     cwd: path.resolve(__dirname, 'scripts'),
   },
@@ -174,7 +185,6 @@ It has the following properties:
 - `timer`: an RxJS observable to the command's timing events (e.g. starting, stopping).
 - `stateChange`: an RxJS observable for changes to the command's `state` property.
 - `messages`: an object with the following properties:
-
   - `incoming`: an RxJS observable for the IPC messages received from the underlying process.
   - `outgoing`: an RxJS observable for the IPC messages sent to the underlying process.
 
@@ -213,18 +223,18 @@ It contains the following properties:
 
 ## FAQ
 
-- Process exited with code _null_?
+- Process exited with code `null`?
 
-  From [Node child_process documentation](http://nodejs.org/api/child_process.html#child_process_event_exit), `exit` event:
+  From [Node child_process documentation](https://nodejs.org/docs/latest/api/child_process.html#event-exit), `exit` event:
 
   > This event is emitted after the child process ends. If the process
   > terminated normally, code is the final exit code of the process,
   > otherwise null. If the process terminated due to receipt of a signal,
   > signal is the string name of the signal, otherwise null.
 
-  So _null_ means the process didn't terminate normally. This will make **concurrently**
+  So `null` means the process didn't terminate normally. This will make **concurrently**
   to return non-zero exit code too.
 
-- Does this work with the npm-replacements [yarn](https://github.com/yarnpkg/yarn), [pnpm](https://pnpm.js.org/), or [Bun](https://bun.sh/)?
+- Does this work with the npm-replacements [yarn](https://yarnpkg.com/), [pnpm](https://pnpm.io/), or [Bun](https://bun.sh/)?
 
   Yes! In all examples above, you may replace "`npm`" with "`yarn`", "`pnpm`", or "`bun`".

package/dist/bin/{concurrently.js → index.js}

@@ -1,43 +1,16 @@
 #!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
-const assert_1 = require("../src/assert");
-const defaults = __importStar(require("../src/defaults"));
-const index_1 = require("../src/index");
-const read_package_1 = require("./read-package");
-const version = String((0, read_package_1.readPackage)().version);
+import process from 'node:process';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import * as defaults from '../lib/defaults.js';
+import { concurrently } from '../lib/index.js';
+import { castArray, splitOutsideParens } from '../lib/utils.js';
+import { normalizeCliCommand } from './normalize-cli-command.js';
+import { readPackageJson } from './read-package-json.js';
+const version = String(readPackageJson().version);
 const epilogue = `For documentation and more examples, visit:\nhttps://github.com/open-cli-tools/concurrently/tree/v${version}/docs`;
 // Clean-up arguments (yargs expects only the arguments after the program name)
-const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+const program = yargs(hideBin(process.argv))
     .parserConfiguration({
     // Avoids options that can be specified multiple times from requiring a `--` to pass commands
     'greedy-arrays': false,
@@ -67,11 +40,6 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
             'Example names: "main,browser,server"',
         type: 'string',
     },
-    'name-separator': {
-        describe: 'The character to split <names> on. Example usage:\n' +
-            '-n "styles|scripts|server" --name-separator "|"',
-        default: defaults.nameSeparator,
-    },
     success: {
         alias: 's',
         describe: 'Which command(s) must exit with code 0 in order for concurrently exit with ' +
@@ -92,7 +60,7 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
         type: 'boolean',
     },
     // This one is provided for free. Chalk reads this itself and removes colors.
-    // https://www.npmjs.com/package/chalk#chalksupportscolor
+    // https://www.npmjs.com/package/chalk#supportscolor
     'no-color': {
         describe: 'Disables colors from logging',
         type: 'boolean',
@@ -113,6 +81,10 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
         type: 'boolean',
         default: defaults.timings,
     },
+    shell: {
+        describe: 'Shell to run commands with. Defaults to cmd.exe on Windows and /bin/sh elsewhere.',
+        type: 'string',
+    },
     'passthrough-arguments': {
         alias: 'P',
         describe: 'Passthrough additional arguments to commands (accessible via placeholders) ' +
@@ -157,7 +129,7 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     },
     'prefix-colors': {
         alias: 'c',
-        describe: 'Comma-separated list of chalk colors to use on prefixes. ' +
+        describe: 'Comma-separated list of Chalk colors to use on prefixes. ' +
             'If there are more commands than colors, the last color will be repeated.\n' +
             '- Available modifiers: reset, bold, dim, italic, underline, inverse, hidden, strikethrough\n' +
             '- Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray, \n' +
@@ -211,24 +183,22 @@ const program = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
             'Can be either the index or the name of the process.',
     },
 })
-    .group(['m', 'n', 'name-separator', 's', 'r', 'no-color', 'hide', 'g', 'timings', 'P', 'teardown'], 'General')
+    .group(['m', 'n', 's', 'r', 'no-color', 'hide', 'g', 'timings', 'shell', 'P', 'teardown'], 'General')
     .group(['p', 'c', 'l', 't', 'pad-prefix'], 'Prefix styling')
     .group(['i', 'default-input-target'], 'Input handling')
     .group(['k', 'kill-others-on-fail', 'kill-signal', 'kill-timeout'], 'Killing other processes')
     .group(['restart-tries', 'restart-after'], 'Restarting')
     .epilogue(epilogue);
 const args = program.parseSync();
-(0, assert_1.assertDeprecated)(args.nameSeparator === defaults.nameSeparator, 'name-separator', 'Use commas as name separators instead.');
-// Get names of commands by the specified separator
-const names = (args.names || '').split(args.nameSeparator);
-const additionalArguments = lodash_1.default.castArray(args['--'] ?? []).map(String);
+const names = (args.names || '').split(',');
+const additionalArguments = castArray(args['--'] ?? []).map(String);
 const commands = args.passthroughArguments ? args._ : args._.concat(additionalArguments);
 if (!commands.length) {
     program.showHelp();
     process.exit();
 }
-(0, index_1.concurrently)(commands.map((command, index) => ({
-    command: String(command),
+concurrently(commands.map((command, index) => ({
+    command: normalizeCliCommand(String(command)),
     name: names[index],
 })), {
     handleInput: args.handleInput,
@@ -245,7 +215,7 @@ if (!commands.length) {
     hide: args.hide.split(','),
     group: args.group,
     prefix: args.prefix,
-    prefixColors: args.prefixColors.split(','),
+    prefixColors: splitOutsideParens(args.prefixColors, ','),
     prefixLength: args.prefixLength,
     padPrefix: args.padPrefix,
     restartDelay: args.restartAfter === 'exponential' ? 'exponential' : Number(args.restartAfter),
@@ -253,6 +223,7 @@ if (!commands.length) {
     successCondition: args.success,
     timestampFormat: args.timestampFormat,
     timings: args.timings,
+    shell: args.shell,
     teardown: args.teardown,
     additionalArguments: args.passthroughArguments ? additionalArguments : undefined,
 }).result.then(() => process.exit(0), () => process.exit(1));

package/dist/bin/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin/index.spec.js

@@ -0,0 +1,368 @@
+import { execSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { subscribeSpyTo } from '@hirez_io/observer-spy';
+import { sendCtrlC, spawnWithWrapper } from 'ctrlc-wrapper';
+import Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+import stringArgv from 'string-argv';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { escapeRegExp } from '../lib/utils.js';
+const isWindows = process.platform === 'win32';
+const createKillMessage = (prefix, signal) => {
+    const map = {
+        SIGTERM: isWindows ? 1 : '(SIGTERM|143)',
+        // Could theoretically be anything (e.g. 0) if process has SIGINT handler
+        SIGINT: isWindows ? '(3221225786|0)' : '(SIGINT|130|0)',
+    };
+    return new RegExp(`${escapeRegExp(prefix)} exited with code ${map[signal] ?? signal}`);
+};
+const concurrentlyBin = path.join(__dirname, '..', 'dist', 'bin', 'index.js');
+// Build once, then spawn the real CLI without a shell (see open-cli-tools/concurrently#346).
+beforeAll(() => {
+    execSync('pnpm run build', { cwd: path.join(__dirname, '..'), stdio: 'pipe' });
+}, 20_000);
+/**
+ * Creates a child process running 'concurrently' with the given args.
+ * Returns observables for its combined stdout + stderr output, close events, pid, and stdin stream.
+ */
+const run = (args, ctrlcWrapper) => {
+    const spawnFn = ctrlcWrapper ? spawnWithWrapper : spawn;
+    const child = spawnFn('node', [concurrentlyBin, ...stringArgv(args)], {
+        cwd: __dirname,
+        env: {
+            ...process.env,
+            // VS Code extension might allow colors, but this breaks assertions.
+            // Force colors to be disabled to avoid that.
+            FORCE_COLOR: '0',
+        },
+    });
+    const stdout = readline.createInterface({
+        input: child.stdout,
+    });
+    const stderr = readline.createInterface({
+        input: child.stderr,
+    });
+    const log = new Rx.Observable((observer) => {
+        stdout.on('line', (line) => {
+            observer.next(line);
+        });
+        stderr.on('line', (line) => {
+            observer.next(line);
+        });
+        child.on('close', () => {
+            observer.complete();
+        });
+    });
+    const exit = Rx.firstValueFrom(Rx.fromEvent(child, 'exit').pipe(map((event) => {
+        const exit = event;
+        return {
+            /** The exit code if the child exited on its own. */
+            code: exit[0],
+            /** The signal by which the child process was terminated. */
+            signal: exit[1],
+        };
+    })));
+    const getLogLines = async () => {
+        const observerSpy = subscribeSpyTo(log);
+        await observerSpy.onComplete();
+        observerSpy.unsubscribe();
+        return observerSpy.getValues();
+    };
+    return {
+        process: child,
+        stdin: child.stdin,
+        pid: child.pid,
+        log,
+        getLogLines,
+        exit,
+    };
+};
+it('has help command', async () => {
+    const exit = await run('--help').exit;
+    expect(exit.code).toBe(0);
+});
+it('prints help when no arguments are passed', async () => {
+    const exit = await run('').exit;
+    expect(exit.code).toBe(0);
+});
+describe('has version command', () => {
+    const pkg = fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8');
+    const { version } = JSON.parse(pkg);
+    it.each(['--version', '-V', '-v'])('%s', async (arg) => {
+        const child = run(arg);
+        const log = await child.getLogLines();
+        expect(log).toContain(version);
+        const { code } = await child.exit;
+        expect(code).toBe(0);
+    });
+});
+describe('exiting conditions', () => {
+    it('is of success by default when running successful commands', async () => {
+        const exit = await run('"echo foo" "echo bar"').exit;
+        expect(exit.code).toBe(0);
+    });
+    it('strips outer CLI wrapper quotes before running a command', async () => {
+        const child = run('"echo foo"');
+        const lines = await child.getLogLines();
+        const exit = await child.exit;
+        expect(lines).toContainEqual(expect.stringContaining('foo'));
+        expect(exit.code).toBe(0);
+    });
+    it('is of failure by default when one of the command fails', async () => {
+        const exit = await run('"echo foo" "exit 1"').exit;
+        expect(exit.code).toBeGreaterThan(0);
+    });
+    it('is of success when --success=first and first command to exit succeeds', async () => {
+        const exit = await run('--success=first "echo foo" "node __fixtures__/sleep.js 0.5 && exit 1"').exit;
+        expect(exit.code).toBe(0);
+    });
+    it('is of failure when --success=first and first command to exit fails', async () => {
+        const exit = await run('--success=first "exit 1" "node __fixtures__/sleep.js 0.5 && echo foo"').exit;
+        expect(exit.code).toBeGreaterThan(0);
+    });
+    describe('is of success when --success=last and last command to exit succeeds', () => {
+        it.each(['--success=last', '-s last'])('%s', async (arg) => {
+            const exit = await run(`${arg} "exit 1" "node __fixtures__/sleep.js 0.5 && echo foo"`)
+                .exit;
+            expect(exit.code).toBe(0);
+        });
+    });
+    it('is of failure when --success=last and last command to exit fails', async () => {
+        const exit = await run('--success=last "echo foo" "node __fixtures__/sleep.js 0.5 && exit 1"').exit;
+        expect(exit.code).toBeGreaterThan(0);
+    });
+    it('is of success when a SIGINT is sent', async () => {
+        // Windows doesn't support sending signals like on POSIX platforms.
+        // However, in a console, processes can be interrupted with CTRL+C (like a SIGINT).
+        // This is what we simulate here with the help of a wrapper application.
+        const child = run('"node __fixtures__/read-echo.js"', isWindows);
+        // Wait for command to have started before sending SIGINT
+        child.log.subscribe((line) => {
+            if (/READING/.test(line)) {
+                if (isWindows) {
+                    // Instruct the wrapper to send CTRL+C to its child
+                    sendCtrlC(child.process);
+                }
+                else {
+                    process.kill(Number(child.pid), 'SIGINT');
+                }
+            }
+        });
+        const lines = await child.getLogLines();
+        const exit = await child.exit;
+        expect(exit.code).toBe(0);
+        expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node __fixtures__/read-echo.js', 
+        // TODO: Flappy value due to race condition, sometimes killed by concurrently (exit code 1),
+        //       sometimes terminated on its own (exit code 0).
+        //       Related issue: https://github.com/open-cli-tools/concurrently/issues/283
+        isWindows ? '(3221225786|0|1)' : 'SIGINT')));
+    });
+});
+describe('does not log any extra output', () => {
+    it.each(['--raw', '-r'])('%s', async (arg) => {
+        const lines = await run(`${arg} "echo foo" "echo bar"`).getLogLines();
+        expect(lines).toHaveLength(2);
+        expect(lines).toContainEqual(expect.stringContaining('foo'));
+        expect(lines).toContainEqual(expect.stringContaining('bar'));
+    });
+});
+describe('--hide', () => {
+    it('hides the output of a process by its index', async () => {
+        const lines = await run('--hide 1 "echo foo" "echo bar"').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('foo'));
+        expect(lines).not.toContainEqual(expect.stringContaining('bar'));
+    });
+    it('hides the output of a process by its name', async () => {
+        const lines = await run('-n foo,bar --hide bar "echo foo" "echo bar"').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('foo'));
+        expect(lines).not.toContainEqual(expect.stringContaining('bar'));
+    });
+    it('hides the output of a process by its index in raw mode', async () => {
+        const lines = await run('--hide 1 --raw "echo foo" "echo bar"').getLogLines();
+        expect(lines).toHaveLength(1);
+        expect(lines).toContainEqual(expect.stringContaining('foo'));
+        expect(lines).not.toContainEqual(expect.stringContaining('bar'));
+    });
+    it('hides the output of a process by its name in raw mode', async () => {
+        const lines = await run('-n foo,bar --hide bar --raw "echo foo" "echo bar"').getLogLines();
+        expect(lines).toHaveLength(1);
+        expect(lines).toContainEqual(expect.stringContaining('foo'));
+        expect(lines).not.toContainEqual(expect.stringContaining('bar'));
+    });
+});
+describe('--group', () => {
+    it('groups output per process', async () => {
+        const lines = await run('--group "echo foo && node __fixtures__/sleep.js 1 && echo bar" "echo baz"').getLogLines();
+        expect(lines.slice(0, 4)).toEqual([
+            expect.stringContaining('foo'),
+            expect.stringContaining('bar'),
+            expect.any(String),
+            expect.stringContaining('baz'),
+        ]);
+    });
+});
+describe('--names', () => {
+    describe('prefixes with names', () => {
+        it.each(['--names', '-n'])('%s', async (arg) => {
+            const lines = await run(`${arg} foo,bar "echo foo" "echo bar"`).getLogLines();
+            expect(lines).toContainEqual(expect.stringContaining('[foo] foo'));
+            expect(lines).toContainEqual(expect.stringContaining('[bar] bar'));
+        });
+    });
+});
+describe('specifies custom prefix', () => {
+    it.each(['--prefix', '-p'])('%s', async (arg) => {
+        const lines = await run(`${arg} command "echo foo" "echo bar"`).getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[echo foo] foo'));
+        expect(lines).toContainEqual(expect.stringContaining('[echo bar] bar'));
+    });
+});
+describe('specifies custom prefix length', () => {
+    it.each(['--prefix command --prefix-length 5', '-p command -l 5'])('%s', async (arg) => {
+        const lines = await run(`${arg} "echo foo" "echo bar"`).getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[ec..o] foo'));
+        expect(lines).toContainEqual(expect.stringContaining('[ec..r] bar'));
+    });
+});
+describe('--pad-prefix', () => {
+    it('pads prefixes with spaces', async () => {
+        const lines = await run('--pad-prefix -n foo,barbaz "echo foo" "echo bar"').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[foo   ]'));
+        expect(lines).toContainEqual(expect.stringContaining('[barbaz]'));
+    });
+});
+describe('--restart-tries', () => {
+    it('changes how many times a command will restart', async () => {
+        const lines = await run('--restart-tries 1 "exit 1"').getLogLines();
+        expect(lines).toEqual([
+            expect.stringContaining('[0] exit 1 exited with code 1'),
+            expect.stringContaining('[0] exit 1 restarted'),
+            expect.stringContaining('[0] exit 1 exited with code 1'),
+        ]);
+    });
+});
+describe('--kill-others', () => {
+    describe('kills on success', () => {
+        it.each(['--kill-others', '-k'])('%s', async (arg) => {
+            const lines = await run(`${arg} "node __fixtures__/sleep.js 10" "exit 0"`).getLogLines();
+            expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+            expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+            expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node __fixtures__/sleep.js 10', 'SIGTERM')));
+        });
+    });
+    it('kills on failure', async () => {
+        const lines = await run('--kill-others "node __fixtures__/sleep.js 10" "exit 1"').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[1] exit 1 exited with code 1'));
+        expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+        expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node __fixtures__/sleep.js 10', 'SIGTERM')));
+    });
+});
+describe('--kill-others-on-fail', () => {
+    it('does not kill on success', async () => {
+        const lines = await run('--kill-others-on-fail "node __fixtures__/sleep.js 0.5" "exit 0"').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[1] exit 0 exited with code 0'));
+        expect(lines).toContainEqual(expect.stringContaining('[0] node __fixtures__/sleep.js 0.5 exited with code 0'));
+    });
+    it('kills on failure', async () => {
+        const lines = await run('--kill-others-on-fail "node __fixtures__/sleep.js 10" "exit 1"').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[1] exit 1 exited with code 1'));
+        expect(lines).toContainEqual(expect.stringContaining('Sending SIGTERM to other processes'));
+        expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node __fixtures__/sleep.js 10', 'SIGTERM')));
+    });
+});
+describe('--handle-input', () => {
+    describe('forwards input to first process by default', () => {
+        it.each(['--handle-input', '-i'])('%s', async (arg) => {
+            const child = run(`${arg} "node __fixtures__/read-echo.js"`);
+            child.log.subscribe((line) => {
+                if (/READING/.test(line)) {
+                    child.stdin.write('stop\n');
+                }
+            });
+            const lines = await child.getLogLines();
+            const exit = await child.exit;
+            expect(exit.code).toBe(0);
+            expect(lines).toContainEqual(expect.stringContaining('[0] stop'));
+            expect(lines).toContainEqual(expect.stringContaining('[0] node __fixtures__/read-echo.js exited with code 0'));
+        });
+    });
+    it('forwards input to process --default-input-target', async () => {
+        const child = run('-ki --default-input-target 1 "node __fixtures__/read-echo.js" "node __fixtures__/read-echo.js"');
+        child.log.subscribe((line) => {
+            if (/\[1\] READING/.test(line)) {
+                child.stdin.write('stop\n');
+            }
+        });
+        const lines = await child.getLogLines();
+        const exit = await child.exit;
+        expect(exit.code).toBeGreaterThan(0);
+        expect(lines).toContainEqual(expect.stringContaining('[1] stop'));
+        expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node __fixtures__/read-echo.js', 'SIGTERM')));
+    });
+    it('forwards input to specified process', async () => {
+        const child = run('-ki "node __fixtures__/read-echo.js" "node __fixtures__/read-echo.js"');
+        child.log.subscribe((line) => {
+            if (/\[1\] READING/.test(line)) {
+                child.stdin.write('1:stop\n');
+            }
+        });
+        const lines = await child.getLogLines();
+        const exit = await child.exit;
+        expect(exit.code).toBeGreaterThan(0);
+        expect(lines).toContainEqual(expect.stringContaining('[1] stop'));
+        expect(lines).toContainEqual(expect.stringMatching(createKillMessage('[0] node __fixtures__/read-echo.js', 'SIGTERM')));
+    });
+});
+describe('--teardown', () => {
+    it('runs teardown commands when input commands exit', async () => {
+        const lines = await run('--teardown "echo bye" "echo hey"').getLogLines();
+        expect(lines).toEqual([
+            expect.stringContaining('[0] hey'),
+            expect.stringContaining('[0] echo hey exited with code 0'),
+            expect.stringContaining('--> Running teardown command "echo bye"'),
+            expect.stringContaining('bye'),
+            expect.stringContaining('--> Teardown command "echo bye" exited with code 0'),
+        ]);
+    });
+    it('runs multiple teardown commands', async () => {
+        const lines = await run('--teardown "echo bye" --teardown "echo bye2" "echo hey"').getLogLines();
+        expect(lines).toContain('bye');
+        expect(lines).toContain('bye2');
+    });
+});
+describe('--timings', () => {
+    const defaultTimestampFormatRegex = /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{3}/;
+    const tableTopBorderRegex = /^--> ┌[─┬]+┐$/;
+    const tableHeaderRowRegex = /^--> │ name +│ duration +│ exit code +│ killed +│ command +│$/;
+    const tableBottomBorderRegex = /^--> └[─┴]+┘$/;
+    const timingsTests = {
+        'shows timings on success': ['node __fixtures__/sleep.js 0.5', 'exit 0'],
+        'shows timings on failure': ['node __fixtures__/sleep.js 0.75', 'exit 1'],
+    };
+    it.each(Object.entries(timingsTests))('%s', async (_, commands) => {
+        const lines = await run(`--timings ${commands.map((command) => `"${command}"`).join(' ')}`).getLogLines();
+        // Expect output to contain process start / stop messages for each command
+        commands.forEach((command, index) => {
+            const escapedCommand = escapeRegExp(command);
+            expect(lines).toContainEqual(expect.stringMatching(new RegExp(`^\\[${index}] ${escapedCommand} started at ${defaultTimestampFormatRegex.source}$`)));
+            expect(lines).toContainEqual(expect.stringMatching(new RegExp(`^\\[${index}] ${escapedCommand} stopped at ${defaultTimestampFormatRegex.source} after (\\d|,)+ms$`)));
+        });
+        // Expect output to contain timings table
+        expect(lines).toContainEqual(expect.stringMatching(tableTopBorderRegex));
+        expect(lines).toContainEqual(expect.stringMatching(tableHeaderRowRegex));
+        expect(lines).toContainEqual(expect.stringMatching(tableBottomBorderRegex));
+    });
+});
+describe('--passthrough-arguments', () => {
+    it('argument placeholders are properly replaced when passthrough-arguments is enabled', async () => {
+        const lines = await run('--passthrough-arguments "echo {1}" -- echo').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[0] echo echo exited with code 0'));
+    });
+    it('argument placeholders are not replaced when passthrough-arguments is disabled', async () => {
+        const lines = await run('"echo {1}" -- echo').getLogLines();
+        expect(lines).toContainEqual(expect.stringContaining('[0] echo {1} exited with code 0'));
+        expect(lines).toContainEqual(expect.stringContaining('[1] echo exited with code 0'));
+    });
+});

package/dist/bin/normalize-cli-command.d.ts

@@ -0,0 +1 @@
+export declare function normalizeCliCommand(command: string): string;

package/dist/bin/normalize-cli-command.js

@@ -0,0 +1,15 @@
+export function normalizeCliCommand(command) {
+    if (command.length < 2) {
+        return command;
+    }
+    const quote = command[0];
+    const last = command.at(-1);
+    if ((quote !== '"' && quote !== "'") || last !== quote) {
+        return command;
+    }
+    const inner = command.slice(1, -1);
+    if (inner.includes(quote)) {
+        return command;
+    }
+    return inner;
+}

package/dist/bin/normalize-cli-command.spec.d.ts

@@ -0,0 +1 @@
+export {};