Concurrently

https://www.npmjs.com/package/concurrently
Admin
Concurrently is a Node.js tool that runs multiple commands concurrently with better output tracking,...
Tokens:13,007
Snippets:114
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Concurrently Globally

Source: https://www.npmjs.com/package/concurrently?activeTab=dependents

Install concurrently globally for system-wide access. This command is for npm users.

```bash
npm i -g concurrently
```

--------------------------------

### Install Concurrently Globally

Source: https://www.npmjs.com/package/concurrently

Install concurrently globally to have it available system-wide. Adjust the command for your preferred package manager.

```bash
npm i -g concurrently
```

```bash
yarn global add concurrently
```

```bash
pnpm add -g concurrently
```

```bash
bun add -g concurrently
```

--------------------------------

### Run multiple commands with concurrently

Source: https://www.npmjs.com/package/concurrently

This example demonstrates how to use the concurrently function to run an array of commands. It shows how to specify commands as strings or objects with additional properties like name, environment variables, and working directory. Options like prefix, killOthers, and restartTries are also configured.

```javascript
const concurrently = require('concurrently');
const { result } = concurrently(
  [
    'npm:watch-*',
    { command: 'nodemon', name: 'server' },
    { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
    {
      command: 'watch',
      name: 'watch',
      cwd: path.resolve(__dirname, 'scripts/watchers'),
    },
  ],
  {
    prefix: 'name',
    killOthers: ['failure', 'success'],
    restartTries: 3,
    cwd: path.resolve(__dirname, 'scripts'),
  },
);
result.then(success, failure);
```

--------------------------------

### Install Concurrently Locally

Source: https://www.npmjs.com/package/concurrently?activeTab=dependents

Install concurrently as a development dependency for a specific project. This command is for npm users.

```bash
npm i -D concurrently
```

--------------------------------

### Install Concurrently Locally

Source: https://www.npmjs.com/package/concurrently

Install concurrently as a dev dependency for a specific package. This is recommended for development purposes. Adjust the command for your preferred package manager.

```bash
npm i -D concurrently
```

```bash
yarn add -D concurrently
```

```bash
pnpm add -D concurrently
```

```bash
bun add -d concurrently
```

--------------------------------

### Check Concurrently Version

Source: https://www.npmjs.com/package/concurrently

Run this command to check the installed version of concurrently.

```bash
concurrently --version
```

--------------------------------

### View Concurrently Help

Source: https://www.npmjs.com/package/concurrently

Run this command to view the list of available flags and options for concurrently.

```bash
concurrently --help
```

--------------------------------

### Command Object Methods

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

Methods available on the Command object to control and interact with the spawned process.

```APIDOC
## Command Methods

### `start()`

Starts the command and sets up all of the above streams.

### `send(message[, handle, options])`

Sends a message to the underlying process via IPC channels, returning a promise that resolves once the message has been sent. See Node.js docs.

### `kill([signal])`

Kills the command, optionally specifying a signal (e.g. `SIGTERM`, `SIGKILL`, etc).
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently?activeTab=dependents

Runs multiple commands concurrently. The `commands` argument is an array of strings, where each string is a command to be executed. The optional `options` argument is an object that can be used to configure the behavior of concurrently.

```APIDOC
## concurrently(commands[, options])

### Description
Runs multiple commands concurrently.

### Parameters
#### Path Parameters
- **commands** (Array<string>) - Required - An array of commands to execute.
- **options** (object) - Optional - Configuration options for concurrently.

### Example
```javascript
const concurrently = require('concurrently');

concurrently([
  'task1 --watch',
  'task2 --watch'
], {
  prefix: ' [%1] ',
  prefixColors: ['blue', 'red']
}).then(
  (success) => console.log(success),
  (failure) => console.error(failure)
);
```
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently

Runs multiple commands concurrently. It accepts an array of commands and an optional options object to configure the execution.

