@alwaysmeticulous/cli 2.7.0 → 2.11.0

package/dist/api/replay-diff.api.d.ts

@@ -0,0 +1,13 @@
+import { ReplayDiff, ReplayDiffData } from "@alwaysmeticulous/api";
+import { AxiosInstance } from "axios";
+export declare const getReplayDiff: ({ client, replayDiffId, }: {
+    client: AxiosInstance;
+    replayDiffId: string;
+}) => Promise<ReplayDiff | null>;
+export declare const createReplayDiff: ({ client, headReplayId, baseReplayId, testRunId, data: replayDiffData, }: {
+    client: AxiosInstance;
+    headReplayId: string;
+    baseReplayId: string;
+    testRunId: string | null;
+    data: ReplayDiffData;
+}) => Promise<ReplayDiff>;

package/dist/api/replay-diff.api.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReplayDiff = exports.getReplayDiff = void 0;
+const axios_1 = __importDefault(require("axios"));
+const getReplayDiff = async ({ client, replayDiffId, }) => {
+    const { data } = await client
+        .get(`replay-diffs/${replayDiffId}`)
+        .catch((error) => {
+        var _a;
+        if (axios_1.default.isAxiosError(error)) {
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                return { data: null };
+            }
+        }
+        throw error;
+    });
+    return data;
+};
+exports.getReplayDiff = getReplayDiff;
+const createReplayDiff = async ({ client, headReplayId, baseReplayId, testRunId, data: replayDiffData, }) => {
+    const { data } = await client.post("replay-diffs", {
+        headReplayId,
+        baseReplayId,
+        ...(testRunId ? { testRunId } : {}),
+        data: replayDiffData,
+    });
+    return data;
+};
+exports.createReplayDiff = createReplayDiff;

package/dist/commands/replay/replay.command.d.ts

@@ -7,8 +7,9 @@ export interface ReplayOptions extends AdditionalReplayOptions {
     screenshottingOptions: ScreenshotAssertionsOptions;
     exitOnMismatch: boolean;
     generatedBy: GeneratedBy;
+    testRunId: string | null;
 }
-export declare const replayCommandHandler: ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, generatedBy, }: ReplayOptions) => Promise<Replay>;
+export declare const replayCommandHandler: ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, generatedBy, testRunId, }: ReplayOptions) => Promise<Replay>;
 export interface RawReplayCommandHandlerOptions extends ScreenshotDiffOptions, Omit<ReplayExecutionOptions, "maxDurationMs" | "maxEventCount">, AdditionalReplayOptions {
     screenshot: boolean;
     appUrl: string | null | undefined;

package/dist/commands/replay/replay.command.js

@@ -10,6 +10,7 @@ const common_1 = require("@alwaysmeticulous/common");
 const loglevel_1 = __importDefault(require("loglevel"));
 const luxon_1 = require("luxon");
 const client_1 = require("../../api/client");
+const replay_diff_api_1 = require("../../api/replay-diff.api");
 const replay_api_1 = require("../../api/replay.api");
 const upload_1 = require("../../api/upload");
 const archive_1 = require("../../archive/archive");
@@ -24,7 +25,7 @@ const commit_sha_utils_1 = require("../../utils/commit-sha.utils");
 const config_utils_1 = require("../../utils/config.utils");
 const version_utils_1 = require("../../utils/version.utils");
 const screenshot_diff_command_1 = require("../screenshot-diff/screenshot-diff.command");
-const replayCommandHandler = async ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, generatedBy, }) => {
+const replayCommandHandler = async ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, generatedBy, testRunId, }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const client = (0, client_1.createClient)({ apiToken });
     // 1. Check session files
