allure 3.10.0 → 3.12.0

package/README.md

@@ -74,7 +74,41 @@ For example:
 npx allure agent -- npm test
 ```
 
-`allure agent` runs with an agent-only profile by default. It creates a fresh output directory automatically, can load an expectations file with `--expectations`, and ignores configured presentation or export plugins such as Awesome or TestOps unless you explicitly fall back to the lower-level `ALLURE_AGENT_*` plus `allure run` flow.
+To analyze existing Allure results or dump archives downloaded from CI without
+rerunning tests, use `agent inspect`:
+
+```bash
+npx allure agent inspect path/to/allure-results
+npx allure agent inspect --dump allure-results-linux.zip --dump allure-results-macos.zip
+npx allure agent inspect --config ./allurerc.mjs --output ./agent-output path/to/allure-results
+```
+
+`agent inspect` accepts the same result inputs and configuration-style options as
+`allure generate`, including result directory globs, `--dump`, `--config`,
+`--cwd`, `--report-name`, `--history-limit`, and `--hide-labels`. Its `--output`
+option writes the agentic output directory.
+
+`allure agent` and `allure agent inspect` use `--report auto` by default. This writes the agent-readable artifacts and, when the stored visible result count is 1000 or fewer, also writes a single-file Awesome report at `awesome/index.html` inside the agent output directory. Runs above that threshold skip the human report to avoid excessive output, and the status is recorded in `index.md`, `manifest/run.json`, and `manifest/human-report.json`.
+
+Use `--report off` for agent-only artifacts, `--report awesome` to force the single-file Awesome report regardless of result count, or `--report config` to force the configured non-agent report plugins inside the agent output directory. Configured presentation or export plugins such as Dashboard or TestOps are otherwise ignored for agent runs.
+
+If you need the human-readable report from the most recent agent run, first run `npx allure agent latest` when the output directory is unknown. Then check `<output>/manifest/human-report.json`; when its status is `generated`, open `<output>/<path>` from that manifest, usually `<output>/awesome/index.html`.
+
+`allure agent` creates a fresh output directory automatically, accepts compact inline expectations such as `--goal`, `--expect-tests`, `--expect-test`, `--expect-label`, and `--expect-step-containing`, and can still load an expectations file with `--expectations` when needed.
+
+Agents and setup tools can inspect the local structured capability contract without scraping help text:
+
+```bash
+npx allure agent capabilities --json
+```
+
+After a run, agents can query the output directory without manually reading every manifest:
+
+```bash
+npx allure agent query --latest summary
+npx allure agent query --latest tests --status failed
+npx allure agent query --from ./agent-output findings --severity high
+```
 
 ### Generating Reports Manually
 
@@ -118,6 +152,7 @@ The Allure CLI includes several helpful global options. Use `--help` to explore
 
 ```bash
 npx allure run --help
