@alwaysmeticulous/cli 2.40.0 → 2.41.0

package/dist/parallel-tests/parallel-tests.handler.js

@@ -1,194 +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.runAllTestsInParallel = void 0;
-const os_1 = require("os");
-const common_1 = require("@alwaysmeticulous/common");
-const loglevel_1 = __importDefault(require("loglevel"));
-const merge_test_results_1 = require("./merge-test-results");
-const screenshot_diff_results_utils_1 = require("./screenshot-diff-results.utils");
-/** Handler for running Meticulous tests in parallel using child processes */
-const runAllTestsInParallel = async ({ testsToRun, parallelTasks, maxRetriesOnFailure, rerunTestsNTimes, executeTest, onTestFinished, onTestFailedToRun, }) => {
-    if (maxRetriesOnFailure && rerunTestsNTimes) {
-        throw new Error("maxRetriesOnFailure and rerunTestsNTimes are mutually exclusive.");
-    }
-    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    let nextId = 0;
-    let queue = testsToRun.map((test) => ({
-        ...test,
-        id: ++nextId,
-    }));
-    /**
-     * The current results, which may still be being updated if we're re-running a test
-     * to check for flakes.
-     */
-    const resultsByTestId = new Map();
-    /**
-     * Results that have been fully checked for flakes. At most one per test case.
-     */
-    const finalResults = [];
-    let progress = {
-        runningTestCases: queue.length,
-        failedTestCases: 0,
-        flakedTestCases: 0,
-        passedTestCases: 0,
-    };
-    const allTasksDone = (0, common_1.defer)();
-    let inProgress = 0;
-    // Average run time when testing on a 16 core machine: 16 parallel tasks @ 56s, 32 parallel tasks @ 52.5s
-    const maxTasks = parallelTasks !== null && parallelTasks !== void 0 ? parallelTasks : Math.max((0, os_1.cpus)().length, 1) * 2;
-    logger.debug(`Running with ${maxTasks} maximum tasks in parallel`);
-    // Starts running a test case in a child process
-    const startTask = (rerunnableTestCase) => {
-        const { id, ...testCase } = rerunnableTestCase;
-        const isRetry = resultsByTestId.has(id);
-        // Handle task completion
-        executeTest(testCase, isRetry)
-            .catch(() => null)
-            .then(async (result) => {
-            var _a;
-            const resultsForTestCase = resultsByTestId.get(id);
-            // Re-run the test if needed, comparing to the base replay.
-            if (!isRetry) {
-                queue.push(...Array.from(new Array(rerunTestsNTimes)).map(() => ({
-                    ...testCase,
-                    id,
-                    baseReplayId: result === null || result === void 0 ? void 0 : result.headReplayId,
-                })));
-            }
-            if (resultsForTestCase != null && result != null) {
-                logRetrySummary(testName({ id, ...testCase }), result, resultsForTestCase.currentResult);
-            }
-            if (resultsForTestCase != null &&
-                resultsForTestCase.currentResult.result === "flake") {
-                // This test has already been declared as flakey, and we can ignore this result. This result
-                // was from an already executing test that we weren't able to cancel.
-                return;
-            }
-            if ((result === null || result === void 0 ? void 0 : result.result) === "fail" && resultsForTestCase == null) {
-                // Let's auto-retry to see if this failure persists
-                queue.push(...Array.from(new Array(maxRetriesOnFailure)).map(() => ({
-                    ...testCase,
-                    id,
-                    baseReplayId: result.headReplayId,
-                })));
-            }
-            if (result == null && (resultsForTestCase === null || resultsForTestCase === void 0 ? void 0 : resultsForTestCase.currentResult) == null) {
-                // This means our original head replay failed fatally (not just a failed diff, but failed to even run)
-                progress = updateProgress(progress, "fail");
-                await (onTestFailedToRun === null || onTestFailedToRun === void 0 ? void 0 : onTestFailedToRun(progress));
-                return;
-            }
-            const mergedResult = getNewMergedResult((_a = resultsForTestCase === null || resultsForTestCase === void 0 ? void 0 : resultsForTestCase.currentResult) !== null && _a !== void 0 ? _a : null, result);
-            const numberOfRetriesExecuted = resultsForTestCase == null
-                ? 0
-                : resultsForTestCase.numberOfRetriesExecuted + 1;
-            resultsByTestId.set(id, {
-                currentResult: mergedResult,
-                numberOfRetriesExecuted,
-            });
-            // Our work is done for this test case if the first result was a pass,
-            // we've performed all the retries, or one of the retries already proved
-            // the result as flakey
-            let isFinalResult;
-            if (rerunTestsNTimes > 0) {
-                isFinalResult = numberOfRetriesExecuted >= rerunTestsNTimes;
-            }
-            else {
-                isFinalResult =
-                    mergedResult.result !== "fail" ||
-                        numberOfRetriesExecuted >= maxRetriesOnFailure;
-            }
-            if (isFinalResult) {
-                // Cancel any replays that are still scheduled
-                queue = queue.filter((otherReplay) => otherReplay.id !== id);
-                finalResults.push(mergedResult);
-                progress = updateProgress(progress, mergedResult.result);
-                await (onTestFinished === null || onTestFinished === void 0 ? void 0 : onTestFinished(progress, finalResults));
-            }
-        })
-            .catch((err) => {
-            logger.error(`Error processing result of completed task for test '${testName({
-                id,
-                ...testCase,
-            })}'`, err);
-        })
-            .finally(() => {
-            // We only decrement inProgress at the very end,
-            // otherwise another promise may call allTasksDone.resolve() while
-            // we're still saving results
-            --inProgress;
-            if (queue.length === 0 && inProgress === 0) {
-                allTasksDone.resolve();
-            }
-            process.nextTick(checkNextTask);
-        });
-    };
-    // Checks if we can start a new child process
-    const checkNextTask = () => {
-        if (inProgress >= maxTasks) {
-            return;
-        }
-        const testCase = queue.shift();
-        if (!testCase) {
-            return;
-        }
-        ++inProgress;
-        if (resultsByTestId.has(testCase.id)) {
-            if (maxRetriesOnFailure > 0) {
-                logger.info(`Test ${testName(testCase)} failed. Retrying to check for flakes...`);
-            }
-            else if (rerunTestsNTimes > 0) {
-                logger.info(`Re-running ${testName(testCase)} to check for flakes...`);
-            }
-        }
-        startTask(testCase);
-        process.nextTick(checkNextTask);
-    };
-    process.nextTick(checkNextTask);
-    await allTasksDone.promise;
-    return finalResults;
-};
-exports.runAllTestsInParallel = runAllTestsInParallel;
-const logRetrySummary = (nameOfTest, retryResult, resultSoFar) => {
-    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    if (retryResult.result === "pass") {
-        logger.info(`Retried taking screenshots for${resultSoFar.result == "fail" ? " failed" : ""} test ${nameOfTest}, but got the same results`);
-    }
-    else {
-        const numDifferingScreenshots = (0, screenshot_diff_results_utils_1.flattenScreenshotDiffResults)(retryResult).filter((result) => result.outcome !== "no-diff").length;
-        logger.info(`Retried taking screenshots for failed test ${nameOfTest}, and ${numDifferingScreenshots} screenshots came out different. Results for these screenshots are assumed to be flakes, and so will be ignored.`);
-    }
-};
-const testName = (testCase) => testCase.title != null ? `'${testCase.title}'` : `#${testCase.id + 1}`;
-const getNewMergedResult = (currentMergedResult, newResult) => {
-    // If currentMergedResult is null then this is our first try, our original head replay
-    if (currentMergedResult == null) {
-        if (newResult == null) {
-            throw new Error("Expected either newResult to be non-null or currentMergedResult to be non-null, but both were null. This case should be handled before getNewMergedResult is called");
-        }
-        // In this case the newResult is our first head replay, our first result,
-        // so lets initialize the mergedResult to this
-        return newResult;
-    }
-    // If currentMergedResult is not null then newResult is a retry, containing comparison screenshots to our original head replay
-    if (newResult == null) {
-        // In this case newResult is a retry of the head replay, but it failed fatally (not just a failed diff, but failed to even run)
-        // So we just ignore this retry
-        return currentMergedResult;
-    }
-    return (0, merge_test_results_1.mergeResults)({
-        currentResult: currentMergedResult,
-        comparisonToHeadReplay: newResult,
-    });
-};
-const updateProgress = (progress, newResult) => {
-    return {
-        runningTestCases: progress.runningTestCases - 1,
-        failedTestCases: progress.failedTestCases + (newResult === "fail" ? 1 : 0),
-        flakedTestCases: progress.flakedTestCases + (newResult === "flake" ? 1 : 0),
-        passedTestCases: progress.passedTestCases + (newResult === "pass" ? 1 : 0),
-    };
-};

