allure 3.15.0 → 3.16.1

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/index.js

@@ -1,7 +1,7 @@
 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, HistoryCommand, JiraClearCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, isAgentTaskMapHelpRequest, } from "./commands/index.js";
+import { AgentCommand, AGENT_TASK_MAP_HELP, AgentCapabilitiesCommand, AgentInspectCommand, AgentLatestCommand, AgentQueryCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, CheckCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, JiraClearCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestOpsPlanCommand, TestPlanCommand, WatchCommand, isAgentTaskMapHelpRequest, } from "./commands/index.js";
 const [node, app, ...args] = argv;
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cli = new Cli({
@@ -30,6 +30,7 @@ cli.register(OpenCommand);
 cli.register(QualityGateCommand);
 cli.register(RunCommand);
 cli.register(SlackCommand);
+cli.register(TestOpsPlanCommand);
 cli.register(TestPlanCommand);
 cli.register(WatchCommand);
 cli.register(ResultsPackCommand);

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);
+};

package/dist/utils/signals.d.ts

@@ -0,0 +1,18 @@
+export declare const SIGNAL_EXIT_CODES: Partial<Record<NodeJS.Signals, number>>;
+export declare const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 60000;
+export declare const COMMAND_TERMINATION_GRACE_MS = 5000;
+export type SignalInfo = {
+    signal: NodeJS.Signals;
+    code: number;
+    receivedAt: number;
+    deadline: number;
+};
+export type SignalNotifier = {
+    signal: AbortSignal;
+    info: () => SignalInfo | undefined;
+    dispose: () => void;
+};
+export declare const notifySignals: (signals?: NodeJS.Signals[], onRepeat?: (signal: NodeJS.Signals) => void) => SignalNotifier;
+export declare const gracefulShutdownRemaining: (info: SignalInfo | undefined) => number | undefined;
+export declare const boundedTerminationSignal: (info: SignalInfo | undefined, graceMs?: number) => AbortSignal;
+export declare const waitForAbort: (signal: AbortSignal) => Promise<void>;

package/dist/utils/signals.js

@@ -0,0 +1,52 @@
+import process from "node:process";
+export const SIGNAL_EXIT_CODES = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+export const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 60000;
+export const COMMAND_TERMINATION_GRACE_MS = 5000;
+const exitCodeForSignal = (signal) => SIGNAL_EXIT_CODES[signal] ?? 1;
+export const notifySignals = (signals = ["SIGINT", "SIGTERM"], onRepeat) => {
+    const controller = new AbortController();
+    let info;
+    const handler = (signal) => {
+        if (info) {
+            onRepeat?.(signal);
+            return;
+        }
+        const receivedAt = Date.now();
+        info = {
+            signal,
+            code: exitCodeForSignal(signal),
+            receivedAt,
+            deadline: receivedAt + GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+        };
+        controller.abort();
+    };
+    for (const signal of signals) {
+        process.on(signal, handler);
+    }
+    return {
+        signal: controller.signal,
+        info: () => info,
+        dispose: () => {
+            for (const signal of signals) {
+                process.off(signal, handler);
+            }
+        },
+    };
+};
+export const gracefulShutdownRemaining = (info) => {
+    if (!info) {
+        return undefined;
+    }
+    return Math.max(0, info.deadline - Date.now());
+};
+export const boundedTerminationSignal = (info, graceMs = COMMAND_TERMINATION_GRACE_MS) => {
+    const remaining = gracefulShutdownRemaining(info);
+    const timeoutMs = remaining === undefined ? graceMs : Math.min(remaining, graceMs);
+    return AbortSignal.timeout(timeoutMs);
+};
+export const waitForAbort = (signal) => signal.aborted
+    ? Promise.resolve()
+    : new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allure",
-  "version": "3.15.0",
+  "version": "3.16.1",
   "description": "Allure Commandline Tool",
   "keywords": [
     "allure",
@@ -32,26 +32,26 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.15.0",
-    "@allurereport/ci": "3.15.0",
-    "@allurereport/core": "3.15.0",
-    "@allurereport/core-api": "3.15.0",
-    "@allurereport/directory-watcher": "3.15.0",
-    "@allurereport/plugin-agent": "3.15.0",
-    "@allurereport/plugin-allure2": "3.15.0",
-    "@allurereport/plugin-api": "3.15.0",
-    "@allurereport/plugin-awesome": "3.15.0",
-    "@allurereport/plugin-classic": "3.15.0",
-    "@allurereport/plugin-csv": "3.15.0",
-    "@allurereport/plugin-dashboard": "3.15.0",
-    "@allurereport/plugin-jira": "3.15.0",
-    "@allurereport/plugin-log": "3.15.0",
-    "@allurereport/plugin-progress": "3.15.0",
-    "@allurereport/plugin-server-reload": "3.15.0",
-    "@allurereport/plugin-slack": "3.15.0",
-    "@allurereport/reader-api": "3.15.0",
-    "@allurereport/service": "3.15.0",
-    "@allurereport/static-server": "3.15.0",
+    "@allurereport/charts-api": "3.16.1",
+    "@allurereport/ci": "3.16.1",
+    "@allurereport/core": "3.16.1",
+    "@allurereport/core-api": "3.16.1",
+    "@allurereport/directory-watcher": "3.16.1",
+    "@allurereport/plugin-agent": "3.16.1",
+    "@allurereport/plugin-allure2": "3.16.1",
+    "@allurereport/plugin-api": "3.16.1",
+    "@allurereport/plugin-awesome": "3.16.1",
+    "@allurereport/plugin-classic": "3.16.1",
+    "@allurereport/plugin-csv": "3.16.1",
+    "@allurereport/plugin-dashboard": "3.16.1",
+    "@allurereport/plugin-jira": "3.16.1",
+    "@allurereport/plugin-log": "3.16.1",
+    "@allurereport/plugin-progress": "3.16.1",
+    "@allurereport/plugin-server-reload": "3.16.1",
+    "@allurereport/plugin-slack": "3.16.1",
+    "@allurereport/reader-api": "3.16.1",
+    "@allurereport/service": "3.16.1",
+    "@allurereport/static-server": "3.16.1",
     "adm-zip": "^0.6.0",
     "clipanion": "^4.0.0-rc.4",
     "glob": "^13.0.6",