allure 3.4.1 → 3.6.0

package/dist/commands/commons/run.js

@@ -0,0 +1,258 @@
+import * as console from "node:console";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { QualityGateState, stringifyQualityGateResults } from "@allurereport/core";
+import { createTestPlan } from "@allurereport/core-api";
+import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allurereport/directory-watcher";
+import { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
+import { KnownError } from "@allurereport/service";
+import { red } from "yoctocolors";
+import { logTests, runProcess, terminationOf } from "../../utils/index.js";
+import { logError } from "../../utils/logs.js";
+import { stopProcessTree } from "../../utils/process.js";
+export const executeNestedAllureCommand = async (params) => {
+    const nestedProcess = runProcess({
+        command: params.command,
+        commandArgs: params.commandArgs,
+        cwd: params.cwd,
+        environmentVariables: params.environmentVariables,
+        logs: params.silent ? "ignore" : "inherit",
+    });
+    return await terminationOf(nestedProcess);
+};
+export const runTests = async (params) => {
+    const { allureReport, knownIssues, cwd, command, commandArgs, logs, environmentVariables, environment, withQualityGate, silent, logProcessExit = true, } = params;
+    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,
+        environmentVariables,
+        logs,
+    });
+    const qualityGateState = new QualityGateState();
+    let qualityGateUnsub;
+    let qualityGateResults = [];
+    let testProcessStdout = "";
+    let testProcessStderr = "";
+    if (withQualityGate) {
+        qualityGateUnsub = allureReport.realtimeSubscriber.onTestResults(async (testResults) => {
+            const trs = await Promise.all(testResults.map((tr) => allureReport.store.testResultById(tr)));
+            const filteredTrs = trs.filter((tr) => tr !== undefined);
+            if (!filteredTrs.length) {
+                return;
+            }
+            const { results, fastFailed } = await allureReport.validate({
+                trs: filteredTrs,
+                state: qualityGateState,
+                environment,
+                knownIssues,
+            });
+            if (!fastFailed) {
+                return;
+            }
+            allureReport.realtimeDispatcher.sendQualityGateResults(results);
+            qualityGateResults = results;
+            try {
+                await stopProcessTree(testProcess.pid);
+            }
+            catch (err) {
+                if (err.message.includes("kill ESRCH")) {
+                    return;
+                }
+                throw err;
+            }
+        });
+    }
+    if (logs === "pipe") {
+        testProcess.stdout?.setEncoding("utf8").on?.("data", (data) => {
+            testProcessStdout += data;
+            if (silent) {
+                return;
+            }
+            process.stdout.write(data);
+        });
+        testProcess.stderr?.setEncoding("utf8").on?.("data", async (data) => {
+            testProcessStderr += data;
+            if (silent) {
+                return;
+            }
+            process.stderr.write(data);
+        });
+    }
+    const code = await terminationOf(testProcess);
+    const afterProcess = Date.now();
+    if (logProcessExit) {
+        if (code !== null) {
+            console.log(`process finished with code ${code} (${afterProcess - beforeProcess}ms)`);
+        }
+        else {
+            console.log(`process terminated (${afterProcess - beforeProcess}ms)`);
+        }
+    }
+    await allureResultsWatch.abort();
+    for (const [ar, watcher] of allureResultsWatchers) {
+        await watcher.abort();
+        allureResultsWatchers.delete(ar);
+    }
+    await processWatcher.abort();
+    qualityGateUnsub?.();
+    return {
+        code,
+        stdout: testProcessStdout,
+        stderr: testProcessStderr,
+        qualityGateResults,
+    };
+};
+export const executeAllureRun = async (params) => {
+    const { allureReport, knownIssues, cwd, command, commandArgs, environmentVariables = {}, environment, withQualityGate, silent, logs, ignoreLogs, maxRerun = 0, logProcessExit = true, } = params;
+    await allureReport.start();
+    const globalExitCode = {
+        original: 0,
+        actual: undefined,
+    };
+    let qualityGateResults = [];
+    let testProcessResult = null;
+    try {
+        testProcessResult = await runTests({
+            logs,
+            silent,
+            allureReport,
+            knownIssues,
+            cwd,
+            command,
+            commandArgs,
+            environment,
+            environmentVariables,
+            withQualityGate,
+            logProcessExit,
+        });
+        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));
+            testProcessResult = await runTests({
+                silent,
+                logs,
+                allureReport,
+                knownIssues,
+                cwd,
+                command,
+                commandArgs,
+                environment,
+                environmentVariables: {
+                    ...environmentVariables,
+                    ALLURE_TESTPLAN_PATH: testPlanPath,
+                    ALLURE_RERUN: `${rerun}`,
+                },
+                withQualityGate,
+                logProcessExit,
+            });
+            await rm(tmpDir, { recursive: true });
+            logTests(await allureReport.store.allTestResults());
+        }
+        const trs = await allureReport.store.allTestResults({ includeHidden: false });
+        qualityGateResults = testProcessResult?.qualityGateResults ?? [];
+        if (withQualityGate && !qualityGateResults.length) {
+            const { results } = await allureReport.validate({
+                trs,
+                knownIssues,
+                environment,
+            });
+            qualityGateResults = results;
+        }
+        if (qualityGateResults.length) {
+            const qualityGateMessage = stringifyQualityGateResults(qualityGateResults);
+            console.error(qualityGateMessage);
+            allureReport.realtimeDispatcher.sendQualityGateResults(qualityGateResults);
+        }
+        globalExitCode.original = testProcessResult?.code ?? -1;
+        if (withQualityGate) {
+            globalExitCode.actual = qualityGateResults.length > 0 ? 1 : 0;
+        }
+    }
+    catch (error) {
+        globalExitCode.actual = 1;
+        if (error instanceof KnownError) {
+            console.error(red(error.message));
+            allureReport.realtimeDispatcher.sendGlobalError({
+                message: error.message,
+            });
+        }
+        else {
+            await logError("Failed to run tests using Allure due to unexpected error", error);
+            allureReport.realtimeDispatcher.sendGlobalError({
+                message: error.message,
+                trace: error.stack,
+            });
+        }
+    }
+    const processFailed = Math.abs(globalExitCode.actual ?? globalExitCode.original) !== 0;
+    if (!ignoreLogs && testProcessResult?.stdout) {
+        const fileName = randomUUID();
+        const stdoutResultFile = new BufferResultFile(Buffer.from(testProcessResult.stdout, "utf8"), `${fileName}`);
+        stdoutResultFile.contentType = "text/plain";
+        allureReport.realtimeDispatcher.sendGlobalAttachment(stdoutResultFile, "stdout.txt");
+    }
+    if (!ignoreLogs && testProcessResult?.stderr) {
+        const fileName = randomUUID();
+        const stderrResultFile = new BufferResultFile(Buffer.from(testProcessResult.stderr, "utf8"), fileName);
+        stderrResultFile.contentType = "text/plain";
+        allureReport.realtimeDispatcher.sendGlobalAttachment(stderrResultFile, "stderr.txt");
+        if (processFailed) {
+            allureReport.realtimeDispatcher.sendGlobalError({
+                message: "Test process has failed",
+                trace: testProcessResult.stderr,
+            });
+        }
+    }
+    allureReport.realtimeDispatcher.sendGlobalExitCode(globalExitCode);
+    await allureReport.done();
+    return {
+        globalExitCode,
+        testProcessResult,
+    };
+};