package/dist/parallel-tests/run-all-tests.d.ts

@@ -1,73 +0,0 @@
-import { TestRunEnvironment } from "@alwaysmeticulous/api";
-import { ReplayExecutionOptions } from "@alwaysmeticulous/common";
-import { TestRun } from "../api/types";
-import { ScreenshotAssertionsEnabledOptions } from "../command-utils/common-types";
-import { DetailedTestCaseResult, TestCaseResult } from "../config/config.types";
-import { TestRunProgress } from "./run-all-tests.types";
-export type RunAllTestsTestRun = Pick<TestRun, "id" | "url" | "status" | "project"> & {
-    progress: TestRunProgress;
-    url: string;
-};
-export interface Options {
-    testsFile: string | null;
-    executionOptions: ReplayExecutionOptions;
-    screenshottingOptions: ScreenshotAssertionsEnabledOptions;
-    apiToken: string | null;
-    commitSha: string;
-    /**
-     * The base commit to compare test results against for test cases that don't have a baseReplayId specified.
-     */
-    baseCommitSha: string | null;
-    appUrl: string | null;
-    /**
-     * If null runs in parralel with a sensible number of parrelel tasks for the given machine.
-     *
-     * Set to 1 to disable parralelism.
-     */
-    parallelTasks: number | null;
-    /**
-     * If set to a value greater than 1 then will re-run any replays that give a screenshot diff
-     * and mark them as a flake if the screenshot generated on one of the retryed replays differs from that
-     * in the first replay.
-     */
-    maxRetriesOnFailure: number;
-    /**
-     * If set to a value greater than 0 then will re-run all replays the specified number of times
-     * and mark them as a flake if the screenshot generated on one of the retryed replays differs from that
-     * in the first replay.
-     *
-     * This is useful for checking flake rates.
-     *
-     * This option is mutually exclusive with maxRetriesOnFailure.
-     */
-    rerunTestsNTimes: number;
-    githubSummary: boolean;
-    /**
-     * If provided it will incorportate the cachedTestRunResults in any calls to store
-     * test run results in the BE, but won't include the cachedTestRunResults in the returned
-     * RunAllTestsResult.
-     */
-    cachedTestRunResults?: TestCaseResult[];
-    /**
-     * Captured environment for this run
-     */
-    environment?: TestRunEnvironment;
-    baseTestRunId: string | null;
-    onTestRunCreated?: (testRun: RunAllTestsTestRun & {
-        status: "Running";
-    }) => void;
-    onTestFinished?: (testRun: RunAllTestsTestRun & {
-        status: "Running";
-    }) => void;
-}
-export interface RunAllTestsResult {
-    testRun: RunAllTestsTestRun & {
-        status: "Success" | "Failure";
-    };
-    testCaseResults: DetailedTestCaseResult[];
-}
-/**
- * Runs all the test cases in the provided file.
- * @returns The results of the tests that were executed (note that this does not include results from any cachedTestRunResults passed in)
- */
-export declare const runAllTests: ({ testsFile, apiToken, commitSha, baseCommitSha, appUrl, executionOptions, screenshottingOptions, parallelTasks, maxRetriesOnFailure, rerunTestsNTimes, cachedTestRunResults: cachedTestRunResults_, githubSummary, environment, baseTestRunId, onTestRunCreated, onTestFinished: onTestFinished_, }: Options) => Promise<RunAllTestsResult>;

