allure 3.20.1 → 3.21.0

package/dist/commands/open.d.ts

@@ -5,6 +5,7 @@ export declare class OpenCommand extends Command {
     resultsDir: string[];
     config: string | undefined;
     port: string | undefined;
+    host: string | undefined;
     cwd: string | undefined;
     hideLabels: string[] | undefined;
     execute(): Promise<void>;

package/dist/commands/open.js

@@ -9,6 +9,7 @@ import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
 import { findFilesByGlobs } from "./../utils/fileSystem.js";
 import { resolveResultsPatterns } from "./../utils/resultsPatterns.js";
+import { serverOptionsFromConfig } from "./../utils/serverOptions.js";
 import { notifySignals, waitForAbort } from "./../utils/signals.js";
 import { generate } from "./commons/generate.js";
 export class OpenCommand extends Command {
@@ -23,6 +24,9 @@ export class OpenCommand extends Command {
         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.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
         });
@@ -35,12 +39,13 @@ export class OpenCommand extends Command {
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
         const config = await readConfig(cwd, this.config, {
             port: this.port,
+            host: this.host,
         });
         const servePath = this.resolveReportPath(cwd, this.resultsDir, config.output);
         const resolvedPatterns = resolveResultsPatterns(this.resultsDir, config.resultsDir);
         if (await this.reportExists(servePath)) {
             await serve({
-                port: config.port ? parseInt(config.port, 10) : undefined,
+                ...serverOptionsFromConfig(config),
                 servePath,
                 open: true,
             });
@@ -49,6 +54,7 @@ export class OpenCommand extends Command {
             const tmpDir = await mkdtemp(join(tmpdir(), "allure-report-"));
             const config = await readConfig(cwd, this.config, {
                 port: this.port,
+                host: this.host,
                 output: tmpDir,
                 hideLabels,
             });
@@ -66,7 +72,7 @@ export class OpenCommand extends Command {
                 process.exit(notifier.info()?.code ?? 0);
             });
             await serve({
-                port: config.port ? parseInt(config.port, 10) : undefined,
+                ...serverOptionsFromConfig(config),
                 servePath: config.output,
                 open: true,
             });
@@ -98,6 +104,10 @@ OpenCommand.usage = Command.Usage({
     examples: [
         ["open ./allure-results", "Generate and serve the report based on given test results directory"],
         ["open --port 8080 ./allure-report", "Serve the report on port 8080"],
+        [
+            "open --host 0.0.0.0 ./allure-report",
+            "Serve the report on all network interfaces, so it is reachable remotely",
+        ],
         [
             "open ./packages/*/allure-results",
             "Generate and serve the report from all Allure result directories matching the pattern",

package/dist/commands/qualityGate.js

@@ -1,6 +1,6 @@
 import * as console from "node:console";
 import { realpath } from "node:fs/promises";
-import { exit, cwd as processCwd } from "node:process";
+import process, { exit, cwd as processCwd } from "node:process";
 import { AllureReport, QualityGateState, filterFailedQualityGateResults, readConfig, stringifyQualityGateResults, } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import * as typanion from "typanion";
@@ -88,6 +88,14 @@ export class QualityGateCommand extends Command {
             return;
         }
         const state = new QualityGateState();
+        let validated = false;
+        process.once("beforeExit", () => {
+            if (validated || (process.exitCode ?? 0) !== 0) {
+                return;
+            }
+            console.error(red("Quality gate hasn't been validated, the report generation has been interrupted"));
+            process.exitCode = 1;
+        });
         allureReport.realtimeSubscriber.onTestResults(async (trsIds) => {
             const trs = await Promise.all(trsIds.map((id) => allureReport.store.testResultById(id)));
             const nonRetryTrs = trs.filter((tr) => !tr.isRetry);
@@ -99,6 +107,7 @@ export class QualityGateCommand extends Command {
             if (!fastFailed) {
                 return;
             }
+            validated = true;
             console.error(stringifyQualityGateResults(results));
             exit(1);
         });
@@ -112,6 +121,7 @@ export class QualityGateCommand extends Command {
             trs: allTrs,
             environment: resolvedEnvironment?.id,
         });
+        validated = true;
         if (filterFailedQualityGateResults(validationResults.results).length === 0) {
             exit(0);
             return;

package/dist/commands/run.d.ts

@@ -7,9 +7,12 @@ export declare class RunCommand extends Command {
     output: string | undefined;
     open: boolean | undefined;
     port: string | undefined;
+    host: string | undefined;
     reportName: string | undefined;
     rerun: string | undefined;
     silent: boolean | undefined;
+    verbose: boolean | undefined;
+    quiet: boolean | undefined;
     ignoreLogs: boolean | undefined;
     dump: string | undefined;
     environment: string | undefined;
@@ -20,6 +23,7 @@ export declare class RunCommand extends Command {
     knownIssues: string | undefined;
     resultsDir: string[] | undefined;
     commandToRun: string[];
+    get silentOutput(): boolean;
     get logs(): "pipe" | "inherit" | "ignore";
     execute(): Promise<void>;
 }

package/dist/commands/run.js

@@ -9,6 +9,8 @@ import { Command, Option, UsageError } from "clipanion";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
 import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
 import { parseRunCommand, resolveResultsPatterns } from "../utils/resultsPatterns.js";
+import { serverOptionsFromConfig } from "../utils/serverOptions.js";
+import { isQuiet } from "../utils/verbosity.js";
 import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
 const missingRunCommandUsageError = () => new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
 const runLogger = new Logger("AllureRun");
@@ -30,6 +32,9 @@ export class RunCommand extends Command {
         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.reportName = Option.String("--report-name,--name", {
             description: "The report name (default: Allure Report)",
         });
@@ -39,6 +44,12 @@ export class RunCommand extends Command {
         this.silent = Option.Boolean("--silent", {
             description: "Don't pipe the process output logs to console (default: 0)",
         });
+        this.verbose = Option.Boolean("--verbose,-v", {
+            description: "Print verbose Allure messages (global flag, cannot be combined with --quiet)",
+        });
+        this.quiet = Option.Boolean("--quiet,-q", {
+            description: "Print errors only and hide the test process output, implies --silent (global flag)",
+        });
         this.ignoreLogs = Option.Boolean("--ignore-logs", {
             description: "Prevent logs attaching to the report (default: false)",
         });
@@ -64,8 +75,11 @@ export class RunCommand extends Command {
         });
         this.commandToRun = Option.Rest();
     }
+    get silentOutput() {
+        return !!(this.silent || this.quiet) || isQuiet();
+    }
     get logs() {
-        if (this.silent) {
+        if (this.silentOutput) {
             return this.ignoreLogs ? "ignore" : "pipe";
         }
         return this.ignoreLogs ? "inherit" : "pipe";
@@ -84,7 +98,7 @@ export class RunCommand extends Command {
                 command,
                 commandArgs,
                 cwd,
-                silent: this.silent,
+                silent: this.silentOutput,
             });
             exit(exitCode ?? -1);
             return;
@@ -100,6 +114,7 @@ export class RunCommand extends Command {
             name: this.reportName,
             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 } : {}),
@@ -146,7 +161,7 @@ export class RunCommand extends Command {
             environment: resolvedEnvironment?.id,
             withQualityGate,
             logs: this.logs,
-            silent: this.silent,
+            silent: this.silentOutput,
             ignoreLogs: this.ignoreLogs,
             maxRerun,
             resultsPatterns,
@@ -155,7 +170,7 @@ export class RunCommand extends Command {
         runLogger.info(`Completed with exit code ${finalExitCode} after ${formatDuration(Date.now() - before)}`);
         if (config.open) {
             await serve({
-                port: config.port ? parseInt(config.port, 10) : undefined,
+                ...serverOptionsFromConfig(config),
                 servePath: config.output,
                 open: true,
             });
@@ -171,7 +186,12 @@ RunCommand.usage = Command.Usage({
     details: "This command runs the specified command and collects Allure results. " +
         "Override results discovery with repeated `--results-dir` (CLI overrides `config.resultsDir`). " +
         "When neither is set, directories named `allure-results` are discovered dynamically. " +
-        "Quote globs in the shell so they are not expanded early.",
+        "Quote globs in the shell so they are not expanded early.\n\n" +
+        "Global flags: `--verbose`/`-v` prints verbose Allure messages, `--quiet`/`-q` prints errors only. " +
+        "They cannot be combined and must come before `--`. " +
+        "`--quiet` also implies `--silent`: the test process output is not printed, but is still attached to the report " +
+        "unless `--ignore-logs` is set. `--verbose` does not change `--silent` or `--ignore-logs`. " +
+        "Without either flag the log level comes from `ALLURE_LOG_LEVEL` (default: info).",
     examples: [
         ["run -- npm run test", "Run npm run test and collect Allure results"],
         ["run --rerun 3 -- npm run test", "Run npm run test and rerun failed tests up to 3 times"],
@@ -179,6 +199,8 @@ RunCommand.usage = Command.Usage({
             "run --dump=my-dump -- npm run test",
             "Run npm run test and pack inner report state into my-dump.zip archive to restore the state in the next run",
         ],
+        ["run --quiet -- npm run test", "Print only errors and hide the test process output"],
+        ["run --verbose -- npm run test", "Print verbose Allure messages while running the tests"],
         [
             "run --results-dir './artifacts/**/allure-results' -- npm test",
             "Override results discovery with a quoted glob",

package/dist/commands/slack.d.ts

@@ -5,7 +5,8 @@ export declare class SlackCommand extends Command {
     resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
-    token: string;
-    channel: string;
+    token: string | undefined;
+    channel: string | undefined;
+    webhook: string | undefined;
     execute(): Promise<void>;
 }

package/dist/commands/slack.js

@@ -3,7 +3,7 @@ import { realpath } from "node:fs/promises";
 import process, { exit } from "node:process";
 import { AllureReport, readConfig } from "@allurereport/core";
 import SlackPlugin from "@allurereport/plugin-slack";
-import { Command, Option } from "clipanion";
+import { Command, Option, UsageError } from "clipanion";
 import { red } from "yoctocolors";
 import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class SlackCommand extends Command {
@@ -19,20 +19,28 @@ export class SlackCommand extends Command {
             description: "The working directory for the command to run (default: current working directory)",
         });
         this.token = Option.String("--token,-t", {
-            description: "Slack Bot User OAuth Token",
-            required: true,
+            description: "Slack Bot User OAuth Token (default: ALLURE_SLACK_TOKEN environment variable)",
+            env: "ALLURE_SLACK_TOKEN",
         });
         this.channel = Option.String("--channel", {
-            description: "Slack channelId",
-            required: true,
+            description: "Slack channelId (default: ALLURE_SLACK_CHANNEL environment variable)",
+            env: "ALLURE_SLACK_CHANNEL",
+        });
+        this.webhook = Option.String("--webhook", {
+            description: "Slack incoming webhook URL (default: ALLURE_SLACK_WEBHOOK environment variable)",
+            env: "ALLURE_SLACK_WEBHOOK",
         });
     }
     async execute() {
+        if (!this.webhook && (!this.token || !this.channel)) {
+            throw new UsageError("Provide either --webhook or both --token and --channel");
+        }
         const cwd = await realpath(this.cwd ?? process.cwd());
         const before = new Date().getTime();
         const defaultSlackOptions = {
             token: this.token,
             channel: this.channel,
+            webhook: this.webhook,
         };
         const config = await readConfig(cwd, this.config);
         const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
@@ -69,6 +77,10 @@ SlackCommand.usage = Command.Usage({
             "slack ./allure-results --token xoxb-token --channel C12345",
             "Post test results from the ./allure-results directory to the specified Slack channel",
         ],
+        [
+            "slack ./allure-results --webhook https://hooks.slack.com/services/...",
+            "Post test results using a Slack incoming webhook",
+        ],
         [
             "slack ./packages/*/allure-results --token xoxb-token --channel C12345",
             "Post test results from all Allure result directories matching the pattern",

package/dist/commands/testopsPlan.js

@@ -23,7 +23,7 @@ export class TestOpsPlanCommand extends Command {
         const endpoint = env.ALLURE_ENDPOINT;
         const accessToken = env.ALLURE_TOKEN;
         if (!endpoint || !accessToken) {
-            console.error(red("ALLURE_ENDPOINT and ALLURE_TOKEN are required to fetch a test plan from TestOps"));
+            console.error(red("ALLURE_ENDPOINT and ALLURE_TOKEN are required to fetch a test plan from Allure TestOps"));
             exit(1);
             return;
         }
@@ -54,10 +54,10 @@ export class TestOpsPlanCommand extends Command {
 }
 TestOpsPlanCommand.paths = [["testops-plan"]];
 TestOpsPlanCommand.usage = Command.Usage({
-    description: "Fetches a testplan.json for the current TestOps job run",
+    description: "Fetches a testplan.json for the current Allure TestOps job run",
     details: "Reads ALLURE_JOB_RUN_ID and, when it's set, downloads the test cases selected for that job run " +
-        "from TestOps and writes them as a testplan.json compatible with ALLURE_TESTPLAN_PATH. " +
-        "Does nothing when ALLURE_JOB_RUN_ID isn't set, which covers every run TestOps didn't trigger itself.",
+        "from Allure TestOps and writes them as a testplan.json compatible with ALLURE_TESTPLAN_PATH. " +
+        "Does nothing when ALLURE_JOB_RUN_ID isn't set, which covers every run Allure TestOps didn't trigger itself.",
     examples: [
         ["testops-plan", "Write ./testplan.json from the current job run, if any"],
         ["testops-plan --output custom-testplan.json", "Write to a custom path instead"],

package/dist/commands/watch.d.ts

@@ -9,6 +9,7 @@ export declare class WatchCommand extends Command {
     reportName: string | undefined;
     open: boolean | undefined;
     port: string | undefined;
+    host: string | undefined;
     preserve: boolean | undefined;
     newOnly: boolean;
     execute(): Promise<void>;

package/dist/commands/watch.js

@@ -12,6 +12,7 @@ import { PathResultFile } from "@allurereport/reader-api";
 import { serve } from "@allurereport/static-server";
 import { Command, Option } from "clipanion";
 import { resolveResultsPatterns } from "../utils/resultsPatterns.js";
+import { serverOptionsFromConfig } from "../utils/serverOptions.js";
 import { boundedTerminationSignal, notifySignals, waitForAbort } from "../utils/signals.js";
 import { allureResultsDirectoriesGlobWatcher } from "./commons/resultsDiscovery.js";
 export class WatchCommand extends Command {
@@ -38,6 +39,9 @@ export class WatchCommand extends Command {
         this.port = Option.String("--port", {
             description: "The port to serve the reports on (default: 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.preserve = Option.Boolean("--preserve", {
             description: "Don't clear terminal output on the data refresh",
         });
@@ -57,6 +61,7 @@ export class WatchCommand extends Command {
             name: this.reportName,
             open: this.open,
             port: this.port,
+            host: this.host,
         });
         const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
         const useDynamicNameDiscovery = resultsPatterns.length === 0;
@@ -70,7 +75,7 @@ export class WatchCommand extends Command {
         }
         const server = await serve({
             servePath: config.output,
-            port: this.port ? parseInt(this.port, 10) : undefined,
+            ...serverOptionsFromConfig(config),
             live: false,
             open: false,
         });
@@ -181,6 +186,10 @@ WatchCommand.usage = Command.Usage({
         "Quote globs in the shell so they are not expanded early.",
     examples: [
         ["watch ./allure-results", "Watch for changes in the ./allure-results directory"],
+        [
+            "watch ./allure-results --host 127.0.0.1",
+            "Watch for changes in the ./allure-results directory and serve the report on the 127.0.0.1 interface only",
+        ],
         [
             "watch ./allure-results --port 8080",
             "Watch for changes in the ./allure-results directory and serve the report on port 8080",

package/dist/index.js

@@ -1,8 +1,11 @@
 import { readFileSync } from "node:fs";
 import process, { argv } from "node:process";
-import { Builtins, Cli } from "clipanion";
-import { AgentCommand, AGENT_TASK_MAP_HELP, AgentCapabilitiesCommand, AgentInspectCommand, AgentLatestCommand, AgentQueryCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, CheckCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, GitlabGenerateCommand, HistoryCommand, JiraClearCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestOpsPlanCommand, TestPlanCommand, WatchCommand, isAgentTaskMapHelpRequest, } from "./commands/index.js";
-const [node, app, ...args] = argv;
+import { Builtins, Cli, UsageError } from "clipanion";
+import { AgentCommand, AGENT_TASK_MAP_HELP, AgentCapabilitiesCommand, AgentInspectCommand, AgentLatestCommand, AgentQueryCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, CheckCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, GitlabGenerateCommand, HistoryCommand, JiraClearCommand, LogCommand, MigrateCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestOpsPlanCommand, TestPlanCommand, WatchCommand, isAgentTaskMapHelpRequest, } from "./commands/index.js";
+import { ALLURE2_MIGRATE_REMINDER, getAllure2Hint } from "./utils/allure2Hints.js";
+import { notifyAboutUpdate, parseUpdateNotifierArgs } from "./utils/updateNotifier.js";
+import { applyVerbosity, extractVerbosityFlags } from "./utils/verbosity.js";
+const [node, app, ...rawArgs] = argv;
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cli = new Cli({
     binaryName: pkg.name,
@@ -26,6 +29,7 @@ cli.register(GenerateCommand);
 cli.register(HistoryCommand);
 cli.register(JiraClearCommand);
 cli.register(LogCommand);
+cli.register(MigrateCommand);
 cli.register(OpenCommand);
 cli.register(QualityGateCommand);
 cli.register(RunCommand);
@@ -38,16 +42,33 @@ cli.register(ResultsUnpackCommand);
 cli.register(GitlabGenerateCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
-void cli
-    .run(args)
-    .then((exitCode) => {
+const printAllure2Hint = (args) => {
+    try {
+        cli.process(args);
+    }
+    catch (error) {
+        const hint = getAllure2Hint(args, error instanceof Error ? error.message : String(error));
+        if (hint) {
+            console.error(`\nComing from Allure 2? ${hint}\n${ALLURE2_MIGRATE_REMINDER}`);
+        }
+    }
+};
+const main = async () => {
+    const { args: notifierArgs, disabled } = parseUpdateNotifierArgs(rawArgs);
+    const { args, verbosity } = extractVerbosityFlags(notifierArgs);
+    applyVerbosity(verbosity);
+    void notifyAboutUpdate(args, disabled || verbosity === "quiet");
+    const exitCode = await cli.run(args);
     if (exitCode === 0 && isAgentTaskMapHelpRequest(args)) {
         process.stdout.write(`\n${AGENT_TASK_MAP_HELP}`);
     }
+    if (exitCode !== 0) {
+        printAllure2Hint(args);
+    }
     process.exitCode = exitCode;
-})
-    .catch((error) => {
-    console.error(error);
+};
+void main().catch((error) => {
+    console.error(error instanceof UsageError ? `Usage Error: ${error.message}` : error);
     process.exitCode = 1;
 });
 export { defineConfig } from "@allurereport/plugin-api";

package/dist/utils/allure2Hints.d.ts

@@ -0,0 +1,8 @@
+export declare const ALLURE2_COMMAND_MAP: readonly {
+    allure2: string;
+    allure3: string;
+    note: string;
+}[];
+export declare const renderAllure2CommandMap: () => string;
+export declare const getAllure2Hint: (args: readonly string[], errorMessage: string) => string | undefined;
+export declare const ALLURE2_MIGRATE_REMINDER = "Run `allure migrate` to see how Allure 2 commands map to Allure 3.";

package/dist/utils/allure2Hints.js

@@ -0,0 +1,90 @@
+const OPTION_HINTS = {
+    "--clean": "`--clean` is available for `allure generate` only: it removes the output directory before generating. " +
+        "`allure run` recreates the output directory on every launch.",
+    "--profile": "Profiles are gone. Use a single allurerc file and pass it with `--config`.",
+    "--configDirectory": "The config directory is gone. Use a single allurerc file and pass it with `--config`.",
+    "--lang": "`generate` and `run` have no `--lang`. Set `reportLanguage` in the plugin options of allurerc, " +
+        "or use a plugin command like `allure awesome --lang <code>`.",
+    "--report-language": "`generate` and `run` have no `--report-language`. Set `reportLanguage` in the plugin options of allurerc, " +
+        "or use a plugin command like `allure awesome --report-language <code>`.",
+    "--single-file": "`generate` and `run` have no `--single-file`. Set `singleFile` in the plugin options of allurerc, " +
+        "or use a plugin command like `allure awesome --single-file`.",
+};
+export const ALLURE2_COMMAND_MAP = [
+    {
+        allure2: "allure serve <results>",
+        allure3: "allure open <results>",
+        note: "Generates the report into a temp directory and serves it. For live updates use `allure watch <results>`",
+    },
+    {
+        allure2: "allure generate <results> -o <dir>",
+        allure3: "allure generate <results> -o <dir>",
+        note: "Same command. Add `--open` to serve the report afterwards",
+    },
+    {
+        allure2: "allure generate <results> --clean",
+        allure3: "allure generate <results> --clean",
+        note: "Same flag: removes the output directory before generating. `allure run` recreates it on every launch",
+    },
+    {
+        allure2: "allure open <report>",
+        allure3: "allure open <report>",
+        note: "Same command. Serves an already generated report",
+    },
+    {
+        allure2: "allure serve|open --host <host> --port <port>",
+        allure3: "allure open --host <host> --port <port>",
+        note: "`--host` and `--port` are also available for `generate --open`, `run` and `watch`, and in allurerc",
+    },
+    {
+        allure2: "run tests, then allure serve",
+        allure3: "allure run -- <test command>",
+        note: "Runs the tests, collects results into a report, and serves it with `--open`",
+    },
+    {
+        allure2: "allure generate --single-file --lang <code>",
+        allure3: "allure awesome <results> --single-file --lang <code>",
+        note: "Or set `singleFile` and `reportLanguage` in the plugin options of allurerc",
+    },
+    {
+        allure2: "--profile <name>, --configDirectory <dir>, allure.yml",
+        allure3: "--config <path to allurerc>",
+        note: "One config file with plugins, report options and quality gates instead of profiles",
+    },
+    {
+        allure2: "allure plugin",
+        allure3: "`plugins` section of allurerc",
+        note: "Plugins are enabled and configured in the config file",
+    },
+    {
+        allure2: "--verbose, --quiet",
+        allure3: "--verbose, --quiet (-v, -q)",
+        note: "Same global flags. For `allure run`, `--quiet` also implies `--silent`; `--ignore-logs` is separate",
+    },
+];
+export const renderAllure2CommandMap = () => [
+    "Allure 2 -> Allure 3",
+    "",
+    ...ALLURE2_COMMAND_MAP.flatMap(({ allure2, allure3, note }) => [
+        `  ${allure2}`,
+        `    -> ${allure3}`,
+        `       ${note}`,
+        "",
+    ]),
+].join("\n");
+const COMMAND_HINTS = {
+    plugin: "There is no `allure plugin` command. Plugins are listed in the `plugins` section of allurerc.",
+    report: "Allure 3 has no `allure report` group. Use `allure generate` to build a report and `allure open` to serve it.",
+};
+const UNSUPPORTED_OPTION_RE = /Unsupported option name \("([^"]+)"\)/;
+export const getAllure2Hint = (args, errorMessage) => {
+    const optionMatch = UNSUPPORTED_OPTION_RE.exec(errorMessage);
+    if (optionMatch) {
+        return OPTION_HINTS[optionMatch[1]];
+    }
+    if (/Command not found/i.test(errorMessage) && args[0] !== undefined) {
+        return COMMAND_HINTS[args[0]];
+    }
+    return undefined;
+};
+export const ALLURE2_MIGRATE_REMINDER = "Run `allure migrate` to see how Allure 2 commands map to Allure 3.";

package/dist/utils/cleanOutput.d.ts

@@ -0,0 +1,9 @@
+export type CleanOutputParams = {
+    output: string;
+    cwd: string;
+    resultsDirs?: string[];
+    inputs?: string[];
+};
+export declare const getUnsafeCleanReason: (params: CleanOutputParams) => Promise<string | undefined>;
+export declare const cleanOutputDirectory: (params: CleanOutputParams) => Promise<void>;
+export declare const isOutputDirectoryNotEmpty: (cwd: string, output: string) => Promise<boolean>;

package/dist/utils/cleanOutput.js

@@ -0,0 +1,62 @@
+import { readdir, realpath, rm, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { cwd as processCwd } from "node:process";
+const isSameOrInside = (parent, child) => {
+    const rel = relative(parent, child);
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+};
+const realResolve = async (path) => {
+    const absolute = resolve(path);
+    try {
+        return await realpath(absolute);
+    }
+    catch {
+        const parent = dirname(absolute);
+        return parent === absolute ? absolute : join(await realResolve(parent), basename(absolute));
+    }
+};
+export const getUnsafeCleanReason = async (params) => {
+    const cwd = resolve(params.cwd);
+    const output = await realResolve(resolve(cwd, params.output));
+    if (output === parse(output).root) {
+        return "it is a filesystem root";
+    }
+    if ((await stat(output).catch(() => undefined))?.isDirectory() === false) {
+        return "it is not a directory";
+    }
+    const mustSurvive = [
+        ["the working directory", cwd],
+        ["the process working directory", processCwd()],
+        ["the home directory", homedir()],
+        ...(params.resultsDirs ?? []).map((dir) => ["a results directory", resolve(cwd, dir)]),
+        ...(params.inputs ?? []).map((file) => ["an input file", resolve(cwd, file)]),
+    ];
+    for (const [label, path] of mustSurvive) {
+        if (isSameOrInside(output, await realResolve(path))) {
+            return `it is or contains ${label} (${path})`;
+        }
+    }
+    for (const dir of params.resultsDirs ?? []) {
+        if (isSameOrInside(await realResolve(resolve(cwd, dir)), output)) {
+            return `it is located inside a results directory (${resolve(cwd, dir)})`;
+        }
+    }
+    return undefined;
+};
+export const cleanOutputDirectory = async (params) => {
+    const output = resolve(params.cwd, params.output);
+    const reason = await getUnsafeCleanReason(params);
+    if (reason) {
+        throw new Error(`Refusing to clean the output directory ${output}: ${reason}`);
+    }
+    await rm(output, { recursive: true, force: true });
+};
+export const isOutputDirectoryNotEmpty = async (cwd, output) => {
+    try {
+        return (await readdir(resolve(cwd, output))).length > 0;
+    }
+    catch {
+        return false;
+    }
+};

package/dist/utils/fileSystem.d.ts

@@ -1,4 +1,7 @@
-export declare const findFilesByGlobs: (basePath: string, patterns: readonly string[]) => Promise<string[]>;
+export declare const findFilesByGlobs: (basePath: string, patterns: readonly string[], { dot, windowsPathsNoEscape }?: {
+    dot?: boolean;
+    windowsPathsNoEscape?: boolean;
+}) => Promise<string[]>;
 export declare const findDirectoriesByGlobs: (basePath: string, patterns: readonly string[]) => Promise<string[]>;
 export declare const findAllureResultDirectories: (basePath: string, patterns: readonly string[]) => Promise<{
     patterns: readonly string[];

package/dist/utils/fileSystem.js

@@ -1,12 +1,12 @@
 import { glob } from "glob";
-export const findFilesByGlobs = async (basePath, patterns) => {
+export const findFilesByGlobs = async (basePath, patterns, { dot = true, windowsPathsNoEscape = true } = {}) => {
     const files = [];
     for (const pattern of patterns) {
         const searchResults = await glob(pattern, {
             nodir: true,
-            dot: true,
+            dot,
             absolute: true,
-            windowsPathsNoEscape: true,
+            windowsPathsNoEscape,
             cwd: basePath,
         });
         files.push(...searchResults);

package/dist/utils/serverOptions.d.ts

@@ -0,0 +1,5 @@
+import type { FullConfig } from "@allurereport/core";
+export declare const serverOptionsFromConfig: (config: Pick<FullConfig, "port" | "host">) => {
+    port: number | undefined;
+    host: string | undefined;
+};

package/dist/utils/serverOptions.js

@@ -0,0 +1,4 @@
+export const serverOptionsFromConfig = (config) => ({
+    port: config.port ? parseInt(config.port, 10) : undefined,
+    host: config.host,
+});