@empiricalrun/test-run 0.13.0 → 0.13.2

package/dist/bin/index.js

@@ -6,138 +6,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const dotenv_1 = __importDefault(require("dotenv"));
-const dashboard_1 = require("../dashboard");
-const cmd_1 = require("../lib/cmd");
-const run_all_tests_1 = require("../lib/run-all-tests");
-const run_specific_test_1 = require("../lib/run-specific-test");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
-const config_parser_1 = require("../utils/config-parser");
+const estimate_time_shard_1 = require("./commands/estimate-time-shard");
+const failed_list_1 = require("./commands/failed-list");
+const merge_1 = require("./commands/merge");
+const optimize_shards_1 = require("./commands/optimize-shards");
+const run_1 = require("./commands/run");
 dotenv_1.default.config({
     path: [".env.local", ".env"],
 });
-const repoDir = process.cwd();
-(async function main() {
-    commander_1.program
-        .option("-n, --name <test-name>", "Name of the test to run")
-        .option("-s, --suites <suites>", "Suites under which the test is defined")
-        .option("-d, --dir <test-dir>", "Path to the test directory")
-        .option("-f, --file <test-file-path>", "Path to the test file")
-        .option("-p, --project <project-name...>", "Test projects to run")
-        .option("--payload <payload>", "Payload to run tests")
-        .option("--skip-teardown", "This options skips running teardown tests")
-        .option("--forbid-only", `This options forbids the use of ".only" in the test files`)
-        .allowUnknownOption();
-    commander_1.program.parse(process.argv);
-    // Accessing the extracted parameters
-    const options = commander_1.program.opts();
-    if (options.name && options.forbidOnly) {
-        console.error("--name and --forbid-only options cannot be used together");
-        process.exit(1);
-    }
-    options.project = options.project || ["*"];
-    const optionsToStrip = [
-        "-n",
-        "--name",
-        "--skip-teardown",
-        "-f",
-        "--file",
-        "-d",
-        "--dir",
-        "-p",
-        "--project",
-        "-s",
-        "--suites",
-        "--payload",
-        options.skipTeardown,
-        options.name,
-        options.dir,
-        options.file,
-        options.suites,
-        options.payload,
-        ...options.project, // an array of comma separated project names/pattern matching globs *,premium-*,super-premium-*,safari
-    ];
-    const pwOptions = process.argv
-        .slice(2)
-        .filter((arg) => !optionsToStrip.includes(arg));
-    const projectName = process.env.PROJECT_NAME || (await (0, utils_1.pickNameFromPackageJson)());
-    if (!projectName) {
-        throw new Error("Project name is required");
-    }
-    const directory = options.dir || "tests";
-    const suites = options.suites && options.suites.trim() !== ""
-        ? options.suites?.split(",")
-        : undefined;
-    let tests = (0, config_parser_1.parseToken)(options.payload)?.tests ||
-        (options.name
-            ? [
-                {
-                    name: options.name,
-                    dir: directory,
-                    filePath: options.file,
-                    suites,
-                },
-            ]
-            : undefined);
-    const environmentSlug = process.env.TEST_RUN_ENVIRONMENT || "";
-    // Fetch environment variables from dashboard
-    const environmentVariables = await (0, dashboard_1.fetchEnvironmentVariables)();
-    const envOverrides = {};
-    // Convert environment variables to key-value pairs for process.env
-    environmentVariables.forEach((envVar) => {
-        envOverrides[envVar.name] = envVar.value;
-    });
-    if (Object.keys(envOverrides).length > 0) {
-        console.log(`Loaded environment variables: ${Object.keys(envOverrides).join(", ")}`);
-    }
-    let environmentSpecificProjects = [];
-    let platform = types_1.Platform.WEB;
-    try {
-        if (environmentSlug) {
-            const { environment, build: latestBuild } = await (0, dashboard_1.fetchEnvironmentAndBuild)(projectName, environmentSlug);
-            platform = environment.platform;
-            environmentSpecificProjects = environment.playwright_projects;
-            if (!process.env.BUILD_URL) {
-                process.env.BUILD_URL = latestBuild?.build_url; // pick the one coming from dispatch, otherwise use the latest build from DB
-            }
-            const buildUrl = process.env.BUILD_URL;
-            await (0, utils_1.downloadBuild)(buildUrl);
-        }
-        const projectFilters = await (0, utils_1.generateProjectFilters)({
-            platform,
-            filteringSets: [...options.project, ...environmentSpecificProjects],
-            repoDir,
-        });
-        if (options.skipTeardown) {
-            await (0, utils_1.handleTeardownSkipFlag)(directory, repoDir);
-        }
-        const hasTestsFilter = tests && tests.length > 0;
-        let commandToRun;
-        if (hasTestsFilter) {
-            commandToRun = await (0, run_specific_test_1.runSpecificTestsCmd)({
-                tests,
-                projects: projectFilters,
-                passthroughArgs: pwOptions.join(" "),
-                platform,
-                envOverrides,
-                repoDir,
-            });
-        }
-        else {
-            commandToRun = (0, run_all_tests_1.runAllTestsCmd)({
-                projects: projectFilters,
-                passthroughArgs: pwOptions.join(" "),
-                platform,
-                envOverrides,
-            });
-        }
-        const { hasTestPassed } = await (0, cmd_1.runTestsForCmd)(commandToRun, repoDir);
-        if (!hasTestPassed) {
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error("Error while running playwright test:", error.message);
-        process.exit(1);
-    }
-})();
+commander_1.program
+    .name("test-run")
+    .description("Empirical test runner CLI")
+    .version("0.13.1");
+(0, run_1.registerRunCommand)(commander_1.program);
+(0, merge_1.registerMergeCommand)(commander_1.program);
+(0, failed_list_1.registerFailedListCommand)(commander_1.program);
+(0, estimate_time_shard_1.registerEstimateTimeShardCommand)(commander_1.program);
+(0, optimize_shards_1.registerOptimizeShardsCommand)(commander_1.program);
+commander_1.program.parse(process.argv);

package/dist/failed-test-list.d.ts

@@ -0,0 +1,35 @@
+export interface TestRunResponse {
+    data: {
+        test_run: {
+            project: {
+                repo_name: string;
+            };
+            testRun: {
+                summary_url: string | null;
+                run_id: number | null;
+            };
+        };
+    } | null;
+    error?: {
+        message: string;
+    };
+}
+export interface FailedTest {
+    projectName: string;
+    file: string;
+    title: string;
+    suites: string[];
+}
+export interface BuildTestListOptions {
+    outputPath?: string;
+    verbose?: boolean;
+    repoName?: string;
+    repoPath?: string;
+}
+export interface BuildTestListResult {
+    failedTests: FailedTest[];
+    testListContent: string;
+    outputPath: string;
+}
+export declare function buildTestListFromFailedTestRun(runId: string, options?: BuildTestListOptions): Promise<BuildTestListResult>;
+//# sourceMappingURL=failed-test-list.d.ts.map

package/dist/failed-test-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failed-test-list.d.ts","sourceRoot":"","sources":["../src/failed-test-list.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE;QACJ,QAAQ,EAAE;YACR,OAAO,EAAE;gBACP,SAAS,EAAE,MAAM,CAAC;aACnB,CAAC;YACF,OAAO,EAAE;gBACP,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;gBAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;aACvB,CAAC;SACH,CAAC;KACH,GAAG,IAAI,CAAC;IACT,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AASD,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAgPD,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,8BAA8B,CAClD,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAiH9B"}

package/dist/failed-test-list.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTestListFromFailedTestRun = buildTestListFromFailedTestRun;
+const reporter_1 = require("@empiricalrun/reporter");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const DOMAIN = process.env.DASHBOARD_DOMAIN || "https://dash.empirical.run";
+const SUITES_DELIMITER = " › ";
+const REPORTS_BASE_URL = "https://reports.empirical.run";
+function buildSummaryUrl(repoName, runId) {
+    const projectSlug = repoName.replace("-tests", "");
+    return `${REPORTS_BASE_URL}/${projectSlug}/${runId}/summary.json`;
+}
+async function fetchTestRun(runId, options) {
+    if (!process.env.EMPIRICALRUN_API_KEY) {
+        throw new Error("EMPIRICALRUN_API_KEY environment variable is required");
+    }
+    const params = new URLSearchParams();
+    if (options.repoName) {
+        params.set("repo_name", options.repoName);
+    }
+    const queryString = params.toString();
+    const url = `${DOMAIN}/api/test-runs/${runId}${queryString ? `?${queryString}` : ""}`;
+    if (options.verbose) {
+        console.log(`Fetching test run from: ${url}`);
+    }
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${process.env.EMPIRICALRUN_API_KEY}`,
+        },
+    });
+    if (!response.ok) {
+        if (options.verbose) {
+            const text = await response.text();
+            console.log(`Response status: ${response.status}`);
+            console.log(`Response body: ${text}`);
+        }
+        throw new Error(`Failed to fetch test run: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
+}
+function getFailedTests(specs) {
+    const failedTests = [];
+    for (const spec of specs) {
+        for (const test of spec.tests) {
+            const status = (0, reporter_1.deriveTestStatus)(test.results);
+            if (status === "fail") {
+                const suites = spec.nesting.slice(1, -1);
+                failedTests.push({
+                    projectName: test.projectName,
+                    file: spec.file,
+                    title: spec.title,
+                    suites,
+                });
+            }
+        }
+    }
+    return failedTests;
+}
+function findTestFile(repoPath, relativePath) {
+    const directPath = path_1.default.join(repoPath, relativePath);
+    if (fs_1.default.existsSync(directPath)) {
+        return { absolutePath: directPath, repoRelativePath: relativePath };
+    }
+    const testsRelative = path_1.default.join("tests", relativePath);
+    const testDirPath = path_1.default.join(repoPath, testsRelative);
+    if (fs_1.default.existsSync(testDirPath)) {
+        return { absolutePath: testDirPath, repoRelativePath: testsRelative };
+    }
+    return null;
+}
+async function getSerialBlockInfo(test, repoPath, verbose) {
+    const fileInfo = findTestFile(repoPath, test.file);
+    if (!fileInfo) {
+        if (verbose) {
+            console.log(`File not found: ${test.file} (searched in repo and tests dir)`);
+        }
+        return null;
+    }
+    const isFileSerial = await (0, utils_1.hasTopLevelDescribeConfigureWithSerialMode)(fileInfo.absolutePath);
+    if (isFileSerial) {
+        if (verbose) {
+            console.log(`File ${test.file} is marked as serial at top level`);
+        }
+        return { file: test.file, serialDescribeName: null, isFileSerial: true };
+    }
+    const { testCaseNode } = await (0, utils_1.getTestCaseNode)({
+        filePath: fileInfo.repoRelativePath,
+        scenarioName: test.title,
+        suites: test.suites,
+        repoDir: repoPath,
+    });
+    if (testCaseNode) {
+        const parentDescribe = (0, utils_1.findFirstSerialDescribeBlock)(testCaseNode);
+        if (parentDescribe) {
+            const describeName = (0, utils_1.getDescribeBlockName)(parentDescribe);
+            if (verbose) {
+                console.log(`Test "${test.title}" is in serial describe block: ${describeName}`);
+            }
+            return {
+                file: test.file,
+                serialDescribeName: describeName ?? null,
+                isFileSerial: false,
+            };
+        }
+    }
+    return null;
+}
+function formatTestListLine(test) {
+    const suitesAndTitle = test.suites.length > 0
+        ? [...test.suites, test.title].join(SUITES_DELIMITER)
+        : test.title;
+    return `[${test.projectName}] › ${test.file} › ${suitesAndTitle}`;
+}
+function getAllTestsFromSpecs(specs) {
+    const tests = [];
+    for (const spec of specs) {
+        for (const test of spec.tests) {
+            const suites = spec.nesting.slice(1, -1);
+            tests.push({
+                projectName: test.projectName,
+                file: spec.file,
+                title: spec.title,
+                suites,
+            });
+        }
+    }
+    return tests;
+}
+function isTestInSerialBlock(test, serialBlock) {
+    if (test.file !== serialBlock.file) {
+        return false;
+    }
+    if (serialBlock.isFileSerial) {
+        return true;
+    }
+    if (serialBlock.serialDescribeName) {
+        return test.suites.includes(serialBlock.serialDescribeName);
+    }
+    return false;
+}
+function generateTestListContent(failedTests, allTests, serialBlocks = []) {
+    const lines = [
+        `# Failed tests from test run`,
+        `# Generated: ${new Date().toISOString()}`,
+        `# Total failed tests: ${failedTests.length}`,
+        "",
+    ];
+    const addedEntries = new Set();
+    for (const serialBlock of serialBlocks) {
+        const projectNames = [
+            ...new Set(failedTests
+                .filter((t) => t.file === serialBlock.file)
+                .map((t) => t.projectName)),
+        ];
+        for (const projectName of projectNames) {
+            const testsInBlock = allTests.filter((t) => t.projectName === projectName && isTestInSerialBlock(t, serialBlock));
+            for (const test of testsInBlock) {
+                const line = formatTestListLine(test);
+                if (!addedEntries.has(line)) {
+                    lines.push(line);
+                    addedEntries.add(line);
+                }
+            }
+        }
+    }
+    for (const test of failedTests) {
+        const isInSerialBlock = serialBlocks.some((s) => s.file === test.file);
+        if (!isInSerialBlock) {
+            const line = formatTestListLine(test);
+            if (!addedEntries.has(line)) {
+                lines.push(line);
+                addedEntries.add(line);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+async function buildTestListFromFailedTestRun(runId, options = {}) {
+    const verbose = options.verbose ?? false;
+    const testRunResponse = await fetchTestRun(runId, {
+        verbose,
+        repoName: options.repoName,
+    });
+    if (!testRunResponse.data) {
+        throw new Error(testRunResponse.error?.message || "Failed to fetch test run");
+    }
+    const { testRun, project } = testRunResponse.data.test_run;
+    let summaryUrl = testRun.summary_url;
+    if (!summaryUrl && testRun.run_id && project.repo_name) {
+        summaryUrl = buildSummaryUrl(project.repo_name, testRun.run_id);
+        if (verbose) {
+            console.log(`Summary URL not in DB, built from run_id: ${summaryUrl}`);
+        }
+    }
+    if (verbose) {
+        console.log(`Summary URL: ${summaryUrl}`);
+    }
+    if (!summaryUrl) {
+        throw new Error("Test run does not have a summary URL and cannot be built (missing run_id)");
+    }
+    if (verbose) {
+        console.log(`Fetching report from: ${summaryUrl}`);
+    }
+    const report = await (0, reporter_1.fetchReport)(summaryUrl);
+    if (!report) {
+        throw new Error("Failed to fetch report from summary URL");
+    }
+    if (verbose) {
+        console.log(`Report has ${report.suites.length} top-level suites`);
+    }
+    const flattenedSpecs = (0, reporter_1.getFlattenedTestList)(report.suites);
+    const allTests = getAllTestsFromSpecs(flattenedSpecs);
+    const failedTests = getFailedTests(flattenedSpecs);
+    if (failedTests.length === 0) {
+        throw new Error("No failed tests found in the report");
+    }
+    if (verbose) {
+        console.log(`Found ${failedTests.length} failed tests, ${allTests.length} total tests`);
+    }
+    const serialBlocks = [];
+    if (options.repoPath) {
+        if (verbose) {
+            console.log(`Checking for serial blocks in repo: ${options.repoPath}`);
+        }
+        for (const test of failedTests) {
+            try {
+                const serialInfo = await getSerialBlockInfo(test, options.repoPath, verbose);
+                if (serialInfo) {
+                    const alreadyAdded = serialBlocks.some((s) => s.file === serialInfo.file &&
+                        s.serialDescribeName === serialInfo.serialDescribeName &&
+                        s.isFileSerial === serialInfo.isFileSerial);
+                    if (!alreadyAdded) {
+                        serialBlocks.push(serialInfo);
+                    }
+                }
+            }
+            catch (error) {
+                if (verbose) {
+                    console.log(`Error checking serial block for ${test.title}: ${error}`);
+                }
+            }
+        }
+        if (verbose && serialBlocks.length > 0) {
+            console.log(`Found ${serialBlocks.length} serial blocks to expand`);
+        }
+    }
+    const testListContent = generateTestListContent(failedTests, allTests, serialBlocks);
+    const outputPath = options.outputPath || path_1.default.join(process.cwd(), `failed-tests-${runId}.txt`);
+    const outputDir = path_1.default.dirname(outputPath);
+    if (!fs_1.default.existsSync(outputDir)) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(outputPath, testListContent, "utf-8");
+    return {
+        failedTests,
+        testListContent,
+        outputPath,
+    };
+}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import { parseTestListOutput } from "./stdout-parser";
 import { Platform, TestCase } from "./types";
 import { getProjectsFromPlaywrightConfig } from "./utils/config";
 export { getProjectsFromPlaywrightConfig, parseTestListOutput, Platform, runSpecificTestsCmd, spawnCmd, };
+export { type BuildTestListOptions, type BuildTestListResult, buildTestListFromFailedTestRun, type FailedTest, } from "./failed-test-list";
 export * from "./glob-matcher";
 export { type CancellationWatcher, startCancellationWatcher, } from "./lib/cancellation-watcher";
 export { filterArrayByGlobMatchersSet, generateProjectFilters } from "./utils";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAI/E,OAAO,EAAkB,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAMjE,OAAO,EACL,+BAA+B,EAC/B,mBAAmB,EACnB,QAAQ,EACR,mBAAmB,EACnB,QAAQ,GACT,CAAC;AACF,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,KAAK,mBAAmB,EACxB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAc/E,wBAAsB,aAAa,CAAC,EAClC,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;CAChC,GAAG,OAAO,CAAC;IACV,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,oBAAoB,CAAC;CACnC,CAAC,CAoBD;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;CACjD,CAAC,CAeD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAI/E,OAAO,EAAkB,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAMjE,OAAO,EACL,+BAA+B,EAC/B,mBAAmB,EACnB,QAAQ,EACR,mBAAmB,EACnB,QAAQ,GACT,CAAC;AACF,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,8BAA8B,EAC9B,KAAK,UAAU,GAChB,MAAM,oBAAoB,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,KAAK,mBAAmB,EACxB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAc/E,wBAAsB,aAAa,CAAC,EAClC,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;CAChC,GAAG,OAAO,CAAC;IACV,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,oBAAoB,CAAC;CACnC,CAAC,CAoBD;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;CACjD,CAAC,CAeD"}

package/dist/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateProjectFilters = exports.filterArrayByGlobMatchersSet = exports.startCancellationWatcher = exports.spawnCmd = exports.runSpecificTestsCmd = exports.Platform = exports.parseTestListOutput = exports.getProjectsFromPlaywrightConfig = void 0;
+exports.generateProjectFilters = exports.filterArrayByGlobMatchersSet = exports.startCancellationWatcher = exports.buildTestListFromFailedTestRun = exports.spawnCmd = exports.runSpecificTestsCmd = exports.Platform = exports.parseTestListOutput = exports.getProjectsFromPlaywrightConfig = void 0;
 exports.runSingleTest = runSingleTest;
 exports.listProjectsAndTests = listProjectsAndTests;
 const fs_1 = __importDefault(require("fs"));
@@ -36,6 +36,8 @@ Object.defineProperty(exports, "getProjectsFromPlaywrightConfig", { enumerable:
 // For test-run package, the library entrypoint, we only support web platform
 // The bin entrypoint has support for mobile also
 const supportedPlatform = types_1.Platform.WEB;
+var failed_test_list_1 = require("./failed-test-list");
+Object.defineProperty(exports, "buildTestListFromFailedTestRun", { enumerable: true, get: function () { return failed_test_list_1.buildTestListFromFailedTestRun; } });
 __exportStar(require("./glob-matcher"), exports);
 var cancellation_watcher_1 = require("./lib/cancellation-watcher");
 Object.defineProperty(exports, "startCancellationWatcher", { enumerable: true, get: function () { return cancellation_watcher_1.startCancellationWatcher; } });

package/dist/lib/cancellation-watcher.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startCancellationWatcher = startCancellationWatcher;
 const DOMAIN = process.env.DASHBOARD_DOMAIN || "https://dash.empirical.run";
-const DEFAULT_POLL_INTERVAL_MS = 5000;
+const DEFAULT_POLL_INTERVAL_MS = 30_000;
 async function checkTestRunStatus(testRunId, apiKey) {
     const url = `${DOMAIN}/api/test-runs/${testRunId}/status`;
     try {

package/dist/lib/merge-reports/html.d.ts

@@ -0,0 +1,2 @@
+export declare function patchMergedHtmlReport(htmlFilePath: string, urlMappings: Record<string, string>): Promise<void>;
+//# sourceMappingURL=html.d.ts.map

package/dist/lib/merge-reports/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/lib/merge-reports/html.ts"],"names":[],"mappings":"AAwEA,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,OAAO,CAAC,IAAI,CAAC,CA8Gf"}

package/dist/lib/merge-reports/html.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchMergedHtmlReport = patchMergedHtmlReport;
+const zip_1 = require("@empiricalrun/r2-uploader/zip");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../../logger");
+const types_1 = require("./types");
+function patchHtmlReportAttachments(report, urlMap) {
+    let patchCount = 0;
+    // report.json has files[].tests[], individual test files have tests[] directly
+    const tests = report.files
+        ? report.files.flatMap((f) => f.tests)
+        : report.tests || [];
+    for (const test of tests) {
+        for (const result of test.results || []) {
+            for (const attachment of result.attachments || []) {
+                if (attachment.path) {
+                    for (const [fileName, url] of urlMap) {
+                        if (attachment.path.endsWith(fileName)) {
+                            attachment.path = url;
+                            patchCount++;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return patchCount;
+}
+async function patchMergedHtmlReport(htmlFilePath, urlMappings) {
+    if (Object.keys(urlMappings).length === 0) {
+        logger_1.logger.debug(`[Merge Reports] No URL mappings to apply`);
+        return;
+    }
+    let htmlContent;
+    const startTime = Date.now();
+    logger_1.logger.info(`[Merge Reports] Starting HTML patch...`);
+    try {
+        htmlContent = await fs_1.default.promises.readFile(htmlFilePath, "utf8");
+        logger_1.logger.info(`[Merge Reports] HTML file read: ${(htmlContent.length / 1024 / 1024).toFixed(2)} MB in ${Date.now() - startTime}ms`);
+    }
+    catch (error) {
+        logger_1.logger.error(`[Merge Reports] Failed to read HTML file:`, error);
+        return;
+    }
+    // Support both old format (1.53.x) and new format (1.57.0+)
+    const oldFormatMatch = htmlContent.match(/window\.playwrightReportBase64\s*=\s*"(?:data:application\/zip;base64,)?([^"]+)"/);
+    const newFormatMatch = htmlContent.match(/<script\s+id="playwrightReportBase64"[^>]*>(?:data:application\/zip;base64,)?([^<]+)<\/script>/);
+    const base64 = oldFormatMatch?.[1] || newFormatMatch?.[1];
+    if (!base64) {
+        logger_1.logger.error(`[Merge Reports] Base64 zip data not found in HTML`);
+        return;
+    }
+    const htmlDir = path_1.default.dirname(path_1.default.resolve(htmlFilePath));
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(htmlDir, "merge-patch-"));
+    const zipPath = path_1.default.join(tempDir, "archive.zip");
+    try {
+        let stepTime = Date.now();
+        await fs_1.default.promises.writeFile(zipPath, Buffer.from(base64, "base64"));
+        await (0, zip_1.extractZipToDirectory)(zipPath, tempDir);
+        await fs_1.default.promises.unlink(zipPath);
+        logger_1.logger.info(`[Merge Reports] Zip extracted in ${Date.now() - stepTime}ms`);
+        const jsonFiles = (await fs_1.default.promises.readdir(tempDir)).filter((f) => f.endsWith(".json"));
+        logger_1.logger.info(`[Merge Reports] Patching ${jsonFiles.length} JSON files with ${Object.keys(urlMappings).length} mappings`);
+        const urlMap = (0, types_1.buildUrlMap)(urlMappings);
+        stepTime = Date.now();
+        let totalPatchCount = 0;
+        const patchResults = await Promise.allSettled(jsonFiles.map(async (file) => {
+            const filePath = path_1.default.join(tempDir, file);
+            const content = await fs_1.default.promises.readFile(filePath, "utf8");
+            const report = JSON.parse(content);
+            const patchCount = patchHtmlReportAttachments(report, urlMap);
+            if (patchCount > 0) {
+                await fs_1.default.promises.writeFile(filePath, JSON.stringify(report), "utf8");
+                logger_1.logger.debug(`[Merge Reports] Patched ${file} (${patchCount} paths)`);
+            }
+            return patchCount;
+        }));
+        for (const result of patchResults) {
+            if (result.status === "rejected") {
+                logger_1.logger.error(`[Merge Reports] Failed to patch JSON file:`, result.reason);
+            }
+            else {
+                totalPatchCount += result.value;
+            }
+        }
+        logger_1.logger.info(`[Merge Reports] JSON patching completed in ${Date.now() - stepTime}ms (${totalPatchCount} paths patched)`);
+        stepTime = Date.now();
+        const newBuffer = await (0, zip_1.createZipFromDirectory)(tempDir);
+        const newBase64 = newBuffer.toString("base64");
+        logger_1.logger.info(`[Merge Reports] New zip created in ${Date.now() - stepTime}ms`);
+        let updatedHtml;
+        if (oldFormatMatch) {
+            updatedHtml = htmlContent.replace(/(window\.playwrightReportBase64\s*=\s*")(?:data:application\/zip;base64,)?[^"]*(")/, `$1data:application/zip;base64,${newBase64}$2`);
+        }
+        else {
+            updatedHtml = htmlContent.replace(/(<script\s+id="playwrightReportBase64"[^>]*>)(?:data:application\/zip;base64,)?[^<]*(<\/script>)/, `$1data:application/zip;base64,${newBase64}$2`);
+        }
+        await fs_1.default.promises.writeFile(htmlFilePath, updatedHtml, "utf8");
+        logger_1.logger.info(`[Merge Reports] HTML file patched successfully`);
+    }
+    catch (error) {
+        logger_1.logger.error(`[Merge Reports] Failed to patch HTML:`, error);
+    }
+    finally {
+        await fs_1.default.promises.rm(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/lib/merge-reports/index.d.ts

@@ -0,0 +1,16 @@
+import type { MergeReportsOptions, UploadOptions } from "./types";
+export { patchMergedHtmlReport } from "./html";
+export { patchSummaryJson } from "./json";
+export type { MergeReportsOptions, UploadOptions } from "./types";
+export declare function runPlaywrightMergeReports(options: MergeReportsOptions): Promise<{
+    success: boolean;
+}>;
+export declare function extractUrlMappingsFromBlobs(blobDir: string): Promise<Record<string, string>>;
+export declare function uploadMergedReports(cwd: string, outputDir: string, uploadOptions: UploadOptions): Promise<void>;
+export declare function mergeReports(options: {
+    blobDir?: string;
+    cwd?: string;
+}): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/merge-reports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/merge-reports/index.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAElE,OAAO,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAC1C,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA6BlE,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CA2B/B;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAoCjC;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,IAAI,CAAC,CAsDf;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CA8DhC"}