package/dist/parallel-tests/run-all-tests.js

@@ -1,237 +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.runAllTests = void 0;
-const common_1 = require("@alwaysmeticulous/common");
-const loglevel_1 = __importDefault(require("loglevel"));
-const client_1 = require("../api/client");
-const project_api_1 = require("../api/project.api");
-const replay_diff_api_1 = require("../api/replay-diff.api");
-const test_run_api_1 = require("../api/test-run.api");
-const config_1 = require("../config/config");
-const replay_assets_1 = require("../local-data/replay-assets");
-const config_utils_1 = require("../utils/config.utils");
-const github_summary_utils_1 = require("../utils/github-summary.utils");
-const run_all_tests_utils_1 = require("../utils/run-all-tests.utils");
-const test_run_environment_utils_1 = require("../utils/test-run-environment.utils");
-const version_utils_1 = require("../utils/version.utils");
-const execute_test_in_child_process_1 = require("./execute-test-in-child-process");
-const parallel_tests_handler_1 = require("./parallel-tests.handler");
-/**
- * Runs all the test cases in the provided file.
- * @returns The results of the tests that were executed (note that this does not include results from any cachedTestRunResults passed in)
- */
-const runAllTests = async ({ testsFile, apiToken, commitSha, baseCommitSha, appUrl, executionOptions, screenshottingOptions, parallelTasks, maxRetriesOnFailure, rerunTestsNTimes, cachedTestRunResults: cachedTestRunResults_, githubSummary, environment, baseTestRunId, onTestRunCreated, onTestFinished: onTestFinished_, }) => {
-    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const client = (0, client_1.createClient)({ apiToken });
-    const project = await (0, project_api_1.getProject)(client);
-    if (!project) {
-        logger.error("Could not retrieve project data. Is the API token correct?");
-        process.exit(1);
-    }
-    const cachedTestRunResults = cachedTestRunResults_ !== null && cachedTestRunResults_ !== void 0 ? cachedTestRunResults_ : [];
-    const config = await (0, config_1.readConfig)(testsFile || undefined);
-    const allTestCases = (0, run_all_tests_utils_1.mergeTestCases)(project.configurationData.testCases, config.testCases);
-    if (!allTestCases.length) {
-        throw new Error("Error! No test case defined");
-    }
-    // Only run the uncached test cases
-    const testCases = allTestCases.filter(({ sessionId, baseTestRunId, title }) => !cachedTestRunResults.find((cached) => cached.sessionId === sessionId &&
-        cached.baseTestRunId === baseTestRunId &&
-        cached.title === title));
-    const meticulousSha = await (0, version_utils_1.getMeticulousVersion)();
-    const replayEventsDependencies = await (0, replay_assets_1.loadReplayEventsDependencies)();
-    const testRun = await (0, test_run_api_1.createTestRun)({
-        client,
-        commitSha,
-        meticulousSha,
-        configData: {
-            ...config,
-            testCases: allTestCases,
-            arguments: {
-                executionOptions,
-                screenshottingOptions,
-                commitSha,
-                baseCommitSha,
-                appUrl,
-                parallelTasks,
-                githubSummary,
-            },
-            environment: (0, test_run_environment_utils_1.getEnvironment)(environment),
-        },
-    });
-    const testRunUrl = (0, test_run_api_1.getTestRunUrl)(testRun);
-    onTestRunCreated === null || onTestRunCreated === void 0 ? void 0 : onTestRunCreated({
-        id: testRun.id,
-        url: testRunUrl,
-        project: testRun.project,
-        status: "Running",
-        progress: {
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: cachedTestRunResults.length,
-            runningTestCases: testCases.length,
-        },
-    });
-    logger.info("");
-    logger.info(`Test run URL: ${testRunUrl}`);
-    logger.info("");
-    const testsToRun = await getTestCasesWithBaseTestRunId({
-        baseCommitSha,
-        baseTestRunId: baseTestRunId !== null && baseTestRunId !== void 0 ? baseTestRunId : null,
-        client,
-        logger,
-        testCases,
-    });
-    const storeTestRunResults = async (status, resultsSoFar) => {
-        const resultsToSendToBE = [
-            ...cachedTestRunResults,
-            ...resultsSoFar.map(
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            ({ screenshotDiffResultsByBaseReplayId, ...result }) => result),
-        ];
-        try {
-            await (0, test_run_api_1.putTestRunResults)({
-                client,
-                testRunId: testRun.id,
-                status,
-                resultData: {
-                    results: resultsToSendToBE,
-                },
-            });
-        }
-        catch (error) {
-            logger.error(`Error while pushing partial results: ${error}`);
-        }
-    };
-    const onProgressUpdated = async (progress) => {
-        onTestFinished_ === null || onTestFinished_ === void 0 ? void 0 : onTestFinished_({
-            id: testRun.id,
-            url: testRunUrl,
-            project: testRun.project,
-            status: "Running",
-            progress: {
-                ...progress,
-                passedTestCases: progress.passedTestCases + cachedTestRunResults.length,
-            },
-        });
-    };
-    const onTestFinished = async (progress, resultsSoFar) => {
-        onProgressUpdated(progress);
-        const newResult = resultsSoFar.at(-1);
-        if (newResult != null) {
-            for (const [baseReplayId, screenshotDiffResults] of Object.entries(newResult.screenshotDiffResultsByBaseReplayId)) {
-                await (0, replay_diff_api_1.createReplayDiff)({
-                    client,
-                    headReplayId: newResult.headReplayId,
-                    baseReplayId: baseReplayId,
-                    testRunId: testRun.id,
-                    data: {
-                        screenshotAssertionsOptions: screenshottingOptions,
-                        screenshotDiffResults,
-                    },
-                });
-            }
-        }
-        await storeTestRunResults("Running", resultsSoFar);
-    };
-    const results = await (0, parallel_tests_handler_1.runAllTestsInParallel)({
-        testsToRun,
-        parallelTasks,
-        maxRetriesOnFailure,
-        rerunTestsNTimes,
-        executeTest: (testCase, isRetry) => {
-            var _a;
-            const initMessage = {
-                kind: "init",
-                data: {
-                    logLevel: logger.getLevel(),
-                    dataDir: (0, common_1.getMeticulousLocalDataDir)(),
-                    replayOptions: {
-                        apiToken,
-                        commitSha,
-                        testCase,
-                        replayTarget: (0, config_utils_1.getReplayTargetForTestCase)({
-                            appUrl,
-                            testCase,
-                        }),
-                        executionOptions,
-                        screenshottingOptions,
-                        generatedBy: { type: "testRun", runId: testRun.id },
-                        testRunId: testRun.id,
-                        baseTestRunId: (_a = testCase.baseTestRunId) !== null && _a !== void 0 ? _a : null,
-                        replayEventsDependencies,
-                        suppressScreenshotDiffLogging: isRetry,
-                    },
-                },
-            };
-            return (0, execute_test_in_child_process_1.executeTestInChildProcess)(initMessage);
-        },
-        onTestFinished,
-        onTestFailedToRun: onProgressUpdated,
-    });
-    const sortedResults = (0, run_all_tests_utils_1.sortResults)({
-        results: results,
-        testCases: config.testCases || [],
-    });
-    const runAllFailure = sortedResults.find(({ result }) => result === "fail");
-    const overallStatus = runAllFailure ? "Failure" : "Success";
-    await storeTestRunResults(overallStatus, sortedResults);
-    logger.info("");
-    logger.info("Results");
-    logger.info("=======");
-    logger.info(`URL: ${testRunUrl}`);
-    logger.info("=======");
-    sortedResults.forEach(({ title, result }) => {
-        logger.info(`${title} => ${result}`);
-    });
-    if (githubSummary) {
-        await (0, github_summary_utils_1.writeGitHubSummary)({ testRunUrl: testRunUrl, results });
-    }
-    return {
-        testRun: {
-            url: testRunUrl,
-            id: testRun.id,
-            project: testRun.project,
-            status: overallStatus,
-            progress: {
-                flakedTestCases: sortedResults.filter(({ result }) => result === "flake").length,
-                passedTestCases: sortedResults.filter(({ result }) => result === "pass")
-                    .length,
-                failedTestCases: sortedResults.filter(({ result }) => result === "fail")
-                    .length,
-                runningTestCases: 0,
-            },
-        },
-        testCaseResults: sortedResults,
-    };
-};
-exports.runAllTests = runAllTests;
-const getTestCasesWithBaseTestRunId = async ({ logger, client, baseCommitSha, baseTestRunId, testCases, }) => {
-    const defaultBaseTestRunId = baseCommitSha != null
-        ? await (0, test_run_api_1.getLatestTestRunId)({
-            client,
-            commitSha: baseCommitSha,
-        })
-        : null;
-    const testsToRun = testCases.map((test) => {
-        // We use the baseTestRunId specified in the test case if it exists, otherwise we use
-        // use the baseTestRunId specified from the CLI args if it exists, otherwise we use the
-        // baseTestRunId for the base commit if it exists, otherwise we use null (don't compare screenshots).
-        const fallbackTestRunId = baseTestRunId !== null && baseTestRunId !== void 0 ? baseTestRunId : defaultBaseTestRunId;
-        if (test.baseTestRunId != null || fallbackTestRunId == null) {
-            return test;
-        }
-        return { ...test, baseTestRunId: fallbackTestRunId };
-    });
-    if (baseCommitSha != null) {
-        testsToRun
-            .filter((test) => test.baseTestRunId == null)
-            .forEach((test) => {
-            logger.warn(`Skipping comparisons for test "${test.title}" since no result to compare against stored for base commit ${baseCommitSha}`);
-        });
-    }
-    return testsToRun;
-};

