allure 3.20.1 → 3.22.0

package/README.md

@@ -73,6 +73,22 @@ Set `ALLURE_LOG_LEVEL=debug` to include details such as selected tests and tempo
 the generic `LOG_LEVEL` environment variable. Use `--silent` to hide the nested test process output while keeping
 Allure lifecycle messages visible.
 
+### Verbosity flags
+
+`-v/--verbose` and `-q/--quiet` are global flags accepted by every command (place them before `--` in `allure run`;
+everything after `--` is passed to your test command untouched).
+
+| Flag | Allure log level | `allure run` test process output |
+| --- | --- | --- |
+| _(none)_ | `ALLURE_LOG_LEVEL`, default `info` | printed |
+| `--verbose`, `-v` | `verbose` | printed |
+| `--quiet`, `-q` | `error` (errors only) | hidden, same as `--silent` |
+
+- The flags override `ALLURE_LOG_LEVEL`. `--verbose` and `--quiet` cannot be combined.
+- `--quiet` implies `--silent`. Logs are still collected into the report unless `--ignore-logs` is set.
+- `--silent` and `--ignore-logs` keep their meaning and are independent of `--verbose`.
+- A lone `allure -v` still prints the version.
+
 ### Running Tests In Agent Mode
 
 When you need agent-friendly markdown output for review, debugging, or scope validation, use the `agent` command:
@@ -103,7 +119,7 @@ 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.
+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 Allure 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`.
 
@@ -123,6 +139,23 @@ npx allure agent query --latest tests --status failed
 npx allure agent query --from ./agent-output findings --severity high
 ```
 
+### Generating GitHub Actions Jobs
+
+Print GitHub Actions jobs that run your tests once per environment and build a single Allure report from all of them:
+
+```bash
+npx allure gh-workflow --env foo --env bar --env baz -- npm test
+```
+
+Paste the output under `jobs:` in a workflow file and fill in the `TODO` steps (runtime setup and dependencies). The output has two jobs:
+
+- `test` runs `allure run --environment=<id> --dump=allure-results-<id> -- <test command>` for every environment in a matrix and uploads `allure-results-<id>.zip` as an artifact;
+- `report` downloads all `allure-results-*` artifacts and runs `allure generate --dump="allure-results-*/*.zip"`.
+
+The environment id, the dump file, the artifact name and the download pattern have to agree with each other; the command keeps them consistent.
+
+Environments come from `--env` (repeatable, no config needed). Without `--env`, the ids declared under `environments` in your Allure config are used (integer-like ids come first, as JavaScript orders object keys). Pass the test command after `--` (default: `npm test`); `--config` is also added to the generated `allure` commands. The versions of the GitHub actions in the output are examples, pin the ones you use. Errors are written to stderr with a non-zero exit code, while command-line syntax errors are reported by the CLI parser on stdout.
+
 ### Generating Reports Manually
 
 If you already have test results and wish to generate a report manually, use the `generate` command:
@@ -149,6 +182,26 @@ npx allure open allure-report/awesome
 
 If the provided directory doesn't contain previously generated report, it will be treated as a source of results, and a new report will be generated on the fly and opened in the browser.
 
+To stop serving the report, press CTRL+C.
+
+#### Serving a report without opening
+
+Use the `serve` command to start a local report server without opening a browser:
+
+```bash
+npx allure serve <reportDir>
+```
+
+Like `open`, this command uses the configured output directory when `<reportDir>` is omitted and generates a report on the fly when given test results. Open the URL printed in the console to view the report.
+
+Use `--host` and `--port` to control the interfaces and port to listen:
+
+```bash
+npx allure serve --port 8080 --host 127.0.0.1
+```
+
+Press CTRL+C to stop serving.
+
 ### 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:
@@ -176,12 +229,20 @@ To check your installed version of Allure 3, use:
 npx allure --version
 ```
 
+For direct interactive CLI invocations, Allure checks the npm registry for a newer version alongside the command.
+Each eligible invocation makes one request with a one-second timeout; no update state is stored on disk. Missing
+package metadata and network errors are silently ignored. The check is skipped for `allure agent`, help and version
+output, quiet mode, CI, non-interactive terminals, and invocations through npm or Yarn. Disable it with `--no-update-notifier`
+(for example, `allure --no-update-notifier generate ./allure-results`), or set `NO_UPDATE_NOTIFIER` for the environment.
+Numbered prerelease versions (such as `3.21.0-beta.2`) check their matching npm dist-tag instead of the stable `latest`
+tag. Unrecognized version formats are silently skipped.
+
 ## 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.  
+> We recommend using the **Awesome** plugin for the best experience.
 > Support for Classic and Allure 2-style reports is currently experimental.
 
 ### Example Configuration File
@@ -248,7 +309,7 @@ For example, setting `"reportLanguage": "fr"` will render the report interface i
 
 You can also use `allurerc.json`, `allurerc.yaml`, or `allurerc.yml` files as a declarative way to configure Allure 3.
 
-> [!WARNING]  
+> [!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.
 

package/dist/commands/{agent.js → agents/index.js}

@@ -1,25 +1,16 @@
 import * as console from "node:console";
-import { randomUUID } from "node:crypto";
-import { mkdir, mkdtemp, realpath, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { mkdir, realpath, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
 import process, { exit } from "node:process";
-import { AGENT_FINDING_CATEGORIES, AGENT_FINDING_SEVERITIES, AGENT_TASK_MAP_HELP, AGENT_TEST_STATUSES, AgentExpectationUsageError, assertExplicitAgentOutputDirIsSafe, buildAgentInlineExpectations, buildAgentQueryPayload, cleanupAgentRunState, cleanupStaleAgentRunStates, createAgentCapabilities, formatAgentOutputLinks, isAgentExpectationUsageError, isAgentTaskMapHelpRequest, isAgentUsageError, loadAgentOutput, normalizeAgentQueryLimit, normalizeAgentQueryView, normalizeAgentRerunPreset, normalizeRepeatedEnumValues, normalizeRepeatedStringValues, parseAgentLabelFilters, readLatestAgentState, resolveAgentSelectionOutputDir, resolveAgentStateDir, selectAgentTestPlan, validateAgentExpectationsFile, writeAgentRunState, writeInvalidAgentExpectationOutput, } from "@allurereport/plugin-agent";
+import { AGENT_FINDING_CATEGORIES, AGENT_FINDING_SEVERITIES, AGENT_TASK_MAP_HELP, AGENT_TEST_STATUSES, AgentExpectationUsageError, assertExplicitAgentOutputDirIsSafe, buildAgentInlineExpectations, buildAgentQueryPayload, createAgentCapabilities, isAgentExpectationUsageError, isAgentTaskMapHelpRequest, isAgentUsageError, loadAgentOutput, normalizeAgentQueryLimit, normalizeAgentQueryView, normalizeAgentRerunPreset, normalizeRepeatedEnumValues, normalizeRepeatedStringValues, parseAgentLabelFilters, readLatestAgentState, resolveAgentSelectionOutputDir, resolveAgentStateDir, selectAgentTestPlan, validateAgentExpectationsFile, } from "@allurereport/plugin-agent";
 import { Command, Option, UsageError } from "clipanion";
-import { parseRunCommand } from "../utils/resultsPatterns.js";
+import { parseRunCommand } from "../../utils/resultsPatterns.js";
+import { formatAgentCommand, formatAgentInspectCommand, printAgentOutputLinks, writeInvalidAgentExpectationRun, } from "./lifecycle.js";
 export { AGENT_TASK_MAP_HELP, createAgentCapabilities, isAgentTaskMapHelpRequest };
 const readOptionalString = (value) => (typeof value === "string" ? value : undefined);
 const readOptionalBoolean = (value) => value === true;
 const readOptionalStringArray = (value) => (Array.isArray(value) ? value : undefined);
-const formatAgentCommand = (args) => args.join(" ");
 const AGENT_HUMAN_REPORT_MODES = ["auto", "off", "awesome", "config"];
-const formatAgentInspectCommand = (params) => [
-    "allure",
-    "agent",
-    "inspect",
-    ...(params.dumps ?? []).flatMap((dump) => ["--dump", dump]),
-    ...(params.resultsDir ?? []),
-].join(" ");
 const buildInlineExpectationsFromOptions = (options) => buildAgentInlineExpectations({
     goal: options.goal,
     taskId: options.taskId,
@@ -34,53 +25,6 @@ const buildInlineExpectationsFromOptions = (options) => buildAgentInlineExpectat
     expectAttachments: options.expectAttachments,
     expectAttachmentFilters: readOptionalStringArray(options.expectAttachmentFilters),
 });
-const printAgentOutputLinks = (outputDir) => {
-    for (const line of formatAgentOutputLinks(outputDir)) {
-        console.log(line);
-    }
-};
-const persistAgentRunState = async (value) => {
-    try {
-        await writeAgentRunState(value);
-    }
-    catch (error) {
-        console.error(`Could not update agent state in ${resolveAgentStateDir(value.cwd)}: ${error.message}`);
-    }
-};
-const logAgentCleanupFailures = (failures) => {
-    for (const failure of failures) {
-        console.error(`Could not clean stale agent output ${failure.state.outputDir}: ${failure.error.message}`);
-    }
-};
-const logAgentOrphanCleanupFailures = (failures) => {
-    for (const failure of failures) {
-        console.error(`Could not clean stale agent output ${failure.outputDir}: ${failure.error.message}`);
-    }
-};
-const cleanupManagedAgentOutputs = async (params) => {
-    try {
-        const result = await cleanupAgentRunState({
-            cwd: params.cwd,
-            currentRunId: params.runId,
-            keepManagedRuns: params.managedOutput ? 1 : 0,
-        });
-        logAgentCleanupFailures(result.failed);
-    }
-    catch (error) {
-        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
-    }
-    try {
-        const staleResult = await cleanupStaleAgentRunStates({
-            cwd: params.cwd,
-            currentRunId: params.runId,
-        });
-        logAgentCleanupFailures(staleResult.failed);
-        logAgentOrphanCleanupFailures(staleResult.orphaned.failed);
-    }
-    catch (error) {
-        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
-    }
-};
 const agentEnvironmentOption = () => Option.String("--environment,--env", {
     description: "Force specific environment ID to all tests in the run. Given environment has higher priority than the one defined in the config file (default: empty string)",
 });
@@ -238,7 +182,7 @@ export class AgentCommand extends Command {
                 output,
                 expectations,
             });
-            const { executeAgentMode } = await import("./agent-run.js");
+            const { executeAgentMode } = await import("./run.js");
             await executeAgentMode({
                 configPath,
                 cwd: configuredCwd,
@@ -263,33 +207,13 @@ export class AgentCommand extends Command {
                 throwCliUsageError(error);
             }
             const expectationError = error;
-            const cwd = await realpath(configuredCwd ?? process.cwd());
-            const runId = randomUUID();
-            const managedOutput = !output;
-            const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
             const commandString = formatAgentCommand(args);
-            const { generatedAt } = await writeInvalidAgentExpectationOutput({
-                outputDir,
+            await writeInvalidAgentExpectationRun({
+                configuredCwd,
+                output,
                 command: commandString,
                 error: expectationError,
             });
-            const generatedAtMs = Date.parse(generatedAt);
-            const generatedAtTimestamp = Number.isFinite(generatedAtMs) ? generatedAtMs : Date.now();
-            await persistAgentRunState({
-                runId,
-                cwd,
-                outputDir,
-                managedOutput,
-                command: commandString,
-                startedAt: generatedAtTimestamp,
-                finishedAt: generatedAtTimestamp,
-                status: "finished",
-                exitCode: 1,
-                pid: process.pid,
-            });
-            await cleanupManagedAgentOutputs({ cwd, runId, managedOutput });
-            printAgentOutputLinks(outputDir);
-            console.error(expectationError.message);
             exit(1);
         }
     }
@@ -428,7 +352,7 @@ export class AgentInspectCommand extends Command {
                 output,
                 expectations,
             });
-            const { executeAgentInspectMode } = await import("./agent-run.js");
+            const { executeAgentInspectMode } = await import("./run.js");
             await executeAgentInspectMode({
                 configPath,
                 cwd: configuredCwd,
@@ -452,33 +376,13 @@ export class AgentInspectCommand extends Command {
                 throwCliUsageError(error);
             }
             const expectationError = error;
-            const cwd = await realpath(configuredCwd ?? process.cwd());
-            const runId = randomUUID();
-            const managedOutput = !output;
-            const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
             const commandString = formatAgentInspectCommand({ dumps, resultsDir });
-            const { generatedAt } = await writeInvalidAgentExpectationOutput({
-                outputDir,
+            await writeInvalidAgentExpectationRun({
+                configuredCwd,
+                output,
                 command: commandString,
                 error: expectationError,
             });
-            const generatedAtMs = Date.parse(generatedAt);
-            const generatedAtTimestamp = Number.isFinite(generatedAtMs) ? generatedAtMs : Date.now();
-            await persistAgentRunState({
-                runId,
-                cwd,
-                outputDir,
-                managedOutput,
-                command: commandString,
-                startedAt: generatedAtTimestamp,
-                finishedAt: generatedAtTimestamp,
-                status: "finished",
-                exitCode: 1,
-                pid: process.pid,
-            });
-            await cleanupManagedAgentOutputs({ cwd, runId, managedOutput });
-            printAgentOutputLinks(outputDir);
-            console.error(expectationError.message);
             exit(1);
         }
     }

package/dist/commands/agents/lifecycle.d.ts

@@ -0,0 +1,20 @@
+import { writeAgentRunState, type AgentExpectationUsageError } from "@allurereport/plugin-agent";
+export declare const formatAgentCommand: (args: string[]) => string;
+export declare const formatAgentInspectCommand: (params: {
+    dumps?: string[];
+    resultsDir?: string[];
+}) => string;
+export declare const resolveAgentOutputDir: (cwd: string, output?: string) => string | Promise<string>;
+export declare const printAgentOutputLinks: (outputDir: string) => void;
+export declare const persistAgentRunState: (value: Parameters<typeof writeAgentRunState>[0]) => Promise<void>;
+export declare const cleanupManagedAgentOutputs: (params: {
+    cwd: string;
+    runId: string;
+    managedOutput: boolean;
+}) => Promise<void>;
+export declare const writeInvalidAgentExpectationRun: (params: {
+    configuredCwd?: string;
+    output?: string;
+    command: string;
+    error: AgentExpectationUsageError;
+}) => Promise<void>;

package/dist/commands/agents/lifecycle.js

@@ -0,0 +1,91 @@
+import * as console from "node:console";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { cleanupAgentRunState, cleanupStaleAgentRunStates, formatAgentOutputLinks, resolveAgentStateDir, writeAgentRunState, writeInvalidAgentExpectationOutput, } from "@allurereport/plugin-agent";
+export const formatAgentCommand = (args) => args.join(" ");
+export const formatAgentInspectCommand = (params) => [
+    "allure",
+    "agent",
+    "inspect",
+    ...(params.dumps ?? []).flatMap((dump) => ["--dump", dump]),
+    ...(params.resultsDir ?? []),
+].join(" ");
+export const resolveAgentOutputDir = (cwd, output) => output ? resolve(cwd, output) : mkdtemp(join(tmpdir(), "allure-agent-"));
+export const printAgentOutputLinks = (outputDir) => {
+    for (const line of formatAgentOutputLinks(outputDir)) {
+        console.log(line);
+    }
+};
+export const persistAgentRunState = async (value) => {
+    try {
+        await writeAgentRunState(value);
+    }
+    catch (error) {
+        console.error(`Could not update agent state in ${resolveAgentStateDir(value.cwd)}: ${error.message}`);
+    }
+};
+const logAgentCleanupFailures = (failures) => {
+    for (const failure of failures) {
+        console.error(`Could not clean stale agent output ${failure.state.outputDir}: ${failure.error.message}`);
+    }
+};
+const logAgentOrphanCleanupFailures = (failures) => {
+    for (const failure of failures) {
+        console.error(`Could not clean stale agent output ${failure.outputDir}: ${failure.error.message}`);
+    }
+};
+export const cleanupManagedAgentOutputs = async (params) => {
+    try {
+        const result = await cleanupAgentRunState({
+            cwd: params.cwd,
+            currentRunId: params.runId,
+            keepManagedRuns: params.managedOutput ? 1 : 0,
+        });
+        logAgentCleanupFailures(result.failed);
+    }
+    catch (error) {
+        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
+    }
+    try {
+        const staleResult = await cleanupStaleAgentRunStates({
+            cwd: params.cwd,
+            currentRunId: params.runId,
+        });
+        logAgentCleanupFailures(staleResult.failed);
+        logAgentOrphanCleanupFailures(staleResult.orphaned.failed);
+    }
+    catch (error) {
+        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
+    }
+};
+export const writeInvalidAgentExpectationRun = async (params) => {
+    const cwd = await realpath(params.configuredCwd ?? process.cwd());
+    const runId = randomUUID();
+    const managedOutput = !params.output;
+    const outputDir = await resolveAgentOutputDir(cwd, params.output);
+    const { generatedAt } = await writeInvalidAgentExpectationOutput({
+        outputDir,
+        command: params.command,
+        error: params.error,
+    });
+    const generatedAtMs = Date.parse(generatedAt);
+    const generatedAtTimestamp = Number.isFinite(generatedAtMs) ? generatedAtMs : Date.now();
+    await persistAgentRunState({
+        runId,
+        cwd,
+        outputDir,
+        managedOutput,
+        command: params.command,
+        startedAt: generatedAtTimestamp,
+        finishedAt: generatedAtTimestamp,
+        status: "finished",
+        exitCode: 1,
+        pid: process.pid,
+    });
+    await cleanupManagedAgentOutputs({ cwd, runId, managedOutput });
+    printAgentOutputLinks(outputDir);
+    console.error(params.error.message);
+};

package/dist/commands/{agent-run.d.ts → agents/run.d.ts}

@@ -1,21 +1,9 @@
-import { writeAgentRunState, type AgentExpectationsInput, type AgentHumanReportMode } from "@allurereport/plugin-agent";
-export declare const formatAgentCommand: (args: string[]) => string;
-export declare const formatAgentInspectCommand: (params: {
-    dumps?: string[];
-    resultsDir?: string[];
-}) => string;
-export declare const printAgentOutputLinks: (outputDir: string) => void;
+import { type AgentExpectationsInput, type AgentHumanReportMode } from "@allurereport/plugin-agent";
 export declare const printAgentRunStart: (outputDir: string, commandString: string) => void;
 export declare const printAgentRunSummary: (outputDir: string, options?: {
     durationMs?: number;
     rerunCommand?: string;
 }) => Promise<void>;
-export declare const persistAgentRunState: (value: Parameters<typeof writeAgentRunState>[0]) => Promise<void>;
-export declare const cleanupManagedAgentOutputs: (params: {
-    cwd: string;
-    runId: string;
-    managedOutput: boolean;
-}) => Promise<void>;
 export type ExecuteAgentModeParams = {
     configPath?: string;
     cwd?: string;

package/dist/commands/{agent-run.js → agents/run.js}

@@ -1,30 +1,17 @@
 import * as console from "node:console";
 import { randomUUID } from "node:crypto";
-import { mkdtemp, realpath, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { realpath, rm } from "node:fs/promises";
+import { resolve } from "node:path";
 import process, { exit } from "node:process";
 import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
-import { createAgentTestPlanContext, AgentUsageError, assertExplicitAgentOutputDirIsSafe, formatAgentOutputLinks, formatAgentRunSummary, isPathInside, loadAgentOutput, normalizeAgentRerunPreset, parseAgentLabelFilters, cleanupAgentRunState, cleanupStaleAgentRunStates, resolveAgentStateDir, writeAgentRunState, } from "@allurereport/plugin-agent";
-import { normalizeCommandEnvironmentOptions, resolveCommandEnvironment } from "../utils/environment.js";
-import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
-import { findFilesByGlobs } from "../utils/fileSystem.js";
-import { resolveAndFindResultsDirs, resolveResultsPatterns } from "../utils/resultsPatterns.js";
-import { createAgentHumanReportConfig } from "./agent-human-report.js";
-import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
-export const formatAgentCommand = (args) => args.join(" ");
-export const formatAgentInspectCommand = (params) => [
-    "allure",
-    "agent",
-    "inspect",
-    ...(params.dumps ?? []).flatMap((dump) => ["--dump", dump]),
-    ...(params.resultsDir ?? []),
-].join(" ");
-export const printAgentOutputLinks = (outputDir) => {
-    for (const line of formatAgentOutputLinks(outputDir)) {
-        console.log(line);
-    }
-};
+import { createAgentTestPlanContext, AgentUsageError, assertExplicitAgentOutputDirIsSafe, formatAgentRunSummary, isPathInside, loadAgentOutput, normalizeAgentRerunPreset, parseAgentLabelFilters, } from "@allurereport/plugin-agent";
+import { normalizeCommandEnvironmentOptions, resolveCommandEnvironment } from "../../utils/environment.js";
+import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../../utils/execution-context.js";
+import { findFilesByGlobs } from "../../utils/fileSystem.js";
+import { resolveAndFindResultsDirs, resolveResultsPatterns } from "../../utils/resultsPatterns.js";
+import { executeAllureRun, executeNestedAllureCommand } from "../commons/run.js";
+import { createAgentHumanReportConfig } from "./human-report.js";
+import { cleanupManagedAgentOutputs, formatAgentCommand, formatAgentInspectCommand, persistAgentRunState, printAgentOutputLinks, resolveAgentOutputDir, } from "./lifecycle.js";
 export const printAgentRunStart = (outputDir, commandString) => {
     console.log(`agent output: ${outputDir}`);
     console.log(commandString);
@@ -48,48 +35,6 @@ export const printAgentRunSummary = async (outputDir, options = {}) => {
         printAgentOutputLinks(outputDir);
     }
 };
-export const persistAgentRunState = async (value) => {
-    try {
-        await writeAgentRunState(value);
-    }
-    catch (error) {
-        console.error(`Could not update agent state in ${resolveAgentStateDir(value.cwd)}: ${error.message}`);
-    }
-};
-const logAgentCleanupFailures = (failures) => {
-    for (const failure of failures) {
-        console.error(`Could not clean stale agent output ${failure.state.outputDir}: ${failure.error.message}`);
-    }
-};
-const logAgentOrphanCleanupFailures = (failures) => {
-    for (const failure of failures) {
-        console.error(`Could not clean stale agent output ${failure.outputDir}: ${failure.error.message}`);
-    }
-};
-export const cleanupManagedAgentOutputs = async (params) => {
-    try {
-        const result = await cleanupAgentRunState({
-            cwd: params.cwd,
-            currentRunId: params.runId,
-            keepManagedRuns: params.managedOutput ? 1 : 0,
-        });
-        logAgentCleanupFailures(result.failed);
-    }
-    catch (error) {
-        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
-    }
-    try {
-        const staleResult = await cleanupStaleAgentRunStates({
-            cwd: params.cwd,
-            currentRunId: params.runId,
-        });
-        logAgentCleanupFailures(staleResult.failed);
-        logAgentOrphanCleanupFailures(staleResult.orphaned.failed);
-    }
-    catch (error) {
-        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
-    }
-};
 export const executeAgentMode = async (params) => {
     const { configPath, cwd: configuredCwd, output, expectations, inlineExpectations, environment, environmentName, silent, rerunFrom, rerunLatest, rerunPreset, rerunEnvironments, rerunLabels, reportMode, args, resultsPatterns: cliResultsPatterns = [], } = params;
     const command = args[0];
@@ -131,7 +76,7 @@ export const executeAgentMode = async (params) => {
         }
         const runId = randomUUID();
         const managedOutput = !output;
-        const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
+        const outputDir = await resolveAgentOutputDir(cwd, output);
         const expectationsPath = expectations ? resolve(cwd, expectations) : undefined;
         const environmentOptions = {
             environment,
@@ -256,7 +201,7 @@ export const executeAgentInspectMode = async (params) => {
     }
     const runId = randomUUID();
     const managedOutput = !output;
-    const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
+    const outputDir = await resolveAgentOutputDir(cwd, output);
     const expectationsPath = expectations ? resolve(cwd, expectations) : undefined;
     const commandString = formatAgentInspectCommand({ dumps: dumpFiles, resultsDir: resultDirectories });
     const hiddenLabels = hideLabels?.length ? hideLabels : undefined;

package/dist/commands/commons/generate.d.ts

@@ -10,4 +10,5 @@ export declare const generate: (params: {
     resultsDir?: string[];
     dump?: string[];
     collectSummary?: boolean;
+    clean?: boolean;
 }) => Promise<GenerateResult | undefined>;

package/dist/commands/commons/generate.js

@@ -1,8 +1,9 @@
-import { exit } from "node:process";
+import { cwd as processCwd, exit } from "node:process";
 import { createReportContext } from "@allurereport/ci";
 import { AllureReport, filterFailedQualityGateResults, stringifyQualityGateResults } from "@allurereport/core";
 import { KnownError } from "@allurereport/service";
-import { red } from "yoctocolors";
+import { red, yellow } from "yoctocolors";
+import { cleanOutputDirectory, isOutputDirectoryNotEmpty } from "../../utils/cleanOutput.js";
 import { findFilesByGlobs } from "../../utils/fileSystem.js";
 import { logError } from "../../utils/logs.js";
 import { resolveAndFindResultsDirs, resolveResultsPatterns } from "../../utils/resultsPatterns.js";
@@ -19,6 +20,31 @@ export const generate = async (params) => {
         exit(1);
         return;
     }
+    if (params.clean) {
+        try {
+            const globalAttachments = await findFilesByGlobs(params.config.cwd ?? processCwd(), params.config.globalAttachments ?? [], { dot: false, windowsPathsNoEscape: false });
+            await cleanOutputDirectory({
+                output: params.config.output,
+                cwd: params.cwd,
+                resultsDirs: resultDirectories,
+                inputs: [
+                    ...dumpFiles,
+                    ...globalAttachments,
+                    params.config.historyPath,
+                    params.config.resolutions?.knownIssuesPath,
+                ].filter((path) => !!path),
+            });
+        }
+        catch (error) {
+            console.error(red(error instanceof Error ? error.message : String(error)));
+            exit(1);
+            return;
+        }
+    }
+    if (!params.clean && params.config.output && (await isOutputDirectoryNotEmpty(params.cwd, params.config.output))) {
+        console.warn(yellow(`The output directory "${params.config.output}" is not empty. Files of a previous report may break the layout ` +
+            "of the new one. Use the --clean option to remove the directory before generating."));
+    }
     try {
         const allureReport = new AllureReport(params.config);
         await allureReport.restoreState(Array.from(dumpFiles));

package/dist/commands/generate.d.ts

@@ -8,8 +8,10 @@ export declare class GenerateCommand extends Command {
     cwd: string | undefined;
     reportName: string | undefined;
     dump: string[] | undefined;
+    clean: boolean | undefined;
     open: boolean | undefined;
     port: string | undefined;
+    host: string | undefined;
     historyLimit: string | undefined;
     historyBaseUrl: string | undefined;
     hideLabels: string[] | undefined;