allure 3.5.0 → 3.6.0

package/dist/utils/agent-select.js

@@ -0,0 +1,141 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { loadAgentOutput, planAgentEnrichmentReview, } from "@allurereport/plugin-agent";
+import { UsageError } from "clipanion";
+import { readLatestAgentState } from "./agent-state.js";
+const AGENT_RERUN_PRESETS = ["review", "failed", "unsuccessful", "all"];
+const ALLURE_ID_LABEL = "ALLURE_ID";
+const isAgentRerunPreset = (value) => AGENT_RERUN_PRESETS.includes(value);
+const readAllureId = (labels) => labels.find((label) => label.name === ALLURE_ID_LABEL)?.value;
+const matchesLabelFilters = (labels, filters) => filters.every((filter) => labels.some((label) => label.name === filter.name && label.value === filter.value));
+const buildTestPlan = (tests) => {
+    const seenSelectors = new Set();
+    const seenIds = new Set();
+    const selected = [];
+    for (const test of tests) {
+        const selector = test.full_name || undefined;
+        const id = readAllureId(test.labels);
+        if (selector && !seenSelectors.has(selector)) {
+            seenSelectors.add(selector);
+            if (id) {
+                seenIds.add(id);
+            }
+            selected.push({
+                selector,
+                ...(id ? { id } : {}),
+            });
+            continue;
+        }
+        if (id && !seenIds.has(id)) {
+            seenIds.add(id);
+            selected.push({ id });
+        }
+    }
+    return {
+        version: "1.0",
+        tests: selected,
+    };
+};
+const selectTestsByPreset = (output, preset) => {
+    switch (preset) {
+        case "review": {
+            const review = planAgentEnrichmentReview(output);
+            const targeted = new Set(review.rerun.targetedTests);
+            return output.tests.filter((test) => targeted.has(test.full_name));
+        }
+        case "failed":
+            return output.tests.filter((test) => test.status === "failed" || test.status === "broken");
+        case "unsuccessful":
+            return output.tests.filter((test) => test.status !== "passed");
+        case "all":
+            return output.tests;
+    }
+};
+export const normalizeAgentRerunPreset = (value) => {
+    if (!value) {
+        return "review";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!isAgentRerunPreset(normalized)) {
+        throw new UsageError(`Invalid rerun preset ${JSON.stringify(value)}. Expected one of: ${AGENT_RERUN_PRESETS.join(", ")}`);
+    }
+    return normalized;
+};
+export const parseAgentLabelFilters = (values) => (values ?? []).map((value) => {
+    const separatorIndex = value.indexOf("=");
+    if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+        throw new UsageError(`Invalid label filter ${JSON.stringify(value)}. Expected the form name=value, for example feature=checkout`);
+    }
+    const name = value.slice(0, separatorIndex).trim();
+    const filterValue = value.slice(separatorIndex + 1).trim();
+    if (!name || !filterValue) {
+        throw new UsageError(`Invalid label filter ${JSON.stringify(value)}. Expected the form name=value, for example feature=checkout`);
+    }
+    return {
+        name,
+        value: filterValue,
+    };
+});
+export const resolveAgentSelectionOutputDir = async (params) => {
+    const { cwd, from, latest } = params;
+    if (from && latest) {
+        throw new UsageError("Use either --from or --latest, not both");
+    }
+    if (!from && !latest) {
+        throw new UsageError("Expected either --from <path> or --latest");
+    }
+    if (from) {
+        return resolve(cwd, from);
+    }
+    const latestState = await readLatestAgentState(cwd);
+    if (!latestState) {
+        throw new UsageError(`No latest agent output found for ${cwd}`);
+    }
+    return latestState.outputDir;
+};
+export const selectAgentTestPlan = async (params) => {
+    const preset = params.preset ?? "review";
+    const output = await loadAgentOutput(params.outputDir);
+    const selectedTests = selectTestsByPreset(output, preset)
+        .filter((test) => (params.environments?.length ? params.environments.includes(test.environment_id) : true))
+        .filter((test) => (params.labelFilters?.length ? matchesLabelFilters(test.labels, params.labelFilters) : true));
+    return {
+        outputDir: output.outputDir,
+        preset,
+        selectedTests,
+        testPlan: buildTestPlan(selectedTests),
+    };
+};
+export const createAgentTestPlanContext = async (params) => {
+    const { from, latest } = params;
+    if (!from && !latest) {
+        return undefined;
+    }
+    const outputDir = await resolveAgentSelectionOutputDir({
+        cwd: params.cwd,
+        from,
+        latest,
+    });
+    const selection = await selectAgentTestPlan({
+        outputDir,
+        preset: params.preset,
+        environments: params.environments,
+        labelFilters: params.labelFilters,
+    });
+    if (!selection.testPlan.tests.length) {
+        throw new UsageError(`No tests matched rerun selection in ${selection.outputDir}. Adjust the preset or filters before rerunning.`);
+    }
+    const tempDir = await mkdtemp(join(tmpdir(), "allure-agent-select-"));
+    const testPlanPath = join(tempDir, "testplan.json");
+    await writeFile(testPlanPath, `${JSON.stringify(selection.testPlan, null, 2)}\n`, "utf-8");
+    return {
+        outputDir: selection.outputDir,
+        preset: selection.preset,
+        selectedCount: selection.testPlan.tests.length,
+        testPlanPath,
+        cleanup: async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+};

package/dist/utils/agent-state.d.ts

@@ -0,0 +1,15 @@
+export type AgentLatestState = {
+    schema: "allure-agent-latest/v1";
+    cwd: string;
+    outputDir: string;
+    expectationsPath?: string;
+    command: string;
+    startedAt: string;
+    finishedAt?: string;
+    status: "running" | "finished";
+    exitCode?: number | null;
+};
+export declare const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
+export declare const resolveAgentStateDir: (cwd: string) => string;
+export declare const writeLatestAgentState: (value: Omit<AgentLatestState, "schema">) => Promise<AgentLatestState>;
+export declare const readLatestAgentState: (cwd: string) => Promise<AgentLatestState | undefined>;

package/dist/utils/agent-state.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+const AGENT_STATE_SCHEMA = "allure-agent-latest/v1";
+export const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
+const isFileNotFoundError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+const projectHash = (cwd) => createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+export const resolveAgentStateDir = (cwd) => {
+    const configuredDir = process.env[ALLURE_AGENT_STATE_DIR_ENV]?.trim();
+    if (configuredDir) {
+        return resolve(configuredDir);
+    }
+    return join(tmpdir(), `allure-agent-state-${projectHash(resolve(cwd))}`);
+};
+const projectStatePath = (cwd) => join(resolveAgentStateDir(cwd), "latest.json");
+const writeJsonAtomic = async (filePath, value) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+    await rename(tempPath, filePath);
+};
+const isAgentLatestState = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.schema === AGENT_STATE_SCHEMA &&
+        typeof candidate.cwd === "string" &&
+        typeof candidate.outputDir === "string" &&
+        typeof candidate.command === "string" &&
+        typeof candidate.startedAt === "string" &&
+        (candidate.expectationsPath === undefined || typeof candidate.expectationsPath === "string") &&
+        (candidate.finishedAt === undefined || typeof candidate.finishedAt === "string") &&
+        (candidate.status === "running" || candidate.status === "finished") &&
+        (candidate.exitCode === undefined || typeof candidate.exitCode === "number" || candidate.exitCode === null));
+};
+export const writeLatestAgentState = async (value) => {
+    const normalizedState = {
+        schema: AGENT_STATE_SCHEMA,
+        cwd: resolve(value.cwd),
+        outputDir: resolve(value.outputDir),
+        expectationsPath: value.expectationsPath ? resolve(value.expectationsPath) : undefined,
+        command: value.command,
+        startedAt: value.startedAt,
+        finishedAt: value.finishedAt,
+        status: value.status,
+        exitCode: value.exitCode,
+    };
+    await writeJsonAtomic(projectStatePath(normalizedState.cwd), normalizedState);
+    return normalizedState;
+};
+export const readLatestAgentState = async (cwd) => {
+    const normalizedCwd = resolve(cwd);
+    const statePath = projectStatePath(normalizedCwd);
+    let raw;
+    try {
+        raw = await readFile(statePath, "utf-8");
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (!isAgentLatestState(parsed)) {
+        throw new Error(`Invalid latest agent state in ${statePath}`);
+    }
+    if (parsed.cwd !== normalizedCwd) {
+        return undefined;
+    }
+    try {
+        await stat(parsed.outputDir);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+    return parsed;
+};

package/dist/utils/environment.d.ts

@@ -1,12 +1,17 @@
-import { type FullConfig } from "@allurereport/core";
 import type { EnvironmentIdentity } from "@allurereport/core-api";
+import { type EnvironmentsConfig } from "@allurereport/core-api";
 type CommandEnvironmentOptions = {
     environment?: string;
     environmentName?: string;
 };
+type EnvironmentConfig = {
+    environment?: string;
+    environments?: EnvironmentsConfig;
+    allowedEnvironments?: string[];
+};
 export declare const environmentOption: () => string | undefined;
 export declare const environmentNameOption: () => string | undefined;
-export declare const resolveCommandEnvironment: (config: Pick<FullConfig, "environment" | "environments" | "allowedEnvironments">, options: CommandEnvironmentOptions & {
+export declare const resolveCommandEnvironment: (config: Pick<EnvironmentConfig, "environment" | "environments" | "allowedEnvironments">, options: CommandEnvironmentOptions & {
     source?: string;
 }) => EnvironmentIdentity | undefined;
 export declare const normalizeCommandEnvironmentOptions: (options: CommandEnvironmentOptions) => {

package/dist/utils/environment.js

@@ -1,4 +1,4 @@
-import { environmentIdentityById, environmentIdentityByName, validateAllowedEnvironmentId, } from "@allurereport/core";
+import { environmentIdentityById, environmentIdentityByName, validateAllowedEnvironmentId } from "@allurereport/core";
 import { validateEnvironmentId, validateEnvironmentName } from "@allurereport/core-api";
 import { Option, UsageError } from "clipanion";
 const environmentOptionDescription = "Force specific environment ID to all tests in the run. Given environment has higher priority than the one defined in the config file (default: empty string)";

package/dist/utils/execution-context.d.ts

@@ -0,0 +1,4 @@
+export declare const ALLURE_CLI_ACTIVE_COMMAND_ENV = "ALLURE_CLI_ACTIVE_COMMAND";
+export type AllureCliActiveCommand = "agent" | "run";
+export declare const getActiveAllureCliCommand: () => AllureCliActiveCommand | undefined;
+export declare const createChildAllureCliEnvironment: (command: AllureCliActiveCommand) => Record<string, string>;

package/dist/utils/execution-context.js

@@ -0,0 +1,9 @@
+import process from "node:process";
+export const ALLURE_CLI_ACTIVE_COMMAND_ENV = "ALLURE_CLI_ACTIVE_COMMAND";
+export const getActiveAllureCliCommand = () => {
+    const activeCommand = process.env[ALLURE_CLI_ACTIVE_COMMAND_ENV];
+    return activeCommand === "agent" || activeCommand === "run" ? activeCommand : undefined;
+};
+export const createChildAllureCliEnvironment = (command) => ({
+    [ALLURE_CLI_ACTIVE_COMMAND_ENV]: command,
+});

package/dist/utils/index.d.ts

@@ -1,3 +1,6 @@
 export * from "./process.js";
 export * from "./terminal.js";
 export * from "./logs.js";
+export * from "./execution-context.js";
+export * from "./agent-state.js";
+export * from "./agent-select.js";

package/dist/utils/index.js

@@ -1,3 +1,6 @@
 export * from "./process.js";
 export * from "./terminal.js";
 export * from "./logs.js";
+export * from "./execution-context.js";
+export * from "./agent-state.js";
+export * from "./agent-select.js";

package/dist/utils/process.js

@@ -18,12 +18,13 @@ export const runProcess = (params) => {
             COLORTERM: "truecolor",
             TERM: "xterm-256color",
         });
+        delete env.NO_COLOR;
     }
     return spawn(command, commandArgs, {
         env,
         cwd,
         stdio: logs,
-        shell: true,
+        shell: IS_WIN,
     });
 };
 export const terminationOf = (testProcess) => new Promise((resolve) => {

package/package.json

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