package/dist/parallel-tests/run-all-tests.types.d.ts

@@ -1,6 +0,0 @@
-export interface TestRunProgress {
-    failedTestCases: number;
-    flakedTestCases: number;
-    passedTestCases: number;
-    runningTestCases: number;
-}

package/dist/parallel-tests/run-all-tests.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parallel-tests/screenshot-diff-results.utils.d.ts

@@ -1,7 +0,0 @@
-import { ScreenshotDiffResult } from "@alwaysmeticulous/api";
-import { DetailedTestCaseResult } from "../config/config.types";
-export type ScreenshotDiffResultWithBaseReplayId = ScreenshotDiffResult & {
-    baseReplayId: string;
-};
-export declare const flattenScreenshotDiffResults: (testCaseResult: DetailedTestCaseResult) => ScreenshotDiffResultWithBaseReplayId[];
-export declare const groupScreenshotDiffResults: (results: ScreenshotDiffResultWithBaseReplayId[]) => Record<string, ScreenshotDiffResult[]>;

package/dist/parallel-tests/screenshot-diff-results.utils.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupScreenshotDiffResults = exports.flattenScreenshotDiffResults = void 0;
-const flattenScreenshotDiffResults = (testCaseResult) => {
-    return Object.entries(testCaseResult.screenshotDiffResultsByBaseReplayId).flatMap(([baseReplayId, diffs]) => {
-        return diffs.map((diff) => ({ ...diff, baseReplayId }));
-    });
-};
-exports.flattenScreenshotDiffResults = flattenScreenshotDiffResults;
-const groupScreenshotDiffResults = (results) => {
-    const groupedResults = {};
-    results.forEach(({ baseReplayId, ...result }) => {
-        var _a;
-        const resultsForBaseReplayId = (_a = groupedResults[baseReplayId]) !== null && _a !== void 0 ? _a : [];
-        resultsForBaseReplayId.push(result);
-        groupedResults[baseReplayId] = resultsForBaseReplayId;
-    });
-    return groupedResults;
-};
-exports.groupScreenshotDiffResults = groupScreenshotDiffResults;

