allure 3.0.0-beta.15 → 3.0.0-beta.16

package/dist/commands/allure2.d.ts

@@ -1,4 +1,6 @@
 type ClassicCommandOptions = {
+    cwd?: string;
+    config?: string;
     output?: string;
     reportName?: string;
     reportLanguage?: string;

package/dist/commands/allure2.js

@@ -1,19 +1,26 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import Allure2Plugin from "@allurereport/plugin-allure2";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const ClassicLegacyCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
-    const config = await resolveConfig({
+    const { config: configPath, output, reportName, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
+    const defaultAllure2Options = {
+        ...rest,
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath, {
         output,
-        name,
-        historyPath,
+        name: reportName,
         knownIssuesPath,
-        plugins: {
-            "@allurereport/plugin-allure2": {
-                options: rest,
-            },
-        },
+        historyPath,
+    }), {
+        id: "allure2",
+        enabled: true,
+        options: defaultAllure2Options,
+        plugin: new Allure2Plugin(defaultAllure2Options),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -26,6 +33,18 @@ export const ClassicLegacyCommand = createCommand({
     name: "allure2 <resultsDir>",
     description: "Generates Allure Classic report based on provided Allure Results",
     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>",
             {

package/dist/commands/awesome.d.ts

@@ -1,4 +1,6 @@
 type AwesomeCommandOptions = {
+    cwd?: string;
+    config?: string;
     output?: string;
     reportName?: string;
     reportLanguage?: string;

package/dist/commands/awesome.js

@@ -1,22 +1,27 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { default as AwesomePlugin } from "@allurereport/plugin-awesome";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const AwesomeCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, groupBy, ...rest } = options;
-    const config = await resolveConfig({
+    const { config: configPath, output, reportName, historyPath, knownIssues: knownIssuesPath, groupBy, ...rest } = options;
+    const defaultAwesomeOptions = {
+        ...rest,
+        groupBy: groupBy?.split(","),
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath, {
         output,
-        name,
-        historyPath,
+        name: reportName,
         knownIssuesPath,
-        plugins: {
-            "@allurereport/plugin-awesome": {
-                options: {
-                    ...rest,
-                    groupBy: groupBy?.split(","),
-                },
-            },
-        },
+        historyPath,
+    }), {
+        id: "awesome",
+        enabled: true,
+        options: defaultAwesomeOptions,
+        plugin: new AwesomePlugin(defaultAwesomeOptions),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -29,6 +34,18 @@ export const AwesomeCommand = createCommand({
     name: "awesome <resultsDir>",
     description: "Generates Allure Awesome report based on provided Allure Results",
     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>",
             {

package/dist/commands/classic.d.ts

@@ -1,4 +1,6 @@
 type ClassicCommandOptions = {
+    cwd?: string;
+    config?: string;
     output?: string;
     reportName?: string;
     reportLanguage?: string;

package/dist/commands/classic.js

@@ -1,19 +1,26 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import ClassicPlugin from "@allurereport/plugin-classic";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const ClassicCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
-    const config = await resolveConfig({
+    const { config: configPath, output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
+    const defaultClassicOptions = {
+        ...rest,
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath, {
         output,
         name,
         historyPath,
         knownIssuesPath,
-        plugins: {
-            "@allurereport/plugin-classic": {
-                options: rest,
-            },
-        },
+    }), {
+        id: "classic",
+        enabled: true,
+        options: defaultClassicOptions,
+        plugin: new ClassicPlugin(defaultClassicOptions),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -26,6 +33,18 @@ export const ClassicCommand = createCommand({
     name: "classic <resultsDir>",
     description: "Generates Allure Classic report based on provided Allure Results",
     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>",
             {

package/dist/commands/csv.d.ts

@@ -1,4 +1,6 @@
 type CsvCommandOptions = {
+    cwd?: string;
+    config?: string;
     separator?: string;
     disableHeaders?: boolean;
     output?: string;

package/dist/commands/csv.js

@@ -1,14 +1,25 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import CsvPlugin from "@allurereport/plugin-csv";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const CsvCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allurereport/plugin-csv": {
-                options,
-            },
-        },
+    const { config: configPath, output, knownIssues: knownIssuesPath, separator, disableHeaders } = options;
+    const defaultCsvOptions = {
+        separator,
+        disableHeaders,
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath, {
+        output,
+        knownIssuesPath,
+    }), {
+        id: "csv",
+        enabled: true,
+        options: defaultCsvOptions,
+        plugin: new CsvPlugin(defaultCsvOptions),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -21,6 +32,18 @@ export const CsvCommand = createCommand({
     name: "csv <resultsDir>",
     description: "Generates CSV report based on provided Allure Results",
     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>",
             {

package/dist/commands/dashboard.d.ts

@@ -1,4 +1,6 @@
 type DashboardCommandOptions = {
+    cwd?: string;
+    config?: string;
     output?: string;
     reportName?: string;
     reportLanguage?: string;

package/dist/commands/dashboard.js

@@ -1,17 +1,25 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import DashboardPlugin from "@allurereport/plugin-dashboard";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const DashboardCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const { output, reportName: name, ...rest } = options;
-    const config = await resolveConfig({
+    const { config: configPath, output, reportName: name, ...rest } = options;
+    const defaultDashboardOptions = {
+        ...rest,
+        reportLanguage: rest.reportLanguage ?? "en",
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath, {
         output,
         name,
-        plugins: {
-            "@allurereport/plugin-dashboard": {
-                options: rest,
-            },
-        },
+    }), {
+        id: "dashboard",
+        enabled: true,
+        options: defaultDashboardOptions,
+        plugin: new DashboardPlugin(defaultDashboardOptions),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -24,6 +32,18 @@ export const DashboardCommand = createCommand({
     name: "dashboard <resultsDir>",
     description: "Generates Allure Dashboard report based on provided Allure Results",
     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>",
             {

package/dist/commands/generate.js

@@ -1,12 +1,26 @@
 import { AllureReport, readConfig } from "@allurereport/core";
+import { KnownError } from "@allurereport/service";
+import { red } from "yoctocolors";
 import { createCommand } from "../utils/commands.js";
+import { logError } from "../utils/logs.js";
 export const GenerateCommandAction = async (resultsDir, options) => {
     const { config: configPath, output, cwd, reportName } = options;
     const config = await readConfig(cwd, configPath, { name: reportName, output });
-    const allureReport = new AllureReport(config);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
+    try {
+        const allureReport = new AllureReport(config);
+        await allureReport.start();
+        await allureReport.readDirectory(resultsDir);
+        await allureReport.done();
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to generate report due to unexpected error", error);
+        process.exit(1);
+    }
 };
 export const GenerateCommand = createCommand({
     name: "generate <resultsDir>",

package/dist/commands/index.d.ts

@@ -15,3 +15,7 @@ export * from "./qualityGate.js";
 export * from "./log.js";
 export * from "./generate.js";
 export * from "./dashboard.js";
+export * from "./login.js";
+export * from "./logout.js";
+export * from "./whoami.js";
+export * from "./projects/index.js";

package/dist/commands/index.js

@@ -15,3 +15,7 @@ export * from "./qualityGate.js";
 export * from "./log.js";
 export * from "./generate.js";
 export * from "./dashboard.js";
+export * from "./login.js";
+export * from "./logout.js";
+export * from "./whoami.js";
+export * from "./projects/index.js";

package/dist/commands/log.d.ts

@@ -1,4 +1,6 @@
 export type LogCommandOptions = {
+    cwd?: string;
+    config?: string;
     allSteps?: boolean;
     withTrace?: boolean;
     groupBy?: "suites" | "features" | "packages" | "none";

package/dist/commands/log.js

@@ -1,14 +1,23 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import LogPlugin from "@allurereport/plugin-log";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const LogCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allurereport/plugin-log": {
-                options,
-            },
-        },
+    const { config: configPath, allSteps, withTrace, groupBy } = options;
+    const defaultLogOptions = {
+        allSteps,
+        withTrace,
+        groupBy,
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath), {
+        id: "log",
+        enabled: true,
+        options: defaultLogOptions,
+        plugin: new LogPlugin(defaultLogOptions),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -21,6 +30,18 @@ export const LogCommand = createCommand({
     name: "log <resultsDir>",
     description: "Prints Allure Results to the console",
     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)",
+            },
+        ],
         [
             "--group-by <label>",
             {

package/dist/commands/login.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    config?: string;
+    cwd?: string;
+};
+export declare const LoginCommandAction: (options?: CommandOptions) => Promise<void>;
+export declare const LoginCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/login.js

@@ -0,0 +1,47 @@
+import { readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { green, red } from "yoctocolors";
+import { createCommand } from "../utils/commands.js";
+import { logError } from "../utils/logs.js";
+export const LoginCommandAction = async (options) => {
+    const { config: configPath, cwd } = options ?? {};
+    const config = await readConfig(cwd, configPath);
+    if (!config?.allureService?.url) {
+        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+        process.exit(1);
+        return;
+    }
+    const serviceClient = new AllureServiceClient(config.allureService);
+    try {
+        await serviceClient.login();
+        console.info(green("Logged in"));
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to login due to unexpected error", error);
+        process.exit(1);
+    }
+};
+export const LoginCommand = createCommand({
+    name: "login",
+    description: "Logs in to the Allure Service",
+    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)",
+            },
+        ],
+    ],
+    action: LoginCommandAction,
+});

package/dist/commands/logout.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    config?: string;
+    cwd?: string;
+};
+export declare const LogoutCommandAction: (options?: CommandOptions) => Promise<void>;
+export declare const LogoutCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/logout.js

@@ -0,0 +1,47 @@
+import { readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { green, red } from "yoctocolors";
+import { createCommand } from "../utils/commands.js";
+import { logError } from "../utils/logs.js";
+export const LogoutCommandAction = async (options) => {
+    const { config: configPath, cwd } = options ?? {};
+    const config = await readConfig(cwd, configPath);
+    if (!config?.allureService?.url) {
+        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+        process.exit(1);
+        return;
+    }
+    const serviceClient = new AllureServiceClient(config.allureService);
+    try {
+        await serviceClient.logout();
+        console.info(green("Logged out"));
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to logout due to unexpected error", error);
+        process.exit(1);
+    }
+};
+export const LogoutCommand = createCommand({
+    name: "logout",
+    description: "Logs out from the Allure Service",
+    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)",
+            },
+        ],
+    ],
+    action: LogoutCommandAction,
+});

package/dist/commands/projects/create.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    config?: string;
+    cwd?: string;
+};
+export declare const ProjectsCreateCommandAction: (projectName?: string, options?: CommandOptions) => Promise<void>;
+export declare const ProjectsCreateCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/projects/create.js

@@ -0,0 +1,79 @@
+import { getGitRepoName, readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import prompts from "prompts";
+import { green, red } from "yoctocolors";
+import { createCommand } from "../../utils/commands.js";
+import { logError } from "../../utils/logs.js";
+export const ProjectsCreateCommandAction = async (projectName, options) => {
+    const { config: configPath, cwd } = options ?? {};
+    const config = await readConfig(cwd, configPath);
+    if (!config?.allureService?.url) {
+        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+        process.exit(1);
+        return;
+    }
+    const serviceClient = new AllureServiceClient(config.allureService);
+    let name = projectName;
+    if (!name) {
+        try {
+            name = await getGitRepoName();
+        }
+        catch (ignored) { }
+    }
+    if (!name) {
+        const res = await prompts({
+            type: "text",
+            name: "name",
+            message: "Enter project name",
+        });
+        name = res?.name;
+    }
+    if (!name) {
+        console.error(red("No project name provided!"));
+        process.exit(1);
+        return;
+    }
+    try {
+        const project = await serviceClient.createProject({
+            name,
+        });
+        const lines = [
+            `The "${green(project.name)}" has been created. Insert following code into your Allure Config file, to enable Allure Service features for the project:`,
+            "",
+            green("{"),
+            green("  allureService: {"),
+            green(`    project: "${project.name}"`),
+            green("  }"),
+            green("}"),
+        ];
+        console.info(lines.join("\n"));
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to create project due to unexpected error", error);
+        process.exit(1);
+    }
+};
+export const ProjectsCreateCommand = createCommand({
+    name: "project-create [name]",
+    description: "",
+    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)",
+            },
+        ],
+    ],
+    action: ProjectsCreateCommandAction,
+});

package/dist/commands/projects/delete.d.ts

@@ -0,0 +1,7 @@
+export type CommandOptions = {
+    force?: boolean;
+    config?: string;
+    cwd?: string;
+};
+export declare const ProjectsDeleteCommandAction: (projectName?: string, options?: CommandOptions) => Promise<void>;
+export declare const ProjectsDeleteCommand: (cli: import("cac").CAC) => void;

package/dist/commands/projects/delete.js

@@ -0,0 +1,74 @@
+import { readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import prompts from "prompts";
+import { green, red } from "yoctocolors";
+import { createCommand } from "../../utils/commands.js";
+import { logError } from "../../utils/logs.js";
+export const ProjectsDeleteCommandAction = async (projectName, options) => {
+    const { force = false } = options ?? {};
+    const { config: configPath, cwd } = options ?? {};
+    const config = await readConfig(cwd, configPath);
+    if (!config?.allureService?.url) {
+        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+        process.exit(1);
+        return;
+    }
+    const serviceClient = new AllureServiceClient(config.allureService);
+    if (!projectName) {
+        console.error(red("No project name is provided"));
+        process.exit(1);
+        return;
+    }
+    if (!force) {
+        const res = await prompts({
+            type: "confirm",
+            name: "value",
+            message: `Are you sure you want to delete project "${projectName}"?`,
+        });
+        if (!res.value) {
+            process.exit(0);
+            return;
+        }
+    }
+    try {
+        await serviceClient.deleteProject({
+            name: projectName,
+        });
+        console.info(green("Project has been deleted"));
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to delete project due to unexpected error", error);
+        process.exit(1);
+    }
+};
+export const ProjectsDeleteCommand = createCommand({
+    name: "project-delete <name>",
+    description: "",
+    options: [
+        [
+            "--force",
+            {
+                description: "Delete project with no confirmation",
+                default: false,
+            },
+        ],
+        [
+            "--config, -c <file>",
+            {
+                description: "The path Allure config file",
+            },
+        ],
+        [
+            "--cwd <cwd>",
+            {
+                description: "The working directory for the command to run (default: current working directory)",
+            },
+        ],
+    ],
+    action: ProjectsDeleteCommandAction,
+});

package/dist/commands/projects/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./create.js";
+export * from "./delete.js";
+export * from "./list.js";

package/dist/commands/projects/index.js

@@ -0,0 +1,3 @@
+export * from "./create.js";
+export * from "./delete.js";
+export * from "./list.js";

package/dist/commands/projects/list.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    config?: string;
+    cwd?: string;
+};
+export declare const ProjectsListCommandAction: (options?: CommandOptions) => Promise<void>;
+export declare const ProjectsListCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/projects/list.js

@@ -0,0 +1,75 @@
+import { readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import prompts from "prompts";
+import { green, red, yellow } from "yoctocolors";
+import { createCommand } from "../../utils/commands.js";
+import { logError } from "../../utils/logs.js";
+export const ProjectsListCommandAction = async (options) => {
+    const { config: configPath, cwd } = options ?? {};
+    const config = await readConfig(cwd, configPath);
+    if (!config?.allureService?.url) {
+        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+        process.exit(1);
+        return;
+    }
+    const serviceClient = new AllureServiceClient(config.allureService);
+    try {
+        const projects = await serviceClient.projects();
+        if (projects.length === 0) {
+            console.info(yellow("No projects found. Create a new one with `allure project-create` command"));
+            return;
+        }
+        const res = await prompts({
+            type: "select",
+            name: "project",
+            message: "Select a project",
+            choices: projects.map((project) => ({
+                title: project.name,
+                value: project.name,
+            })),
+        });
+        if (!res?.project) {
+            console.error(red("No project selected"));
+            process.exit(1);
+            return;
+        }
+        const lines = [
+            "Insert following code into your Allure Config file, to enable Allure Service features for the project:",
+            "",
+            green("{"),
+            green("  allureService: {"),
+            green(`    project: "${res.project}"`),
+            green("  }"),
+            green("}"),
+        ];
+        console.info(lines.join("\n"));
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to get projects due to unexpected error", error);
+        process.exit(1);
+    }
+};
+export const ProjectsListCommand = createCommand({
+    name: "projects",
+    description: "Shows list of all available projects for current user",
+    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)",
+            },
+        ],
+    ],
+    action: ProjectsListCommandAction,
+});

package/dist/commands/run.d.ts

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

package/dist/commands/run.js

@@ -3,13 +3,16 @@ import { createTestPlan } from "@allurereport/core-api";
 import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allurereport/directory-watcher";
 import Awesome from "@allurereport/plugin-awesome";
 import { PathResultFile } from "@allurereport/reader-api";
+import { KnownError } from "@allurereport/service";
 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 { red } from "yoctocolors";
 import { createCommand } from "../utils/commands.js";
 import { logTests, runProcess, terminationOf } from "../utils/index.js";
+import { logError } from "../utils/logs.js";
 const runTests = async (allureReport, cwd, command, commandArgs, environment, silent) => {
     let testProcessStarted = false;
     const allureResultsWatchers = new Map();
@@ -80,48 +83,59 @@ export const RunCommandAction = async (options) => {
             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 Awesome({
-                            reportName: config.name,
-                        }),
-                    },
-                ]),
-        ],
-    });
-    await allureReport.start();
-    let code = 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;
+    try {
+        const allureReport = new AllureReport({
+            ...config,
+            realTime: false,
+            plugins: [
+                ...(config.plugins?.length
+                    ? config.plugins
+                    : [
+                        {
+                            id: "awesome",
+                            enabled: true,
+                            options: {},
+                            plugin: new Awesome({
+                                reportName: config.name,
+                            }),
+                        },
+                    ]),
+            ],
+        });
+        await allureReport.start();
+        let code = 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));
+            code = 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(code ?? allureReport.exitCode);
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
         }
-        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));
-        code = 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 logError("Failed to run tests using Allure due to unexpected error", error);
+        process.exit(1);
     }
-    await allureReport.done();
-    await allureReport.validate();
-    process.exit(code ?? allureReport.exitCode);
 };
 export const RunCommand = createCommand({
     name: "run",

package/dist/commands/slack.d.ts

@@ -1,4 +1,6 @@
 type CommandOptions = {
+    cwd?: string;
+    config?: string;
     token: string;
     channel: string;
 };

package/dist/commands/slack.js

@@ -1,14 +1,22 @@
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import SlackPlugin from "@allurereport/plugin-slack";
 import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import process from "node:process";
 import { createCommand } from "../utils/commands.js";
 export const SlackCommandAction = async (resultsDir, options) => {
+    const cwd = await realpath(options.cwd ?? process.cwd());
     const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allurereport/plugin-slack": {
-                options,
-            },
-        },
+    const { config: configPath, token, channel } = options;
+    const defaultSlackOptions = {
+        token,
+        channel,
+    };
+    const config = enforcePlugin(await readConfig(cwd, configPath), {
+        id: "slack",
+        enabled: true,
+        options: defaultSlackOptions,
+        plugin: new SlackPlugin(defaultSlackOptions),
     });
     const allureReport = new AllureReport(config);
     await allureReport.start();
@@ -21,6 +29,18 @@ export const SlackCommand = createCommand({
     name: "slack <resultsDir>",
     description: "Posts test results into Slack Channel",
     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)",
+            },
+        ],
         [
             "--token, -t <token>",
             {

package/dist/commands/whoami.d.ts

@@ -0,0 +1,7 @@
+type CommandOptions = {
+    config?: string;
+    cwd?: string;
+};
+export declare const WhoamiCommandAction: (options?: CommandOptions) => Promise<void>;
+export declare const WhoamiCommand: (cli: import("cac").CAC) => void;
+export {};

package/dist/commands/whoami.js

@@ -0,0 +1,51 @@
+import { readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { green, red } from "yoctocolors";
+import { createCommand } from "../utils/commands.js";
+import { logError } from "../utils/logs.js";
+export const WhoamiCommandAction = async (options) => {
+    const { config: configPath, cwd } = options ?? {};
+    const config = await readConfig(cwd, configPath);
+    if (!config?.allureService?.url) {
+        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+        process.exit(1);
+        return;
+    }
+    const serviceClient = new AllureServiceClient(config.allureService);
+    try {
+        const profile = await serviceClient.profile();
+        const lines = [`You are logged in as "${profile.email}"`];
+        if (config.allureService?.project) {
+            lines.push(`Current project is "${config.allureService.project}"`);
+        }
+        console.info(green(lines.join("\n")));
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            process.exit(1);
+            return;
+        }
+        await logError("Failed to get profile due to unexpected error", error);
+        process.exit(1);
+    }
+};
+export const WhoamiCommand = createCommand({
+    name: "whoami",
+    description: "Prints information about current user",
+    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)",
+            },
+        ],
+    ],
+    action: WhoamiCommandAction,
+});

package/dist/index.js

@@ -2,7 +2,7 @@ import { cac } from "cac";
 import console from "node:console";
 import { readFileSync } from "node:fs";
 import { cwd } from "node:process";
-import { AwesomeCommand, ClassicCommand, ClassicLegacyCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, } from "./commands/index.js";
+import { AwesomeCommand, ClassicCommand, ClassicLegacyCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, LoginCommand, LogoutCommand, OpenCommand, ProjectsCreateCommand, ProjectsDeleteCommand, ProjectsListCommand, QualityGateCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, WhoamiCommand, } 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 = [
@@ -21,12 +21,19 @@ const commands = [
     SlackCommand,
     TestPlanCommand,
     WatchCommand,
+    LoginCommand,
+    LogoutCommand,
+    WhoamiCommand,
+    ProjectsCreateCommand,
+    ProjectsDeleteCommand,
+    ProjectsListCommand,
 ];
 commands.forEach((command) => {
     command(cli);
 });
 cli.on("command:*", () => {
-    console.error("Invalid command: %s", cli.args.join(" "));
+    console.error(`Invalid command: "${cli.args.join(" ")}"`);
+    console.error("See --help for a list of available commands");
     process.exit(1);
 });
 console.log(cwd());

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/logs.d.ts

@@ -0,0 +1,3 @@
+export declare const getLogFileName: () => string;
+export declare const readLogs: () => Promise<string>;
+export declare const logError: (message: string, error: Error) => Promise<void>;

package/dist/utils/logs.js

@@ -0,0 +1,32 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { red } from "yoctocolors";
+const LOGS_DIRECTORY = join(homedir(), ".allure", "logs");
+export const getLogFileName = () => `${new Date().toISOString().replace(/:/g, "-")}.log`;
+export const readLogs = async () => {
+    await mkdir(LOGS_DIRECTORY, { recursive: true });
+    const logFilePath = join(LOGS_DIRECTORY, getLogFileName());
+    try {
+        const logs = await readFile(logFilePath, "utf-8");
+        return logs;
+    }
+    catch (err) {
+        return "";
+    }
+};
+export const logError = async (message, error) => {
+    let logs = await readLogs();
+    if (!logs) {
+        logs += `${new Date().toISOString()}[ERROR] ${error.message}\n`;
+    }
+    else {
+        logs += `\n${new Date().toISOString()}[ERROR] ${error.message}\n`;
+    }
+    if (error.stack) {
+        logs += `${error.stack}\n`;
+    }
+    const logFilePath = join(LOGS_DIRECTORY, getLogFileName());
+    await writeFile(logFilePath, logs, "utf-8");
+    console.error(red(`${message}. Check logs for more details: ${logFilePath}`));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allure",
-  "version": "3.0.0-beta.15",
+  "version": "3.0.0-beta.16",
   "description": "Allure Commandline Tool",
   "keywords": [
     "allure",
@@ -30,21 +30,25 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/core": "3.0.0-beta.15",
-    "@allurereport/core-api": "3.0.0-beta.15",
-    "@allurereport/directory-watcher": "3.0.0-beta.15",
-    "@allurereport/plugin-allure2": "3.0.0-beta.15",
-    "@allurereport/plugin-api": "3.0.0-beta.15",
-    "@allurereport/plugin-awesome": "3.0.0-beta.15",
-    "@allurereport/plugin-classic": "3.0.0-beta.15",
-    "@allurereport/plugin-dashboard": "3.0.0-beta.15",
-    "@allurereport/plugin-progress": "3.0.0-beta.15",
-    "@allurereport/plugin-server-reload": "3.0.0-beta.15",
-    "@allurereport/plugin-slack": "3.0.0-beta.15",
-    "@allurereport/reader-api": "3.0.0-beta.15",
-    "@allurereport/static-server": "3.0.0-beta.15",
+    "@allurereport/core": "3.0.0-beta.16",
+    "@allurereport/core-api": "3.0.0-beta.16",
+    "@allurereport/directory-watcher": "3.0.0-beta.16",
+    "@allurereport/plugin-allure2": "3.0.0-beta.16",
+    "@allurereport/plugin-api": "3.0.0-beta.16",
+    "@allurereport/plugin-awesome": "3.0.0-beta.16",
+    "@allurereport/plugin-classic": "3.0.0-beta.16",
+    "@allurereport/plugin-csv": "3.0.0-beta.16",
+    "@allurereport/plugin-dashboard": "3.0.0-beta.16",
+    "@allurereport/plugin-log": "3.0.0-beta.16",
+    "@allurereport/plugin-progress": "3.0.0-beta.16",
+    "@allurereport/plugin-server-reload": "3.0.0-beta.16",
+    "@allurereport/plugin-slack": "3.0.0-beta.16",
+    "@allurereport/reader-api": "3.0.0-beta.16",
+    "@allurereport/service": "3.0.0-beta.16",
+    "@allurereport/static-server": "3.0.0-beta.16",
     "cac": "^6.7.14",
     "lodash.omit": "^4.5.0",
+    "prompts": "^2.4.2",
     "yoctocolors": "^2.1.1"
   },
   "devDependencies": {
@@ -52,10 +56,11 @@
     "@types/eslint": "^8.56.11",
     "@types/lodash.omit": "^4.5.9",
     "@types/node": "^20.17.9",
+    "@types/prompts": "^2",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@vitest/runner": "^2.1.8",
-    "@vitest/snapshot": "^2.1.8",
+    "@vitest/runner": "^2.1.9",
+    "@vitest/snapshot": "^2.1.9",
     "allure-vitest": "^3.0.9",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
@@ -66,6 +71,6 @@
     "eslint-plugin-prefer-arrow": "^1.2.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   }
 }