allure 0.0.0 → 3.0.0-beta.0

package/README.md

@@ -0,0 +1,33 @@
+# Allure CLI
+ 
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+The Allure CLI is a main entry point which includes many sub-commands
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add allure
+yarn add allure
+pnpm add allure
+```
+
+## Usage
+
+The CLI provides a set of commands to work with Allure Report features. To see the list of available commands, run:
+
+```shell
+allure --help
+```

package/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./dist/index.js";

package/dist/commands/awesome.d.ts

@@ -0,0 +1,12 @@
+type AwesomeCommandOptions = {
+    output?: string;
+    reportName?: string;
+    reportLanguage?: string;
+    logo?: string;
+    singleFile?: boolean;
+    historyPath?: string;
+    knownIssues?: string;
+};
+export declare const AwesomeCommandAction: (resultsDir: string, options: AwesomeCommandOptions) => Promise<void>;
+export declare const AwesomeCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/awesome.js

@@ -0,0 +1,81 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const AwesomeCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
+    const config = await resolveConfig({
+        output,
+        name,
+        historyPath,
+        knownIssuesPath,
+        plugins: {
+            "@allure/plugin-awesome": {
+                options: rest,
+            },
+        },
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    const after = new Date().getTime();
+    console.log(`the report successfully generated (${after - before}ms)`);
+};
+export const AwesomeCommand = createCommand({
+    name: "awesome <resultsDir>",
+    description: "Generates Allure Awesome report based on provided Allure Results",
+    options: [
+        [
+            "--output, -o <file>",
+            {
+                description: "The output directory name. Absolute paths are accepted as well",
+                default: "allure-report",
+            },
+        ],
+        [
+            "--report-name, --name <string>",
+            {
+                description: "The report name",
+                default: "Allure Report",
+            },
+        ],
+        [
+            "--single-file",
+            {
+                description: "Generate single file report",
+                default: false,
+            },
+        ],
+        [
+            "--logo <string>",
+            {
+                description: "Path to the report logo which will be displayed in the header",
+            },
+        ],
+        [
+            "--theme <string>",
+            {
+                description: "Default theme of the report (default: OS theme)",
+            },
+        ],
+        [
+            "--report-language, --lang <string>",
+            {
+                description: "Default language of the report (default: OS language)",
+            },
+        ],
+        [
+            "--history-path, -h <file>",
+            {
+                description: "The path to history file",
+            },
+        ],
+        [
+            "--known-issues <file>",
+            {
+                description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+            },
+        ],
+    ],
+    action: AwesomeCommandAction,
+});

package/dist/commands/classic.d.ts

@@ -0,0 +1,11 @@
+type ClassicCommandOptions = {
+    output?: string;
+    reportName?: string;
+    reportLanguage?: string;
+    singleFile?: boolean;
+    historyPath?: string;
+    knownIssues?: string;
+};
+export declare const ClassicCommandAction: (resultsDir: string, options: ClassicCommandOptions) => Promise<void>;
+export declare const ClassicCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/classic.js

@@ -0,0 +1,69 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const ClassicCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
+    const config = await resolveConfig({
+        output,
+        name,
+        historyPath,
+        knownIssuesPath,
+        plugins: {
+            "@allure/plugin-classic": {
+                options: rest,
+            },
+        },
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    const after = new Date().getTime();
+    console.log(`the report successfully generated (${after - before}ms)`);
+};
+export const ClassicCommand = createCommand({
+    name: "classic <resultsDir>",
+    description: "Generates Allure Classic report based on provided Allure Results",
+    options: [
+        [
+            "--output, -o <file>",
+            {
+                description: "The output directory name. Absolute paths are accepted as well",
+                default: "allure-report",
+            },
+        ],
+        [
+            "--report-name, --name <string>",
+            {
+                description: "The report name",
+                default: "Allure Report",
+            },
+        ],
+        [
+            "--report-language, --lang <string>",
+            {
+                description: "Default language of the report (default: OS language)",
+            },
+        ],
+        [
+            "--single-file",
+            {
+                description: "Generate single file report",
+                default: false,
+            },
+        ],
+        [
+            "--history-path, -h <file>",
+            {
+                description: "The path to history file",
+            },
+        ],
+        [
+            "--known-issues <file>",
+            {
+                description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+            },
+        ],
+    ],
+    action: ClassicCommandAction,
+});

package/dist/commands/csv.d.ts

@@ -0,0 +1,9 @@
+type CsvCommandOptions = {
+    separator?: string;
+    disableHeaders?: boolean;
+    output?: string;
+    knownIssues?: string;
+};
+export declare const CsvCommandAction: (resultsDir: string, options: CsvCommandOptions) => Promise<void>;
+export declare const CsvCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/csv.js

@@ -0,0 +1,51 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const CsvCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    const config = await resolveConfig({
+        plugins: {
+            "@allure/plugin-csv": {
+                options,
+            },
+        },
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    const after = new Date().getTime();
+    console.log(`the report successfully generated (${after - before}ms)`);
+};
+export const CsvCommand = createCommand({
+    name: "csv <resultsDir>",
+    description: "Generates CSV report based on provided Allure Results",
+    options: [
+        [
+            "--output, -o <file>",
+            {
+                description: "The output file name. Absolute paths are accepted as well",
+                default: "allure.csv",
+            },
+        ],
+        [
+            "--disable-headers",
+            {
+                description: "Specify, to disable CSV headers",
+            },
+        ],
+        [
+            "--separator <string>",
+            {
+                description: "The csv separator",
+                default: ",",
+            },
+        ],
+        [
+            "--known-issues <file>",
+            {
+                description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+            },
+        ],
+    ],
+    action: CsvCommandAction,
+});

package/dist/commands/generate.d.ts

@@ -0,0 +1,9 @@
+type CommandOptions = {
+    config?: string;
+    output?: string;
+    cwd?: string;
+    reportName?: string;
+};
+export declare const GenerateCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
+export declare const GenerateCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/generate.js

@@ -0,0 +1,35 @@
+import { AllureReport, readRuntimeConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const GenerateCommandAction = async (resultsDir, options) => {
+    const { config: configPath, output, cwd, reportName } = options;
+    const config = await readRuntimeConfig(configPath, cwd, output, reportName);
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+};
+export const GenerateCommand = createCommand({
+    name: "generate <resultsDir>",
+    description: "Generates the report to specified directory",
+    options: [
+        [
+            "--config, -c <file>",
+            {
+                description: "The path Allure config file",
+            },
+        ],
+        [
+            "--output, -o <file>",
+            {
+                description: "The output directory name. Absolute paths are accepted as well (default: allure-report)",
+            },
+        ],
+        [
+            "--cwd <cwd>",
+            {
+                description: "The working directory for the command to run (default: current working directory)",
+            },
+        ],
+    ],
+    action: GenerateCommandAction,
+});

package/dist/commands/history.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    historyPath?: string;
+    reportName?: string;
+};
+export declare const HistoryCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
+export declare const HistoryCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/history.js

@@ -0,0 +1,34 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const HistoryCommandAction = async (resultsDir, options) => {
+    const config = await resolveConfig({
+        historyPath: options.historyPath,
+        name: options.reportName,
+        plugins: {},
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+};
+export const HistoryCommand = createCommand({
+    name: "history <resultsDir>",
+    description: "Generates the history to specified folder",
+    options: [
+        [
+            "--history-path, -h <file>",
+            {
+                description: "The path to history file",
+                default: "history.jsonl",
+            },
+        ],
+        [
+            "--report-name, --name <string>",
+            {
+                description: "The report name",
+                default: "Allure Report",
+            },
+        ],
+    ],
+    action: HistoryCommandAction,
+});

package/dist/commands/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./history.js";
+export * from "./testplan.js";
+export * from "./classic.js";
+export * from "./awesome.js";
+export * from "./csv.js";
+export * from "./history.js";
+export * from "./knownIssue.js";
+export * from "./run.js";
+export * from "./slack.js";
+export * from "./testplan.js";
+export * from "./watch.js";
+export * from "./open.js";
+export * from "./qualityGate.js";
+export * from "./log.js";
+export * from "./generate.js";

package/dist/commands/index.js

@@ -0,0 +1,15 @@
+export * from "./history.js";
+export * from "./testplan.js";
+export * from "./classic.js";
+export * from "./awesome.js";
+export * from "./csv.js";
+export * from "./history.js";
+export * from "./knownIssue.js";
+export * from "./run.js";
+export * from "./slack.js";
+export * from "./testplan.js";
+export * from "./watch.js";
+export * from "./open.js";
+export * from "./qualityGate.js";
+export * from "./log.js";
+export * from "./generate.js";

package/dist/commands/knownIssue.d.ts

@@ -0,0 +1,6 @@
+type CommandOptions = {
+    output?: string;
+};
+export declare const KnownIssueCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
+export declare const KnownIssueCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/knownIssue.js

@@ -0,0 +1,27 @@
+import { AllureReport, createConfig, writeKnownIssues } from "@allure/core";
+import console from "node:console";
+import { resolve } from "node:path";
+import { createCommand } from "../utils/commands.js";
+export const KnownIssueCommandAction = async (resultsDir, options) => {
+    const { output = "known-issues.json" } = options;
+    const config = await createConfig({});
+    const allureReport = new AllureReport(config);
+    const targetPath = resolve(output);
+    await allureReport.readDirectory(resultsDir);
+    await writeKnownIssues(allureReport.store, output);
+    console.log(`writing known-issues.json to ${targetPath}`);
+};
+export const KnownIssueCommand = createCommand({
+    name: "known-issue <resultsDir>",
+    description: "Generates a known issue list",
+    options: [
+        [
+            "--output, -o <file>",
+            {
+                description: "The output file name. Absolute paths are accepted as well",
+                default: "known-issues.json",
+            },
+        ],
+    ],
+    action: KnownIssueCommandAction,
+});

package/dist/commands/log.d.ts

@@ -0,0 +1,7 @@
+export type LogCommandOptions = {
+    allSteps?: boolean;
+    withTrace?: boolean;
+    groupBy?: "suites" | "features" | "packages" | "none";
+};
+export declare const LogCommandAction: (resultsDir: string, options: LogCommandOptions) => Promise<void>;
+export declare const LogCommand: (cli: import("cac").CAC) => void;

package/dist/commands/log.js

@@ -0,0 +1,46 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const LogCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    const config = await resolveConfig({
+        plugins: {
+            "@allure/plugin-log": {
+                options,
+            },
+        },
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    const after = new Date().getTime();
+    console.log(`the report successfully generated (${after - before}ms)`);
+};
+export const LogCommand = createCommand({
+    name: "log <resultsDir>",
+    description: "Prints Allure Results to the console",
+    options: [
+        [
+            "--group-by <label>",
+            {
+                description: "Group tests by type (none, suite, feature, package, etc.)",
+                default: "suite",
+            },
+        ],
+        [
+            "--all-steps",
+            {
+                description: "Show all steps. By default only failed steps are shown",
+                default: false,
+            },
+        ],
+        [
+            "--with-trace",
+            {
+                description: "Print stack trace for failed tests",
+                default: false,
+            },
+        ],
+    ],
+    action: LogCommandAction,
+});

package/dist/commands/open.d.ts

@@ -0,0 +1,8 @@
+type CommandOptions = {
+    config?: string;
+    port?: number;
+    live: boolean;
+};
+export declare const OpenCommandAction: (reportDir: string | undefined, options: CommandOptions) => Promise<void>;
+export declare const OpenCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/open.js

@@ -0,0 +1,39 @@
+import { readRuntimeConfig } from "@allure/core";
+import { serve } from "@allure/static-server";
+import { createCommand } from "../utils/commands.js";
+export const OpenCommandAction = async (reportDir, options) => {
+    const { config: configPath, port, live } = options;
+    const config = await readRuntimeConfig(configPath, undefined, reportDir);
+    await serve({
+        port: port,
+        servePath: config.output,
+        live: Boolean(live),
+        open: true,
+    });
+};
+export const OpenCommand = createCommand({
+    name: "open [reportDir]",
+    description: "Serves specified directory",
+    options: [
+        [
+            "--config, -c <file>",
+            {
+                description: "The path Allure config file",
+            },
+        ],
+        [
+            "--port <string>",
+            {
+                description: "The port to serve the reports on. If not set, the server starts on a random port",
+            },
+        ],
+        [
+            "--live",
+            {
+                description: "Reload pages on any file change in the served directory",
+                default: false,
+            },
+        ],
+    ],
+    action: OpenCommandAction,
+});

package/dist/commands/qualityGate.d.ts

@@ -0,0 +1,6 @@
+type QualityGateCommandOptions = {
+    cwd?: string;
+};
+export declare const QualityGateCommandAction: (resultsDir: string, options: QualityGateCommandOptions) => Promise<void>;
+export declare const QualityGateCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/qualityGate.js

@@ -0,0 +1,46 @@
+import { AllureReport, readRuntimeConfig } from "@allure/core";
+import console from "node:console";
+import process from "node:process";
+import { bold, red } from "yoctocolors";
+import { createCommand } from "../utils/commands.js";
+export const QualityGateCommandAction = async (resultsDir, options) => {
+    const cwd = options.cwd ?? process.cwd();
+    const fullConfig = await readRuntimeConfig(cwd, "./allure-report");
+    const allureReport = new AllureReport(fullConfig);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    await allureReport.validate();
+    if (allureReport.exitCode === 0) {
+        return;
+    }
+    const failedResults = allureReport.validationResults.filter((result) => !result.success);
+    console.error(red(`Quality gate has failed with ${bold(failedResults.length.toString())} errors:\n`));
+    for (const result of failedResults) {
+        let scope = "";
+        switch (result.meta?.type) {
+            case "label":
+                scope = `(label[${result.meta.name}="${result.meta.value}"])`;
+                break;
+            case "parameter":
+                scope = `(parameter[${result.meta.name}="${result.meta.value}"])`;
+                break;
+        }
+        console.error(red(`⨯ ${bold(`${result.rule}${scope}`)}: expected ${result.expected}, actual ${result.actual}`));
+    }
+    console.error(red(`\nThe process has been exited with code 1`));
+    process.exit(allureReport.exitCode);
+};
+export const QualityGateCommand = createCommand({
+    name: "quality-gate <resultsDir>",
+    description: "Returns status code 1 if there any test failure above specified success rate",
+    options: [
+        [
+            "--cwd <cwd>",
+            {
+                description: "The working directory for the command to run (default: current working directory)",
+            },
+        ],
+    ],
+    action: QualityGateCommandAction,
+});

package/dist/commands/run.d.ts

@@ -0,0 +1,10 @@
+export type RunCommandOptions = {
+    config?: string;
+    cwd?: string;
+    output?: string;
+    reportName?: string;
+    rerun?: number;
+    silent?: boolean;
+} & Record<"--", string[]>;
+export declare const RunCommandAction: (options: RunCommandOptions) => Promise<never>;
+export declare const RunCommand: (cli: import("cac").CAC) => void;

package/dist/commands/run.js

@@ -0,0 +1,167 @@
+import { AllureReport, isFileNotFoundError, readRuntimeConfig } from "@allure/core";
+import { createTestPlan } from "@allure/core-api";
+import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allure/directory-watcher";
+import AllureAwesome from "@allure/plugin-awesome";
+import { PathResultFile } from "@allure/reader-api";
+import * as console from "node:console";
+import { mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { createCommand } from "../utils/commands.js";
+import { logTests, runProcess, terminationOf } from "../utils/index.js";
+const runTests = async (allureReport, cwd, command, commandArgs, environment, silent) => {
+    let testProcessStarted = false;
+    const allureResultsWatchers = new Map();
+    const processWatcher = delayedFileProcessingWatcher(async (path) => {
+        await allureReport.readResult(new PathResultFile(path));
+    }, {
+        indexDelay: 200,
+        minProcessingDelay: 1000,
+    });
+    const allureResultsWatch = allureResultsDirectoriesWatcher(cwd, async (newAllureResults, deletedAllureResults) => {
+        for (const delAr of deletedAllureResults) {
+            const watcher = allureResultsWatchers.get(delAr);
+            if (watcher) {
+                await watcher.abort();
+            }
+            allureResultsWatchers.delete(delAr);
+        }
+        for (const newAr of newAllureResults) {
+            if (allureResultsWatchers.has(newAr)) {
+                continue;
+            }
+            const watcher = newFilesInDirectoryWatcher(newAr, async (path) => {
+                await processWatcher.addFile(path);
+            }, {
+                ignoreInitial: !testProcessStarted,
+                indexDelay: 300,
+            });
+            allureResultsWatchers.set(newAr, watcher);
+            await watcher.initialScan();
+        }
+    }, { indexDelay: 600 });
+    await allureResultsWatch.initialScan();
+    testProcessStarted = true;
+    const beforeProcess = Date.now();
+    const testProcess = runProcess(command, commandArgs, cwd, environment, silent);
+    const code = await terminationOf(testProcess);
+    const afterProcess = Date.now();
+    console.log(`process finished with code ${code ?? 0} (${afterProcess - beforeProcess})ms`);
+    await allureResultsWatch.abort();
+    for (const [ar, watcher] of allureResultsWatchers) {
+        await watcher.abort();
+        allureResultsWatchers.delete(ar);
+    }
+    await processWatcher.abort();
+};
+export const RunCommandAction = async (options) => {
+    const args = options["--"];
+    if (!args || !args.length) {
+        throw new Error("expecting command to be specified after --, e.g. allure run -- npm run test");
+    }
+    const before = new Date().getTime();
+    process.on("exit", (code) => {
+        const after = new Date().getTime();
+        console.log(`exit code ${code} (${after - before}ms)`);
+    });
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    const cwd = await realpath(options.cwd ?? process.cwd());
+    console.log(`${command} ${commandArgs.join(" ")}`);
+    const { config: configPath, output, reportName, rerun: maxRerun = 0, silent = false } = options;
+    const config = await readRuntimeConfig(configPath, cwd, output, reportName);
+    try {
+        await rm(config.output, { recursive: true });
+    }
+    catch (e) {
+        if (!isFileNotFoundError(e)) {
+            console.error("could not clean output directory", e);
+        }
+    }
+    const allureReport = new AllureReport({
+        ...config,
+        realTime: false,
+        plugins: [
+            ...(config.plugins?.length
+                ? config.plugins
+                : [
+                    {
+                        id: "awesome",
+                        enabled: true,
+                        options: {},
+                        plugin: new AllureAwesome({
+                            reportName: config.name,
+                        }),
+                    },
+                ]),
+        ],
+    });
+    await allureReport.start();
+    await runTests(allureReport, cwd, command, commandArgs, {}, silent);
+    for (let rerun = 0; rerun < maxRerun; rerun++) {
+        const failed = await allureReport.store.failedTestResults();
+        if (failed.length === 0) {
+            console.log("no failed tests is detected.");
+            break;
+        }
+        const testPlan = createTestPlan(failed);
+        console.log(`rerun number ${rerun} of ${testPlan.tests.length} tests:`);
+        logTests(failed);
+        const tmpDir = await mkdtemp(join(tmpdir(), "allure-run-"));
+        const testPlanPath = resolve(tmpDir, `${rerun}-testplan.json`);
+        await writeFile(testPlanPath, JSON.stringify(testPlan));
+        await runTests(allureReport, cwd, command, commandArgs, {
+            ALLURE_TESTPLAN_PATH: testPlanPath,
+            ALLURE_RERUN: `${rerun}`,
+        }, silent);
+        await rm(tmpDir, { recursive: true });
+        logTests(await allureReport.store.allTestResults());
+    }
+    await allureReport.done();
+    await allureReport.validate();
+    process.exit(allureReport.exitCode);
+};
+export const RunCommand = createCommand({
+    name: "run",
+    description: "Run specified command",
+    options: [
+        [
+            "--config, -c <file>",
+            {
+                description: "The path Allure config file",
+            },
+        ],
+        [
+            "--cwd <cwd>",
+            {
+                description: "The working directory for the command to run (Default: current working directory)",
+            },
+        ],
+        [
+            "--output, -o <file>",
+            {
+                description: "The output file name, allure.csv by default. Accepts absolute paths (Default: ./allure-report)",
+            },
+        ],
+        [
+            "--report-name, --name <string>",
+            {
+                description: "The report name (Default: Allure Report)",
+            },
+        ],
+        [
+            "--rerun <number>",
+            {
+                description: "The number of reruns for failed tests (Default: 0)",
+            },
+        ],
+        [
+            "--silent",
+            {
+                description: "Don't pipe the process output logs to console (Default: 0)",
+            },
+        ],
+    ],
+    action: RunCommandAction,
+});

package/dist/commands/slack.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    token: string;
+    channel: string;
+};
+export declare const SlackCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
+export declare const SlackCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/slack.js

@@ -0,0 +1,37 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { createCommand } from "../utils/commands.js";
+export const SlackCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    const config = await resolveConfig({
+        plugins: {
+            "@allure/plugin-slack": {
+                options,
+            },
+        },
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    const after = new Date().getTime();
+    console.log(`the report successfully generated (${after - before}ms)`);
+};
+export const SlackCommand = createCommand({
+    name: "slack <resultsDir>",
+    description: "Posts test results into Slack Channel",
+    options: [
+        [
+            "--token, -t <token>",
+            {
+                description: "Slack Bot User OAuth Token",
+            },
+        ],
+        [
+            "--channel, -c <channel>",
+            {
+                description: "Slack channelId",
+            },
+        ],
+    ],
+    action: SlackCommandAction,
+});

package/dist/commands/testplan.d.ts

@@ -0,0 +1,6 @@
+type CommandOptions = {
+    output?: string;
+};
+export declare const TestPlanCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
+export declare const TestPlanCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/testplan.js

@@ -0,0 +1,37 @@
+import { AllureReport, resolveConfig } from "@allure/core";
+import { basename, dirname, resolve } from "node:path";
+import { createCommand } from "../utils/commands.js";
+export const TestPlanCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    const resolved = resolve(options.output ?? "./testplan.json");
+    const output = dirname(resolved);
+    const fileName = basename(resolved);
+    const config = await resolveConfig({
+        output: output,
+        plugins: {
+            "@allure/plugin-testplan": {
+                options: { fileName },
+            },
+        },
+    });
+    const allureReport = new AllureReport(config);
+    await allureReport.start();
+    await allureReport.readDirectory(resultsDir);
+    await allureReport.done();
+    const after = new Date().getTime();
+    console.log(`the report successfully generated (${after - before}ms)`);
+};
+export const TestPlanCommand = createCommand({
+    name: "testplan <resultsDir>",
+    description: "Generates testplan.json based on provided Allure Results",
+    options: [
+        [
+            "--output, -o <file>",
+            {
+                description: "The output file name. Absolute paths are accepted as well",
+                default: "testplan.json",
+            },
+        ],
+    ],
+    action: TestPlanCommandAction,
+});

package/dist/commands/watch.d.ts

@@ -0,0 +1,10 @@
+type WatchCommandOptions = {
+    config?: string;
+    output?: string;
+    cwd?: string;
+    reportName?: string;
+    port?: string;
+};
+export declare const WatchCommandAction: (resultsDir: string, options: WatchCommandOptions) => Promise<void>;
+export declare const WatchCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/watch.js

@@ -0,0 +1,118 @@
+import { AllureReport, isFileNotFoundError, readRuntimeConfig } from "@allure/core";
+import { newFilesInDirectoryWatcher } from "@allure/directory-watcher";
+import AllureAwesome from "@allure/plugin-awesome";
+import ProgressPlugin from "@allure/plugin-progress";
+import ServerReloadPlugin from "@allure/plugin-server-reload";
+import { PathResultFile } from "@allure/reader-api";
+import { serve } from "@allure/static-server";
+import * as console from "node:console";
+import { rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { createCommand } from "../utils/commands.js";
+export const WatchCommandAction = async (resultsDir, options) => {
+    const before = new Date().getTime();
+    process.on("exit", (code) => {
+        const after = new Date().getTime();
+        console.log(`exit code ${code} (${after - before}ms)`);
+    });
+    const { config: configPath, output, cwd, reportName } = options;
+    const config = await readRuntimeConfig(configPath, cwd, output, reportName);
+    try {
+        await rm(config.output, { recursive: true });
+    }
+    catch (e) {
+        if (!isFileNotFoundError(e)) {
+            console.error("could not clean output directory", e);
+        }
+    }
+    const server = await serve({
+        servePath: config.output,
+        port: options.port ? parseInt(options.port) : undefined,
+        live: false,
+        open: false,
+    });
+    const allureReport = new AllureReport({
+        ...config,
+        realTime: true,
+        plugins: [
+            ...(config.plugins?.length
+                ? config.plugins
+                : [
+                    {
+                        id: "awesome",
+                        enabled: true,
+                        options: {},
+                        plugin: new AllureAwesome({
+                            reportName: config.name,
+                        }),
+                    },
+                ]),
+            {
+                id: "watch log",
+                enabled: true,
+                options: {},
+                plugin: new ProgressPlugin(),
+            },
+            {
+                id: "server reload",
+                enabled: true,
+                options: {},
+                plugin: new ServerReloadPlugin({
+                    server,
+                }),
+            },
+        ],
+    });
+    await allureReport.start();
+    const input = resolve(resultsDir);
+    const { abort } = newFilesInDirectoryWatcher(input, async (path) => {
+        await allureReport.readResult(new PathResultFile(path));
+    });
+    const pluginIdToOpen = config.plugins?.find((plugin) => !!plugin.options.open)?.id;
+    if (pluginIdToOpen) {
+        await server.open(join(server.url, pluginIdToOpen));
+    }
+    else {
+        await server.open(server.url);
+    }
+    console.info("Press Ctrl+C to exit");
+    process.on("SIGINT", async () => {
+        console.log("");
+        await abort();
+        await server.stop();
+        await allureReport.done();
+        process.exit(0);
+    });
+};
+export const WatchCommand = createCommand({
+    name: "watch <resultsDir>",
+    description: "Watches Allure Results changes in Real-time",
+    options: [
+        [
+            "--cwd <cwd>",
+            {
+                description: "The working directory for the command to run (default: current working directory)",
+            },
+        ],
+        [
+            "--output, -o <file>",
+            {
+                description: "The output file name, allure.csv by default. Accepts absolute paths (default: ./allure-report)",
+            },
+        ],
+        [
+            "--report-name, --name <string>",
+            {
+                description: "The report name (default: Allure Report)",
+            },
+        ],
+        [
+            "--port <port>",
+            {
+                description: "The port to serve the reports on (default: random port)",
+            },
+        ],
+    ],
+    action: WatchCommandAction,
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { defineConfig } from "@allure/core";
+export { defineConfig };

package/dist/index.js

@@ -0,0 +1,33 @@
+import { defineConfig } from "@allure/core";
+import { cac } from "cac";
+import console from "node:console";
+import { readFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { ClassicCommand, AwesomeCommand, CsvCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, } from "./commands/index.js";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const cli = cac(pkg.name).usage(pkg.description).help().version(pkg.version);
+const commands = [
+    ClassicCommand,
+    AwesomeCommand,
+    CsvCommand,
+    GenerateCommand,
+    HistoryCommand,
+    KnownIssueCommand,
+    LogCommand,
+    OpenCommand,
+    QualityGateCommand,
+    RunCommand,
+    SlackCommand,
+    TestPlanCommand,
+    WatchCommand,
+];
+commands.forEach((command) => {
+    command(cli);
+});
+cli.on("command:*", () => {
+    console.error("Invalid command: %s", cli.args.join(" "));
+    process.exit(1);
+});
+console.log(cwd());
+cli.parse();
+export { defineConfig };

package/dist/utils/commands.d.ts

@@ -0,0 +1,16 @@
+import { CAC } from "cac";
+export type OptionDescription = [string] | [
+    string,
+    {
+        description?: string;
+        type?: any[];
+        default?: any;
+    }
+];
+export type CreateCommandOptions = {
+    name: string;
+    description?: string;
+    options?: OptionDescription[];
+    action: (...args: any[]) => Promise<void>;
+};
+export declare const createCommand: (payload: CreateCommandOptions) => (cli: CAC) => void;

package/dist/utils/commands.js

@@ -0,0 +1,14 @@
+export const createCommand = (payload) => {
+    if (!payload.name)
+        throw new Error("Command name is not provided!");
+    if (!payload.action)
+        throw new Error("Command action is not provided!");
+    return (cli) => {
+        const command = cli.command(payload.name, payload.description);
+        payload?.options?.forEach(([name, parameters]) => {
+            const { description = "", ...rest } = parameters || {};
+            command.option(name, description, rest);
+        });
+        command.action(payload.action);
+    };
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./process.js";
+export * from "./terminal.js";

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./process.js";
+export * from "./terminal.js";

package/dist/utils/process.d.ts

@@ -0,0 +1,3 @@
+import { ChildProcess } from "node:child_process";
+export declare const runProcess: (command: string, commandArgs: string[], cwd: string | undefined, environment: Record<string, string>, silent?: boolean) => ChildProcess;
+export declare const terminationOf: (testProcess: ChildProcess) => Promise<number | null>;

package/dist/utils/process.js

@@ -0,0 +1,15 @@
+import { spawn } from "node:child_process";
+export const runProcess = (command, commandArgs, cwd, environment, silent) => {
+    return spawn(command, commandArgs, {
+        env: {
+            ...process.env,
+            ...environment,
+        },
+        cwd,
+        stdio: silent ? "ignore" : "inherit",
+        shell: true,
+    });
+};
+export const terminationOf = (testProcess) => new Promise((resolve) => {
+    testProcess.on("exit", (code) => resolve(code));
+});

package/dist/utils/terminal.d.ts

@@ -0,0 +1,3 @@
+import { TestResult, TestStatus } from "@allure/core-api";
+export declare const status2color: (status: TestStatus) => import("yoctocolors").Format;
+export declare const logTests: (testResults: TestResult[]) => void;

package/dist/utils/terminal.js

@@ -0,0 +1,20 @@
+import { formatDuration } from "@allure/core-api";
+import console from "node:console";
+import { blue, gray, green, red, yellow } from "yoctocolors";
+export const status2color = (status) => {
+    switch (status) {
+        case "failed":
+            return red;
+        case "broken":
+            return yellow;
+        case "passed":
+            return green;
+        case "skipped":
+            return gray;
+        default:
+            return blue;
+    }
+};
+export const logTests = (testResults) => {
+    testResults.forEach((tr) => console.log(`${tr.fullName} ${status2color(tr.status)(tr.status)} ${tr.duration !== undefined ? gray(`(${formatDuration(tr.duration)})`) : ""}`));
+};

package/package.json

@@ -1,11 +1,64 @@
 {
   "name": "allure",
-  "version": "0.0.0",
-  "description": "None right now",
-  "main": "index.js",
+  "version": "3.0.0-beta.0",
+  "description": "Allure Commandline Tool",
+  "keywords": [
+    "allure",
+    "testing",
+    "report"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "./cli.js",
+  "files": [
+    "./dist"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "start": "node ./cli.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@allure/core": "3.0.0-beta.0",
+    "@allure/core-api": "3.0.0-beta.0",
+    "@allure/directory-watcher": "3.0.0-beta.0",
+    "@allure/plugin-awesome": "3.0.0-beta.0",
+    "@allure/plugin-progress": "3.0.0-beta.0",
+    "@allure/plugin-server-reload": "3.0.0-beta.0",
+    "@allure/plugin-slack": "3.0.0-beta.0",
+    "@allure/reader-api": "3.0.0-beta.0",
+    "@allure/static-server": "3.0.0-beta.0",
+    "cac": "^6.7.14",
+    "lodash.omit": "^4.5.0",
+    "yoctocolors": "^2.1.1"
   },
-  "author": "Pierre-Yves Gérardy",
-  "license": "ISC"
-}
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@types/lodash.omit": "^4.5.9",
+    "@types/node": "^20.17.9",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/runner": "^2.1.8",
+    "allure-vitest": "^3.0.7",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-n": "^17.10.1",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}