allure 3.20.1 → 3.22.0

package/dist/commands/serve.js

@@ -0,0 +1,168 @@
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { cwd as processCwd, exit } from "node:process";
+import { readConfig } from "@allurereport/core";
+import { serve } from "@allurereport/static-server";
+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";
+const ESCALATION_DELAY = 3000;
+export class BaseServeCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.Rest({
+            name: "A report path to open, or results patterns. Overrides config.resultsDir. " +
+                "Empty Rest serves the configured output.",
+        });
+        this.config = Option.String("--config,-c", {
+            description: "Path to Allure configuration file",
+        });
+        this.port = Option.String("--port", {
+            description: "Port for the report server. Overrides the configured port; otherwise, a random available port is used",
+        });
+        this.host = Option.String("--host", {
+            description: "Host address to bind the report server to, e.g. 127.0.0.1 or 0.0.0.0. " +
+                "Overrides the configured host (default: all interfaces)",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "Working directory for the command (default: current working directory)",
+        });
+        this.hideLabels = Option.Array("--hide-labels", {
+            description: "Hide labels by exact name in generated reports. Repeat the option for multiple labels",
+        });
+    }
+    async execute() {
+        const cwd = this.cwd ?? processCwd();
+        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);
+        const onSignalRepeat = (signal) => {
+            const info = notifier.info();
+            if (signal !== "SIGINT" ||
+                info?.signal !== "SIGINT" ||
+                Date.now() >= (info?.receivedAt ?? 0) + ESCALATION_DELAY) {
+                exit(info?.code ?? 1);
+            }
+        };
+        const notifier = notifySignals(["SIGINT", "SIGTERM"], onSignalRepeat);
+        const signalExitCode = () => {
+            const info = notifier.info();
+            return info?.signal === "SIGINT" ? 0 : (info?.code ?? 0);
+        };
+        let server;
+        let tmpDir;
+        try {
+            if (await this.reportExists(servePath)) {
+                if (notifier.signal.aborted) {
+                    return signalExitCode();
+                }
+                server = await serve({
+                    ...serverOptionsFromConfig(config),
+                    servePath,
+                    open: this.shouldOpen,
+                });
+            }
+            else if (resolvedPatterns.length) {
+                tmpDir = await mkdtemp(join(tmpdir(), "allure-report-"));
+                const config = await readConfig(cwd, this.config, {
+                    port: this.port,
+                    host: this.host,
+                    output: tmpDir,
+                    hideLabels,
+                });
+                if (notifier.signal.aborted) {
+                    return signalExitCode();
+                }
+                await generate({
+                    resultsDir: this.resultsDir,
+                    cwd,
+                    config,
+                });
+                if (notifier.signal.aborted) {
+                    return signalExitCode();
+                }
+                server = await serve({
+                    ...serverOptionsFromConfig(config),
+                    servePath: config.output,
+                    open: this.shouldOpen,
+                });
+            }
+            else {
+                console.error(red(`A report doesn't exist in ${servePath} and no input was provided to generate.`));
+                return 1;
+            }
+            await waitForAbort(notifier.signal);
+            console.info(`Allure is stopping.`);
+        }
+        finally {
+            try {
+                await server?.stop();
+            }
+            catch { }
+            if (tmpDir) {
+                try {
+                    await rm(tmpDir, { recursive: true, force: true });
+                }
+                catch { }
+            }
+            notifier.dispose();
+        }
+        return signalExitCode();
+    }
+    resolveReportPath(cwd, inputs, fallback = "allure-report") {
+        if (inputs.length <= 1) {
+            const [maybeRelativeReportPath = fallback] = inputs;
+            return resolve(cwd, maybeRelativeReportPath);
+        }
+    }
+    async reportExists(reportPath) {
+        if (reportPath && existsSync(reportPath)) {
+            const summaryFiles = await findFilesByGlobs(reportPath, [join("**", "summary.json")]);
+            return summaryFiles.length > 0;
+        }
+        return false;
+    }
+}
+BaseServeCommand.paths = [["serve"]];
+BaseServeCommand.usage = Command.Usage({
+    description: "Serves an existing report or generates and serves a report from test results.",
+    details: "This command starts a report server without opening a browser. If test results are provided, it generates the" +
+        " report in a temporary directory before serving it. With no arguments, it serves the configured output " +
+        "directory or, if no report exists there, generates a report from the configured test results. Use --open " +
+        "to also open the report in the default browser.",
+    examples: [
+        ["serve ./allure-results", "Generate and serve the report from the given test results directory"],
+        ["serve --port 8080 ./allure-report", "Serve the report on port 8080"],
+        ["serve --open ./allure-report", "Serve the report and open it in the default browser"],
+        ["serve --host 127.0.0.1 ./allure-report", "Serve the report on the loopback interface only."],
+        [
+            "serve ./packages/*/allure-results",
+            "Generate and serve the report from all test results directories matching the pattern",
+        ],
+        [
+            "serve ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate and serve the report from two test results directories",
+        ],
+    ],
+});
+export class ServeCommand extends BaseServeCommand {
+    constructor() {
+        super(...arguments);
+        this.open = Option.Boolean("--open", {
+            description: "Open the report in the default browser (default: false)",
+        });
+    }
+    get shouldOpen() {
+        return Boolean(this.open);
+    }
+}

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, GhWorkflowCommand, GitlabGenerateCommand, HistoryCommand, JiraClearCommand, LogCommand, MigrateCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, ServeCommand, 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,
@@ -23,12 +26,15 @@ cli.register(ClassicCommand);
 cli.register(CsvCommand);
 cli.register(DashboardCommand);
 cli.register(GenerateCommand);
+cli.register(GhWorkflowCommand);
 cli.register(HistoryCommand);
 cli.register(JiraClearCommand);
 cli.register(LogCommand);
+cli.register(MigrateCommand);
 cli.register(OpenCommand);
 cli.register(QualityGateCommand);
 cli.register(RunCommand);
+cli.register(ServeCommand);
 cli.register(SlackCommand);
 cli.register(TestOpsPlanCommand);
 cli.register(TestPlanCommand);
@@ -38,16 +44,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/ghWorkflow.d.ts

@@ -0,0 +1,10 @@
+import type { EnvironmentsConfig } from "@allurereport/core-api";
+export type GhWorkflowOptions = {
+    environmentIds: readonly string[];
+    testCommand?: readonly string[];
+    config?: string;
+};
+export declare const shellQuote: (value: string) => string;
+export declare const normalizeEnvironmentIds: (values: readonly string[]) => string[];
+export declare const configuredEnvironmentIds: (environments: EnvironmentsConfig | undefined) => string[];
+export declare const buildGhWorkflowYaml: ({ environmentIds, testCommand, config, }: GhWorkflowOptions) => string;