allure 3.15.0 → 3.16.0

package/dist/commands/history.js

@@ -1,14 +1,14 @@
 import * as console from "node:console";
 import process, { exit } from "node:process";
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, readRawConfig, resolveConfig } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class HistoryCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.historyPath = Option.String("--history-path,-h", {
             description: "The path to history file",
@@ -21,7 +21,9 @@ export class HistoryCommand extends Command {
         });
     }
     async execute() {
-        const { resultDirectories, patterns } = await findAllureResultDirectories(process.cwd(), this.resultsDir);
+        const cwd = process.cwd();
+        const rawConfig = await readRawConfig(cwd);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, rawConfig.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);

package/dist/commands/jira/clear.js

@@ -8,7 +8,7 @@ class BaseJiraCommand extends Command {
     constructor() {
         super(...arguments);
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",

package/dist/commands/log.js

@@ -5,15 +5,15 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import LogPlugin from "@allurereport/plugin-log";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class LogCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -30,12 +30,6 @@ export class LogCommand extends Command {
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         const defaultLogOptions = {
             allSteps: this.allSteps ?? false,
@@ -43,6 +37,12 @@ export class LogCommand extends Command {
             groupBy: this.groupBy ?? "suite",
         };
         const config = await readConfig(cwd, this.config);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
+        if (!resultDirectories.length) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
+            exit(1);
+            return;
+        }
         config.plugins = [
             {
                 id: "log",

package/dist/commands/open.js

@@ -8,15 +8,17 @@ 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 { notifySignals, waitForAbort } from "./../utils/signals.js";
 import { generate } from "./commons/generate.js";
 export class OpenCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "A report to open or a pattern to match test results directories in the current working directory (default: configured output)",
+            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: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.port = Option.String("--port", {
             description: "The port to serve the reports on. If not set, the server starts on a random port",
@@ -35,6 +37,7 @@ export class OpenCommand extends Command {
             port: this.port,
         });
         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,
@@ -42,7 +45,7 @@ export class OpenCommand extends Command {
                 open: true,
             });
         }
-        else if (this.resultsDir.length) {
+        else if (resolvedPatterns.length) {
             const tmpDir = await mkdtemp(join(tmpdir(), "allure-report-"));
             const config = await readConfig(cwd, this.config, {
                 port: this.port,
@@ -54,12 +57,13 @@ export class OpenCommand extends Command {
                 cwd,
                 config,
             });
-            process.on("SIGINT", async () => {
+            const notifier = notifySignals(["SIGINT", "SIGTERM"]);
+            void waitForAbort(notifier.signal).then(async () => {
                 try {
                     await rm(config.output, { recursive: true });
                 }
                 catch { }
-                process.exit(0);
+                process.exit(notifier.info()?.code ?? 0);
             });
             await serve({
                 port: config.port ? parseInt(config.port, 10) : undefined,

package/dist/commands/qualityGate.js

@@ -6,15 +6,15 @@ import { Command, Option } from "clipanion";
 import * as typanion from "typanion";
 import { red } from "yoctocolors";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class QualityGateCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.fastFail = Option.Boolean("--fast-fail", {
             description: "Force the command to fail if there are any rule failures",
@@ -81,7 +81,7 @@ export class QualityGateCommand extends Command {
             exit(-1);
             return;
         }
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);

package/dist/commands/results/pack.d.ts

@@ -5,6 +5,7 @@ export declare class ResultsPackCommand extends Command {
     static usage: import("clipanion").Usage;
     resultsDir: string | undefined;
     name: string | undefined;
+    config: string | undefined;
     cwd: string | undefined;
     execute(): Promise<void>;
 }

package/dist/commands/results/pack.js

@@ -9,44 +9,42 @@ import * as fs from "node:fs/promises";
 import { realpath } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { exit } from "node:process";
+import { readRawConfig } from "@allurereport/core";
 import AdmZip from "adm-zip";
 import { Command, Option } from "clipanion";
-import { glob } from "glob";
 import { green, red } from "yoctocolors";
+import { resolveAndFindResultsDirs } from "../../utils/resultsPatterns.js";
 export class ResultsPackCommand extends Command {
     constructor() {
         super(...arguments);
         _ResultsPackCommand_instances.add(this);
         this.resultsDir = Option.String({
             required: false,
-            name: "Pattern to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Pattern to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.name = Option.String("--name", {
             description: "The archive name (default: allure-results.zip)",
         });
+        this.config = Option.String("--config,-c", {
+            description: "The path to Allure config file",
+        });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
         });
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const rawConfig = await readRawConfig(cwd, this.config);
+        const cliPatterns = this.resultsDir ? [this.resultsDir] : [];
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, cliPatterns, rawConfig.resultsDir);
         const archiveName = this.name ?? "allure-results.zip";
-        const resultsDirectories = (await glob(resultsDir, {
-            mark: true,
-            nodir: false,
-            dot: true,
-            absolute: true,
-            windowsPathsNoEscape: true,
-            cwd,
-        })).filter((p) => /(\/|\\)$/.test(p));
         const resultsFiles = new Set();
-        if (resultsDirectories.length === 0) {
-            console.error(red(`No test results directories found matching pattern: ${resultsDir}`));
+        if (resultDirectories.length === 0) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);
             return;
         }
-        for (const dir of resultsDirectories) {
+        for (const dir of resultDirectories) {
             const files = await fs.readdir(dir);
             if (files.length === 0) {
                 continue;

package/dist/commands/run.d.ts

@@ -17,6 +17,7 @@ export declare class RunCommand extends Command {
     historyLimit: string | undefined;
     hideLabels: string[] | undefined;
     knownIssues: string | undefined;
+    resultsDir: string[] | undefined;
     commandToRun: string[];
     get logs(): "pipe" | "inherit" | "ignore";
     execute(): Promise<void>;

package/dist/commands/run.js

@@ -7,12 +7,14 @@ import { serve } from "@allurereport/static-server";
 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 { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
+const missingRunCommandUsageError = () => new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
 export class RunCommand extends Command {
     constructor() {
         super(...arguments);
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -52,6 +54,9 @@ export class RunCommand extends Command {
         this.knownIssues = Option.String("--known-issues", {
             description: "Path to known issues file",
         });
+        this.resultsDir = Option.Array("--results-dir", {
+            description: "Glob pattern or path for Allure results directories (repeatable). Overrides config.resultsDir. Quote globs in the shell",
+        });
         this.commandToRun = Option.Rest();
     }
     get logs() {
@@ -61,17 +66,15 @@ export class RunCommand extends Command {
         return this.ignoreLogs ? "inherit" : "pipe";
     }
     async execute() {
-        const args = this.commandToRun.filter((arg) => arg !== "--");
-        if (!args || !args.length) {
-            throw new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
+        const { command, commandArgs } = parseRunCommand(this.commandToRun);
+        if (!command) {
+            throw missingRunCommandUsageError();
         }
         const before = new Date().getTime();
         process.on("exit", (exitCode) => {
             const after = new Date().getTime();
             console.log(`exit code ${exitCode} (${after - before}ms)`);
         });
-        const command = args[0];
-        const commandArgs = args.slice(1);
         const cwd = await realpath(this.cwd ?? process.cwd());
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
         console.log(`${command} ${commandArgs.join(" ")}`);
@@ -100,6 +103,7 @@ export class RunCommand extends Command {
             historyLimit: this.historyLimit !== undefined ? parseInt(this.historyLimit, 10) : undefined,
             knownIssuesPath: this.knownIssues,
         });
+        const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
         const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
         const withRerun = maxRerun > 0;
         const withQualityGate = !!config.qualityGate && !withRerun;
@@ -149,6 +153,7 @@ export class RunCommand extends Command {
             silent: this.silent,
             ignoreLogs: this.ignoreLogs,
             maxRerun,
+            resultsPatterns,
         });
         if (config.open) {
             await serve({
@@ -165,7 +170,10 @@ export class RunCommand extends Command {
 RunCommand.paths = [["run"]];
 RunCommand.usage = Command.Usage({
     description: "Run specified command",
-    details: "This command runs the specified command and collects Allure results.",
+    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.",
     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"],
@@ -173,5 +181,9 @@ 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 --results-dir './artifacts/**/allure-results' -- npm test",
+            "Override results discovery with a quoted glob",
+        ],
     ],
 });

package/dist/commands/slack.js

@@ -5,15 +5,15 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import SlackPlugin from "@allurereport/plugin-slack";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class SlackCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -29,18 +29,18 @@ export class SlackCommand extends Command {
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         const defaultSlackOptions = {
             token: this.token,
             channel: this.channel,
         };
         const config = await readConfig(cwd, this.config);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
+        if (!resultDirectories.length) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
+            exit(1);
+            return;
+        }
         config.plugins = [
             {
                 id: "slack",

package/dist/commands/testplan.js

@@ -1,22 +1,24 @@
 import * as console from "node:console";
 import { basename, dirname, resolve } from "node:path";
-import { exit } from "node:process";
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { cwd as processCwd, exit } from "node:process";
+import { AllureReport, readRawConfig, resolveConfig } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class TestPlanCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.output = Option.String("--output,-o", {
             description: "The output file name. Absolute paths are accepted as well",
         });
     }
     async execute() {
-        const { resultDirectories, patterns } = await findAllureResultDirectories(process.cwd(), this.resultsDir);
+        const cwd = processCwd();
+        const rawConfig = await readRawConfig(cwd);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, rawConfig.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);

package/dist/commands/watch.d.ts

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

package/dist/commands/watch.js

@@ -2,25 +2,26 @@ import * as console from "node:console";
 import { realpath } from "node:fs/promises";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
-import process, { exit } from "node:process";
+import process from "node:process";
 import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
-import { newFilesInDirectoryWatcher } from "@allurereport/directory-watcher";
+import { allureResultsDirectoriesWatcher, newFilesInDirectoryWatcher } from "@allurereport/directory-watcher";
 import Awesome from "@allurereport/plugin-awesome";
 import ProgressPlugin from "@allurereport/plugin-progress";
 import ServerReloadPlugin from "@allurereport/plugin-server-reload";
 import { PathResultFile } from "@allurereport/reader-api";
 import { serve } from "@allurereport/static-server";
 import { Command, Option } from "clipanion";
-import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveResultsPatterns } from "../utils/resultsPatterns.js";
+import { boundedTerminationSignal, notifySignals, waitForAbort } from "../utils/signals.js";
+import { allureResultsDirectoriesGlobWatcher } from "./commons/resultsDiscovery.js";
 export class WatchCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Empty patterns use name-based discovery.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -40,15 +41,12 @@ export class WatchCommand extends Command {
         this.preserve = Option.Boolean("--preserve", {
             description: "Don't clear terminal output on the data refresh",
         });
+        this.newOnly = Option.Boolean("--new-only", true, {
+            description: "Skip whatever test results already exist on disk at startup and only react to results written after the watch has started, instead of ingesting the existing backlog first (default: true). Pass --no-new-only to ingest the existing backlog too",
+        });
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         process.on("exit", (code) => {
             const after = new Date().getTime();
@@ -60,6 +58,8 @@ export class WatchCommand extends Command {
             open: this.open,
             port: this.port,
         });
+        const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
+        const useDynamicNameDiscovery = resultsPatterns.length === 0;
         try {
             await rm(config.output, { recursive: true });
         }
@@ -110,39 +110,85 @@ export class WatchCommand extends Command {
         });
         await allureReport.start();
         const abortFunctions = [];
-        for (const directory of resultDirectories) {
-            const { abort } = newFilesInDirectoryWatcher(directory, async (path) => {
-                await allureReport.readResult(new PathResultFile(path));
-            });
-            abortFunctions.push(abort);
-        }
+        const perDirectoryWatchers = new Map();
+        let isInitialDiscovery = true;
+        const onDiscoveryUpdate = async (newDirectories, deletedDirectories) => {
+            for (const deletedDir of deletedDirectories) {
+                const watcher = perDirectoryWatchers.get(deletedDir);
+                if (watcher) {
+                    await watcher.abort();
+                }
+                perDirectoryWatchers.delete(deletedDir);
+            }
+            for (const newDir of newDirectories) {
+                if (perDirectoryWatchers.has(newDir)) {
+                    continue;
+                }
+                const watcher = newFilesInDirectoryWatcher(newDir, async (path) => {
+                    await allureReport.readResult(new PathResultFile(path));
+                }, { ignoreInitial: this.newOnly && isInitialDiscovery });
+                perDirectoryWatchers.set(newDir, watcher);
+                await watcher.initialScan();
+            }
+            isInitialDiscovery = false;
+        };
+        const discoveryWatcher = useDynamicNameDiscovery
+            ? allureResultsDirectoriesWatcher(cwd, onDiscoveryUpdate)
+            : allureResultsDirectoriesGlobWatcher(cwd, resultsPatterns, onDiscoveryUpdate, { indexDelay: 600 });
+        await discoveryWatcher.initialScan();
+        abortFunctions.push(discoveryWatcher.abort);
+        abortFunctions.push(async (immediately) => {
+            for (const watcher of perDirectoryWatchers.values()) {
+                await watcher.abort(immediately);
+            }
+            perDirectoryWatchers.clear();
+        });
         const pluginIdToOpen = config.plugins?.find((plugin) => !!plugin.options.open)?.id;
         if (pluginIdToOpen) {
             await server.open(join(server.url, pluginIdToOpen));
         }
         console.info("Press Ctrl+C to exit");
-        process.on("SIGINT", async () => {
-            console.log("");
+        const notifier = notifySignals(["SIGINT", "SIGTERM"], (signal) => {
+            console.log(`\nreceived another ${signal}, force exiting...`);
+            process.exit(130);
+        });
+        await waitForAbort(notifier.signal);
+        const signalInfo = notifier.info();
+        console.log(`\nreceived ${signalInfo?.signal}, stopping (press again to force exit)...`);
+        const terminationSignal = boundedTerminationSignal(signalInfo, 5000);
+        const cleanup = (async () => {
             for (const abort of abortFunctions) {
-                await abort();
+                await abort(true);
             }
             await server.stop();
             await allureReport.done();
-            process.exit(0);
-        });
+        })();
+        const timedOut = await Promise.race([cleanup.then(() => false), waitForAbort(terminationSignal).then(() => true)]);
+        if (timedOut) {
+            console.log("shutdown is taking too long, force exiting...");
+            process.exit(130);
+        }
+        notifier.dispose();
+        process.exit(signalInfo?.code ?? 0);
     }
 }
 WatchCommand.paths = [["watch"]];
 WatchCommand.usage = Command.Usage({
     description: "Watches Allure Results changes in Real-time",
-    details: "This command watches for changes in the Allure Results directory and updates the report in real-time.",
+    details: "This command watches for changes in Allure Results directories and updates the report in real-time. " +
+        "CLI patterns and config.resultsDir use live re-glob discovery. " +
+        "When both are empty, directories named `allure-results` are discovered dynamically (unlike generate, which defaults to `./**/allure-results`). " +
+        "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 --port 8080",
             "Watch for changes in the ./allure-results directory and serve the report on port 8080",
         ],
-        ["watch ./packages/*/allure-results", "Watch for changes in all Allure result directories matching the pattern"],
+        [
+            "watch './packages/*/allure-results'",
+            "Watch for changes in all Allure result directories matching the pattern",
+        ],
         [
             "watch ./packages/foo/allure-results ./packages/bar/allure-results",
             "Watch for changes in two Allure result directories",

package/dist/utils/index.d.ts

@@ -3,3 +3,5 @@ export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
 export * from "./fileSystem.js";
+export * from "./resultsPatterns.js";
+export * from "./signals.js";

package/dist/utils/index.js

@@ -3,3 +3,5 @@ export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
 export * from "./fileSystem.js";
+export * from "./resultsPatterns.js";
+export * from "./signals.js";

package/dist/utils/process.js

@@ -74,6 +74,7 @@ export const runProcess = (params) => {
 };
 export const terminationOf = (testProcess) => new Promise((resolve) => {
     testProcess.on("exit", (code) => resolve(code));
+    testProcess.on("error", () => resolve(null));
 });
 export const stopProcessTree = async (pid, { signal = "SIGTERM" } = {}) => {
     const tree = new Map();

package/dist/utils/resultsPatterns.d.ts

@@ -0,0 +1,12 @@
+export declare const normalizeResultsDir: (value?: string | readonly string[]) => string[];
+export declare const resolveResultsPatterns: (cliPatterns?: string | readonly string[] | null, configResultsDir?: string | readonly string[]) => string[];
+export declare const normalizeResultsDirectoryPath: (path: string) => string;
+export type ParsedRunCommand = {
+    command: string | undefined;
+    commandArgs: string[];
+};
+export declare const parseRunCommand: (args: string[]) => ParsedRunCommand;
+export declare const resolveAndFindResultsDirs: (cwd: string, cliPatterns: readonly string[], configResultsDir?: string | string[]) => Promise<{
+    patterns: readonly string[];
+    resultDirectories: string[];
+}>;

package/dist/utils/resultsPatterns.js

@@ -0,0 +1,37 @@
+import { resolve } from "node:path";
+import { findAllureResultDirectories } from "./fileSystem.js";
+export const normalizeResultsDir = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    const values = typeof value === "string" ? [value] : [...value];
+    return values.filter((entry) => entry.length > 0);
+};
+export const resolveResultsPatterns = (cliPatterns, configResultsDir) => {
+    const fromCli = normalizeResultsDir(cliPatterns ?? undefined);
+    if (fromCli.length) {
+        return fromCli;
+    }
+    return normalizeResultsDir(configResultsDir);
+};
+export const normalizeResultsDirectoryPath = (path) => {
+    return resolve(path.replace(/[/\\]+$/, ""));
+};
+export const parseRunCommand = (args) => {
+    let start = 0;
+    while (start < args.length && args[start] === "--") {
+        start += 1;
+    }
+    const commandParts = args.slice(start);
+    if (!commandParts.length) {
+        return { command: undefined, commandArgs: [] };
+    }
+    return {
+        command: commandParts[0],
+        commandArgs: commandParts.slice(1),
+    };
+};
+export const resolveAndFindResultsDirs = async (cwd, cliPatterns, configResultsDir) => {
+    const patterns = resolveResultsPatterns(cliPatterns, configResultsDir);
+    return findAllureResultDirectories(cwd, patterns);
+};