# @allurereport/plugin-progress

> Allure Plugin to show generation progress in console

Latest version **3.20.0** (published 2026-10-02) · Apache-2.0 license · 0 weekly downloads

## Install

```sh
npm install @allurereport/plugin-progress
pnpm add @allurereport/plugin-progress
yarn add @allurereport/plugin-progress
bun add @allurereport/plugin-progress
```

## Health

**Score 70/100 (B)** — status: active.

Positive: has types; esm support; no vulnerabilities; recently updated; high maintenance score; high quality score.

Warnings: low downloads.

## Facts

| | |
|---|---|
| Version | 3.20.0 |
| Published | 2026-10-02 |
| First published | 2024-12-12 |
| Weekly downloads | 0 |
| License | Apache-2.0 |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 3 |
| Unpacked size | 18.1 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 414 |
| Author | Qameta Software |
| Maintainers | qameta-bot, baev |
| Keywords | allure, cli, plugin, report, stdout, testing |

## Links

- npm: https://www.npmjs.com/package/@allurereport/plugin-progress
- Repository: https://github.com/allure-framework/allure3
- npm.io page: https://npm.io/package/@allurereport/plugin-progress

## Dependencies (3)

- [yoctocolors](https://npm.io/package/yoctocolors.md) ^2.2.0
- [@allurereport/core-api](https://npm.io/package/@allurereport/core-api.md) 3.20.0
- [@allurereport/plugin-api](https://npm.io/package/@allurereport/plugin-api.md) 3.20.0

## Alternatives

- [@salesforce/cli](https://npm.io/package/@salesforce/cli.md) — 389.7K weekly downloads
- [@mintlify/cli](https://npm.io/package/@mintlify/cli.md) — 208.9K weekly downloads
- [@grafana/e2e-selectors](https://npm.io/package/@grafana/e2e-selectors.md) — 128.7K weekly downloads
- [mintlify](https://npm.io/package/mintlify.md) — 112.0K weekly downloads
- [@intlayer/cli](https://npm.io/package/@intlayer/cli.md) — 22.8K weekly downloads

## Recent versions

- 3.20.0 (latest) — 2026-10-02
- 3.19.1 — 2026-09-29
- 3.19.0 — 2026-09-28
- 3.18.0 — 2026-09-18
- 3.17.0 — 2026-09-09
- 3.16.1 — 2026-09-07
- 3.16.0 — 2026-08-25
- 3.15.0 — 2026-08-13
- 3.14.3 — 2026-07-13
- 3.14.2 — 2026-07-08
- 3.14.1 — 2026-07-03
- 3.14.0 — 2026-06-30
- 3.13.2 — 2026-06-26
- 3.13.1 — 2026-06-24
- 3.13.0 — 2026-06-23
- … 45 more at https://npm.io/package/@allurereport/plugin-progress/versions

## README

# Allure 3

**Allure 3** is the next evolution of the Allure reporting framework, rebuilt from the ground up with a new architecture and expanded capabilities. Unlike its predecessor, **Allure 2**, this version is developed in **TypeScript** and introduces a modular plugin system for greater flexibility. A key addition is the **Awesome** plugin, which delivers an enhanced UI for better report visualization.

The **Allure 3 CLI** provides a comprehensive suite of commands designed to streamline the generation, serving, and management of test reports.

[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")

- Learn more about Allure Report at https://allurereport.org
- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
- 📢 [Official annoucements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
- 💬 [General Discussion](https://github.com/orgs/allure-framework/discussions/categories/general-discussion)  – engage in casual conversations, share insights and ideas with the community

## Key Features

Allure 3 introduces several notable improvements. The framework has been entirely rewritten in **TypeScript**, making it more extensible and easier to maintain. Its **plugin system** allows you to customize and extend reporting functionality to fit your specific needs. Configuration has been simplified with a **single file** managing all report settings, making it more convenient to handle multiple reports.

One of the standout features is **real-time reporting**, which lets you view live updates during test execution using the `watch` command. The report interface itself has been redesigned to enhance usability and clarity. Moreover, Allure 3 maintains **compatibility with the entire Allure ecosystem**, supporting all major test frameworks.

## Installation

To install Allure 3 globally, you can use [`npm`](https://docs.npmjs.com/downloading-and-installing-packages-globally). Simply run:

```bash
npm install -g allure
```

However, we recommend using `npx` for running Allure commands without needing a global installation:

```bash
npx allure run -- <test_command>
```

This approach ensures you always use the latest version without managing global dependencies.

## Commands

### Running Tests and Generating Reports

Running tests and generating a report with Allure 3 is straightforward. Using the `run` command, you can execute your test suite and automatically generate a report:

```bash
npx allure run -- <test_command>
```

For example, if you're using `npm` as your test runner, the command would be:

```bash
npx allure run -- npm test
```

If you need to hide some labels use `--hide-labels` option:

```bash
npx allure run --hide-labels=owner --hide-labels=tag -- npm test
```

To successfully generate a report, ensure that your test setup outputs results into an `allure-results` directory, which is automatically detected by Allure 3. This directory can be placed at any nested level within your project (e.g., `out/tests/allure-results`), provided it retains the correct name.

After the tests complete, the report is generated automatically. Existing results from previous runs are ignored, as Allure 3 focuses solely on new data to ensure accurate and up-to-date reporting.

### Running Tests In Agent Mode

When you need agent-friendly markdown output for review, debugging, or scope validation, use the `agent` command:

```bash
npx allure agent -- <test_command>
```

For example:

```bash
npx allure agent -- npm test
```

To analyze existing Allure results or dump archives downloaded from CI without
rerunning tests, use `agent inspect`:

```bash
npx allure agent inspect path/to/allure-results
npx allure agent inspect --dump allure-results-linux.zip --dump allure-results-macos.zip
npx allure agent inspect --config ./allurerc.mjs --output ./agent-output path/to/allure-results
```

`agent inspect` accepts the same result inputs and configuration-style options as
`allure generate`, including result directory globs, `--dump`, `--config`,
`--cwd`, `--report-name`, `--history-limit`, and `--hide-labels`. Its `--output`
option writes the agentic output directory.

`allure agent` and `allure agent inspect` use `--report auto` by default. This writes the agent-readable artifacts and, when the stored visible result count is 1000 or fewer, also writes a single-file Awesome report at `awesome/index.html` inside the agent output directory. Runs above that threshold skip the human report to avoid excessive output, and the status is recorded in `index.md`, `manifest/run.json`, and `manifest/human-report.json`.

Use `--report off` for agent-only artifacts, `--report awesome` to force the single-file Awesome report regardless of result count, or `--report config` to force the configured non-agent report plugins inside the agent output directory. Configured presentation or export plugins such as Dashboard or TestOps are otherwise ignored for agent runs.

If you need the human-readable report from the most recent agent run, first run `npx allure agent latest` when the output directory is unknown. Then check `<output>/manifest/human-report.json`; when its status is `generated`, open `<output>/<path>` from that manifest, usually `<output>/awesome/index.html`.

`allure agent` creates a fresh output directory automatically, accepts compact inline expectations such as `--goal`, `--expect-tests`, `--expect-test`, `--expect-label`, and `--expect-step-containing`, and can load an expectations file with `--expectations`.

Agents and setup tools can inspect the local structured capability contract without scraping help text:

```bash
npx allure agent capabilities --json
```

### Generating Reports Manually

If you already have test results and wish to generate a report manually, use the `generate` command:

```bash
npx allure generate <resultsDir>
```

By default, this command produces an **Allure 3 Awesome** report. You can customize output settings, such as the destination directory, through the configuration file. If you prefer a **Classic** or **Allure 2-style** report, or need to disable certain plugins, these adjustments can also be made via configuration.

### Viewing Reports

To view a previously generated report locally, the `open` command serves it in your default browser:

```bash
npx allure open <reportDir>
```

When `<reportDir>` is omitted, Allure 3 uses the configured output directory, falling back to `allure-report` when no output is configured. To open the Awesome report directly, point to the nested directory:

```bash
npx allure open allure-report/awesome
```

You can also open a directory with result files. The report will be generated on the fly and opened in the browser:

```bash
npx allure open ./allure-results
```

### Real-time Report Monitoring

When you need to monitor test execution live, the `watch` command provides dynamic report updates. It continuously monitors the specified results directory for changes and refreshes the report automatically:

```bash
npx allure watch <allureResultsDir>
```

This command is ideal for iterative development and debugging, allowing you to see immediate feedback as you modify and rerun tests. The browser tab updates seamlessly whenever new results are detected.

### Command-line Options

The Allure CLI includes several helpful global options. Use `--help` to explore available commands or get detailed usage information for a specific command:

```bash
npx allure run --help
npx allure agent capabilities --json
npx allure agent --help
npx allure watch --help
```

To check your installed version of Allure 3, use:

```bash
npx allure --version
```

## Configuration

Allure 3 uses an `allurerc.ts`, `allurerc.mts`, `allurerc.cts`, `allurerc.mjs`, or `allurerc.js` configuration file to manage report settings, including the report name, output directory, and plugin options.

> [!TIP]
> We recommend using the **Awesome** plugin for the best experience.  
> Support for Classic and Allure 2-style reports is currently experimental.

### Example Configuration File

```js
import { defineConfig } from "allure";

export default defineConfig({
  name: "Allure Report Example",
  output: "./out/allure-report",
  hideLabels: ["owner", /^_/],
  plugins: {
    awesome: {
      options: {
        singleFile: true,
        reportLanguage: "en",
      },
    },
  },
});
```

In this example, the generated report is named *Allure Report Example* and saved to the `./out/allure-report` directory. The **Awesome** plugin is enabled with options to produce a single-file HTML report in English.

### TypeScript Configuration File

TypeScript configuration files are loaded directly by the Allure CLI, so you don't need to precompile them or install `tsx` or `ts-node`.

```ts
import type { AllureConfig } from "allure";

export default {
  name: "Allure Report Example",
  output: "./out/allure-report",
} satisfies AllureConfig;
```

For editor type checking, make sure the `allure` package is available to your project, for example as a local dev dependency. If you run Allure only as a global CLI, you can still use a TypeScript config without importing from `allure`.

### Configuration Options

The configuration file allows you to fine-tune report generation. Key options include:

- **`name`**: Specifies the report’s display name.
- **`output`**: Defines the directory where the report will be saved.
- **`hideLabels`** *(`(string | RegExp)[]`)*: Hides matching labels by name in report data. Currently, only Allure Awesome report respects the option. Labels with names starting with `_` are hidden by default.
- **`plugins`**: Enables and configures plugins, with each supporting various options.

### Awesome Plugin Options

The **Awesome** plugin offers several customizable options:

- **`singleFile`** *(boolean)*: If set to `true`, generates the report as a single standalone HTML file.
- **`reportName`** *(string)*: Overrides the default report name.
- **`open`** *(boolean)*: Automatically opens the report after generation if enabled.
- **`reportLanguage`** *(string)*: Sets the UI language of the report. Supported languages include:

  `az`, `br`, `de`, `en`, `es`, `fr`, `he`, `ja`, `kr`, `nl`, `pl`, `ru`, `sv`, `tr`, `zh`.

For example, setting `"reportLanguage": "fr"` will render the report interface in French.

### Categories (Awesome only)

> [!NOTE]
> Categories are currently supported only by the **Awesome** report.

Categories let you group test results into named buckets with optional grouping inside each category.
Configuration is defined at the top level of `defineConfig`.

> [!IMPORTANT]
> A test result can belong to only one category. The first matching rule wins, and results are not duplicated across categories.

#### Example

```js
import { defineConfig } from "allure";

export default defineConfig({
  name: "Allure Report Example",
  output: "./out/allure-report",
  categories: [
    {
      name: "Product errors",
      matchers: { statuses: ["failed"] },
      groupBy: ["severity", "owner", "environment"],
      groupByMessage: true,
      groupEnvironments: true,
      expand: true,
    },
    {
      name: "Flaky tests",
      matchers: { flaky: true },
      groupBy: ["flaky"],
      groupByMessage: false,
      hide: false,
    },
  ],
  plugins: {
    awesome: {
      options: {
        reportLanguage: "en",
      },
    },
  },
});
```

#### `categories` shape

You can provide either:

- an array of rules: `categories: CategoryRule[]`
- or an object with rules: `categories: { rules: CategoryRule[] }`

#### Default categories

If `categories` is not specified, two built‑in categories are enabled by default:

- **Product errors**: `statuses: ["failed"]`
- **Test errors**: `statuses: ["broken"]`

These defaults are always appended, but you can override them by defining rules with the same names.

#### Disabling categories

To skip categories generation entirely, use the short flag:

```js
export default defineConfig({
  categories: false,
});
```

#### Try it in the sandbox

To see categories in action, use the demo setup in the `packages/sandbox` folder and run it from there.

#### CategoryRule fields

- `**name**` *(string, required)*: Category title shown in the report.
- `**matchers*`* *(object | function | array, required)*:
  - **Object matcher** supports:
    - `statuses`: `TestStatus[]` (`passed`, `failed`, `broken`, `skipped`, `unknown`)
    - `labels`: `{ [labelName]: string | RegExp }`
    - `message`: `string | RegExp`
    - `trace`: `string | RegExp`
    - `flaky`: `boolean`
    - `transitions`: `TestStatusTransition[]` (`new`, `fixed`, `regressed`, `malfunctioned`)
    - `environments`: `string[]`
  - **Function matcher**: `(data) => boolean` where `data` includes
  `status`, `labels`, `message`, `trace`, `flaky`, `duration`, `transition`, `environment` or any custom label in your test results.
  - **Array of matchers**: any mix of object/function matchers.
- `**groupBy**` *(array)*: grouping order for category tree.
  - Built‑in selectors: `flaky`, `owner`, `severity`, `transition`, `status`, `environment`, `layer`
  - Custom selector: `{ label: "myLabel" }`
- `**groupByMessage*`* *(boolean, default `true`)*: show message grouping.
- `**groupEnvironments*`* *(boolean, optional)*:
  - `true` → always group by environments (default)
  - `false` → never group by environments
- `**expand*`* *(boolean, default `false`)*: expand category by default.
- `**hide*`* *(boolean, default `false`)*: exclude category from the tree.

### Declarative configuration format

You can also use `allurerc.json`, `allurerc.yaml`, or `allurerc.yml` files as a declarative way to configure Allure 3.

> [!WARNING]  
> Declarative formats don't support advanced features such as tests filtering or environments.
> If you need these features, please consider using the `allurerc.ts`, `allurerc.mts`, `allurerc.cts`, `allurerc.mjs`, or `allurerc.js` files.

## Official CI/CD Integrations

- [GitHub Actions](https://github.com/marketplace/actions/allure-report-official)
- [Azure DevOps](https://marketplace.visualstudio.com/items?itemName=qameta.allure-azure-pipelines)

---
_Source: https://npm.io/package/@allurereport/plugin-progress · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._