@empiricalrun/test-run 0.16.0 → 0.17.0

package/dist/bin/commands/optimize-shards.js

@@ -1,544 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerOptimizeShardsCommand = registerOptimizeShardsCommand;
-const reporter_1 = require("@empiricalrun/reporter");
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const SUITES_DELIMITER = " › ";
-const BATCH_SIZE = 100;
-async function fetchTestHistoryBatch(testCaseIds, dashboardUrl, apiKey, cacheKey) {
-    const url = `${dashboardUrl}/api/test-cases/history/batch`;
-    const response = await fetch(url, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`,
-        },
-        body: JSON.stringify({
-            test_case_ids: testCaseIds,
-            ...(cacheKey && { cache_key: cacheKey }),
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch test history: ${response.status}`);
-    }
-    return response.json();
-}
-async function fetchTestHistory(testCaseIds, dashboardUrl, cacheKey) {
-    const apiKey = process.env.EMPIRICALRUN_API_KEY;
-    if (!apiKey) {
-        throw new Error("EMPIRICALRUN_API_KEY environment variable is required");
-    }
-    const result = {};
-    for (let i = 0; i < testCaseIds.length; i += BATCH_SIZE) {
-        const batch = testCaseIds.slice(i, i + BATCH_SIZE);
-        const batchResult = await fetchTestHistoryBatch(batch, dashboardUrl, apiKey, cacheKey);
-        Object.assign(result, batchResult);
-    }
-    return result;
-}
-function getPlaywrightTestList(shard) {
-    const shardArg = shard ? `--shard ${shard}` : "";
-    try {
-        const output = (0, child_process_1.execSync)(`npx playwright test ${shardArg} --list --reporter=json`.trim(), {
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        return JSON.parse(output);
-    }
-    catch (error) {
-        if (error.stdout) {
-            try {
-                return JSON.parse(error.stdout);
-            }
-            catch {
-                throw new Error(`Failed to parse playwright JSON output: ${error.message}`);
-            }
-        }
-        throw new Error(`Failed to get test list from playwright: ${error.message}`);
-    }
-}
-function getShardInfoReporterPath() {
-    try {
-        const reporterPath = require.resolve("@empiricalrun/reporter/shard-info-reporter");
-        return reporterPath;
-    }
-    catch {
-        const fallbackPath = path_1.default.resolve(__dirname, "../../../../reporter/dist/shard-info-reporter.js");
-        if (fs_1.default.existsSync(fallbackPath)) {
-            return fallbackPath;
-        }
-        throw new Error("Could not resolve @empiricalrun/reporter/shard-info-reporter. " +
-            "Make sure @empiricalrun/reporter is installed.");
-    }
-}
-function getShardInfoReport() {
-    const reporterPath = getShardInfoReporterPath();
-    try {
-        const output = (0, child_process_1.execSync)(`npx playwright test --list --reporter=${reporterPath}`, {
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        return JSON.parse(output);
-    }
-    catch (error) {
-        if (error.stdout) {
-            try {
-                return JSON.parse(error.stdout);
-            }
-            catch {
-                throw new Error(`Failed to parse shard info output: ${error.message}`);
-            }
-        }
-        throw new Error(`Failed to get shard info from playwright: ${error.message}`);
-    }
-}
-function extractSuiteMetadata(suites, configFullyParallel) {
-    const metadata = new Map();
-    function traverse(suite, parentParallelMode) {
-        let effectiveMode;
-        if (suite.parallelMode !== "none") {
-            effectiveMode = suite.parallelMode;
-        }
-        else if (parentParallelMode !== "none") {
-            effectiveMode = parentParallelMode;
-        }
-        else if (configFullyParallel) {
-            effectiveMode = "parallel";
-        }
-        else {
-            effectiveMode = "default";
-        }
-        const specIds = suite.specs.map((s) => s.id);
-        if (specIds.length > 0) {
-            const key = `${suite.file}:${suite.line}`;
-            metadata.set(key, {
-                file: suite.file,
-                line: suite.line,
-                parallelMode: effectiveMode,
-                hasBeforeAllHooks: suite.hasBeforeAllHooks,
-                hasAfterAllHooks: suite.hasAfterAllHooks,
-                specIds,
-            });
-        }
-        for (const child of suite.suites) {
-            traverse(child, effectiveMode);
-        }
-    }
-    for (const suite of suites) {
-        traverse(suite, "none");
-    }
-    return metadata;
-}
-function buildSpecToGroupKeyMap(suiteMetadata) {
-    const specToGroupKey = new Map();
-    for (const [suiteKey, meta] of suiteMetadata) {
-        for (const specId of meta.specIds) {
-            if (meta.parallelMode === "serial" || meta.parallelMode === "default") {
-                specToGroupKey.set(specId, `file:${meta.file}`);
-            }
-            else if (meta.hasBeforeAllHooks || meta.hasAfterAllHooks) {
-                specToGroupKey.set(specId, `hooks:${suiteKey}`);
-            }
-            else {
-                specToGroupKey.set(specId, `test:${specId}`);
-            }
-        }
-    }
-    return specToGroupKey;
-}
-function flattenedSpecsToTestInfos(specs, historyResponse, includeRetries, defaultDuration, specToGroupKey) {
-    const tests = [];
-    for (const spec of specs) {
-        for (const test of spec.tests) {
-            const history = historyResponse[spec.id] || [];
-            let estimatedDuration = defaultDuration;
-            if (history.length > 0) {
-                const durationField = includeRetries
-                    ? "duration_total"
-                    : "duration_per_retry";
-                const durations = history
-                    .map((r) => r[durationField])
-                    .sort((a, b) => a - b);
-                const p75Index = Math.floor(durations.length * 0.75);
-                estimatedDuration =
-                    durations[Math.min(p75Index, durations.length - 1)] ??
-                        defaultDuration;
-            }
-            const baseGroupKey = specToGroupKey?.get(spec.id) ?? `test:${spec.id}`;
-            const groupKey = `${test.projectName}:${baseGroupKey}`;
-            tests.push({
-                id: spec.id,
-                title: spec.title,
-                file: spec.file,
-                projectName: test.projectName,
-                nesting: spec.nesting,
-                suitesString: spec.suitesString,
-                estimatedDuration,
-                groupKey,
-            });
-        }
-    }
-    return tests;
-}
-function buildTestGroups(tests) {
-    const groupMap = new Map();
-    for (const test of tests) {
-        let group = groupMap.get(test.groupKey);
-        if (!group) {
-            group = {
-                key: test.groupKey,
-                tests: [],
-                totalDuration: 0,
-            };
-            groupMap.set(test.groupKey, group);
-        }
-        group.tests.push(test);
-        group.totalDuration += test.estimatedDuration;
-    }
-    return [...groupMap.values()];
-}
-function packGroupsIntoShards(groups, numShards) {
-    // Deterministic sort: by duration DESC, then by key ASC for stability
-    const sorted = [...groups].sort((a, b) => {
-        const durationDiff = b.totalDuration - a.totalDuration;
-        if (durationDiff !== 0)
-            return durationDiff;
-        return a.key.localeCompare(b.key);
-    });
-    const shards = Array.from({ length: numShards }, (_, i) => ({
-        index: i + 1,
-        groups: [],
-        tests: [],
-        totalDuration: 0,
-    }));
-    if (shards.length === 0) {
-        return shards;
-    }
-    for (const group of sorted) {
-        // Deterministic selection: pick lowest index shard when durations are equal
-        let targetShard = shards[0];
-        for (const shard of shards) {
-            if (shard.totalDuration < targetShard.totalDuration) {
-                targetShard = shard;
-            }
-        }
-        targetShard.groups.push(group);
-        targetShard.tests.push(...group.tests);
-        targetShard.totalDuration += group.totalDuration;
-    }
-    return shards;
-}
-function formatTestListLine(test) {
-    const suites = test.nesting.slice(1, -1);
-    const suitesAndTitle = suites.length > 0
-        ? [...suites, test.title].join(SUITES_DELIMITER)
-        : test.title;
-    return `[${test.projectName}] › ${test.file} › ${suitesAndTitle}`;
-}
-function generateTestListContent(shard, workers) {
-    const parallelizedDuration = shard.totalDuration / workers;
-    const totalSeconds = Math.round(parallelizedDuration / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    const lines = [
-        `# Shard ${shard.index} - Optimized bin packing`,
-        `# Tests: ${shard.tests.length}`,
-        `# Total duration: ${Math.round(shard.totalDuration)}ms`,
-        `# Estimated with ${workers} workers: ${minutes}m ${seconds}s`,
-        `# Generated: ${new Date().toISOString()}`,
-        "",
-    ];
-    for (const test of shard.tests) {
-        lines.push(formatTestListLine(test));
-    }
-    return lines.join("\n");
-}
-function formatDuration(ms, workers) {
-    const parallelizedDuration = ms / workers;
-    const totalSeconds = Math.round(parallelizedDuration / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    return `${minutes}m ${seconds}s`;
-}
-function buildProjectDurations(tests) {
-    const projectDurations = new Map();
-    for (const t of tests) {
-        const prev = projectDurations.get(t.projectName) ?? 0;
-        projectDurations.set(t.projectName, prev + t.estimatedDuration);
-    }
-    return projectDurations;
-}
-function moveTest(test, from, to) {
-    const idx = from.tests.findIndex((t) => t.id === test.id && t.projectName === test.projectName);
-    if (idx !== -1)
-        from.tests.splice(idx, 1);
-    to.tests.push(test);
-    from.totalDuration -= test.estimatedDuration;
-    to.totalDuration += test.estimatedDuration;
-    const project = test.projectName;
-    const fromDur = (from.projectDurations.get(project) ?? 0) - test.estimatedDuration;
-    if (fromDur <= 0)
-        from.projectDurations.delete(project);
-    else
-        from.projectDurations.set(project, fromDur);
-    const toDur = (to.projectDurations.get(project) ?? 0) + test.estimatedDuration;
-    to.projectDurations.set(project, toDur);
-}
-function isParallelTest(test) {
-    return test.groupKey.includes(":test:");
-}
-function buildMoveCandidates(tests) {
-    const parallelTests = [];
-    const groupedTests = new Map();
-    for (const t of tests) {
-        if (isParallelTest(t)) {
-            parallelTests.push({ tests: [t], totalDuration: t.estimatedDuration });
-        }
-        else {
-            const group = groupedTests.get(t.groupKey) ?? [];
-            group.push(t);
-            groupedTests.set(t.groupKey, group);
-        }
-    }
-    const serialGroups = [...groupedTests.values()].map((group) => ({
-        tests: group,
-        totalDuration: group.reduce((sum, t) => sum + t.estimatedDuration, 0),
-    }));
-    return [...parallelTests, ...serialGroups];
-}
-function tryMoveOneGroup(heavyShard, allShards, currentMakespan) {
-    const destCandidates = [...allShards]
-        .filter((s) => s.index !== heavyShard.index)
-        .sort((a, b) => a.totalDuration - b.totalDuration);
-    const moveCandidates = buildMoveCandidates(heavyShard.tests);
-    moveCandidates.sort((a, b) => b.totalDuration - a.totalDuration);
-    for (const dest of destCandidates) {
-        const uninvolvedShardsMax = Math.max(...allShards
-            .filter((s) => s.index !== heavyShard.index && s.index !== dest.index)
-            .map((s) => s.totalDuration), 0);
-        const eligibleCandidates = moveCandidates.filter((c) => c.tests.every((t) => dest.projectDurations.has(t.projectName)));
-        if (eligibleCandidates.length === 0)
-            continue;
-        for (const candidate of eligibleCandidates) {
-            const newHeavyDuration = heavyShard.totalDuration - candidate.totalDuration;
-            const newDestDuration = dest.totalDuration + candidate.totalDuration;
-            const newMakespan = Math.max(newHeavyDuration, newDestDuration, uninvolvedShardsMax);
-            if (newMakespan < currentMakespan) {
-                for (const t of candidate.tests) {
-                    moveTest(t, heavyShard, dest);
-                }
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function rebalanceShardsIncrementally(shards, options) {
-    const maxMoves = options?.maxMoves ?? 1000;
-    const minImbalanceMs = options?.minImbalanceMs ?? 0;
-    const getMakespan = () => Math.max(...shards.map((s) => s.totalDuration));
-    const getImbalance = () => {
-        const durations = shards.map((s) => s.totalDuration);
-        return Math.max(...durations) - Math.min(...durations);
-    };
-    let moves = 0;
-    while (moves < maxMoves) {
-        const imbalance = getImbalance();
-        if (imbalance <= minImbalanceMs)
-            break;
-        const currentMakespan = getMakespan();
-        const shardsByDuration = [...shards].sort((a, b) => b.totalDuration - a.totalDuration);
-        let moved = false;
-        for (const heavyShard of shardsByDuration) {
-            if (heavyShard.totalDuration < currentMakespan * 0.9)
-                break;
-            if (tryMoveOneGroup(heavyShard, shards, currentMakespan)) {
-                moved = true;
-                break;
-            }
-        }
-        if (!moved)
-            break;
-        moves++;
-    }
-    return shards;
-}
-function registerOptimizeShardsCommand(program) {
-    program
-        .command("optimize-shards")
-        .description("Generate optimized shard test-list files using bin packing algorithm")
-        .requiredOption("--shards <count>", "Number of shards to create")
-        .option("--dashboard-url <url>", "Dashboard URL for fetching test history", process.env.DASHBOARD_DOMAIN || "https://dash.empirical.run")
-        .option("--workers <workers>", "Number of parallel workers per shard", "8")
-        .option("--include-retries", "Use total duration including retries (accounts for flakiness)", false)
-        .option("--default-duration <ms>", "Default duration for tests without history", "30000")
-        .option("--output-dir <dir>", "Output directory for test-list files", "./shards")
-        .option("--cache-key <key>", "Cache key for duration data (e.g., commit SHA). Ensures all workers see same data.")
-        .option("--strategy <strategy>", "Optimization strategy: 'lpt' (bin packing from scratch) or 'incremental' (improve Playwright defaults)", "incremental")
-        .action(async (options) => {
-        const { shards: shardCountStr, dashboardUrl, includeRetries, outputDir, cacheKey, strategy, } = options;
-        const workers = parseInt(options.workers, 10);
-        const shardCount = parseInt(shardCountStr, 10);
-        const defaultDuration = parseInt(options.defaultDuration, 10);
-        if (shardCount < 1) {
-            console.error("Shard count must be at least 1");
-            process.exit(1);
-        }
-        console.log(`Fetching test metadata from playwright...`);
-        const shardInfoReport = getShardInfoReport();
-        const allTestsReport = getPlaywrightTestList();
-        const allSpecs = (0, reporter_1.getFlattenedTestList)(allTestsReport.suites);
-        if (allSpecs.length === 0) {
-            console.log("No tests found.");
-            process.exit(0);
-        }
-        const testCaseIds = allSpecs.map((spec) => spec.id);
-        console.log(`Found ${testCaseIds.length} tests. Fetching history...`);
-        let historyResponse = {};
-        try {
-            historyResponse = await fetchTestHistory(testCaseIds, dashboardUrl, cacheKey);
-        }
-        catch (error) {
-            console.error("Failed to fetch test history:", error.message);
-            process.exit(1);
-        }
-        const testsWithHistory = testCaseIds.filter((id) => (historyResponse[id]?.length ?? 0) > 0).length;
-        console.log(`History found for ${testsWithHistory}/${testCaseIds.length} tests`);
-        const configFullyParallel = shardInfoReport.config.fullyParallel;
-        console.log(`Config fullyParallel: ${configFullyParallel}`);
-        const suiteMetadata = extractSuiteMetadata(shardInfoReport.suites, configFullyParallel);
-        const specToGroupKey = buildSpecToGroupKeyMap(suiteMetadata);
-        const serialCount = [...specToGroupKey.values()].filter((k) => k.startsWith("file:")).length;
-        const parallelCount = [...specToGroupKey.values()].filter((k) => k.startsWith("test:")).length;
-        const hooksCount = [...specToGroupKey.values()].filter((k) => k.startsWith("hooks:")).length;
-        console.log(`Test grouping: ${parallelCount} parallel, ${serialCount} serial/default, ${hooksCount} with hooks`);
-        const allTests = flattenedSpecsToTestInfos(allSpecs, historyResponse, includeRetries, defaultDuration, specToGroupKey);
-        const validStrategies = ["lpt", "incremental"];
-        if (!validStrategies.includes(strategy)) {
-            console.error(`Invalid strategy: ${strategy}. Must be one of: ${validStrategies.join(", ")}`);
-            process.exit(1);
-        }
-        console.log(`\n--- Playwright Default Sharding ---`);
-        const defaultShards = [];
-        for (let i = 1; i <= shardCount; i++) {
-            const shardReport = getPlaywrightTestList(`${i}/${shardCount}`);
-            const shardSpecs = (0, reporter_1.getFlattenedTestList)(shardReport.suites);
-            const shardTests = flattenedSpecsToTestInfos(shardSpecs, historyResponse, includeRetries, defaultDuration);
-            const totalDuration = shardTests.reduce((sum, t) => sum + t.estimatedDuration, 0);
-            defaultShards.push({
-                index: i,
-                tests: shardTests,
-                totalDuration,
-                projectDurations: buildProjectDurations(shardTests),
-            });
-            console.log(`  Shard ${i}/${shardCount}: ${shardTests.length} tests, ~${formatDuration(totalDuration, workers)}`);
-        }
-        const playwrightMaxDuration = Math.max(...defaultShards.map((s) => s.totalDuration));
-        const playwrightMinDuration = Math.min(...defaultShards.map((s) => s.totalDuration));
-        console.log(`  Makespan (max shard): ${formatDuration(playwrightMaxDuration, workers)}`);
-        console.log(`  Imbalance: ${formatDuration(playwrightMaxDuration - playwrightMinDuration, workers)}`);
-        let finalShards;
-        let optimizedMaxDuration;
-        let optimizedMinDuration;
-        if (strategy === "lpt") {
-            console.log(`\n--- Optimized Bin Packing (LPT) ---`);
-            const testGroups = buildTestGroups(allTests);
-            console.log(`  Built ${testGroups.length} test groups from ${allTests.length} tests`);
-            const lptShards = packGroupsIntoShards(testGroups, shardCount);
-            finalShards = lptShards.map((s) => ({
-                index: s.index,
-                tests: s.tests,
-                totalDuration: s.totalDuration,
-                projectDurations: buildProjectDurations(s.tests),
-            }));
-            for (const shard of finalShards) {
-                console.log(`  Shard ${shard.index}/${shardCount}: ${shard.tests.length} tests, ~${formatDuration(shard.totalDuration, workers)}`);
-            }
-        }
-        else {
-            console.log(`\n--- Incremental Project-aware Rebalancing ---`);
-            const shardsToRebalance = defaultShards.map((s) => ({
-                index: s.index,
-                tests: [...s.tests],
-                totalDuration: s.totalDuration,
-                projectDurations: new Map(s.projectDurations),
-            }));
-            finalShards = rebalanceShardsIncrementally(shardsToRebalance, {
-                minImbalanceMs: workers * 5000,
-                maxMoves: 1000,
-            });
-            for (const shard of finalShards) {
-                console.log(`  Shard ${shard.index}/${shardCount}: ${shard.tests.length} tests, ~${formatDuration(shard.totalDuration, workers)}`);
-            }
-        }
-        optimizedMaxDuration = Math.max(...finalShards.map((s) => s.totalDuration));
-        optimizedMinDuration = Math.min(...finalShards.map((s) => s.totalDuration));
-        console.log(`  Makespan (max shard): ${formatDuration(optimizedMaxDuration, workers)}`);
-        console.log(`  Imbalance: ${formatDuration(optimizedMaxDuration - optimizedMinDuration, workers)}`);
-        const improvement = ((playwrightMaxDuration - optimizedMaxDuration) /
-            playwrightMaxDuration) *
-            100;
-        console.log(`\n  Improvement: ${improvement.toFixed(1)}% faster makespan`);
-        const absoluteOutputDir = path_1.default.isAbsolute(outputDir)
-            ? outputDir
-            : path_1.default.join(process.cwd(), outputDir);
-        if (!fs_1.default.existsSync(absoluteOutputDir)) {
-            fs_1.default.mkdirSync(absoluteOutputDir, { recursive: true });
-        }
-        console.log(`\n--- Writing Test List Files ---`);
-        for (const shard of finalShards) {
-            const shardForContent = {
-                index: shard.index,
-                groups: [],
-                tests: shard.tests,
-                totalDuration: shard.totalDuration,
-            };
-            const content = generateTestListContent(shardForContent, workers);
-            const filePath = path_1.default.join(absoluteOutputDir, `shard-${shard.index}.txt`);
-            fs_1.default.writeFileSync(filePath, content, "utf-8");
-            console.log(`  Written: ${filePath}`);
-        }
-        const comparison = finalShards.map((os) => {
-            const pw = defaultShards.find((p) => p.index === os.index);
-            return {
-                shardIndex: os.index,
-                playwrightTestCount: pw.tests.length,
-                playwrightEstimatedMs: Math.round(pw.totalDuration / workers),
-                optimizedTestCount: os.tests.length,
-                optimizedEstimatedMs: Math.round(os.totalDuration / workers),
-            };
-        });
-        const summaryPath = path_1.default.join(absoluteOutputDir, "summary.json");
-        fs_1.default.writeFileSync(summaryPath, JSON.stringify({
-            generatedAt: new Date().toISOString(),
-            shardCount,
-            workers,
-            strategy,
-            totalTests: allTests.length,
-            testsWithHistory,
-            testsWithoutHistory: allTests.length - testsWithHistory,
-            includeRetries,
-            defaultDurationMs: defaultDuration,
-            playwright: {
-                makespanMs: Math.round(playwrightMaxDuration / workers),
-                imbalanceMs: Math.round((playwrightMaxDuration - playwrightMinDuration) / workers),
-            },
-            optimized: {
-                makespanMs: Math.round(optimizedMaxDuration / workers),
-                imbalanceMs: Math.round((optimizedMaxDuration - optimizedMinDuration) / workers),
-            },
-            improvementPercent: parseFloat(improvement.toFixed(1)),
-            shards: comparison,
-        }, null, 2), "utf-8");
-        console.log(`  Written: ${summaryPath}`);
-        console.log(`\nDone! Run shards with:`);
-        for (let i = 1; i <= shardCount; i++) {
-            console.log(`  npx playwright test --test-list ${path_1.default.join(outputDir, `shard-${i}.txt`)}`);
-        }
-    });
-}

package/dist/lib/cancellation-watcher.d.ts

@@ -1,5 +0,0 @@
-export type CancellationWatcher = {
-    stop: () => void;
-};
-export declare function startCancellationWatcher(testRunId: string, apiKey: string, onCancel: () => void, pollIntervalMs?: number): CancellationWatcher;
-//# sourceMappingURL=cancellation-watcher.d.ts.map

package/dist/lib/cancellation-watcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cancellation-watcher.d.ts","sourceRoot":"","sources":["../../src/lib/cancellation-watcher.ts"],"names":[],"mappings":"AAqCA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,IAAI,EACpB,cAAc,SAA2B,GACxC,mBAAmB,CAgCrB"}

package/dist/lib/cancellation-watcher.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startCancellationWatcher = startCancellationWatcher;
-const DOMAIN = process.env.DASHBOARD_DOMAIN || "https://dash.empirical.run";
-const DEFAULT_POLL_INTERVAL_MS = 30_000;
-async function checkTestRunStatus(testRunId, apiKey) {
-    const url = `${DOMAIN}/api/test-runs/${testRunId}/status`;
-    try {
-        const response = await fetch(url, {
-            headers: { Authorization: `Bearer ${apiKey}` },
-        });
-        if (!response.ok) {
-            console.log(`[CancellationWatcher] Failed to check status: HTTP ${response.status} from ${url}`);
-            return { isTerminal: false, status: null };
-        }
-        const result = (await response.json());
-        const status = result.data || { isTerminal: false, status: null };
-        return status;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.log(`[CancellationWatcher] Failed to check status: ${message}`);
-        return { isTerminal: false, status: null };
-    }
-}
-function startCancellationWatcher(testRunId, apiKey, onCancel, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
-    let stopped = false;
-    console.log(`[CancellationWatcher] Starting watcher for test run ${testRunId} (polling every ${pollIntervalMs}ms)`);
-    console.log(`[CancellationWatcher] Dashboard domain: ${DOMAIN}`);
-    const poll = async () => {
-        while (!stopped) {
-            const { status } = await checkTestRunStatus(testRunId, apiKey);
-            if (status === "cancelling" || status === "cancelled") {
-                console.log(`[CancellationWatcher] Test run ${testRunId} is ${status}, triggering cancellation`);
-                onCancel();
-                stopped = true;
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-        }
-    };
-    poll();
-    return {
-        stop: () => {
-            console.log(`[CancellationWatcher] Stopping watcher for ${testRunId}`);
-            stopped = true;
-        },
-    };
-}