package/dist/parallel-tests/task.handler.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/parallel-tests/task.handler.js

@@ -1,86 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@alwaysmeticulous/common");
-const Sentry = __importStar(require("@sentry/node"));
-const loglevel_1 = __importDefault(require("loglevel"));
-const luxon_1 = require("luxon");
-const logger_utils_1 = require("../utils/logger.utils");
-const sentry_utils_1 = require("../utils/sentry.utils");
-const parallel_replay_handler_1 = require("./parallel-replay.handler");
-const INIT_TIMEOUT = luxon_1.Duration.fromObject({ second: 1 });
-const waitForInitMessage = () => {
-    return Promise.race([
-        new Promise((resolve) => {
-            const messageHandler = (message) => {
-                if (message &&
-                    typeof message === "object" &&
-                    message["kind"] === "init") {
-                    const initMessage = message;
-                    resolve(initMessage);
-                    process.off("message", messageHandler);
-                }
-            };
-            process.on("message", messageHandler);
-        }),
-        new Promise((_resolve, reject) => {
-            setTimeout(() => {
-                reject(new Error("Timed out waiting for init message"));
-            }, INIT_TIMEOUT.toMillis());
-        }),
-    ]);
-};
-const main = async () => {
-    (0, logger_utils_1.initLogger)();
-    await (0, sentry_utils_1.initSentry)();
-    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    if (!process.send) {
-        console.error("Error: not started as a child process");
-        process.exit(1);
-    }
-    const initMessage = await waitForInitMessage();
-    const { logLevel, dataDir, replayOptions } = initMessage.data;
-    logger.setLevel(logLevel);
-    (0, common_1.setMeticulousLocalDataDir)(dataDir);
-    const result = await (0, parallel_replay_handler_1.handleReplay)(replayOptions);
-    const resultMessage = {
-        kind: "result",
-        data: {
-            result,
-        },
-    };
-    process.send(resultMessage);
-    process.disconnect();
-    await Sentry.flush(sentry_utils_1.SENTRY_FLUSH_TIMEOUT.toMillis());
-};
-main().catch(async (error) => {
-    console.error(error);
-    Sentry.captureException(error);
-    await Sentry.flush(sentry_utils_1.SENTRY_FLUSH_TIMEOUT.toMillis());
-    process.exit(1);
-});