package/dist/commands/index.d.ts

@@ -2,6 +2,7 @@ export * from "./history.js";
 export * from "./testplan.js";
 export * from "./classic.js";
 export * from "./allure2.js";
+export * from "./agent.js";
 export * from "./awesome.js";
 export * from "./csv.js";
 export * from "./history.js";

package/dist/commands/index.js

@@ -2,6 +2,7 @@ export * from "./history.js";
 export * from "./testplan.js";
 export * from "./classic.js";
 export * from "./allure2.js";
+export * from "./agent.js";
 export * from "./awesome.js";
 export * from "./csv.js";
 export * from "./history.js";

package/dist/commands/run.d.ts

@@ -1,11 +1,4 @@
-import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 import { Command } from "clipanion";
-export type TestProcessResult = {
-    code: number | null;
-    stdout: string;
-    stderr: string;
-    qualityGateResults: QualityGateValidationResult[];
-};
 export declare class RunCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;

package/dist/commands/run.js

@@ -1,136 +1,16 @@
 import * as console from "node:console";
-import { randomUUID } from "node:crypto";
-import { mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { realpath, rm } from "node:fs/promises";
+import { resolve } from "node:path";
 import process, { exit } from "node:process";
-import { AllureReport, QualityGateState, isFileNotFoundError, readConfig, stringifyQualityGateResults, } from "@allurereport/core";
-import { createTestPlan } from "@allurereport/core-api";
-import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allurereport/directory-watcher";
+import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
 import Awesome from "@allurereport/plugin-awesome";
-import { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
-import { KnownError } from "@allurereport/service";
 import { serve } from "@allurereport/static-server";
 import { Command, Option, UsageError } from "clipanion";
 import { red } from "yoctocolors";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
-import { logTests, runProcess, terminationOf } from "../utils/index.js";
-import { logError } from "../utils/logs.js";
-import { stopProcessTree } from "../utils/process.js";
-const runTests = async (params) => {
-    const { allureReport, knownIssues, cwd, command, commandArgs, logs, environmentVariables, environment, withQualityGate, silent, } = params;
-    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,
-        environmentVariables,
-        logs,
-    });
-    const qualityGateState = new QualityGateState();
-    let qualityGateUnsub;
-    let qualityGateResults = [];
-    let testProcessStdout = "";
-    let testProcessStderr = "";
-    if (withQualityGate) {
-        qualityGateUnsub = allureReport.realtimeSubscriber.onTestResults(async (testResults) => {
-            const trs = await Promise.all(testResults.map((tr) => allureReport.store.testResultById(tr)));
-            const filteredTrs = trs.filter((tr) => tr !== undefined);
-            if (!filteredTrs.length) {
-                return;
-            }
-            const { results, fastFailed } = await allureReport.validate({
-                trs: filteredTrs,
-                state: qualityGateState,
-                environment,
-                knownIssues,
-            });
-            if (!fastFailed) {
-                return;
-            }
-            allureReport.realtimeDispatcher.sendQualityGateResults(results);
-            qualityGateResults = results;
-            try {
-                await stopProcessTree(testProcess.pid);
-            }
-            catch (err) {
-                if (err.message.includes("kill ESRCH")) {
-                    return;
-                }
-                throw err;
-            }
-        });
-    }
-    if (logs === "pipe") {
-        testProcess.stdout?.setEncoding("utf8").on?.("data", (data) => {
-            testProcessStdout += data;
-            if (silent) {
-                return;
-            }
-            process.stdout.write(data);
-        });
-        testProcess.stderr?.setEncoding("utf8").on?.("data", async (data) => {
-            testProcessStderr += data;
-            if (silent) {
-                return;
-            }
-            process.stderr.write(data);
-        });
-    }
-    const code = await terminationOf(testProcess);
-    const afterProcess = Date.now();
-    if (code !== null) {
-        console.log(`process finished with code ${code} (${afterProcess - beforeProcess}ms)`);
-    }
-    else {
-        console.log(`process terminated (${afterProcess - beforeProcess}ms)`);
-    }
-    await allureResultsWatch.abort();
-    for (const [ar, watcher] of allureResultsWatchers) {
-        await watcher.abort();
-        allureResultsWatchers.delete(ar);
-    }
-    await processWatcher.abort();
-    qualityGateUnsub?.();
-    return {
-        code,
-        stdout: testProcessStdout,
-        stderr: testProcessStderr,
-        qualityGateResults,
-    };
-};
+import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
+import { executeAgentMode } from "./agent.js";
+import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
 export class RunCommand extends Command {
     constructor() {
         super(...arguments);
@@ -185,11 +65,22 @@ export class RunCommand extends Command {
         if (!args || !args.length) {
             throw new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
         }
-        const environmentOptions = {
-            environment: this.environment,
-            environmentName: this.environmentName,
-        };
-        normalizeCommandEnvironmentOptions(environmentOptions);
+        const legacyAgentOutput = process.env.ALLURE_AGENT_OUTPUT;
+        if (legacyAgentOutput) {
+            await executeAgentMode({
+                configPath: this.config,
+                cwd: this.cwd,
+                output: resolve(process.cwd(), legacyAgentOutput),
+                expectations: process.env.ALLURE_AGENT_EXPECTATIONS
+                    ? resolve(process.cwd(), process.env.ALLURE_AGENT_EXPECTATIONS)
+                    : undefined,
+                environment: this.environment,
+                environmentName: this.environmentName,
+                silent: this.silent,
+                args,
+            });
+            return;
+        }
         const before = new Date().getTime();
         process.on("exit", (exitCode) => {
             const after = new Date().getTime();
@@ -200,6 +91,21 @@ export class RunCommand extends Command {
         const cwd = await realpath(this.cwd ?? process.cwd());
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
         console.log(`${command} ${commandArgs.join(" ")}`);
+        if (getActiveAllureCliCommand()) {
+            const exitCode = await executeNestedAllureCommand({
+                command,
+                commandArgs,
+                cwd,
+                silent: this.silent,
+            });
+            exit(exitCode ?? -1);
+            return;
+        }
+        const environmentOptions = {
+            environment: this.environment,
+            environmentName: this.environmentName,
+        };
+        normalizeCommandEnvironmentOptions(environmentOptions);
         const maxRerun = this.rerun ? parseInt(this.rerun, 10) : 0;
         const config = await readConfig(cwd, this.config, {
             output: this.output,
@@ -246,113 +152,20 @@ export class RunCommand extends Command {
             ],
         });
         const knownIssues = await allureReport.store.allKnownIssues();
-        await allureReport.start();
-        const globalExitCode = {
-            original: 0,
-            actual: undefined,
-        };
-        let qualityGateResults;
-        let testProcessResult = null;
-        try {
-            testProcessResult = await runTests({
-                logs: this.logs,
-                silent: this.silent,
-                allureReport,
-                knownIssues,
-                cwd,
-                command,
-                commandArgs,
-                environment: resolvedEnvironment?.id,
-                environmentVariables: {},
-                withQualityGate,
-            });
-            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));
-                testProcessResult = await runTests({
-                    silent: this.silent,
-                    logs: this.logs,
-                    allureReport,
-                    knownIssues,
-                    cwd,
-                    command,
-                    commandArgs,
-                    environment: resolvedEnvironment?.id,
-                    environmentVariables: {
-                        ALLURE_TESTPLAN_PATH: testPlanPath,
-                        ALLURE_RERUN: `${rerun}`,
-                    },
-                    withQualityGate,
-                });
-                await rm(tmpDir, { recursive: true });
-                logTests(await allureReport.store.allTestResults());
-            }
-            const trs = await allureReport.store.allTestResults({ includeHidden: false });
-            qualityGateResults = testProcessResult?.qualityGateResults ?? [];
-            if (withQualityGate && !qualityGateResults?.length) {
-                const { results } = await allureReport.validate({
-                    trs,
-                    knownIssues,
-                    environment: resolvedEnvironment?.id,
-                });
-                qualityGateResults = results;
-            }
-            if (qualityGateResults?.length) {
-                const qualityGateMessage = stringifyQualityGateResults(qualityGateResults);
-                console.error(qualityGateMessage);
-                allureReport.realtimeDispatcher.sendQualityGateResults(qualityGateResults);
-            }
-            globalExitCode.original = testProcessResult?.code ?? -1;
-            if (withQualityGate) {
-                globalExitCode.actual = qualityGateResults.length > 0 ? 1 : 0;
-            }
-        }
-        catch (error) {
-            globalExitCode.actual = 1;
-            if (error instanceof KnownError) {
-                console.error(red(error.message));
-                allureReport.realtimeDispatcher.sendGlobalError({
-                    message: error.message,
-                });
-            }
-            else {
-                await logError("Failed to run tests using Allure due to unexpected error", error);
-                allureReport.realtimeDispatcher.sendGlobalError({
-                    message: error.message,
-                    trace: error.stack,
-                });
-            }
-        }
-        const processFailed = Math.abs(globalExitCode.actual ?? globalExitCode.original) !== 0;
-        if (!this.ignoreLogs && testProcessResult?.stdout) {
-            const fileName = randomUUID();
-            const stdoutResultFile = new BufferResultFile(Buffer.from(testProcessResult.stdout, "utf8"), `${fileName}`);
-            stdoutResultFile.contentType = "text/plain";
-            allureReport.realtimeDispatcher.sendGlobalAttachment(stdoutResultFile, "stdout.txt");
-        }
-        if (!this.ignoreLogs && testProcessResult?.stderr) {
-            const fileName = randomUUID();
-            const stderrResultFile = new BufferResultFile(Buffer.from(testProcessResult.stderr, "utf8"), fileName);
-            stderrResultFile.contentType = "text/plain";
-            allureReport.realtimeDispatcher.sendGlobalAttachment(stderrResultFile, "stderr.txt");
-            if (processFailed) {
-                allureReport.realtimeDispatcher.sendGlobalError({
-                    message: "Test process has failed",
-                    trace: testProcessResult.stderr,
-                });
-            }
-        }
-        allureReport.realtimeDispatcher.sendGlobalExitCode(globalExitCode);
-        await allureReport.done();
+        const { globalExitCode } = await executeAllureRun({
+            allureReport,
+            knownIssues,
+            cwd,
+            command,
+            commandArgs,
+            environmentVariables: createChildAllureCliEnvironment("run"),
+            environment: resolvedEnvironment?.id,
+            withQualityGate,
+            logs: this.logs,
+            silent: this.silent,
+            ignoreLogs: this.ignoreLogs,
+            maxRerun,
+        });
         if (config.open) {
             await serve({
                 port: config.port ? parseInt(config.port, 10) : undefined,

package/dist/index.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { argv } from "node:process";
 import { Builtins, Cli } from "clipanion";
-import { Allure2Command, AwesomeCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, JiraClearCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, WhoamiCommand, } from "./commands/index.js";
+import { AgentCommand, AgentLatestCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, JiraClearCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, WhoamiCommand, } from "./commands/index.js";
 const [node, app, ...args] = argv;
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cli = new Cli({
@@ -11,6 +11,10 @@ const cli = new Cli({
 });
 cli.register(AwesomeCommand);
 cli.register(Allure2Command);
+cli.register(AgentLatestCommand);
+cli.register(AgentSelectCommand);
+cli.register(AgentStateDirCommand);
+cli.register(AgentCommand);
 cli.register(ClassicCommand);
 cli.register(CsvCommand);
 cli.register(DashboardCommand);

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

@@ -0,0 +1,41 @@
+import type { TestPlan } from "@allurereport/core-api";
+import { type AgentTestManifestLine } from "@allurereport/plugin-agent";
+export type AgentRerunPreset = "review" | "failed" | "unsuccessful" | "all";
+export type AgentLabelFilter = {
+    name: string;
+    value: string;
+};
+export type AgentSelectionResult = {
+    outputDir: string;
+    preset: AgentRerunPreset;
+    selectedTests: AgentTestManifestLine[];
+    testPlan: TestPlan;
+};
+export type AgentTestPlanContext = {
+    outputDir: string;
+    preset: AgentRerunPreset;
+    selectedCount: number;
+    testPlanPath: string;
+    cleanup: () => Promise<void>;
+};
+export declare const normalizeAgentRerunPreset: (value?: string) => AgentRerunPreset;
+export declare const parseAgentLabelFilters: (values?: string[]) => AgentLabelFilter[];
+export declare const resolveAgentSelectionOutputDir: (params: {
+    cwd: string;
+    from?: string;
+    latest?: boolean;
+}) => Promise<string>;
+export declare const selectAgentTestPlan: (params: {
+    outputDir: string;
+    preset?: AgentRerunPreset;
+    environments?: string[];
+    labelFilters?: AgentLabelFilter[];
+}) => Promise<AgentSelectionResult>;
+export declare const createAgentTestPlanContext: (params: {
+    cwd: string;
+    from?: string;
+    latest?: boolean;
+    preset?: AgentRerunPreset;
+    environments?: string[];
+    labelFilters?: AgentLabelFilter[];
+}) => Promise<AgentTestPlanContext | undefined>;