@alwaysmeticulous/cli 2.5.2 → 2.5.5

package/dist/commands/download-session/download-session.command.d.ts

@@ -1,7 +1,10 @@
-import { CommandModule } from "yargs";
-interface Options {
-    apiToken?: string | null | undefined;
-    sessionId: string;
-}
-export declare const downloadSession: CommandModule<unknown, Options>;
-export {};
+/// <reference types="yargs" />
+export declare const downloadSession: import("yargs").CommandModule<unknown, import("yargs").InferredOptionTypes<{
+    apiToken: {
+        string: true;
+    };
+    sessionId: {
+        string: true;
+        demandOption: true;
+    };
+}>>;

package/dist/commands/download-session/download-session.command.js

@@ -2,24 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadSession = void 0;
 const client_1 = require("../../api/client");
+const command_builder_1 = require("../../command-utils/command-builder");
 const sessions_1 = require("../../local-data/sessions");
-const sentry_utils_1 = require("../../utils/sentry.utils");
 const handler = async ({ apiToken, sessionId, }) => {
     const client = (0, client_1.createClient)({ apiToken });
     await (0, sessions_1.getOrFetchRecordedSession)(client, sessionId);
     await (0, sessions_1.getOrFetchRecordedSessionData)(client, sessionId);
 };
