allure 3.20.0 → 3.21.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`.
 
@@ -176,6 +192,14 @@ 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.

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;

package/dist/commands/generate.js

@@ -2,6 +2,7 @@ import { cwd as processCwd } from "node:process";
 import { readConfig } from "@allurereport/core";
 import { serve } from "@allurereport/static-server";
 import { Command, Option } from "clipanion";
+import { serverOptionsFromConfig } from "../utils/serverOptions.js";
 import { generate } from "./commons/generate.js";
 export class GenerateCommand extends Command {
     constructor() {
@@ -26,12 +27,19 @@ export class GenerateCommand extends Command {
                 "Allure loads the matched archives before generating the report. " +
                 "This option can be specified multiple times.",
         });
+        this.clean = Option.Boolean("--clean", {
+            description: "Remove the output directory before generating the report (default: false). " +
+                "Refuses to remove the working directory, the home directory, a filesystem root, or the results directories",
+        });
         this.open = Option.Boolean("--open", {
             description: "Open the report in the default browser after generation (default: false)",
         });
         this.port = Option.String("--port", {
             description: "The port to serve the reports on. If not set, the server starts on a random port",
         });
+        this.host = Option.String("--host", {
+            description: "The host (network interface) to serve the reports on, e.g. 127.0.0.1 or 0.0.0.0 (default: all interfaces)",
+        });
         this.historyLimit = Option.String("--history-limit", {
             description: "Limits the number of history entries to keep (default: unlimited)",
         });
@@ -54,6 +62,7 @@ export class GenerateCommand extends Command {
             output: this.output,
             open: this.open,
             port: this.port,
+            host: this.host,
             hideLabels,
             historyLimit: this.historyLimit !== undefined ? parseInt(this.historyLimit, 10) : undefined,
             ...(this.historyBaseUrl !== undefined ? { historyBaseUrl: this.historyBaseUrl } : {}),
@@ -64,13 +73,14 @@ export class GenerateCommand extends Command {
             resultsDir: this.resultsDir,
             cwd,
             config,
+            clean: this.clean,
         });
         if (!result) {
             return;
         }
         if (config.open) {
             await serve({
-                port: config.port ? parseInt(config.port, 10) : undefined,
+                ...serverOptionsFromConfig(config),
                 servePath: config.output,
                 open: true,
             });
@@ -84,11 +94,19 @@ GenerateCommand.usage = Command.Usage({
     details: "This command generates a report from the provided Allure Results directories. " +
         "When a quality gate is configured, the command validates the loaded results and finishes writing the report or dump before returning its status.",
     examples: [
+        [
+            "generate ./allure-results --open --host 0.0.0.0",
+            "Generate a report and serve it on all network interfaces after generation",
+        ],
         ["generate ./allure-results", "Generate a report from the ./allure-results directory"],
         [
             "generate ./allure-results --output custom-report",
             "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
+        [
+            "generate ./allure-results --clean",
+            "Remove the existing report directory before generating a fresh report from ./allure-results",
+        ],
         [
             "generate --dump=windows.zip --dump=macos.zip ./allure-results",
             "Generate a report using data from windows.zip and macos.zip archives and using results from the ./allure-results directory",

package/dist/commands/index.d.ts

@@ -2,7 +2,7 @@ export * from "./history.js";
 export * from "./testplan.js";
 export * from "./classic.js";
 export * from "./allure2.js";
-export * from "./agent.js";
+export * from "./agents/index.js";
 export * from "./awesome.js";
 export * from "./csv.js";
 export * from "./check.js";
@@ -20,3 +20,4 @@ export * from "./dashboard.js";
 export * from "./results/index.js";
 export * from "./jira/index.js";
 export * from "./gitlab/index.js";
+export * from "./migrate.js";

package/dist/commands/index.js

@@ -2,7 +2,7 @@ export * from "./history.js";
 export * from "./testplan.js";
 export * from "./classic.js";
 export * from "./allure2.js";
-export * from "./agent.js";
+export * from "./agents/index.js";
 export * from "./awesome.js";
 export * from "./csv.js";
 export * from "./check.js";
@@ -20,3 +20,4 @@ export * from "./dashboard.js";
 export * from "./results/index.js";
 export * from "./jira/index.js";
 export * from "./gitlab/index.js";
+export * from "./migrate.js";

package/dist/commands/migrate.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "clipanion";
+export declare class MigrateCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    execute(): Promise<void>;
+}

package/dist/commands/migrate.js

@@ -0,0 +1,15 @@
+import { Command } from "clipanion";
+import { renderAllure2CommandMap } from "../utils/allure2Hints.js";
+export class MigrateCommand extends Command {
+    async execute() {
+        this.context.stdout.write(`${renderAllure2CommandMap()}\n`);
+    }
+}
+MigrateCommand.paths = [["migrate"]];
+MigrateCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Shows how Allure 2 commands map to Allure 3",
+    details: "This command prints the Allure 3 equivalents of the Allure 2 commands and options " +
+        "(serve, generate --clean, --host, --profile, etc.) for users who are moving from Allure 2.",
+    examples: [["migrate", "Print the Allure 2 to Allure 3 command mapping"]],
+});