```APIDOC
## concurrently(commands[, options])

### Description
Runs multiple commands concurrently. It accepts an array of commands and an optional options object to configure the execution.

### Parameters
#### Path Parameters
- **commands** (Array<string | object>) - Required - An array of commands to run. Each command can be a string or an object with detailed properties.
  - **command** (string) - The command to execute.
  - **name** (string) - Optional - A name for the command, used for logging and identification.
  - **prefixColor** (string) - Optional - The color for the command's prefix.
  - **env** (object) - Optional - Environment variables for the command.
  - **cwd** (string) - Optional - The working directory for the command.
  - **ipc** (string) - Optional - Identifier for inter-process communication.
- **options** (object) - Optional - Configuration options for the concurrent execution.
  - **cwd** (string) - The working directory for all commands. Overridable per command. Default: `process.cwd()`.
  - **defaultInputTarget** (number) - The default input target for `inputStream`. Default: `0`.
  - **handleInput** (boolean) - If `true`, reads input from `process.stdin`.
  - **inputStream** (Readable stream) - A stream to read input from. Overrides `handleInput`.
  - **pauseInputStreamOnFinish** (boolean) - Pauses the input stream when all processes finish. Default: `true`.
  - **killOthersOn** (Array<string>) - Statuses to kill other commands upon first exit. Possible values: `success`, `failure`.
  - **maxProcesses** (number) - Maximum number of processes to run simultaneously.
  - **outputStream** (Writable stream) - Stream to write logs to. Default: `process.stdout`.
  - **prefix** (string) - Prefix type for logging. Possible values: `index`, `pid`, `time`, `command`, `name`, `none`, or a template.
  - **prefixColors** (Array<string> | string) - List of colors or a string for prefixes. `auto` enables automatic color picking.
  - **prefixLength** (number) - Number of characters to show for `command` prefix. Default: `10`.
  - **raw** (boolean) - If `true`, logs raw process output without prefixes or coloring. Overridable per command.
  - **successCondition** (string) - Condition for success. `first`, `last`, or anything else (all must succeed).
  - **restartTries** (number) - Number of attempts to restart a dying process. Default: `0`.
  - **restartDelay** (number) - Delay in milliseconds between process restarts. Default: `0`.
  - **timestampFormat** (string) - Unicode format for `time` prefix. Default: `yyyy-MM-dd HH:mm:ss.SSS`.
  - **additionalArguments** (Array<any>) - List of additional arguments to replace in each command.

### Returns
An object with the shape `{ result, commands }`:
  - **result** (Promise) - Resolves on success, rejects on failure. Contains an array of `CloseEvent`s in termination order.
  - **commands** (Array<Command>) - An array of all spawned `Command` objects.

### Request Example
```javascript
const concurrently = require('concurrently');
const { result } = concurrently(
  [
    'npm:watch-*',
    { command: 'nodemon', name: 'server' },
    { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
    {
      command: 'watch',
      name: 'watch',
      cwd: path.resolve(__dirname, 'scripts/watchers'),
    },
  ],
  {
    prefix: 'name',
    killOthers: ['failure', 'success'],
    restartTries: 3,
    cwd: path.resolve(__dirname, 'scripts'),
  },
);
result.then(success, failure);
```
```

--------------------------------

### Command Object

Source: https://www.npmjs.com/package/concurrently?activeTab=code

Represents a spawned command and provides methods to interact with it. It exposes streams for stdout, stderr, and various events.

```APIDOC
## `Command`

An object that contains all information about a spawned command, and ways to interact with it.

### Properties

* `index`: the index of the command among all commands spawned.
* `command`: the command line of the command.
* `name`: the name of the command; defaults to an empty string.
* `cwd`: the current working directory of the command.
* `env`: an object with all the environment variables that the command will be spawned with.
* `killed`: whether the command has been killed.
* `state`: the command's state. Can be one of:
    * `stopped`: if the command was never started
    * `started`: if the command is currently running
    * `errored`: if the command failed spawning
    * `exited`: if the command is not running anymore, e.g. it received a close event
* `pid`: the command's process ID.
* `stdin`: a Writable stream to the command's `stdin`.
* `stdout`: an RxJS observable to the command's `stdout`.
* `stderr`: an RxJS observable to the command's `stderr`.
* `error`: an RxJS observable to the command's error events (e.g. when it fails to spawn).
* `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.
Both observables emit `MessageEvent`s. Note that if the command wasn't spawned with IPC support, these won't emit any values.
* `close`: an RxJS observable to the command's close events. See `CloseEvent` for more information.

### Methods

* `start()`: starts the command and sets up all of the above streams
* `send(message[, handle, options])`: sends a message to the underlying process via IPC channels, returning a promise that resolves once the message has been sent. See Node.js docs.
* `kill([signal])`: kills the command, optionally specifying a signal (e.g. `SIGTERM`, `SIGKILL`, etc).
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently?activeTab=dependents

Executes an array of commands concurrently. It supports various options for customization, such as setting the working directory, handling input/output streams, and defining success conditions.

```APIDOC
## concurrently(commands[, options])

### Description

Executes an array of commands concurrently. It supports various options for customization, such as setting the working directory, handling input/output streams, and defining success conditions.

### Parameters

#### `commands`

- An array of either strings (containing the commands to run) or objects with the shape `{ command, name, prefixColor, env, cwd, ipc }`.

#### `options` (optional)

- `cwd` (string): The working directory to be used by all commands. Can be overridden per command. Default: `process.cwd()`.
- `defaultInputTarget` (number): The default input target when reading from `inputStream`. Default: `0`.
- `handleInput` (boolean): When `true`, reads input from `process.stdin`.
- `inputStream` (Readable stream): A `Readable` stream 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` (boolean): By default, pauses the input stream when all processes have finished. If you need to read from the input stream after `concurrently` has finished, set this to `false`.
- `killOthersOn` (array of strings): 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` (number): How many processes should run at once.
- `outputStream` (Writable stream): A `Writable` stream to write logs to. Default: `process.stdout`.
- `prefix` (string): 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` (array of strings or string): A list of colors or a string as supported by chalk and additional style `auto` for an automatically picked color. Prefix colors specified per-command take precedence over this list.
- `prefixLength` (number): How many characters to show when prefixing with `command`. Default: `10`.
- `raw` (boolean): Whether raw mode should be used, meaning strictly process output will be logged, without any prefixes, coloring or extra stuff. Can be overridden per command.
- `successCondition` (string): The condition to consider the run was successful. If `first`, only the first process to exit will make up the success of the run; if `last`, the last process that exits will determine whether the run succeeds. Anything else means all processes should exit successfully.
- `restartTries` (number): How many attempts to restart a process that dies will be made. Default: `0`.
- `restartDelay` (number): How many milliseconds to wait between process restarts. Default: `0`.
- `timestampFormat` (string): A Unicode format to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.SSS`.
- `additionalArguments` (array): List of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.

### Returns

- An object in the shape `{ result, commands }`.
  - `result` (Promise): A Promise that resolves if the run was successful (according to `successCondition` option), or rejects, containing an array of `CloseEvent`, in the order that the commands terminated.
  - `commands` (array): An array of all spawned `Command`s.

### Example

```javascript
const concurrently = require('concurrently');
const { result } = concurrently(
  [
    'npm:watch-*',
    { command: 'nodemon', name: 'server' },
    { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
    {
      command: 'watch',
      name: 'watch',
      cwd: path.resolve(__dirname, 'scripts/watchers'),
    },
  ],
  {
    prefix: 'name',
    killOthers: ['failure', 'success'],
    restartTries: 3,
    cwd: path.resolve(__dirname, 'scripts'),
  },
);
result.then(success, failure);
```
```

--------------------------------

### Command Object

Source: https://www.npmjs.com/package/concurrently?activeTab=versions

The Command object provides information about a spawned command and methods to interact with it. It exposes properties for command details, state, and streams for stdout, stderr, and events.

```APIDOC
## Command Object Properties

### Properties
- `index` (number): The index of the command among all commands spawned.
- `command` (string): The command line of the command.
- `name` (string): The name of the command; defaults to an empty string.
- `cwd` (string): The current working directory of the command.
- `env` (object): An object with all the environment variables that the command will be spawned with.
- `killed` (boolean): Whether the command has been killed.
- `state` (string): The command's state. Can be one of `stopped`, `started`, `errored`, `exited`.
- `pid` (number): The command's process ID.
- `stdin` (Writable stream): A Writable stream to the command's `stdin`.
- `stdout` (RxJS observable): An RxJS observable to the command's `stdout`.
- `stderr` (RxJS observable): An RxJS observable to the command's `stderr`.
- `error` (RxJS observable): An RxJS observable to the command's error events (e.g. when it fails to spawn).
- `timer` (RxJS observable): An RxJS observable to the command's timing events (e.g. starting, stopping).
- `stateChange` (RxJS observable): An RxJS observable for changes to the command's `state` property.
- `messages` (object): An object with properties for IPC messages.
  - `incoming` (RxJS observable): An RxJS observable for the IPC messages received from the underlying process.
  - `outgoing` (RxJS observable): An RxJS observable for the IPC messages sent to the underlying process.
- `close` (RxJS observable): An RxJS observable to the command's close events.

### Methods
- `start()`: Starts the command and sets up all of the above streams.
- `send(message[, handle, options])`: Sends a message to the underlying process via IPC channels, returning a promise that resolves once the message has been sent.
- `kill([signal])`: Kills the command, optionally specifying a signal (e.g. `SIGTERM`, `SIGKILL`, etc).
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

Runs multiple commands concurrently. It accepts an array of commands and an optional options object to customize its behavior.

```APIDOC
## concurrently(commands[, options])

### Description
Runs multiple commands concurrently. It accepts an array of commands and an optional options object to customize its behavior.

### Parameters
#### `commands`
- An array of strings (containing the commands to run) or objects with the shape `{ command, name, prefixColor, env, cwd, ipc }`.

#### `options` (optional)
- `cwd`: The working directory to be used by all commands. Can be overridden per command. Default: `process.cwd()`.
- `defaultInputTarget`: The default input target when reading from `inputStream`. Default: `0`.
- `handleInput`: When `true`, reads input from `process.stdin`.
- `inputStream`: A `Readable` stream 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 when all processes have finished. If you need to read from the input stream after `concurrently` has finished, set this to `false`.
- `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 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 and additional style `auto` for an automatically picked color. Prefix colors specified per-command take precedence over this list.
- `prefixLength`: How many characters to show when prefixing with `command`. Default: `10`.
- `raw`: Whether raw mode should be used, meaning strictly process output will be logged, without any prefixes, coloring or extra stuff. Can be overridden per command.
- `successCondition`: The condition to consider the run was successful. If `first`, only the first process to exit will make up the success of the run; if `last`, the last process that exits will determine whether the run succeeds. Anything else means all processes should exit successfully.
- `restartTries`: How many attempts to restart a process that dies will be made. Default: `0`.
- `restartDelay`: How many milliseconds to wait between process restarts. Default: `0`.
- `timestampFormat`: A Unicode format to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.SSS`.
- `additionalArguments`: List of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.

### Returns
- An object in the shape `{ result, commands }`.
  - `result`: A `Promise` that resolves if the run was successful (according to `successCondition` option), or rejects, containing an array of `CloseEvent`, in the order that the commands terminated.
  - `commands`: An array of all spawned `Command`s.

### Example
```javascript
const concurrently = require('concurrently');
const { result } = concurrently(
  [
    'npm:watch-*',
    { command: 'nodemon', name: 'server' },
    { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
    {
      command: 'watch',
      name: 'watch',
      cwd: path.resolve(__dirname, 'scripts/watchers'),
    },
  ],
  {
    prefix: 'name',
    killOthers: ['failure', 'success'],
    restartTries: 3,
    cwd: path.resolve(__dirname, 'scripts'),
  },
);
result.then(success, failure);
```
```

--------------------------------

### Command Object

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

Represents a single command to be executed by concurrently, allowing for more detailed configuration.

```APIDOC
## Command Object

### Description
An object that can be used instead of a string in the `commands` array to provide more detailed configuration for a single command.

### Fields
- **command** (string): The command to execute.
- **name** (string): An optional name for the command, used for identification in output.
- **prefix** (string): An optional prefix for this specific command's output.
- **color** (string): An optional color for this specific command's output prefix.
- **cwd** (string): An optional current working directory for this command.
- **env** (object): An optional environment variables object for this command.
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently

The main function to run multiple commands concurrently. It takes an array of commands and an optional options object.

```APIDOC
## concurrently(commands[, options])

### Description

Runs multiple commands concurrently. Accepts an array of command strings and an optional configuration object.

### Parameters

#### commands

- **commands** (Array<string>) - Required - An array of command strings to execute.

#### options

- **options** (object) - Optional - Configuration options for concurrently.
  - **prefix** (string) - Optional - A prefix to add to each line of output.
  - **killOthers** (boolean) - Optional - If true, kills all other processes when one exits.
  - **timestampFormat** (string) - Optional - Format for timestamps in the output.

### Example

```javascript
import concurrently from 'concurrently';

concurrently([
  'npm run watch-js',
  'npm run watch-css'
], {
  killOthers: ['success', 'failure'],
  prefix: 'ND'`,
  timestampFormat: 'HH:mm:ss'
}).then(
  (success) => console.log(success.join("\n")),
  (err) => console.error(err)
);
```
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

The main function to run multiple commands concurrently. It takes an array of commands and an optional options object.

```APIDOC
## concurrently(commands[, options])

### Description
Runs multiple commands concurrently. This is the primary function for programmatic usage.

### Parameters
#### commands
- **commands** (Array<string | Command>): An array of commands to execute. Each command can be a string or a `Command` object.

#### options
- **options** (object) - Optional - Configuration options for concurrently.
  - **cwd** (string): The current working directory for the commands.
  - **stdin** (boolean): Whether to pipe stdin to the child processes.
  - **raw** (boolean): Whether to use raw mode for output.
  - **prefix** (string): A prefix to add to each line of output.
  - **prefixColors** (Array<string>): An array of colors to use for prefixes.
  - **restartTries** (number): Number of times to restart commands.
  - **restartDelay** (number): Delay in milliseconds before restarting commands.
  - **killOthers** (boolean): Whether to kill other processes when one dies.
  - **successCondition** (string): Condition for success (e.g., 'all-ok', 'first-success').
  - **onInput** (function): Callback function for input events.
  - **onOutput** (function): Callback function for output events.
  - **onClose** (function): Callback function for close events.

### Returns
- A Promise that resolves when all commands have finished or rejects if any command fails (depending on `successCondition`).
```

--------------------------------

### Command

Source: https://www.npmjs.com/package/concurrently

Represents a command to be executed by concurrently. This is typically a string.

```APIDOC
## Command

### Description

A command to be executed. This is usually a string representing a shell command.

### Type

`string`

### Example

```javascript
const commands = [
  'echo "First command"',
  'sleep 2 && echo "Second command"'
];
```
```

--------------------------------

### Command

Source: https://www.npmjs.com/package/concurrently?activeTab=code

Represents a single command to be executed by concurrently. This is typically a string, but can also be an object for more complex configurations.

```APIDOC
## Command

### Description

A `Command` in the context of `concurrently` typically refers to a single instruction that will be executed. While most commonly represented as a string, it can also be an object to provide additional configuration for that specific command.

### Type

- **string** or **object**

### String Representation

When provided as a string, it's the command to be executed directly in the shell.

### Object Representation

When provided as an object, it allows for more granular control over the command's execution:

- **name** (string) - Optional - A name for the command, which can be used for identification or logging.
- **command** (string) - Required - The actual command string to execute.
- **cwd** (string) - Optional - The current working directory for this specific command.
- **env** (object) - Optional - Environment variables specific to this command.
- **prefix** (string) - Optional - A prefix to apply to the output of this command.
- **prefixColor** (string) - Optional - The color to use for the prefix of this command's output.

### Example

```javascript
import concurrently from 'concurrently';

const commands = [
  { command: 'npm run build', name: 'Build Process', prefixColor: 'blue' },
  { command: 'npm run test', name: 'Test Process', prefixColor: 'red' },
];

concurrently(commands);
```
```

--------------------------------

### concurrently(commands[, options])

Source: https://www.npmjs.com/package/concurrently?activeTab=versions

Runs multiple commands concurrently. It accepts an array of commands and an optional options object to customize its behavior. Returns an object containing a result Promise and the spawned commands.

```APIDOC
## `concurrently(commands[, options])`

### Description
Runs multiple commands concurrently. It accepts an array of commands and an optional options object to customize its behavior. Returns an object containing a result Promise and the spawned commands.

### Parameters
#### `commands`
- An array of strings (containing the commands to run) or objects with the shape `{ command, name, prefixColor, env, cwd, ipc }`.

#### `options` (optional)
- `cwd`: The working directory to be used by all commands. Can be overridden per command. Default: `process.cwd()`.
- `defaultInputTarget`: The default input target when reading from `inputStream`. Default: `0`.
- `handleInput`: When `true`, reads input from `process.stdin`.
- `inputStream`: A `Readable` stream 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 when all of the processes have finished. If you need to read from the input stream after `concurrently` has finished, set this to `false`.
- `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 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 and additional style `auto` for an automatically picked color. Prefix colors specified per-command take precedence over this list.
- `prefixLength`: How many characters to show when prefixing with `command`. Default: `10`.
- `raw`: Whether raw mode should be used, meaning strictly process output will be logged, without any prefixes, coloring or extra stuff. Can be overridden per command.
- `successCondition`: The condition to consider the run was successful. If `first`, only the first process to exit will make up the success of the run; if `last`, the last process that exits will determine whether the run succeeds. Anything else means all processes should exit successfully.
- `restartTries`: How many attempts to restart a process that dies will be made. Default: `0`.
- `restartDelay`: How many milliseconds to wait between process restarts. Default: `0`.
- `timestampFormat`: A Unicode format to use when prefixing with `time`. Default: `yyyy-MM-dd HH:mm:ss.SSS`.
- `additionalArguments`: List of additional arguments passed that will get replaced in each command. If not defined, no argument replacing will happen.

### Returns
An object in the shape `{ result, commands }`:
- `result`: A `Promise` that resolves if the run was successful (according to `successCondition` option), or rejects, containing an array of `CloseEvent`, in the order that the commands terminated.
- `commands`: An array of all spawned `Command`s.

### Example
```javascript
const concurrently = require('concurrently');
const { result } = concurrently(
  [
    'npm:watch-*',
    { command: 'nodemon', name: 'server' },
    { command: 'deploy', name: 'deploy', env: { PUBLIC_KEY: '...' } },
    {
      command: 'watch',
      name: 'watch',
      cwd: path.resolve(__dirname, 'scripts/watchers'),
    },
  ],
  {
    prefix: 'name',
    killOthers: ['failure', 'success'],
    restartTries: 3,
    cwd: path.resolve(__dirname, 'scripts'),
  },
);
result.then(success, failure);
```
```

--------------------------------

### Command Object Properties

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

The Command object provides detailed information about a spawned command and exposes streams for its output and state changes.

```APIDOC
## Command Object

An object that contains all information about a spawned command, and ways to interact with it.

### Properties

*   `index` (number): The index of the command among all commands spawned.
*   `command` (string): The command line of the command.
*   `name` (string): The name of the command; defaults to an empty string.
*   `cwd` (string): The current working directory of the command.
*   `env` (object): An object with all the environment variables that the command will be spawned with.
*   `killed` (boolean): Whether the command has been killed.
*   `state` (string): The command's state. Can be one of:
    *   `stopped`: if the command was never started
    *   `started`: if the command is currently running
    *   `errored`: if the command failed spawning
    *   `exited`: if the command is not running anymore, e.g. it received a close event
*   `pid` (number): The command's process ID.
*   `stdin` (Writable stream): A Writable stream to the command's `stdin`.
*   `stdout` (RxJS observable): An RxJS observable to the command's `stdout`.
*   `stderr` (RxJS observable): An RxJS observable to the command's `stderr`.
*   `error` (RxJS observable): An RxJS observable to the command's error events (e.g. when it fails to spawn).
*   `timer` (RxJS observable): An RxJS observable to the command's timing events (e.g. starting, stopping).
*   `stateChange` (RxJS observable): An RxJS observable for changes to the command's `state` property.
*   `messages` (object): An object containing IPC message observables:
    *   `incoming` (RxJS observable): An RxJS observable for the IPC messages received from the underlying process. Emits `MessageEvent`s.
    *   `outgoing` (RxJS observable): An RxJS observable for the IPC messages sent to the underlying process. Emits `MessageEvent`s.
*   `close` (RxJS observable): An RxJS observable to the command's close events. See `CloseEvent` for more information.
```

--------------------------------

### Configure Scripts in package.json

Source: https://www.npmjs.com/package/concurrently

When using concurrently within the scripts section of package.json, escape the quotes around the commands.

```json
"start": "concurrently 'command1 arg' 'command2 arg'"
```

--------------------------------

### Run Multiple Commands

Source: https://www.npmjs.com/package/concurrently

Use concurrently to run multiple commands concurrently. Ensure separate commands are surrounded by quotes to be treated as single commands.

```bash
concurrently 'command1 arg' 'command2 arg'
```

--------------------------------

### Command

Source: https://www.npmjs.com/package/concurrently?activeTab=dependents

Represents a command to be executed by concurrently. This is typically a string that can be directly passed to a shell.

```APIDOC
## Command

### Description
Represents a command to be executed by concurrently. This is typically a string that can be directly passed to a shell.

### Type
string
```

--------------------------------

### CloseEvent

Source: https://www.npmjs.com/package/concurrently?activeTab=versions

Contains information about a command's closing event.

```APIDOC
## CloseEvent

### Properties
- `command` (object): A stripped down version of `Command`, including only `name`, `command`, `env` and `cwd` properties.
- `index` (number): The index of the command among all commands spawned.
- `killed` (boolean): Whether the command exited because it was killed.
- `exitCode` (number | string | null): The exit code of the command's process, or the signal which it was killed with.
- `timings` (object): An object in the shape `{ startDate, endDate, durationSeconds }`.
```

--------------------------------

### CloseEvent

Source: https://www.npmjs.com/package/concurrently?activeTab=code

Provides information about a command's closing event.

```APIDOC
## `CloseEvent`

An object with information about a command's closing event.

### Properties

* `command`: a stripped down version of `Command`, including only `name`, `command`, `env` and `cwd` properties.
* `index`: the index of the command among all commands spawned.
* `killed`: whether the command exited because it was killed.
* `exitCode`: the exit code of the command's process, or the signal which it was killed with.
* `timings`: an object in the shape `{ startDate, endDate, durationSeconds }`.
```

--------------------------------

### CloseEvent Object

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

Contains information about a command's closing event.

```APIDOC
## CloseEvent

An object with information about a command's closing event.

### Properties

*   `command` (object): A stripped down version of `Command`, including only `name`, `command`, `env` and `cwd` properties.
*   `index` (number): The index of the command among all commands spawned.
*   `killed` (boolean): Whether the command exited because it was killed.
*   `exitCode` (number | string | null): The exit code of the command's process, or the signal which it was killed with.
*   `timings` (object): An object in the shape `{ startDate, endDate, durationSeconds }`.
```

--------------------------------

### MessageEvent Object

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

Represents an IPC message exchanged with the underlying command process.

```APIDOC
## MessageEvent

An object that represents a message that was received from/sent to the underlying command process.

### Properties

*   `message`: The message itself.
*   `handle` (`net.Socket`, `net.Server`, `dgram.Socket`, or `undefined`): A network handle, if one was sent, or `undefined`.
```

--------------------------------

### MessageEvent

Source: https://www.npmjs.com/package/concurrently?activeTab=versions

Represents a message sent or received via IPC channels from the underlying command process.

```APIDOC
## MessageEvent

### Properties
- `message` (any): The message itself.
- `handle` (net.Socket | net.Server | dgram.Socket | undefined): A network socket or server if one was sent, or `undefined`.
```

--------------------------------

### CloseEvent

Source: https://www.npmjs.com/package/concurrently?activeTab=code

Represents an event that occurs when a child process exits.

```APIDOC
## CloseEvent

### Description

The `CloseEvent` is an object that is part of the result when `concurrently` finishes execution. It provides information about the exit of a child process.

### Properties

- **command** (string) - The command that was executed.
- **exitCode** (number | null) - The exit code of the process. `null` if the process was terminated by a signal.
- **signal** (string | null) - The signal that terminated the process, if applicable. `null` otherwise.
- **stdout** (string) - The standard output captured from the process.
- **stderr** (string) - The standard error captured from the process.

### Example

When `concurrently` resolves, the `results` object might contain information structured like this:

```javascript
// Example of a successful result structure
{
  results: [
    {
      command: 'echo "Hello"',
      exitCode: 0,
      signal: null,
      stdout: 'Hello\n',
      stderr: ''
    }
  ],
  // ... other potential properties of the results object
}
```
```

--------------------------------

### CloseEvent Object

Source: https://www.npmjs.com/package/concurrently?activeTab=dependencies

Represents an event that occurs when a child process is closed.

```APIDOC
## CloseEvent Object

### Description
An object representing the event emitted when a child process managed by concurrently is closed.

### Fields
- **name** (string): The name of the command that closed.
- **exitCode** (number): The exit code of the closed process.
- **signal** (string | null): The signal that terminated the process, if any.
- **killed** (boolean): Whether the process was killed by concurrently.
```

--------------------------------

### CloseEvent

Source: https://www.npmjs.com/package/concurrently?activeTab=dependents

Represents an event that occurs when a child process managed by concurrently closes.

```APIDOC
## CloseEvent

### Description
Represents an event that occurs when a child process managed by concurrently closes.

### Properties
- **command** (string) - The command that was executed.
- **exitCode** (number) - The exit code of the process.
- **killed** (boolean) - Whether the process was killed.
- **signal** (string | null) - The signal that terminated the process, if any.
```

--------------------------------

### CloseEvent

Source: https://www.npmjs.com/package/concurrently

Represents an event that occurs when a process managed by concurrently closes.

```APIDOC
## CloseEvent

### Description

An object representing the event when a child process managed by concurrently closes.

### Properties

- **id** (number) - The ID of the process.
- **signal** (string | null) - The signal that caused the process to close, or null if it exited normally.
- **exitCode** (number | null) - The exit code of the process, or null if it was terminated by a signal.
```
Tokens:
Raw