-exports.downloadSession = {
-    command: "download-session",
+exports.downloadSession = (0, command_builder_1.buildCommand)("download-session")
+    .details({
     describe: "Download recorded session from Meticulous",
-    builder: {
-        apiToken: {
-            string: true,
-        },
-        sessionId: {
-            string: true,
-            demandOption: true,
-        },
+})
+    .options({
+    apiToken: {
+        string: true,
     },
-    handler: (0, sentry_utils_1.wrapHandler)(handler),
-};
+    sessionId: {
+        string: true,
+        demandOption: true,
+    },
+})
+    .handler(handler);

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

@@ -1,4 +1,4 @@
-import { CommandModule } from "yargs";
+/// <reference types="yargs" />
 export interface RecordCommandHandlerOptions {
     apiToken: string | null | undefined;
     commitSha: string | null | undefined;
@@ -12,4 +12,39 @@ export interface RecordCommandHandlerOptions {
     onDetectedSession?: (sessionId: string) => void;
 }
 export declare const recordCommandHandler: (options: RecordCommandHandlerOptions) => Promise<void>;
-export declare const record: CommandModule<unknown, RecordCommandHandlerOptions>;
+export declare const record: import("yargs").CommandModule<unknown, import("yargs").InferredOptionTypes<{
+    apiToken: {
+        string: true;
+        demandOption: true;
+    };
+    commitSha: {
+        string: true;
+    };
+    devTools: {
+        boolean: true;
+        description: string;
+    };
+    bypassCSP: {
+        boolean: true;
+        description: string;
+    };
+    width: {
+        number: true;
+    };
+    height: {
+        number: true;
+    };
+    uploadIntervalMs: {
+        number: true;
+        description: string;
+    };
+    incognito: {
+        boolean: true;
+        description: string;
+        default: boolean;
+    };
+    trace: {
+        boolean: true;
+        description: string;
+    };
+}>>;

package/dist/commands/record/record.command.js

@@ -10,9 +10,9 @@ const loglevel_1 = __importDefault(require("loglevel"));
 const client_1 = require("../../api/client");
 const project_api_1 = require("../../api/project.api");
 const session_api_1 = require("../../api/session.api");
+const command_builder_1 = require("../../command-utils/command-builder");
 const replay_assets_1 = require("../../local-data/replay-assets");
 const commit_sha_utils_1 = require("../../utils/commit-sha.utils");
-const sentry_utils_1 = require("../../utils/sentry.utils");
 const recordCommandHandler = async ({ apiToken, commitSha: commitSha_, devTools, bypassCSP, width, height, uploadIntervalMs, incognito, trace, onDetectedSession: onDetectedSession_, }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const debugLogger = trace ? await common_1.DebugLogger.create() : null;
@@ -99,44 +99,44 @@ const recordCommandHandler = async ({ apiToken, commitSha: commitSha_, devTools,
     });
 };
 exports.recordCommandHandler = recordCommandHandler;
-exports.record = {
-    command: "record",
+exports.record = (0, command_builder_1.buildCommand)("record")
+    .details({
     describe: "Record a session",
-    builder: {
-        apiToken: {
-            string: true,
-            demandOption: true,
-        },
-        commitSha: {
-            string: true,
-        },
-        devTools: {
-            boolean: true,
-            description: "Open Chrome Dev Tools",
-        },
-        bypassCSP: {
-            boolean: true,
-            description: "Enables bypass CSP in the browser",
-        },
-        width: {
-            number: true,
-        },
-        height: {
-            number: true,
-        },
-        uploadIntervalMs: {
-            number: true,
-            description: "Meticulous recording upload interval (in milliseconds)",
-        },
-        incognito: {
-            boolean: true,
-            description: "Use an incognito browsing context",
-            default: true,
-        },
-        trace: {
-            boolean: true,
-            description: "Enable verbose logging",
-        },
+})
+    .options({
+    apiToken: {
+        string: true,
+        demandOption: true,
     },
-    handler: (0, sentry_utils_1.wrapHandler)(exports.recordCommandHandler),
-};
+    commitSha: {
+        string: true,
+    },
+    devTools: {
+        boolean: true,
+        description: "Open Chrome Dev Tools",
+    },
+    bypassCSP: {
+        boolean: true,
+        description: "Enables bypass CSP in the browser",
+    },
+    width: {
+        number: true,
+    },
+    height: {
+        number: true,
+    },
+    uploadIntervalMs: {
+        number: true,
+        description: "Meticulous recording upload interval (in milliseconds)",
+    },
+    incognito: {
+        boolean: true,
+        description: "Use an incognito browsing context",
+        default: true,
+    },
+    trace: {
+        boolean: true,
+        description: "Enable verbose logging",
+    },
+})
+    .handler(exports.recordCommandHandler);

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

@@ -1,13 +1,14 @@
-import { Replay, ReplayExecutionOptions, ReplayTarget } from "@alwaysmeticulous/common";
-import { CommandModule } from "yargs";
+/// <reference types="yargs" />
+import { GeneratedBy, Replay, ReplayExecutionOptions, ReplayTarget } from "@alwaysmeticulous/common";
 import { ScreenshotAssertionsOptions, ScreenshotDiffOptions } from "../../command-utils/common-types";
 export interface ReplayOptions extends AdditionalReplayOptions {
     replayTarget: ReplayTarget;
     executionOptions: ReplayExecutionOptions;
     screenshottingOptions: ScreenshotAssertionsOptions;
     exitOnMismatch: boolean;
+    generatedBy: GeneratedBy;
 }
-export declare const replayCommandHandler: ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, }: ReplayOptions) => Promise<Replay>;
+export declare const replayCommandHandler: ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, generatedBy, }: ReplayOptions) => Promise<Replay>;
 export interface RawReplayCommandHandlerOptions extends ScreenshotDiffOptions, Omit<ReplayExecutionOptions, "maxDurationMs" | "maxEventCount">, AdditionalReplayOptions {
     screenshot: boolean;
     appUrl: string | null | undefined;
@@ -26,5 +27,114 @@ interface AdditionalReplayOptions {
     cookiesFile: string | null | undefined;
 }
 export declare const rawReplayCommandHandler: ({ apiToken, commitSha, sessionId, appUrl, simulationIdForAssets, headless, devTools, bypassCSP, screenshot, screenshotSelector, baseSimulationId, diffThreshold, diffPixelThreshold, save, padTime, shiftTime, networkStubbing, moveBeforeClick, cookiesFile, skipPauses, maxDurationMs, maxEventCount, storyboard, }: RawReplayCommandHandlerOptions) => Promise<Replay>;
-export declare const replay: CommandModule<unknown, RawReplayCommandHandlerOptions>;
+export declare const getReplayTarget: ({ appUrl, simulationIdForAssets, }: {
+    appUrl: string | null;
+    simulationIdForAssets: string | null;
+}) => ReplayTarget;
+export declare const replay: import("yargs").CommandModule<unknown, import("yargs").InferredOptionTypes<{
+    maxDurationMs: {
+        number: true;
+        description: string;
+    };
+    maxEventCount: {
+        number: true;
+        description: string;
+    };
+    storyboard: {
+        boolean: true;
+        description: string;
+        default: boolean;
+    };
+    diffThreshold: {
+        readonly number: true;
+        readonly description: "Acceptable maximum proportion of changed pixels, between 0 and 1. If this proportion is exceeded then the test will fail.";
+        readonly default: 0.01;
+    };
+    diffPixelThreshold: {
+        readonly number: true;
+        readonly description: "A number between 0 and 1. Color/brightness differences in individual pixels will be ignored if the difference is less than this threshold. A value of 1.0 would accept any difference in color, while a value of 0.0 would accept no difference in color.";
+        readonly default: 0.01;
+    };
+    headless: {
+        readonly boolean: true;
+        readonly description: "Start browser in headless mode";
+        readonly default: false;
+    };
+    devTools: {
+        readonly boolean: true;
+        readonly description: "Open Chrome Dev Tools";
+        readonly default: false;
+    };
+    bypassCSP: {
+        readonly boolean: true;
+        readonly description: "Enables bypass CSP in the browser (danger: this could mean you tests hit your production backend)";
+        readonly default: false;
+    };
+    padTime: {
+        readonly boolean: true;
+        readonly description: "Pad replay time according to recording duration. Please note this option will be ignored if running with the '--skipPauses' option.";
+        readonly default: true;
+    };
+    shiftTime: {
+        readonly boolean: true;
+        readonly description: "Shift time during simulation to be set as the recording time";
+        readonly default: true;
+    };
+    networkStubbing: {
+        readonly boolean: true;
+        readonly description: "Stub network requests during replay";
+        readonly default: true;
+    };
+    skipPauses: {
+        readonly boolean: true;
+        readonly description: "Fast forward through any pauses to replay as fast as possible. Warning: this option is experimental and may be deprecated";
+        readonly default: false;
+    };
+    apiToken: {
+        readonly string: true;
+    };
+    commitSha: {
+        readonly string: true;
+    };
+    sessionId: {
+        string: true;
+        demandOption: true;
+    };
+    appUrl: {
+        string: true;
+        description: string;
+    };
+    simulationIdForAssets: {
+        string: true;
+        conflicts: string;
+        description: string;
+    };
+    screenshot: {
+        boolean: true;
+        description: string;
+        default: boolean;
+    };
+    screenshotSelector: {
+        string: true;
+        description: string;
+    };
+    baseSimulationId: {
+        string: true;
+        description: string;
+        alias: string;
+    };
+    save: {
+        boolean: true;
+        description: string;
+    };
+    moveBeforeClick: {
+        boolean: true;
+        description: string;
+        default: boolean;
+    };
+    cookiesFile: {
+        string: true;
+        description: string;
+    };
+}>>;
 export {};

package/dist/commands/replay/replay.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.replay = exports.rawReplayCommandHandler = exports.replayCommandHandler = void 0;
+exports.replay = exports.getReplayTarget = exports.rawReplayCommandHandler = exports.replayCommandHandler = void 0;
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const common_1 = require("@alwaysmeticulous/common");
@@ -13,6 +13,7 @@ const client_1 = require("../../api/client");
 const replay_api_1 = require("../../api/replay.api");
 const upload_1 = require("../../api/upload");
 const archive_1 = require("../../archive/archive");
+const command_builder_1 = require("../../command-utils/command-builder");
 const common_options_1 = require("../../command-utils/common-options");
 const local_data_utils_1 = require("../../local-data/local-data.utils");
 const replay_assets_1 = require("../../local-data/replay-assets");
@@ -21,10 +22,9 @@ const serve_assets_from_simulation_1 = require("../../local-data/serve-assets-fr
 const sessions_1 = require("../../local-data/sessions");
 const commit_sha_utils_1 = require("../../utils/commit-sha.utils");
 const config_utils_1 = require("../../utils/config.utils");
-const sentry_utils_1 = require("../../utils/sentry.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, }) => {
+const replayCommandHandler = async ({ replayTarget, executionOptions, screenshottingOptions, apiToken, sessionId, commitSha: commitSha_, save, exitOnMismatch, baseSimulationId: baseReplayId_, cookiesFile, generatedBy, }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const client = (0, client_1.createClient)({ apiToken });
     // 1. Check session files
@@ -72,6 +72,7 @@ const replayCommandHandler = async ({ replayTarget, executionOptions, screenshot
         sessionData,
         recordingId: "manual-replay",
         meticulousSha: "meticulousSha",
+        generatedBy,
         dependencies: {
             browserUserInteractions: {
                 key: "browserUserInteractions",
@@ -118,7 +119,7 @@ const replayCommandHandler = async ({ replayTarget, executionOptions, screenshot
         sessionId,
         meticulousSha,
         version: "v2",
-        metadata: {},
+        metadata: { generatedBy },
     });
     const uploadUrlData = await (0, replay_api_1.getReplayPushUrl)(client, replay.id);
     if (!uploadUrlData) {
@@ -208,6 +209,7 @@ const rawReplayCommandHandler = ({ apiToken, commitSha, sessionId, appUrl, simul
         maxDurationMs: maxDurationMs !== null && maxDurationMs !== void 0 ? maxDurationMs : null,
         maxEventCount: maxEventCount !== null && maxEventCount !== void 0 ? maxEventCount : null,
     };
+    const generatedByOption = { type: "replayCommand" };
     const storyboardOptions = storyboard
         ? { enabled: true }
         : { enabled: false };
@@ -220,7 +222,7 @@ const rawReplayCommandHandler = ({ apiToken, commitSha, sessionId, appUrl, simul
         }
         : { enabled: false };
     return (0, exports.replayCommandHandler)({
-        replayTarget: getReplayTarget({
+        replayTarget: (0, exports.getReplayTarget)({
             appUrl: appUrl !== null && appUrl !== void 0 ? appUrl : null,
             simulationIdForAssets: simulationIdForAssets !== null && simulationIdForAssets !== void 0 ? simulationIdForAssets : null,
         }),
@@ -233,6 +235,7 @@ const rawReplayCommandHandler = ({ apiToken, commitSha, sessionId, appUrl, simul
         baseSimulationId,
         save,
         exitOnMismatch: true,
+        generatedBy: generatedByOption,
     });
 };
 exports.rawReplayCommandHandler = rawReplayCommandHandler;
@@ -245,70 +248,71 @@ const getReplayTarget = ({ appUrl, simulationIdForAssets, }) => {
     }
     return { type: "original-recorded-url" };
 };
-exports.replay = {
-    command: "simulate",
+exports.getReplayTarget = getReplayTarget;
+exports.replay = (0, command_builder_1.buildCommand)("simulate")
+    .details({
     aliases: ["replay"],
     describe: "Simulate (replay) a recorded session",
-    builder: {
-        apiToken: common_options_1.OPTIONS.apiToken,
-        commitSha: common_options_1.OPTIONS.commitSha,
-        sessionId: {
-            string: true,
-            demandOption: true,
-        },
-        appUrl: {
-            string: true,
-            description: "The URL to execute the test against. If left absent will use the URL the test was originally recorded against.",
-        },
-        simulationIdForAssets: {
-            string: true,
-            conflicts: "appUrl",
-            description: "If present will run the session against a local server serving up previously snapshotted assets (HTML, JS, CSS etc.) from the specified prior simulation, instead of against a URL. An alternative to specifying an app URL.",
-        },
-        screenshot: {
-            boolean: true,
-            description: "Take a screenshot at the end of simulation",
-            default: true,
-        },
-        screenshotSelector: {
-            string: true,
-            description: "Query selector to screenshot a specific DOM element instead of the whole page",
-        },
-        baseSimulationId: {
-            string: true,
-            description: "Base simulation id to diff the final state screenshot against",
-            alias: "baseReplayId",
-        },
-        save: {
-            boolean: true,
-            description: "Adds the simulation to the list of test cases in meticulous.json",
-        },
-        moveBeforeClick: {
-            boolean: true,
-            description: "Simulate mouse movement before clicking",
-            default: false,
-        },
-        cookiesFile: {
-            string: true,
-            description: "Path to cookies to inject before simulation",
-        },
-        ...common_options_1.COMMON_REPLAY_OPTIONS,
-        ...common_options_1.SCREENSHOT_DIFF_OPTIONS,
-        maxDurationMs: {
-            number: true,
-            description: "Maximum duration (in milliseconds) the simulation will run",
-        },
-        maxEventCount: {
-            number: true,
-            description: "Maximum number of events the simulation will run",
-        },
-        storyboard: {
-            boolean: true,
-            description: "Take a storyboard of screenshots during simulation",
-            default: false,
-        },
+})
+    .options({
+    apiToken: common_options_1.OPTIONS.apiToken,
+    commitSha: common_options_1.OPTIONS.commitSha,
+    sessionId: {
+        string: true,
+        demandOption: true,
     },
-    handler: (0, sentry_utils_1.wrapHandler)(async (options) => {
-        await (0, exports.rawReplayCommandHandler)(options);
-    }),
-};
+    appUrl: {
+        string: true,
+        description: "The URL to execute the test against. If left absent will use the URL the test was originally recorded against.",
+    },
+    simulationIdForAssets: {
+        string: true,
+        conflicts: "appUrl",
+        description: "If present will run the session against a local server serving up previously snapshotted assets (HTML, JS, CSS etc.) from the specified prior simulation, instead of against a URL. An alternative to specifying an app URL.",
+    },
+    screenshot: {
+        boolean: true,
+        description: "Take a screenshot at the end of simulation",
+        default: true,
+    },
+    screenshotSelector: {
+        string: true,
+        description: "Query selector to screenshot a specific DOM element instead of the whole page",
+    },
+    baseSimulationId: {
+        string: true,
+        description: "Base simulation id to diff the final state screenshot against",
+        alias: "baseReplayId",
+    },
+    save: {
+        boolean: true,
+        description: "Adds the simulation to the list of test cases in meticulous.json",
+    },
+    moveBeforeClick: {
+        boolean: true,
+        description: "Simulate mouse movement before clicking",
+        default: false,
+    },
+    cookiesFile: {
+        string: true,
+        description: "Path to cookies to inject before simulation",
+    },
+    ...common_options_1.COMMON_REPLAY_OPTIONS,
+    ...common_options_1.SCREENSHOT_DIFF_OPTIONS,
+    maxDurationMs: {
+        number: true,
+        description: "Maximum duration (in milliseconds) the simulation will run",
+    },
+    maxEventCount: {
+        number: true,
+        description: "Maximum number of events the simulation will run",
+    },
+    storyboard: {
+        boolean: true,
+        description: "Take a storyboard of screenshots during simulation",
+        default: false,
+    },
+})
+    .handler(async (options) => {
+    await (0, exports.rawReplayCommandHandler)(options);
+});

package/dist/commands/run-all-tests/run-all-tests.command.d.ts

@@ -1,17 +1,90 @@
-import { ReplayExecutionOptions } from "@alwaysmeticulous/common";
-import { CommandModule } from "yargs";
-import { ScreenshotDiffOptions } from "../../command-utils/common-types";
-interface Options extends ScreenshotDiffOptions, ReplayExecutionOptions {
-    apiToken?: string;
-    commitSha?: string;
-    appUrl?: string;
-    useAssetsSnapshottedInBaseSimulation: boolean;
-    githubSummary?: boolean;
-    parallelize?: boolean;
-    parallelTasks?: number | null;
-    deflake: boolean;
-    useCache: boolean;
-    testsFile?: string;
-}
-export declare const runAllTests: CommandModule<unknown, Options>;
-export {};
+/// <reference types="yargs" />
+export declare const runAllTests: import("yargs").CommandModule<unknown, import("yargs").InferredOptionTypes<{
+    readonly diffThreshold: {
+        readonly number: true;
+        readonly description: "Acceptable maximum proportion of changed pixels, between 0 and 1. If this proportion is exceeded then the test will fail.";
+        readonly default: 0.01;
+    };
+    readonly diffPixelThreshold: {
+        readonly number: true;
+        readonly description: "A number between 0 and 1. Color/brightness differences in individual pixels will be ignored if the difference is less than this threshold. A value of 1.0 would accept any difference in color, while a value of 0.0 would accept no difference in color.";
+        readonly default: 0.01;
+    };
+    readonly headless: {
+        readonly boolean: true;
+        readonly description: "Start browser in headless mode";
+        readonly default: false;
+    };
+    readonly devTools: {
+        readonly boolean: true;
+        readonly description: "Open Chrome Dev Tools";
+        readonly default: false;
+    };
+    readonly bypassCSP: {
+        readonly boolean: true;
+        readonly description: "Enables bypass CSP in the browser (danger: this could mean you tests hit your production backend)";
+        readonly default: false;
+    };
+    readonly padTime: {
+        readonly boolean: true;
+        readonly description: "Pad replay time according to recording duration. Please note this option will be ignored if running with the '--skipPauses' option.";
+        readonly default: true;
+    };
+    readonly shiftTime: {
+        readonly boolean: true;
+        readonly description: "Shift time during simulation to be set as the recording time";
+        readonly default: true;
+    };
+    readonly networkStubbing: {
+        readonly boolean: true;
+        readonly description: "Stub network requests during replay";
+        readonly default: true;
+    };
+    readonly skipPauses: {
+        readonly boolean: true;
+        readonly description: "Fast forward through any pauses to replay as fast as possible. Warning: this option is experimental and may be deprecated";
+        readonly default: false;
+    };
+    readonly apiToken: {
+        readonly string: true;
+    };
+    readonly commitSha: {
+        readonly string: true;
+    };
+    readonly appUrl: {
+        readonly string: true;
+        readonly description: "The URL to execute the tests against. If left absent here and in the test cases file, then will use the URL the test was originally recorded against.";
+    };
+    readonly useAssetsSnapshottedInBaseSimulation: {
+        readonly boolean: true;
+        readonly description: string;
+        readonly default: false;
+    };
+    readonly githubSummary: {
+        readonly boolean: true;
+        readonly description: "Outputs a summary page for GitHub actions";
+    };
+    readonly parallelize: {
+        readonly boolean: true;
+        readonly description: "Run tests in parallel";
+    };
+    readonly parallelTasks: {
+        readonly number: true;
+        readonly description: "Number of tasks to run in parallel";
+        readonly coerce: (value: number | null | undefined) => number | null | undefined;
+    };
+    readonly deflake: {
+        readonly boolean: true;
+        readonly description: "Attempt to deflake failing tests";
+        readonly default: false;
+    };
+    readonly useCache: {
+        readonly boolean: true;
+        readonly description: "Use result cache";
+        readonly default: false;
+    };
+    readonly testsFile: {
+        readonly string: true;
+        readonly description: string;
+    };
+}>>;