@testim/testim-cli 3.255.0 → 3.256.0

package/player/utils/imageCaptureUtils.js

@@ -16,16 +16,6 @@ class RectIsOutsideOfImageError extends Error {
     }
 }
 
-/**
- * @param {never} tabId
- * @param {import('./windowUtils')} windowUtils
- * @param {import('./screenshotUtils')} screenshotUtils
- * */
-const ImageCaptureUtils = function (tabId, windowUtils, screenshotUtils) {
-    this.windowUtils = windowUtils;
-    this.screenshotUtils = screenshotUtils;
-};
-
 async function cropImageFromImageData(imageData, imageInfo) {
     const _image = imageInfo.image || imageInfo;
     const pixelRatio = imageInfo.devicePixelRatio;
@@ -114,6 +104,7 @@ function stitchImage(fullSize, parts) {
     return chromeStitchImage(fullSize, parts);
 }
 
+// ???????????
 function uploadDataUrl() {
     return Promise.resolve();
 }
@@ -148,74 +139,80 @@ function getElementAbsoluteRectangle(elementRect, pixelRatio) {
     };
 }
 
-ImageCaptureUtils.prototype = {
-    takeViewPortImage() {
-        return this.screenshotUtils.takeScreenshot()
-            .then((imageInfo) => ((typeof imageInfo === 'string') ? imageInfo : imageInfo.image));
-    },
+class ImageCaptureUtils {
+    /**
+     * @param {unknown} _unusedId
+     * @param {import('./windowUtils')} windowUtils
+     * @param {import('./screenshotUtils')} screenshotUtils
+     * */
+    constructor(_unusedId, windowUtils, screenshotUtils) {
+        this.windowUtils = windowUtils;
+        this.screenshotUtils = screenshotUtils;
+    }
+
+    async takeViewPortImage() {
+        const imageInfo = await this.screenshotUtils.takeScreenshot();
+        return ((typeof imageInfo === 'string') ? imageInfo : imageInfo.image);
+    }
 
     takeImageForComparison() {
         return this.takeViewPortImage();
-    },
+    }
 
-    takeAreaDataUrl(areas, format) {
+    async takeAreaDataUrl(areas, format) {
         // Future changes in clickim will pass parameters to this function as a single object
         if (areas.areas) {
             areas = areas.areas;
         }
 
-        return this.screenshotUtils.takeScreenshot(format)
-            .then((imageInfo) => cropImageFromImageData(areas, imageInfo).then((result) => {
-                result.screenImage = imageInfo.image;
-                result.absoluteScreenHighlight = getElementAbsoluteRectangle(areas.elementRect, imageInfo.devicePixelRatio);
-                return result;
-            }));
-    },
+        const imageInfo = await this.screenshotUtils.takeScreenshot(format);
+        const result = await cropImageFromImageData(areas, imageInfo);
+        result.screenImage = imageInfo.image;
+        result.absoluteScreenHighlight = getElementAbsoluteRectangle(areas.elementRect, imageInfo.devicePixelRatio);
+        return result;
+    }
 
-    takeArea(areas) {
+    async takeArea(areas) {
         // Future changes in clickim will pass parameters to this function as a single object
         if (areas.areas) {
             areas = areas.areas;
         }
 
-        return this.screenshotUtils.takeScreenshot()
-            .then((imageInfo) => {
-                const result = {};
-                result.screenImage = imageInfo.image;
-                result.absoluteScreenHighlight = getElementAbsoluteRectangle(areas.elementRect, imageInfo.devicePixelRatio);
-                return result;
-            }).then(uploadAllDataUrls);
-    },
+        const imageInfo = await this.screenshotUtils.takeScreenshot();
+        return uploadAllDataUrls({
+            screenImage: imageInfo.image,
+            absoluteScreenHighlight: getElementAbsoluteRectangle(areas.elementRect, imageInfo.devicePixelRatio),
+        });
+    }
 
     forcePixelRatio(forceRatio) {
         return this.screenshotUtils.forcePixelRatio(forceRatio);
-    },
+    }
 
     getCurrentDevicePixelRatio() {
         return this.screenshotUtils.getCurrentDevicePixelRatio();
-    },
+    }
 
     async takeStitchedDataUrl(useImprovedScreenshotStitching) {
-        const windowUtil = this.windowUtils;
-        const getCurrentScrollPosition = windowUtil.getCurrentScrollPosition.bind(windowUtil);
+        const { windowUtils, screenshotUtils } = this;
 
-        const that = this;
         const stabilize = () => utils.delay(250);
         const usingImprovedStitching = Boolean(useImprovedScreenshotStitching);
-        const scroll = usingImprovedStitching ?
-            (pos) => windowUtil.scrollToPositionWithoutAnimation.bind(windowUtil)(pos) :
-            (pos) => windowUtil.scrollToPosition.bind(windowUtil)(pos);
-
-        function createPart(position, crop) {
-            return scroll(position)
-                .then(stabilize)
-                .then(() => that.screenshotUtils.takeScreenshot())
-                .then(imageInfo => cropImageFromImageData({ elementRect: crop }, imageInfo))
-                .then(cropResult => ({
-                    position: { left: position.x + crop.left, top: position.y + crop.top },
-                    size: { width: crop.width, height: crop.height },
-                    image: cropResult.elementImage,
-                }));
+
+        async function createPart(position, crop) {
+            if (usingImprovedStitching) {
+                await windowUtils.scrollToPositionWithoutAnimation(position);
+            } else {
+                await windowUtils.scrollToPosition(position);
+            }
+            await stabilize();
+            const imageInfo = await screenshotUtils.takeScreenshot();
+            const cropResult = await cropImageFromImageData({ elementRect: crop }, imageInfo);
+            return ({
+                position: { left: position.x + crop.left, top: position.y + crop.top },
+                size: { width: crop.width, height: crop.height },
+                image: cropResult.elementImage,
+            });
         }
 
         async function takeAllParts(positionsData) {
@@ -232,36 +229,39 @@ ImageCaptureUtils.prototype = {
             const VPW = viewPortSize.width;
             const FPH = Math.max(fullPageSize.height, viewPortSize.height);
             const VPH = viewPortSize.height;
-            const Ws = (Array.apply(null, new Array(Math.ceil(FPW / VPW)))).map((_, i) => ({
+            const Ws = Array.from({ length: Math.ceil(FPW / VPW) }, (__, i) => ({
                 scrollX: Math.min(i * VPW, FPW - VPW),
                 cropX: i * VPW - Math.min(i * VPW, FPW - VPW),
                 cropW: VPW - (i * VPW - Math.min(i * VPW, FPW - VPW)),
             }));
-            const Hs = (Array.apply(null, new Array(Math.ceil(FPH / VPH)))).map((_, i) => ({
+            const Hs = Array.from({ length: Math.ceil(FPH / VPH) }, (__, i) => ({
                 scrollY: Math.min(i * VPH, FPH - VPH),
                 cropY: i * VPH - Math.min(i * VPH, FPH - VPH),
                 cropH: VPH - (i * VPH - Math.min(i * VPH, FPH - VPH)),
             }));
-            const positions = Ws.reduce((posList, w) => posList.concat(Hs.map((h) => ({
+            return Ws.flatMap(w => Hs.map(h => ({
                 scrollPos: { x: w.scrollX, y: h.scrollY },
                 cropData: {
-                    top: h.cropY, left: w.cropX, width: w.cropW, height: h.cropH,
+                    top: h.cropY,
+                    left: w.cropX,
+                    width: w.cropW,
+                    height: h.cropH,
                 },
-            }))), []);
-            return positions;
+            }))
+            );
         }
 
         async function createStitchImage(fullPageSize, viewPortSize) {
-            const originalPosition = await getCurrentScrollPosition();
+            const originalPosition = await windowUtils.getCurrentScrollPosition();
             const positions = getPartsPositions(fullPageSize, viewPortSize);
             const parts = await takeAllParts(positions);
-            await windowUtil.scrollToPosition(originalPosition);
+            await windowUtils.scrollToPosition(originalPosition);
             return stitchImage(fullPageSize, parts);
         }
 
-        const [fullPageSize, viewPortSize] = await Promise.all([windowUtil.getFullPageSize(), windowUtil.getViewportSize()]);
+        const [fullPageSize, viewPortSize] = await Promise.all([windowUtils.getFullPageSize(), windowUtils.getViewportSize()]);
         return await createStitchImage(fullPageSize, viewPortSize);
-    },
-};
+    }
+}
 
 module.exports = ImageCaptureUtils;

package/player/utils/screenshotUtils.js

@@ -1,9 +1,15 @@
+// @ts-check
+
 'use strict';
 
 const Promise = require('bluebird');
 const pRetry = require('p-retry');
 
 class ScreenshotUtils {
+    /**
+     * @param {any} tabId
+     * @param {import('../webdriver')} driver
+     */
     constructor(tabId, driver, options = { takeScreenshots: true }) {
         this.tabId = tabId;
         this.driver = driver;
@@ -21,23 +27,21 @@ class ScreenshotUtils {
         return this.options.takeScreenshots;
     }
 
-    takeScreenshot() {
+    async takeScreenshot() {
         if (!this.shouldTakeScreenshots()) {
-            return Promise.resolve({ devicePixelRatio: 1, image: '' });
+            return { devicePixelRatio: 1, image: '' };
         }
         const MAX_RETRY_COUNT = 3;
         const SCREENSHOT_RETRY_DELAY = 2000;
         const devicePixelRatioPromise = this.currentDevicePixelRatio ? Promise.resolve(this.currentDevicePixelRatio) : this.getDevicePixelRatio();
         const getScreenshot = () => Promise.all([devicePixelRatioPromise, this.driver.takeScreenshot()]);
-        return pRetry(getScreenshot, { retries: MAX_RETRY_COUNT, minTimeout: SCREENSHOT_RETRY_DELAY })
-            .then(([devicePixelRatio, image]) => {
-                const base64 = image ? image.value : '';
-                const dataUrl = `data:image/png;base64,${this.base64AddPadding(base64.replace(/[\r\n]/g, ''))}`;
-                return {
-                    image: dataUrl,
-                    devicePixelRatio,
-                };
-            });
+        const [devicePixelRatio, image] = await pRetry(getScreenshot, { retries: MAX_RETRY_COUNT, minTimeout: SCREENSHOT_RETRY_DELAY });
+        const base64 = image ? image.value : '';
+        const dataUrl = `data:image/png;base64,${this.base64AddPadding(base64.replace(/[\r\n]/g, ''))}`;
+        return {
+            image: dataUrl,
+            devicePixelRatio,
+        };
     }
 
     getDevicePixelRatio() {
@@ -49,7 +53,7 @@ class ScreenshotUtils {
             }
         }
 
-        return this.driver.executeJS(devicePixelRatioJS).then(result => Promise.resolve(result.value));
+        return this.driver.executeJS(devicePixelRatioJS).then(result => result.value);
     }
 
     forcePixelRatio(forceRatio = 1) {
@@ -63,4 +67,3 @@ class ScreenshotUtils {
 }
 
 module.exports = ScreenshotUtils;
-

package/player/utils/windowUtils.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 'use strict';
 
 const Promise = require('bluebird');
@@ -7,6 +9,10 @@ const { PageNotAvailableError } = require('../../errors');
 const logger = require('../../commons/logger').getLogger('window-utils');
 
 class WindowUtils {
+    /**
+     * @param {number} id tab or worker id
+     * @param {import('../webdriver')} driver
+     * */
     constructor(id, driver) {
         this.id = id;
         this.driver = driver;
@@ -131,12 +137,12 @@ class WindowUtils {
             });
     }
 
-    setViewportSize(size) {
-        return this.driver.setViewportSize(size.width, size.height)
-            .then(() => this.checkSize(size));
+    async setViewportSize(size) {
+        await this.driver.setViewportSize(size.width, size.height);
+        return await this.checkSize(size);
     }
 
-    validatePageIsAvailable() {
+    async validatePageIsAvailable() {
         /* eslint-disable */
         function pageIsAvailable() {
             var locationObj;
@@ -153,7 +159,8 @@ class WindowUtils {
         }
         /* eslint-enable */
 
-        return this.driver.executeJS(pageIsAvailable).then(result => (result.value ? Promise.resolve() : Promise.reject(new PageNotAvailableError())));
+        const result = await this.driver.executeJS(pageIsAvailable);
+        return await (result.value ? Promise.resolve() : Promise.reject(new PageNotAvailableError()));
     }
 
     focusTab() {
@@ -164,9 +171,14 @@ class WindowUtils {
         return undefined;
     }
 
-    getOsAndBrowser() {
-        return pRetry(() => this.driver.getBrowserAndOS(), { retries: 3 })
-            .then(osAndBrowser => ({ uaBrowserName: osAndBrowser.browser, uaOs: osAndBrowser.os, userAgent: osAndBrowser.userAgent, browserVersion: osAndBrowser.browserVersion }));
+    async getOsAndBrowser() {
+        const osAndBrowser = await pRetry(() => this.driver.getBrowserAndOS(), { retries: 3 });
+        return {
+            uaBrowserName: osAndBrowser.browser,
+            uaOs: osAndBrowser.os,
+            userAgent: osAndBrowser.userAgent,
+            browserVersion: osAndBrowser.browserVersion,
+        };
     }
 
     getUserAgentInfo() {

package/processHandler.js

@@ -7,6 +7,10 @@ const logger = require('./commons/logger').getLogger('process-handler');
 
 const exitHooks = [];
 
+/**
+ * @param {(e: any) => void} onExit
+ * @param {NodeJS.Process=} _process
+ */
 module.exports = function (onExit, _process = process) {
     async function cleanup(err) {
         // give cleanup and socket reports a chance to run

package/runOptions.d.ts

@@ -70,6 +70,11 @@ interface LightweightSettings {
     disableProjectDefaults: boolean;
 }
 
+type InitUserWithAuth = Awaited<ReturnType<typeof import('./commons/testimServicesApi')['initializeUserWithAuth']>>;
+interface ProjectData extends Pick<InitUserWithAuth['projectById'], 'type' | 'name' | 'defaults'> {
+    projectId: string;
+}
+
 // TODO: consider typing better, based on the validations we do (example: must have one of grid/grid-id/host&port/test plan)
 interface RunnerOptions extends Partial<Omit<TunnelOptions, 'tunnelOnlyMode' | 'tunnel'>> {
     token: string;
@@ -103,6 +108,26 @@ interface RunnerOptions extends Partial<Omit<TunnelOptions, 'tunnelOnlyMode' | '
     retentionDays?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
     retries?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
 
+    // #region Data set based on values from server
+    company: {
+        companyId: string;
+        onprem: boolean;
+        storageBaseUrl: string;
+        storageType: string;
+        name: string;
+        planType: 'pro' | 'free' | 'trial';
+        isPOC: boolean;
+        isStartUp: boolean;
+        activePlan: import('services/src/commons/mongo/db-dto-definitions/DbCompanyProjects').Plan;
+    };
+    gridData?: Awaited<ReturnType<typeof import('./services/gridService')['getGridData']>>;
+    sfdcCredential?: string;
+    editorUrl?: string;
+    allGrids?: InitUserWithAuth['allGrids'];
+    authData?: InitUserWithAuth['authData'];
+    projectData?: ProjectData;
+    // #endregion
+
     // #region What to execute
     testId: string[];
     name: string[];
@@ -161,7 +186,7 @@ interface RunnerOptions extends Partial<Omit<TunnelOptions, 'tunnelOnlyMode' | '
 
     // #region Extension debugging
     ext?: string;
-    extensionLocation?: string[];
+    extensionLocation: string[];
     extensionPath?: string;
     // #endregion
 
@@ -243,6 +268,7 @@ interface RunnerOptions extends Partial<Omit<TunnelOptions, 'tunnelOnlyMode' | '
     lightweightMode?: LightweightSettings;
     createPrefechedData?: boolean;
     saveRCALocally?: boolean | string;
+    localRCASaver?: string;
     // #endregion
 
     // #region intersections

package/runOptions.js

@@ -804,7 +804,7 @@ module.exports = {
 
         program.port = program.port && Number(program.port);
 
-        if (program.retries <= 0 || _.isNaN(program.retries)) {
+        if (program.retries <= 0 || Number.isNaN(program.retries)) {
             throw new ArgError('test failure retry count could not be a negative number or string, --retries <max_num_of_retries>');
         }
 
@@ -823,27 +823,27 @@ module.exports = {
             }
         }
 
-        if (program.browserTimeout <= 0 || _.isNaN(program.browserTimeout)) {
+        if (program.browserTimeout <= 0 || Number.isNaN(program.browserTimeout)) {
             throw new ArgError('get browser timeout could not be a negative number, --browser-timeout <get-browser-timeout>');
         }
 
-        if (program.newBrowserWaitTimeout <= 0 || _.isNaN(program.newBrowserWaitTimeout)) {
+        if (program.newBrowserWaitTimeout <= 0 || Number.isNaN(program.newBrowserWaitTimeout)) {
             throw new ArgError('max new browser wait timeout could not be a negative number, --new-browser-wait-timeout <max-wait-to-browser>');
         }
 
-        if (program.timeout <= 0 || _.isNaN(program.timeout)) {
+        if (program.timeout <= 0 || Number.isNaN(program.timeout)) {
             throw new ArgError('test run timeout could not be a negative number, --timeout <run-timeout>');
         }
 
-        if (program.beforeParallel <= 0 || _.isNaN(program.beforeParallel)) {
+        if (program.beforeParallel <= 0 || Number.isNaN(program.beforeParallel)) {
             throw new ArgError('before-parallel could not be a negative number or not number, --before-parallel <number-of-tests>');
         }
 
-        if (program.parallel <= 0 || _.isNaN(program.parallel)) {
+        if (program.parallel <= 0 || Number.isNaN(program.parallel)) {
             throw new ArgError('parallel could not be a negative number or not number, --parallel <number-of-tests>');
         }
 
-        if (program.afterParallel <= 0 || _.isNaN(program.afterParallel)) {
+        if (program.afterParallel <= 0 || Number.isNaN(program.afterParallel)) {
             throw new ArgError('after-parallel could not be a negative number or not number, --after-parallel <number-of-tests>');
         }
 

package/runner.js

@@ -1,32 +1,34 @@
 'use strict';
 
 /* eslint-disable no-console */
-const { CLI_MODE } = require('./commons/constants');
 const _ = require('lodash');
-const { EDITOR_URL } = require('./commons/config');
-const tunnel = require('./commons/testimTunnel');
 const utils = require('./utils');
 const reporter = require('./reports/reporter');
-const testimCustomToken = require('./commons/testimCustomToken');
-const socketService = require('./commons/socket/socketService');
-const servicesApi = require('./commons/testimServicesApi.js');
-const npmDriver = require('./testimNpmDriver.js');
+const npmDriver = require('./testimNpmDriver');
+const tunnel = require('./commons/testimTunnel');
+const perf = require('./commons/performance-logger');
+const gridService = require('./services/gridService');
 const analytics = require('./commons/testimAnalytics');
+const featureFlags = require('./commons/featureFlags');
 const branchService = require('./services/branchService');
-const gridService = require('./services/gridService');
+const servicesApi = require('./commons/testimServicesApi');
+const TestPlanRunner = require('./runners/TestPlanRunner');
+const socketService = require('./commons/socket/socketService');
+const testimCustomToken = require('./commons/testimCustomToken');
+const labFeaturesService = require('./services/labFeaturesService');
+const featureAvailabilityService = require('./commons/featureAvailabilityService');
+const { getLogger } = require('./commons/logger');
+const { EDITOR_URL } = require('./commons/config');
+const { CLI_MODE } = require('./commons/constants');
 const { ArgError, QuotaDepletedError } = require('./errors');
-const featureFlags = require('./commons/featureFlags');
-const perf = require('./commons/performance-logger');
 const { prepareMockNetwork, initializeUserWithAuth } = require('./commons/prepareRunner');
 
 const FREE_PLAN_MINIMUM_BROWSER_TIMEOUT = 30 * 60 * 1000;
 
-const TestPlanRunner = require('./runners/TestPlanRunner');
-const labFeaturesService = require('./services/labFeaturesService');
-const featureAvailabilityService = require('./commons/featureAvailabilityService');
 
-const logger = require('./commons/logger').getLogger('runner');
+const logger = getLogger('runner');
 
+/** @param {import('./runOptions').RunnerOptions} options */
 function validateCLIRunsAreAllowed(options) {
     const hasCliAccess = _.get(options, 'company.activePlan.premiumFeatures.allowCLI');
 
@@ -34,14 +36,16 @@ function validateCLIRunsAreAllowed(options) {
         const projectId = options.project;
         analytics.track(options.authData.uid, 'cli-not-supported', { projectId });
         console.warn('Testim CLI is not supported in this plan');
+        // TODO: shouldn't this throw an error? 🤔
     }
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function validateProjectQuotaNotDepleted(options) {
     const projectId = options.project;
 
     const usage = await servicesApi.getUsageForCurrentBillingPeriod(projectId);
-    const isExecutionBlocked = usage && usage.isExecutionBlocked;
+    const isExecutionBlocked = usage?.isExecutionBlocked;
     if (!isExecutionBlocked) {
         return;
     }
@@ -51,6 +55,10 @@ async function validateProjectQuotaNotDepleted(options) {
     throw new QuotaDepletedError();
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['companyByProjectId']} company
+ */
 function validateOptionsForCompany(options, company) {
     const optionsRetention = options.retentionDays;
     if (!optionsRetention) {
@@ -63,8 +71,9 @@ function validateOptionsForCompany(options, company) {
     }
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function validateCliAccount(options) {
-    if (options.lightweightMode && options.lightweightMode.disableQuotaBlocking) {
+    if (options.lightweightMode?.disableQuotaBlocking) {
         return;
     }
     try {
@@ -73,13 +82,14 @@ async function validateCliAccount(options) {
             validateCLIRunsAreAllowed(options),
         ]);
     } catch (err) {
-        if (err instanceof ArgError || err instanceof QuotaDepletedError) {
+        if ([ArgError, QuotaDepletedError].some(errType => err instanceof errType)) {
             throw err;
         }
         logger.error('could not validate cli account', { err });
     }
 }
 
+/** @param {string} projectId */
 function analyticsIdentify(projectId) {
     const authData = testimCustomToken.getTokenV3UserData();
     return analytics.identify({
@@ -95,6 +105,7 @@ function analyticsIdentify(projectId) {
     });
 }
 
+/** @param {string} projectId */
 function initSocketServices(projectId, { disableResults = false, disableRemoteStep = false }) {
     if (featureFlags.flags.useNewWSCLI.isEnabled() && !disableResults && !disableRemoteStep) {
         return socketService.connect(projectId);
@@ -110,6 +121,10 @@ function initSocketServices(projectId, { disableResults = false, disableRemoteSt
     return undefined;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['branchName']} branchInfoFromServer
+ */
 function setBranch(options, branchInfoFromServer) {
     const { branch, autoDetect } = options;
     branchService.setCurrentBranch(branchInfoFromServer, autoDetect);
@@ -118,14 +133,19 @@ function setBranch(options, branchInfoFromServer) {
     }
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function setSfdcCredential(options) {
-    const { projectData: { projectId } } = options;
+    const { projectData: { projectId } = {} } = options;
     const branch = branchService.getCurrentBranch();
     if (_.get(options, 'company.activePlan.premiumFeatures.ttaForSalesforce')) {
         options.sfdcCredential = await servicesApi.loadSfdcCredential({ projectId, branch });
     }
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['companyByProjectId']} company
+ */
 function setCompany(options, company) {
     const { onprem, id, storageBaseUrl, storageType, name, activePlan = {} } = company;
     if (onprem) {
@@ -161,6 +181,10 @@ function setCompany(options, company) {
     };
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['editorConfig']} editorConfig
+ */
 function setSystemInfo(options, editorConfig) {
     if (EDITOR_URL) {
         options.editorUrl = EDITOR_URL;
@@ -169,14 +193,26 @@ function setSystemInfo(options, editorConfig) {
     options.editorUrl = editorConfig.editorUrl;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['allGrids']} allGrids
+ */
 function setAllGrids(options, allGrids) {
     options.allGrids = allGrids;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['authData']} authData
+ */
 function setAuthData(options, authData) {
     options.authData = authData;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['projectById']} project
+ */
 function setProject(options, project) {
     const { id, name, type, defaults } = project;
     featureFlags.setProjectId(id);
@@ -189,10 +225,12 @@ function setProject(options, project) {
     };
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function setGrid(options) {
     options.gridData = await gridService.getGridData(options);
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function setMockNetworkRules(options) {
     const { project } = options;
     const props = { projectId: project };
@@ -236,8 +274,9 @@ async function runRunner(options, customExtensionLocalLocation) {
     return results;
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 function showFreeGridRunWarningIfNeeded(options) {
-    if (featureAvailabilityService.shouldShowFreeGridRunWarning(options.gridData && options.gridData.type)) {
+    if (featureAvailabilityService.shouldShowFreeGridRunWarning(options.gridData?.type)) {
         const CYAN = '\x1b[36m';
         const UNDERSCORE = '\x1b[4m';
         const RESET = '\x1b[0m';
@@ -252,15 +291,15 @@ function showFreeGridRunWarningIfNeeded(options) {
  * - Reporting the user to analytics
  * - Authenticating the user and exchanging their token for a jwt
  * - Sets the grids for the company and validates the user has permission to run the CLI
- * @param {Object} options - the run options passed to the CLI, namely the project and token
+ * @param {import('./runOptions').RunnerOptions} options - the run options passed to the CLI, namely the project and token
  */
 async function init(options) {
     perf.log('start runner init');
     const { project, lightweightMode, useChromeLauncher, mode, disableSockets } = options;
     const featureFlagsReady = featureFlags.fetch();
     const socketConnected = initSocketServices(project, {
-        disableResults: disableSockets || Boolean(lightweightMode && lightweightMode.disableResults && (useChromeLauncher || mode !== 'extension')),
-        disableRemoteStep: disableSockets || Boolean(lightweightMode && lightweightMode.disableRemoteStep),
+        disableResults: disableSockets || Boolean(lightweightMode?.disableResults && (useChromeLauncher || mode !== 'extension')),
+        disableRemoteStep: disableSockets || Boolean(lightweightMode?.disableRemoteStep),
     });
 
     featureFlagsReady.catch(() => {}); // suppress unhandled rejection
@@ -280,7 +319,7 @@ async function init(options) {
     setAuthData(options, authData);
     await setSfdcCredential(options);
 
-    if (!(options.lightweightMode && options.lightweightMode.disableLabs)) {
+    if (!options.lightweightMode?.disableLabs) {
         await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);
     }