@@ -73,6 +74,7 @@ const replayCommandHandler = async ({ replayTarget, executionOptions, screenshot
         recordingId: "manual-replay",
         meticulousSha: "meticulousSha",
         generatedBy,
+        testRunId,
         dependencies: {
             browserUserInteractions: {
                 key: "browserUserInteractions",
@@ -152,15 +154,38 @@ const replayCommandHandler = async ({ replayTarget, executionOptions, screenshot
         await (0, replays_1.getOrFetchReplayArchive)(client, baseReplayId);
         const baseReplayScreenshotsDir = (0, replays_1.getScreenshotsDir)((0, replays_1.getReplayDir)(baseReplayId));
         const headReplayScreenshotsDir = (0, replays_1.getScreenshotsDir)(tempDir);
-        await (0, screenshot_diff_command_1.diffScreenshots)({
+        const screenshotDiffResults = await (0, screenshot_diff_command_1.diffScreenshots)({
             client,
             baseReplayId,
             headReplayId: replay.id,
             baseScreenshotsDir: baseReplayScreenshotsDir,
             headScreenshotsDir: headReplayScreenshotsDir,
             diffOptions: screenshottingOptions.diffOptions,
-            exitOnMismatch: !!exitOnMismatch,
         });
+        const replayDiff = await (0, replay_diff_api_1.createReplayDiff)({
+            client,
+            headReplayId: replay.id,
+            baseReplayId,
+            testRunId,
+            data: {
+                screenshotAssertionsOptions: screenshottingOptions,
+                screenshotDiffResults,
+            },
+        });
+        logger.debug(replayDiff);
+        try {
+            (0, screenshot_diff_command_1.checkScreenshotDiffResult)({
+                baseReplayId,
+                headReplayId: replay.id,
+                results: screenshotDiffResults,
+                diffOptions: screenshottingOptions.diffOptions,
+            });
+        }
+        catch (error) {
+            if (exitOnMismatch) {
+                throw error;
+            }
+        }
     }
     // 13. Add test case to meticulous.json if --save option is passed
     if (save) {
@@ -237,6 +262,7 @@ const rawReplayCommandHandler = ({ apiToken, commitSha, sessionId, appUrl, simul
         save,
         exitOnMismatch: true,
         generatedBy: generatedByOption,
+        testRunId: null,
     });
 };
 exports.rawReplayCommandHandler = rawReplayCommandHandler;

package/dist/commands/run-all-tests/run-all-tests.command.js

@@ -98,6 +98,7 @@ const handler = async ({ apiToken, commitSha: commitSha_, appUrl, useAssetsSnaps
                 commitSha,
                 deflake: deflake !== null && deflake !== void 0 ? deflake : false,
                 generatedBy: { type: "testRun", runId: testRun.id },
+                testRunId: testRun.id,
             });
             results.push(result);
             await (0, test_run_api_1.putTestRunResults)({

package/dist/commands/screenshot-diff/screenshot-diff.command.d.ts

@@ -1,37 +1,30 @@
 /// <reference types="yargs" />
+import { ScreenshotDiffOptions, ScreenshotDiffResult } from "@alwaysmeticulous/api";
 import { AxiosInstance } from "axios";
-import { ScreenshotDiffOptions } from "../../command-utils/common-types";
-import { CompareImageResult } from "../../image/diff.utils";
-export declare class DiffError extends Error {
+export declare const diffScreenshots: ({ client, headReplayId, baseReplayId, headScreenshotsDir, baseScreenshotsDir, diffOptions, }: {
+    client: AxiosInstance;
+    baseReplayId: string;
+    headReplayId: string;
+    baseScreenshotsDir: string;
+    headScreenshotsDir: string;
+    diffOptions: ScreenshotDiffOptions;
+}) => Promise<ScreenshotDiffResult[]>;
+export declare const checkScreenshotDiffResult: ({ baseReplayId, headReplayId, results, diffOptions, }: {
+    baseReplayId: string;
+    headReplayId: string;
+    results: ScreenshotDiffResult[];
+    diffOptions: ScreenshotDiffOptions;
+}) => void;
+export declare class ScreenshotDiffError extends Error {
     readonly extras?: {
         baseReplayId: string;
         headReplayId: string;
-        threshold: number;
-        value?: number;
     } | undefined;
     constructor(message: string, extras?: {
         baseReplayId: string;
         headReplayId: string;
-        threshold: number;
-        value?: number;
     } | undefined);
 }
-declare type ComparisonOutcome = "pass" | "fail";
-export interface ScreenshotDiffResult {
-    baseScreenshotFile: string;
-    headScreenshotFile: string;
-    outcome: ComparisonOutcome;
-    comparisonResult: CompareImageResult;
-}
-export declare const diffScreenshots: (options: {
-    client: AxiosInstance;
-    baseReplayId: string;
-    headReplayId: string;
-    baseScreenshotsDir: string;
-    headScreenshotsDir: string;
-    diffOptions: ScreenshotDiffOptions;
-    exitOnMismatch: boolean;
-}) => Promise<ScreenshotDiffResult[]>;
 export declare const screenshotDiff: import("yargs").CommandModule<unknown, import("yargs").InferredOptionTypes<{
     apiToken: {
         string: true;
@@ -57,4 +50,3 @@ export declare const screenshotDiff: import("yargs").CommandModule<unknown, impo
         readonly default: 0.01;
     };
 }>>;
-export {};

package/dist/commands/screenshot-diff/screenshot-diff.command.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.screenshotDiff = exports.diffScreenshots = exports.DiffError = void 0;
+exports.screenshotDiff = exports.ScreenshotDiffError = exports.checkScreenshotDiffResult = exports.diffScreenshots = void 0;
 const path_1 = require("path");
 const common_1 = require("@alwaysmeticulous/common");
 const loglevel_1 = __importDefault(require("loglevel"));
@@ -15,116 +15,163 @@ const diff_utils_1 = require("../../image/diff.utils");
 const io_utils_1 = require("../../image/io.utils");
 const replays_1 = require("../../local-data/replays");
 const screenshot_diffs_1 = require("../../local-data/screenshot-diffs");
-class DiffError extends Error {
-    constructor(message, extras) {
-        super(message);
-        this.extras = extras;
-    }
-}
-exports.DiffError = DiffError;
-const diffScreenshots = async ({ client, baseReplayId, headReplayId, baseScreenshotsDir, headScreenshotsDir, diffOptions, exitOnMismatch, }) => {
-    const { diffThreshold, diffPixelThreshold } = diffOptions;
+const diffScreenshots = async ({ client, headReplayId, baseReplayId, headScreenshotsDir, baseScreenshotsDir, diffOptions, }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
+    const { diffThreshold, diffPixelThreshold } = diffOptions;
     const baseReplayScreenshots = await (0, replays_1.getScreenshotFiles)(baseScreenshotsDir);
     const headReplayScreenshots = await (0, replays_1.getScreenshotFiles)(headScreenshotsDir);
-    // Assume base replay screenshots are always a subset of the head replay screenshots.
-    // We report any missing base replay screenshots for visibility but don't count it as a difference.
-    const missingHeadImages = new Set([...baseReplayScreenshots].filter((file) => !headReplayScreenshots.includes(file)));
-    let totalMismatchPixels = 0;
-    const comparisonResults = [];
-    try {
-        if (missingHeadImages.size > 0) {
-            logComparisonResultMessage(logger, `Head replay is missing screenshots: ${[...missingHeadImages].sort()}`, "fail");
-            throw new DiffError(`Head replay is missing screenshots: ${[...missingHeadImages].sort()}`, {
-                baseReplayId,
-                headReplayId,
-                threshold: diffThreshold,
-            });
+    const missingHeadImages = new Set(baseReplayScreenshots.filter((file) => !headReplayScreenshots.includes(file)));
+    const missingHeadImagesResults = Array.from(missingHeadImages).flatMap((screenshotFileName) => {
+        const identifier = getScreenshotIdentifier(screenshotFileName);
+        if (identifier == null) {
+            return [];
         }
-        for (const screenshotFileName of headReplayScreenshots) {
-            if (!baseReplayScreenshots.includes(screenshotFileName)) {
-                logger.info(`Screenshot ${screenshotFileName} not present in base replay`);
-                continue;
-            }
-            const baseScreenshotFile = (0, path_1.join)(baseScreenshotsDir, screenshotFileName);
-            const headScreenshotFile = (0, path_1.join)(headScreenshotsDir, screenshotFileName);
-            const baseScreenshot = await (0, io_utils_1.readPng)(baseScreenshotFile);
-            const headScreenshot = await (0, io_utils_1.readPng)(headScreenshotFile);
-            const comparisonResult = (0, diff_utils_1.compareImages)({
-                base: baseScreenshot,
-                head: headScreenshot,
-                pixelThreshold: diffPixelThreshold,
-            });
-            totalMismatchPixels += comparisonResult.mismatchPixels;
-            logger.debug({
-                screenshotFileName,
-                mismatchPixels: comparisonResult.mismatchPixels,
-                mismatchFraction: comparisonResult.mismatchFraction,
-            });
-            await (0, screenshot_diffs_1.writeScreenshotDiff)({
-                baseReplayId,
-                headReplayId,
-                screenshotFileName,
-                diff: comparisonResult.diff,
-            });
-            comparisonResults.push({
-                baseScreenshotFile,
-                headScreenshotFile,
-                comparisonResult,
-                outcome: comparisonResult.mismatchFraction > diffThreshold ? "fail" : "pass",
-            });
+        return [
+            {
+                identifier,
+                outcome: "missing-head",
+                baseScreenshotFile: `screenshots/${screenshotFileName}`,
+            },
+        ];
+    });
+    const diffAgainstBase = async (screenshotFileName) => {
+        const identifier = getScreenshotIdentifier(screenshotFileName);
+        if (identifier == null) {
+            return [];
         }
-        await (0, replay_api_1.postScreenshotDiffStats)(client, {
+        if (!baseReplayScreenshots.includes(screenshotFileName)) {
+            return [
+                {
+                    identifier,
+                    outcome: "missing-base",
+                    headScreenshotFile: `screenshots/${screenshotFileName}`,
+                },
+            ];
+        }
+        const baseScreenshotFile = (0, path_1.join)(baseScreenshotsDir, screenshotFileName);
+        const headScreenshotFile = (0, path_1.join)(headScreenshotsDir, screenshotFileName);
+        const baseScreenshot = await (0, io_utils_1.readPng)(baseScreenshotFile);
+        const headScreenshot = await (0, io_utils_1.readPng)(headScreenshotFile);
+        if (baseScreenshot.width !== baseScreenshot.width ||
+            headScreenshot.height !== headScreenshot.height) {
+            return [
+                {
+                    identifier,
+                    outcome: "different-size",
+                    headScreenshotFile: `screenshots/${screenshotFileName}`,
+                    baseScreenshotFile: `screenshots/${screenshotFileName}`,
+                    baseWidth: baseScreenshot.width,
+                    baseHeight: baseScreenshot.height,
+                    headWidth: headScreenshot.width,
+                    headHeight: headScreenshot.height,
+                },
+            ];
+        }
+        const comparisonResult = (0, diff_utils_1.compareImages)({
+            base: baseScreenshot,
+            head: headScreenshot,
+            pixelThreshold: diffPixelThreshold,
+        });
+        await (0, screenshot_diffs_1.writeScreenshotDiff)({
             baseReplayId,
             headReplayId,
-            stats: {
-                width: 0,
-                height: 0,
-                mismatchPixels: totalMismatchPixels,
-            },
+            screenshotFileName,
+            diff: comparisonResult.diff,
         });
-        const diffUrl = await (0, replay_api_1.getDiffUrl)(client, baseReplayId, headReplayId);
-        logger.info(`View screenshot diff at ${diffUrl}`);
-        comparisonResults.forEach((result) => {
-            logComparisonResultMessage(logger, `${Math.round(result.comparisonResult.mismatchFraction * 100)}% pixel mismatch for screenshot ${(0, path_1.basename)(result.headScreenshotFile)} (threshold is ${Math.round(diffThreshold * 100)}%)`, result.outcome);
+        return [
+            {
+                identifier,
+                outcome: comparisonResult.mismatchFraction > diffThreshold
+                    ? "diff"
+                    : "no-diff",
+                headScreenshotFile: `screenshots/${screenshotFileName}`,
+                baseScreenshotFile: `screenshots/${screenshotFileName}`,
+                width: baseScreenshot.width,
+                height: baseScreenshot.height,
+                mismatchPixels: comparisonResult.mismatchPixels,
+                mismatchFraction: comparisonResult.mismatchFraction,
+            },
+        ];
+    };
+    const headDiffResults = (await Promise.all(headReplayScreenshots.map(diffAgainstBase))).flat();
+    const diffUrl = await (0, replay_api_1.getDiffUrl)(client, baseReplayId, headReplayId);
+    logger.info(`View screenshot diff at ${diffUrl}`);
+    return [...missingHeadImagesResults, ...headDiffResults];
+};
+exports.diffScreenshots = diffScreenshots;
+const checkScreenshotDiffResult = ({ baseReplayId, headReplayId, results, diffOptions, }) => {
+    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
+    const missingHeadImagesResults = results.flatMap((result) => result.outcome === "missing-head" ? [result] : []);
+    if (missingHeadImagesResults.length) {
+        const message = `Head replay is missing screenshots: ${missingHeadImagesResults
+            .map(({ baseScreenshotFile }) => (0, path_1.basename)(baseScreenshotFile))
+            .sort()} => FAIL!`;
+        logger.info(message);
+        throw new ScreenshotDiffError(message, {
+            baseReplayId,
+            headReplayId,
         });
-        // Check if individual screenshot mismatch is higher than the threshold.
-        const mismatchingScreenshots = comparisonResults.filter((result) => result.outcome == "fail");
-        if (mismatchingScreenshots.length) {
-            logger.info(`Screenshots ${mismatchingScreenshots
-                .map((result) => (0, path_1.basename)(result.headScreenshotFile))
-                .sort()} do not match!`);
-            if (exitOnMismatch) {
-                process.exit(1);
-            }
-            throw new DiffError(`Screenshots ${mismatchingScreenshots.map((result) => (0, path_1.basename)(result.headScreenshotFile))} do not match!`, {
+    }
+    const missingBaseImagesResults = results.flatMap((result) => result.outcome === "missing-base" ? [result] : []);
+    if (missingHeadImagesResults.length) {
+        const message = `Notice: Base replay is missing screenshots: ${missingBaseImagesResults
+            .map(({ headScreenshotFile }) => (0, path_1.basename)(headScreenshotFile))
+            .sort()}`;
+        logger.info(message);
+    }
+    results.forEach((result) => {
+        const { outcome } = result;
+        if (outcome === "different-size") {
+            const message = `Screenshots ${(0, path_1.basename)(result.headScreenshotFile)} have different sizes => FAIL!`;
+            logger.info(message);
+            throw new ScreenshotDiffError(message, {
                 baseReplayId,
                 headReplayId,
-                threshold: diffThreshold,
             });
         }
-    }
-    catch (error) {
-        if (!(error instanceof DiffError)) {
-            logger.error(error);
+        if (outcome === "diff" || outcome === "no-diff") {
+            const mismatch = (result.mismatchFraction * 100).toFixed(3);
+            const threshold = (diffOptions.diffThreshold * 100).toFixed(3);
+            const message = `${mismatch}% pixel mismatch for screenshot ${(0, path_1.basename)(result.headScreenshotFile)} (threshold is ${threshold}%) => ${outcome === "no-diff" ? "PASS" : "FAIL!"}`;
+            logger.info(message);
+            if (outcome === "diff") {
+                throw new ScreenshotDiffError(message, {
+                    baseReplayId,
+                    headReplayId,
+                });
+            }
         }
-        if (exitOnMismatch) {
-            process.exit(1);
+    });
+};
+exports.checkScreenshotDiffResult = checkScreenshotDiffResult;
+class ScreenshotDiffError extends Error {
+    constructor(message, extras) {
+        super(message);
+        this.extras = extras;
+    }
+}
+exports.ScreenshotDiffError = ScreenshotDiffError;
+const getScreenshotIdentifier = (filename) => {
+    const name = (0, path_1.basename)(filename);
+    if (name === "final-state.png") {
+        return {
+            type: "end-state",
+        };
+    }
+    if (name.startsWith("screenshot-after-event")) {
+        const match = name.match(/^(?:.*)-(\d+)[.]png$/);
+        const eventNumber = match ? parseInt(match[1], 10) : undefined;
+        if (match && eventNumber != null && !isNaN(eventNumber)) {
+            return {
+                type: "after-event",
+                eventNumber: eventNumber - 1,
+            };
         }
-        throw new DiffError(`Error while diffing: ${error}`, {
-            baseReplayId,
-            headReplayId,
-            threshold: diffThreshold,
-            value: 1,
-        });
     }
-    return comparisonResults;
-};
-exports.diffScreenshots = diffScreenshots;
-const logComparisonResultMessage = (logger, message, outcome) => {
-    logger.info(`${message} => ${outcome === "pass" ? "PASS" : "FAIL!"}`);
+    return undefined;
 };
 const handler = async ({ apiToken, baseSimulationId: baseReplayId, headSimulationId: headReplayId, threshold, pixelThreshold, }) => {
+    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const client = (0, client_1.createClient)({ apiToken });
     await (0, replays_1.getOrFetchReplay)(client, baseReplayId);
     await (0, replays_1.getOrFetchReplayArchive)(client, baseReplayId);
@@ -132,17 +179,24 @@ const handler = async ({ apiToken, baseSimulationId: baseReplayId, headSimulatio
     await (0, replays_1.getOrFetchReplayArchive)(client, headReplayId);
     const baseScreenshotsDir = (0, replays_1.getScreenshotsDir)((0, replays_1.getReplayDir)(baseReplayId));
     const headScreenshotsDir = (0, replays_1.getScreenshotsDir)((0, replays_1.getReplayDir)(headReplayId));
-    await (0, exports.diffScreenshots)({
+    const diffOptions = {
+        diffThreshold: threshold,
+        diffPixelThreshold: pixelThreshold,
+    };
+    const results = await (0, exports.diffScreenshots)({
         client,
         baseReplayId,
         headReplayId,
         baseScreenshotsDir,
         headScreenshotsDir,
-        diffOptions: {
-            diffThreshold: threshold,
-            diffPixelThreshold: pixelThreshold,
-        },
-        exitOnMismatch: true,
+        diffOptions,
+    });
+    logger.debug(results);
+    (0, exports.checkScreenshotDiffResult)({
+        baseReplayId,
+        headReplayId,
+        results,
+        diffOptions,
     });
 };
 exports.screenshotDiff = (0, command_builder_1.buildCommand)("screenshot-diff")

package/dist/config/config.js

@@ -24,11 +24,11 @@ const getConfigFilePath = async () => {
 const validateReplayOptions = (prevOptions) => {
     const { screenshotSelector, diffThreshold, diffPixelThreshold, moveBeforeClick, simulationIdForAssets, } = prevOptions;
     return {
-        ...(screenshotSelector ? { screenshotSelector } : {}),
-        ...(diffThreshold ? { diffThreshold } : {}),
-        ...(diffPixelThreshold ? { diffPixelThreshold } : {}),
-        ...(moveBeforeClick ? { moveBeforeClick } : {}),
-        ...(simulationIdForAssets ? { simulationIdForAssets } : {}),
+        ...(screenshotSelector != null ? { screenshotSelector } : {}),
+        ...(diffThreshold != null ? { diffThreshold } : {}),
+        ...(diffPixelThreshold != null ? { diffPixelThreshold } : {}),
+        ...(moveBeforeClick != null ? { moveBeforeClick } : {}),
+        ...(simulationIdForAssets != null ? { simulationIdForAssets } : {}),
     };
 };
 const validateConfig = (prevConfig) => {

package/dist/deflake-tests/deflake-tests.handler.d.ts

@@ -12,6 +12,7 @@ interface HandleReplayOptions {
     apiToken: string | null;
     commitSha: string;
     generatedBy: GeneratedBy;
+    testRunId: string | null;
 }
 export declare const deflakeReplayCommandHandler: (options: DeflakeReplayCommandHandlerOptions) => Promise<TestCaseResult>;
 export {};

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

@@ -8,7 +8,7 @@ const common_1 = require("@alwaysmeticulous/common");
 const loglevel_1 = __importDefault(require("loglevel"));
 const replay_command_1 = require("../commands/replay/replay.command");
 const screenshot_diff_command_1 = require("../commands/screenshot-diff/screenshot-diff.command");
-const handleReplay = async ({ testCase, replayTarget, executionOptions, screenshottingOptions, apiToken, commitSha, generatedBy, }) => {
+const handleReplay = async ({ testCase, replayTarget, executionOptions, screenshottingOptions, apiToken, commitSha, generatedBy, testRunId, }) => {
     var _a, _b;
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const replayPromise = (0, replay_command_1.replayCommandHandler)({
@@ -23,6 +23,7 @@ const handleReplay = async ({ testCase, replayTarget, executionOptions, screensh
         exitOnMismatch: false,
         cookiesFile: null,
         generatedBy,
+        testRunId,
     });
     const result = await replayPromise
         .then((replay) => ({
@@ -31,7 +32,7 @@ const handleReplay = async ({ testCase, replayTarget, executionOptions, screensh
         result: "pass",
     }))
         .catch((error) => {
-        if (error instanceof screenshot_diff_command_1.DiffError && error.extras) {
+        if (error instanceof screenshot_diff_command_1.ScreenshotDiffError && error.extras) {
             return {
                 ...testCase,
                 headReplayId: error.extras.headReplayId,

package/dist/index.d.ts

@@ -9,4 +9,3 @@ export { runAllTests } from "./commands/run-all-tests/run-all-tests.command";
 export { screenshotDiff } from "./commands/screenshot-diff/screenshot-diff.command";
 export { showProject } from "./commands/show-project/show-project.command";
 export { updateTests } from "./commands/update-tests/update-tests.command";
-export { uploadBuild } from "./commands/upload-build/upload-build.command";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadBuild = exports.updateTests = exports.showProject = exports.screenshotDiff = exports.runAllTests = exports.replay = exports.record = exports.downloadSession = exports.downloadReplay = exports.debugReplay = exports.createTest = exports.bootstrap = void 0;
+exports.updateTests = exports.showProject = exports.screenshotDiff = exports.runAllTests = exports.replay = exports.record = exports.downloadSession = exports.downloadReplay = exports.debugReplay = exports.createTest = exports.bootstrap = void 0;
 var bootstrap_command_1 = require("./commands/bootstrap/bootstrap.command");
 Object.defineProperty(exports, "bootstrap", { enumerable: true, get: function () { return bootstrap_command_1.bootstrap; } });
 var create_test_command_1 = require("./commands/create-test/create-test.command");
@@ -23,5 +23,3 @@ var show_project_command_1 = require("./commands/show-project/show-project.comma
 Object.defineProperty(exports, "showProject", { enumerable: true, get: function () { return show_project_command_1.showProject; } });
 var update_tests_command_1 = require("./commands/update-tests/update-tests.command");
 Object.defineProperty(exports, "updateTests", { enumerable: true, get: function () { return update_tests_command_1.updateTests; } });
-var upload_build_command_1 = require("./commands/upload-build/upload-build.command");
-Object.defineProperty(exports, "uploadBuild", { enumerable: true, get: function () { return upload_build_command_1.uploadBuild; } });

package/dist/main.js

@@ -18,7 +18,6 @@ const screenshot_diff_command_1 = require("./commands/screenshot-diff/screenshot
 const serve_command_1 = require("./commands/serve/serve.command");
 const show_project_command_1 = require("./commands/show-project/show-project.command");
 const update_tests_command_1 = require("./commands/update-tests/update-tests.command");
-const upload_build_command_1 = require("./commands/upload-build/upload-build.command");
 const logger_utils_1 = require("./utils/logger.utils");
 const sentry_utils_1 = require("./utils/sentry.utils");
 const handleDataDir = (dataDir) => {
@@ -43,7 +42,6 @@ const main = () => {
         .command(screenshot_diff_command_1.screenshotDiff)
         .command(show_project_command_1.showProject)
         .command(update_tests_command_1.updateTests)
-        .command(upload_build_command_1.uploadBuild)
         .command("serve", false, serve_command_1.serve) // This is a debugging command, so we hide it to not pollute the main menu
         .help()
         .strict()

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

@@ -71,6 +71,7 @@ const runAllTestsInParallel = async ({ config, client, testRun, apiToken, commit
                     executionOptions,
                     screenshottingOptions,
                     generatedBy: { type: "testRun", runId: testRun.id },
+                    testRunId: testRun.id,
                 },
             },
         };