package/dist/utils/api-token.utils.d.ts

@@ -1 +0,0 @@
-export declare const getApiToken: (apiToken: string | null | undefined) => string | null;

package/dist/utils/api-token.utils.js

@@ -1,31 +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.getApiToken = void 0;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const common_1 = require("@alwaysmeticulous/common");
-const loglevel_1 = __importDefault(require("loglevel"));
-const PERSONAL_CONFIG_FILE_PATH = ".meticulous/config.json";
-const getApiToken = (apiToken) => {
-    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    if (apiToken) {
-        return apiToken;
-    }
-    if (process.env["METICULOUS_API_TOKEN"]) {
-        return process.env["METICULOUS_API_TOKEN"];
-    }
-    const personalConfigFileAbsolutePath = (0, path_1.join)((0, os_1.homedir)(), PERSONAL_CONFIG_FILE_PATH);
-    if ((0, fs_1.existsSync)(personalConfigFileAbsolutePath)) {
-        const config = JSON.parse((0, fs_1.readFileSync)(personalConfigFileAbsolutePath).toString("utf-8"));
-        if (config.apiToken) {
-            logger.info(`Using apiToken from ${personalConfigFileAbsolutePath}`);
-            return config.apiToken;
-        }
-    }
-    return null;
-};
-exports.getApiToken = getApiToken;

package/dist/utils/commit-sha.utils.d.ts

@@ -1 +0,0 @@
-export declare const getCommitSha: (commitSha: string | null | undefined) => Promise<string>;