+npx allure agent capabilities --json
 npx allure agent --help
 npx allure watch --help
 ```

package/dist/commands/agent-human-report.d.ts

@@ -0,0 +1,23 @@
+import { type FullConfig, type PluginInstance } from "@allurereport/core";
+import type { AgentHumanReportMode, AgentHumanReportStatus, AgentHumanReportStatusProvider } from "@allurereport/plugin-agent";
+export declare const AGENT_HUMAN_REPORT_THRESHOLD = 1000;
+type AgentHumanReportConfigOverride = {
+    name?: FullConfig["name"];
+    open?: FullConfig["open"];
+    port?: FullConfig["port"];
+    hideLabels?: FullConfig["hideLabels"];
+    historyLimit?: FullConfig["historyLimit"];
+};
+type AgentHumanReportBuildParams = {
+    mode: AgentHumanReportMode;
+    cwd: string;
+    configPath?: string;
+    outputDir: string;
+    configOverride?: AgentHumanReportConfigOverride;
+};
+export declare const createAgentHumanReportConfig: ({ mode, cwd, configPath, outputDir, configOverride, }: AgentHumanReportBuildParams) => Promise<{
+    status: AgentHumanReportStatus;
+    statusProvider: AgentHumanReportStatusProvider;
+    plugins: PluginInstance[];
+}>;
+export {};

package/dist/commands/agent-human-report.js

@@ -0,0 +1,171 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AgentHumanReportPlugin_realtime, _AgentHumanReportPlugin_generated;
+import * as console from "node:console";
+import { readConfig, readRawConfig } from "@allurereport/core";
+import AwesomePlugin from "@allurereport/plugin-awesome";
+export const AGENT_HUMAN_REPORT_THRESHOLD = 1000;
+const createInitialHumanReportStatus = (mode) => ({
+    schema_version: "allure-agent-human-report/v1",
+    mode,
+    status: mode === "off" ? "disabled" : "pending",
+    result_count: null,
+    threshold: AGENT_HUMAN_REPORT_THRESHOLD,
+    path: null,
+    reports: [],
+    reason: mode === "off" ? "disabled by --report off" : null,
+    error: null,
+});
+const isAgentPluginId = (id) => id === "agent" || id === "plugin-agent";
+const isAwesomeDescriptor = (id, descriptor) => id === "awesome" ||
+    id === "@allurereport/plugin-awesome" ||
+    descriptor.import === "awesome" ||
+    descriptor.import === "@allurereport/plugin-awesome";
+const configuredAwesomeOptions = async (cwd, configPath) => {
+    const rawConfig = await readRawConfig(cwd, configPath);
+    const plugins = rawConfig.plugins ?? {};
+    for (const id of Object.keys(plugins)) {
+        const descriptor = plugins[id];
+        if (isAwesomeDescriptor(id, descriptor)) {
+            return (descriptor.options ?? {});
+        }
+    }
+    return {};
+};
+const recordGeneratedReport = (status, pluginId, path) => {
+    const alreadyRecorded = status.reports.some((report) => report.plugin_id === pluginId && report.path === path);
+    if (!alreadyRecorded) {
+        status.reports.push({
+            plugin_id: pluginId,
+            path,
+        });
+    }
+    status.status = status.error ? "failed" : "generated";
+    status.path ?? (status.path = path);
+    status.reason = null;
+    status.generated_at = new Date().toISOString();
+};
+const recordFailedReport = (status, pluginId, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    status.status = "failed";
+    status.error ?? (status.error = message);
+    status.errors = [...(status.errors ?? []), { plugin_id: pluginId, message }];
+};
+class AgentHumanReportPlugin {
+    constructor(params) {
+        this.params = params;
+        _AgentHumanReportPlugin_realtime.set(this, void 0);
+        _AgentHumanReportPlugin_generated.set(this, false);
+        this.start = async (_context, _store, realtime) => {
+            __classPrivateFieldSet(this, _AgentHumanReportPlugin_realtime, realtime, "f");
+        };
+        this.done = async (context, store) => {
+            const { mode, status, threshold, pluginId, plugin, reportPath } = this.params;
+            const resultCount = (await store.allTestResults()).length;
+            status.result_count = resultCount;
+            if (status.status === "skipped") {
+                return;
+            }
+            if (mode === "auto" && resultCount > threshold) {
+                status.status = "skipped";
+                status.reason = `result count ${resultCount} exceeds threshold ${threshold}`;
+                return;
+            }
+            try {
+                await plugin.start?.(context, store, __classPrivateFieldGet(this, _AgentHumanReportPlugin_realtime, "f"));
+                await plugin.done?.(context, store);
+                __classPrivateFieldSet(this, _AgentHumanReportPlugin_generated, true, "f");
+                recordGeneratedReport(status, pluginId, reportPath);
+            }
+            catch (error) {
+                recordFailedReport(status, pluginId, error);
+                console.error(`agent human report ${pluginId} error`, error);
+            }
+        };
+        this.info = async (context, store) => {
+            if (!__classPrivateFieldGet(this, _AgentHumanReportPlugin_generated, "f")) {
+                return undefined;
+            }
+            return this.params.plugin.info?.(context, store);
+        };
+    }
+}
+_AgentHumanReportPlugin_realtime = new WeakMap(), _AgentHumanReportPlugin_generated = new WeakMap();
+const wrapHumanReportPlugin = (params) => {
+    const { mode, status, plugin, reportPath = `${plugin.id}/` } = params;
+    return {
+        ...plugin,
+        plugin: new AgentHumanReportPlugin({
+            mode,
+            status,
+            threshold: AGENT_HUMAN_REPORT_THRESHOLD,
+            pluginId: plugin.id,
+            plugin: plugin.plugin,
+            reportPath,
+        }),
+    };
+};
+export const createAgentHumanReportConfig = async ({ mode, cwd, configPath, outputDir, configOverride, }) => {
+    const status = createInitialHumanReportStatus(mode);
+    const statusProvider = () => status;
+    if (mode === "off") {
+        return {
+            status,
+            statusProvider,
+            plugins: [],
+        };
+    }
+    if (mode === "auto" || mode === "awesome") {
+        const awesomeOptions = {
+            ...(await configuredAwesomeOptions(cwd, configPath)),
+            singleFile: true,
+        };
+        const awesomePlugin = {
+            id: "awesome",
+            enabled: true,
+            options: awesomeOptions,
+            plugin: new AwesomePlugin(awesomeOptions),
+        };
+        return {
+            status,
+            statusProvider,
+            plugins: [
+                wrapHumanReportPlugin({
+                    mode,
+                    status,
+                    plugin: awesomePlugin,
+                    reportPath: "awesome/index.html",
+                }),
+            ],
+        };
+    }
+    const reportConfig = await readConfig(cwd, configPath, {
+        ...configOverride,
+        output: outputDir,
+    });
+    const plugins = reportConfig.plugins
+        ?.filter((plugin) => !isAgentPluginId(plugin.id))
+        .map((plugin) => wrapHumanReportPlugin({
+        mode,
+        status,
+        plugin,
+    })) ?? [];
+    if (!plugins.length) {
+        status.status = "disabled";
+        status.reason = "no configured non-agent report plugins";
+    }
+    return {
+        status,
+        statusProvider,
+        plugins,
+    };
+};

package/dist/commands/agent-run.d.ts

@@ -0,0 +1,49 @@
+import { writeAgentRunState, type AgentExpectationsInput, type AgentHumanReportMode } from "@allurereport/plugin-agent";
+export declare const formatAgentCommand: (args: string[]) => string;
+export declare const formatAgentInspectCommand: (params: {
+    dumps?: string[];
+    resultsDir?: string[];
+}) => string;
+export declare const printAgentOutputLinks: (outputDir: string) => void;
+export declare const persistAgentRunState: (value: Parameters<typeof writeAgentRunState>[0]) => Promise<void>;
+export declare const cleanupManagedAgentOutputs: (params: {
+    cwd: string;
+    runId: string;
+    managedOutput: boolean;
+}) => Promise<void>;
+export type ExecuteAgentModeParams = {
+    configPath?: string;
+    cwd?: string;
+    output?: string;
+    expectations?: string;
+    inlineExpectations?: AgentExpectationsInput;
+    environment?: string;
+    environmentName?: string;
+    silent?: boolean;
+    rerunFrom?: string;
+    rerunLatest?: boolean;
+    rerunPreset?: string;
+    rerunEnvironments?: string[];
+    rerunLabels?: string[];
+    reportMode: AgentHumanReportMode;
+    args: string[];
+};
+export declare const executeAgentMode: (params: ExecuteAgentModeParams) => Promise<void>;
+export type ExecuteAgentInspectModeParams = {
+    configPath?: string;
+    cwd?: string;
+    output?: string;
+    expectations?: string;
+    inlineExpectations?: AgentExpectationsInput;
+    environment?: string;
+    environmentName?: string;
+    reportName?: string;
+    open?: boolean;
+    port?: string;
+    historyLimit?: string;
+    hideLabels?: string[];
+    dumps?: string[];
+    reportMode: AgentHumanReportMode;
+    resultsDir: string[];
+};
+export declare const executeAgentInspectMode: (params: ExecuteAgentInspectModeParams) => Promise<never>;

package/dist/commands/agent-run.js

@@ -0,0 +1,335 @@
+import * as console from "node:console";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import process, { exit } from "node:process";
+import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { createAgentTestPlanContext, AgentUsageError, formatAgentOutputLinks, isPathInside, normalizeAgentRerunPreset, parseAgentLabelFilters, cleanupAgentRunState, cleanupStaleAgentRunStates, resolveAgentStateDir, writeAgentRunState, } from "@allurereport/plugin-agent";
+import { normalizeCommandEnvironmentOptions, resolveCommandEnvironment } from "../utils/environment.js";
+import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
+import { findAllureResultDirectories, findFilesByGlobs } from "../utils/fileSystem.js";
+import { createAgentHumanReportConfig } from "./agent-human-report.js";
+import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
+export const formatAgentCommand = (args) => args.join(" ");
+export const formatAgentInspectCommand = (params) => [
+    "allure",
+    "agent",
+    "inspect",
+    ...(params.dumps ?? []).flatMap((dump) => ["--dump", dump]),
+    ...(params.resultsDir ?? []),
+].join(" ");
+export const printAgentOutputLinks = (outputDir) => {
+    for (const line of formatAgentOutputLinks(outputDir)) {
+        console.log(line);
+    }
+};
+export const persistAgentRunState = async (value) => {
+    try {
+        await writeAgentRunState(value);
+    }
+    catch (error) {
+        console.error(`Could not update agent state in ${resolveAgentStateDir(value.cwd)}: ${error.message}`);
+    }
+};
+const logAgentCleanupFailures = (failures) => {
+    for (const failure of failures) {
+        console.error(`Could not clean stale agent output ${failure.state.outputDir}: ${failure.error.message}`);
+    }
+};
+const logAgentOrphanCleanupFailures = (failures) => {
+    for (const failure of failures) {
+        console.error(`Could not clean stale agent output ${failure.outputDir}: ${failure.error.message}`);
+    }
+};
+export const cleanupManagedAgentOutputs = async (params) => {
+    try {
+        const result = await cleanupAgentRunState({
+            cwd: params.cwd,
+            currentRunId: params.runId,
+            keepManagedRuns: params.managedOutput ? 1 : 0,
+        });
+        logAgentCleanupFailures(result.failed);
+    }
+    catch (error) {
+        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
+    }
+    try {
+        const staleResult = await cleanupStaleAgentRunStates({
+            cwd: params.cwd,
+            currentRunId: params.runId,
+        });
+        logAgentCleanupFailures(staleResult.failed);
+        logAgentOrphanCleanupFailures(staleResult.orphaned.failed);
+    }
+    catch (error) {
+        console.error(`Could not clean agent state in ${resolveAgentStateDir(params.cwd)}: ${error.message}`);
+    }
+};
+export const executeAgentMode = async (params) => {
+    const { configPath, cwd: configuredCwd, output, expectations, inlineExpectations, environment, environmentName, silent, rerunFrom, rerunLatest, rerunPreset, rerunEnvironments, rerunLabels, reportMode, args, } = params;
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    const cwd = await realpath(configuredCwd ?? process.cwd());
+    const commandString = formatAgentCommand(args);
+    const hasRerunSource = !!rerunFrom || !!rerunLatest;
+    const hasRerunFilters = !!rerunPreset || !!rerunEnvironments?.length || !!rerunLabels?.length;
+    if (!hasRerunSource && hasRerunFilters) {
+        throw new AgentUsageError("Use rerun filters only together with --rerun-from <path> or --rerun-latest");
+    }
+    const rerunContext = await createAgentTestPlanContext({
+        cwd,
+        from: rerunFrom,
+        latest: rerunLatest,
+        preset: normalizeAgentRerunPreset(rerunPreset),
+        environments: rerunEnvironments?.length ? rerunEnvironments : undefined,
+        labelFilters: parseAgentLabelFilters(rerunLabels),
+    });
+    const childEnvironmentVariables = {
+        ...createChildAllureCliEnvironment("agent"),
+        ...(rerunContext ? { ALLURE_TESTPLAN_PATH: rerunContext.testPlanPath } : {}),
+    };
+    try {
+        if (getActiveAllureCliCommand()) {
+            console.log(commandString);
+            const exitCode = await executeNestedAllureCommand({
+                command,
+                commandArgs,
+                cwd,
+                ...(rerunContext ? { environmentVariables: { ALLURE_TESTPLAN_PATH: rerunContext.testPlanPath } } : {}),
+                silent,
+            });
+            exit(exitCode ?? -1);
+            return;
+        }
+        const runId = randomUUID();
+        const managedOutput = !output;
+        const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
+        const expectationsPath = expectations ? resolve(cwd, expectations) : undefined;
+        const environmentOptions = {
+            environment,
+            environmentName,
+        };
+        normalizeCommandEnvironmentOptions(environmentOptions);
+        if (expectationsPath && isPathInside(outputDir, expectationsPath)) {
+            throw new AgentUsageError(`--expectations path ${JSON.stringify(expectationsPath)} must not be inside the agent output directory ${JSON.stringify(outputDir)}`);
+        }
+        const humanReport = await createAgentHumanReportConfig({
+            mode: reportMode,
+            cwd,
+            configPath,
+            outputDir,
+        });
+        const config = await readConfig(cwd, configPath, {
+            output: outputDir,
+            plugins: {
+                agent: {
+                    options: {
+                        outputDir,
+                        command: commandString,
+                        humanReport: humanReport.statusProvider,
+                        ...(expectationsPath ? { expectationsPath } : {}),
+                        ...(inlineExpectations ? { expectations: inlineExpectations } : {}),
+                    },
+                },
+            },
+        });
+        const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
+        try {
+            await rm(outputDir, { recursive: true });
+        }
+        catch (error) {
+            if (!isFileNotFoundError(error)) {
+                console.error("could not clean output directory", error);
+            }
+        }
+        const startedAt = Date.now();
+        await persistAgentRunState({
+            runId,
+            cwd,
+            outputDir,
+            managedOutput,
+            expectationsPath,
+            command: commandString,
+            startedAt,
+            status: "running",
+            pid: process.pid,
+        });
+        printAgentOutputLinks(outputDir);
+        if (expectationsPath) {
+            console.log(`agent expectations: ${expectationsPath}`);
+        }
+        else if (inlineExpectations) {
+            console.log("agent expectations: CLI options");
+        }
+        console.log(commandString);
+        const allureReport = new AllureReport({
+            ...config,
+            output: outputDir,
+            environment: resolvedEnvironment?.id,
+            open: false,
+            port: undefined,
+            qualityGate: undefined,
+            allureService: undefined,
+            realTime: false,
+            plugins: [...humanReport.plugins, ...(config.plugins ?? [])],
+        });
+        const knownIssues = await allureReport.store.allKnownIssues();
+        const { globalExitCode } = await executeAllureRun({
+            allureReport,
+            knownIssues,
+            cwd,
+            command,
+            commandArgs,
+            environmentVariables: childEnvironmentVariables,
+            environment: resolvedEnvironment?.id,
+            withQualityGate: false,
+            logs: "pipe",
+            silent,
+            ignoreLogs: false,
+            logProcessExit: false,
+        });
+        await persistAgentRunState({
+            runId,
+            cwd,
+            outputDir,
+            managedOutput,
+            expectationsPath,
+            command: commandString,
+            startedAt,
+            finishedAt: Date.now(),
+            status: "finished",
+            exitCode: globalExitCode.actual ?? globalExitCode.original,
+            pid: process.pid,
+        });
+        await cleanupManagedAgentOutputs({ cwd, runId, managedOutput });
+        exit(globalExitCode.actual ?? globalExitCode.original);
+    }
+    finally {
+        await rerunContext?.cleanup();
+    }
+};
+export const executeAgentInspectMode = async (params) => {
+    const { configPath, cwd: configuredCwd, output, expectations, inlineExpectations, environment, environmentName, reportName, open, port, historyLimit, hideLabels, dumps = [], reportMode, resultsDir, } = params;
+    const cwd = await realpath(configuredCwd ?? process.cwd());
+    const dumpFiles = dumps.length ? await findFilesByGlobs(cwd, dumps) : [];
+    const shouldReadResults = resultsDir.length > 0 || dumps.length === 0;
+    const { resultDirectories = [], patterns = resultsDir } = shouldReadResults
+        ? await findAllureResultDirectories(cwd, resultsDir)
+        : {};
+    if (dumps.length > 0 && dumpFiles.length === 0) {
+        throw new AgentUsageError(`No dump files found matching pattern: ${dumps.join(", ")}`);
+    }
+    if (resultDirectories.length === 0 && dumpFiles.length === 0) {
+        const inspectedPatterns = [...(patterns ?? []), ...dumps];
+        throw new AgentUsageError(`No test results directories or dump files found matching pattern: ${inspectedPatterns}`);
+    }
+    const runId = randomUUID();
+    const managedOutput = !output;
+    const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
+    const expectationsPath = expectations ? resolve(cwd, expectations) : undefined;
+    const commandString = formatAgentInspectCommand({ dumps: dumpFiles, resultsDir: resultDirectories });
+    const hiddenLabels = hideLabels?.length ? hideLabels : undefined;
+    const environmentOptions = {
+        environment,
+        environmentName,
+    };
+    normalizeCommandEnvironmentOptions(environmentOptions);
+    if (expectationsPath && isPathInside(outputDir, expectationsPath)) {
+        throw new AgentUsageError(`--expectations path ${JSON.stringify(expectationsPath)} must not be inside the agent output directory ${JSON.stringify(outputDir)}`);
+    }
+    const historyLimitValue = historyLimit ? parseInt(historyLimit, 10) : undefined;
+    const humanReport = await createAgentHumanReportConfig({
+        mode: reportMode,
+        cwd,
+        configPath,
+        outputDir,
+        configOverride: {
+            name: reportName,
+            open,
+            port,
+            hideLabels: hiddenLabels,
+            historyLimit: historyLimitValue,
+        },
+    });
+    const config = await readConfig(cwd, configPath, {
+        name: reportName,
+        output: outputDir,
+        open,
+        port,
+        hideLabels: hiddenLabels,
+        historyLimit: historyLimitValue,
+        plugins: {
+            agent: {
+                options: {
+                    outputDir,
+                    command: commandString,
+                    humanReport: humanReport.statusProvider,
+                    ...(expectationsPath ? { expectationsPath } : {}),
+                    ...(inlineExpectations ? { expectations: inlineExpectations } : {}),
+                },
+            },
+        },
+    });
+    const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
+    try {
+        await rm(outputDir, { recursive: true });
+    }
+    catch (error) {
+        if (!isFileNotFoundError(error)) {
+            console.error("could not clean output directory", error);
+        }
+    }
+    const startedAt = Date.now();
+    await persistAgentRunState({
+        runId,
+        cwd,
+        outputDir,
+        managedOutput,
+        expectationsPath,
+        command: commandString,
+        startedAt,
+        status: "running",
+        pid: process.pid,
+    });
+    printAgentOutputLinks(outputDir);
+    if (expectationsPath) {
+        console.log(`agent expectations: ${expectationsPath}`);
+    }
+    else if (inlineExpectations) {
+        console.log("agent expectations: CLI options");
+    }
+    console.log(commandString);
+    const allureReport = new AllureReport({
+        ...config,
+        output: outputDir,
+        environment: resolvedEnvironment?.id,
+        open: false,
+        port: undefined,
+        qualityGate: undefined,
+        allureService: undefined,
+        realTime: false,
+        plugins: [...humanReport.plugins, ...(config.plugins ?? [])],
+    });
+    await allureReport.restoreState(Array.from(dumpFiles));
+    await allureReport.start();
+    for (const dir of resultDirectories) {
+        await allureReport.readDirectory(dir);
+    }
+    await allureReport.done();
+    await persistAgentRunState({
+        runId,
+        cwd,
+        outputDir,
+        managedOutput,
+        expectationsPath,
+        command: commandString,
+        startedAt,
+        finishedAt: Date.now(),
+        status: "finished",
+        exitCode: 0,
+        pid: process.pid,
+    });
+    await cleanupManagedAgentOutputs({ cwd, runId, managedOutput });
+    exit(0);
+};