@testim/testim-cli 3.254.0 → 3.256.0

package/agent/routers/cliJsCode/service.js

@@ -40,10 +40,6 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
         return all;
     }, '');
 
-    if (fileDataUrl === 'data:') { // fix chrome/safari bug that creates malformed datauri for empty files
-        fileDataUrl = 'data:,';
-    }
-
     const fileDataUrlToFileBuffer = !fileDataUrl ? 'var fileBuffer = null;' :
         `
             ${dataUriToBuffer.toString()}
@@ -297,10 +293,6 @@ function runCodeWithWorkerThread(transactionId, incomingParams, context, code, p
         return all;
     }, '');
 
-    if (fileDataUrl === 'data:') { // fix chrome/safari bug that creates malformed datauri for empty files
-        fileDataUrl = 'data:,';
-    }
-
     const fileDataUrlToFileBuffer = !fileDataUrl ? 'var fileBuffer = null;' :
         `
             ${dataUriToBuffer.toString()}
@@ -581,6 +573,17 @@ function runCodeWithPackages(code, stepId, incomingParams, context, testResultId
             }
         }
 
+        const emptyFileDataUrl = 'data:,';
+        if (fileDataUrl === 'data:') { // Fix chrome/safari bug that creates malformed data-uri for empty files
+            logger.debug('runCodeWithPackages, fileDataUrl was an empty string ', { fileDataUrl });
+            fileDataUrl = emptyFileDataUrl;
+        }
+
+        if (Buffer.isBuffer(fileDataUrl)) { // Fix, S3 is returning a buffer and not a string on empty files
+            logger.debug('runCodeWithPackages, fileDataUrl was an empty Buffer ', { fileDataUrl });
+            fileDataUrl = emptyFileDataUrl;
+        }
+
         if (workerThreads && featureFlags.flags.enableWorkerThreadsCliCodeExecution.isEnabled()) {
             return runCodeWithWorkerThread(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl);
         }

package/agent/routers/codim/router.test.js

@@ -1,20 +1,16 @@
 'use strict';
 
 const router = require('./router');
-
 const path = require('path');
 const os = require('os');
 const compression = require('compression');
 const express = require('express');
-
-const app = express();
 const bodyParser = require('body-parser');
-const Promise = require('bluebird');
-const { promiseFromCallback } = require('../../../utils');
 const superagent = require('superagent');
+const fs = require('fs');
 const { expect } = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
 
-const fs = Promise.promisifyAll(require('fs'));
+const app = express();
 
 app.use(bodyParser.urlencoded({ extended: false, limit: '50mb' }));
 app.use(compression());
@@ -25,25 +21,26 @@ app.use('/files', router.router);
 describe('codim router', () => {
     let listener;
     async function saveLocators(locatorsObject) {
-        const request = superagent.post(`http://localhost:${listener.address().port}/files/locators`)
-            .send(locatorsObject);
-        await promiseFromCallback((callback) => request.end(callback));
+        const request = superagent.post(`http://localhost:${listener.address().port}/files/locators`).send(locatorsObject);
+        await request;
     }
 
     async function loadLocators() {
         const request = superagent.get(`http://localhost:${listener.address().port}/files/locators`);
-        return await promiseFromCallback((callback) => request.end(callback)).then(x => x.text).then(JSON.parse);
+        const response = await request;
+        return JSON.parse(response.text);
     }
 
     let tmpDir;
+
     before((done) => {
         tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tdk-test-'));
         process.chdir(tmpDir);
-        listener = app.listen(0, done);
+        listener = app.listen(0, () => done());
     });
 
     after(async () => {
-        await fs.unlinkAsync(tmpDir).catch(() => {});
+        await fs.promises.unlink(tmpDir).catch(() => {});
     });
 
     it('saves locators', async () => {

package/agent/routers/codim/service.js

@@ -2,17 +2,16 @@
 
 const _ = require('lodash');
 const path = require('path');
-const Promise = require('bluebird');
-const fs = Promise.promisifyAll(require('fs'));
+const fsPromises = require('fs/promises');
 const { fromPairs } = require('lodash');
 const { buildCodeTests } = require('../../../runners/buildCodeTests');
 const { AbortError } = require('../../../commons/AbortError');
 
 const findTestFolder = _.memoize(async (fromFolder) => {
-    const files = await fs.readdirAsync(fromFolder);
+    const files = await fsPromises.readdir(fromFolder);
     // this is either invoked by running the Testim CLI from inside the tests folder or from inside the `init` folder
     // so deal with the case we're inside tests.
-    const isInProjectFolder = files.includes('tests') && (await fs.statAsync(path.join(fromFolder, 'tests'))).isDirectory();
+    const isInProjectFolder = files.includes('tests') && (await fsPromises.stat(path.join(fromFolder, 'tests'))).isDirectory();
     if (isInProjectFolder) {
         return path.join(fromFolder, 'tests');
     }
@@ -27,7 +26,7 @@ async function getLocalLocators() {
         // eslint-disable-next-line no-eval
         return eval(buffer.toString().replace(/require/g, '(x => /locator\.(.*)\.json/.exec(x)[1])'));
     }
-    const locators = await fs.readFileAsync(locatorsFilePath).then(parseLocators, () => ({}));
+    const locators = await fsPromises.readFile(locatorsFilePath).then(parseLocators, () => ({}));
     return _(Object.keys(locators)).map((id) => {
         const escapedId = id.replace(/"/g, '\\"');
         return [escapedId, locators[id]];
@@ -36,7 +35,7 @@ async function getLocalLocators() {
 
 async function findTests(folder = process.cwd()) {
     const testFolder = await findTestFolder(folder);
-    const filesWithStat = await fs.promises.readdir(testFolder, { withFileTypes: true });
+    const filesWithStat = await fsPromises.readdir(testFolder, { withFileTypes: true });
 
     // things we know are not tests but end in js
     const excluded = ['webpack.config.js', 'tsconfig.js', '.DS_Store', 'functions.js'];
@@ -70,13 +69,14 @@ async function getLocalLocatorContents(locators, full = false, originFolder = pr
     if (full) {
         const folder = await findTestFolder(originFolder);
         for (const key of Object.values(locators)) {
-            props[key] = fs.promises.readFile(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
+            props[key] = fsPromises.readFile(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
         }
     }
     try {
         const contents = await promiseFromProps(props);
         return contents;
     } catch (e) {
+        // eslint-disable-next-line no-console
         console.error(e);
         return {};
     }
@@ -104,10 +104,10 @@ async function saveTest({
     if (filename.endsWith('locators/locators.js')) {
         throw new Error('Cannot override locators file from the internet as it is evaluated by the runner');
     }
-    await fs.writeFileAsync(filename, body);
-    await fs.mkdirAsync(path.join(folder, 'locators')).catch(() => {});
+    await fsPromises.writeFile(filename, body);
+    await fsPromises.mkdir(path.join(folder, 'locators')).catch(() => {});
     for (const { id, body } of locators) {
-        await fs.writeFileAsync(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify(body));
+        await fsPromises.writeFile(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify(body));
     }
     const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
     const localLocatorMap = await getLocalLocators();
@@ -120,15 +120,15 @@ async function writeLocators(locatorsFilePath, locatorMap) {
         content += `  "${key}": require('./locator.${value}.json'),\n`;
     }
     content += '};';
-    await fs.writeFileAsync(locatorsFilePath, content);
+    await fsPromises.writeFile(locatorsFilePath, content);
 }
 async function saveLocators(locators, { mergeIntoExisting } = { mergeIntoExisting: false }) {
     const folder = await findTestFolder(process.cwd());
     const locatorsFilePath = path.join(folder, 'locators', 'locators.js');
-    await fs.mkdirAsync(path.join(folder, 'locators')).catch(() => {});
+    await fsPromises.mkdir(path.join(folder, 'locators')).catch(() => {});
 
     for (const { name, id, elementLocator } of locators) {
-        await fs.writeFileAsync(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify({ name, id, elementLocator }));
+        await fsPromises.writeFile(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify({ name, id, elementLocator }));
     }
     const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
     if (mergeIntoExisting) {
@@ -139,14 +139,14 @@ async function saveLocators(locators, { mergeIntoExisting } = { mergeIntoExistin
     await writeLocators(locatorsFilePath, locatorMap);
 }
 
-async function compileFunctionsLibrary({ fileSystem, bypassWebpack } = {}, optionalAbortSignal) {
+async function compileFunctionsLibrary({ fileSystem, bypassWebpack } = {}, optionalAbortSignal = undefined) {
     const folder = await findTestFolder(process.cwd());
-    if (optionalAbortSignal && optionalAbortSignal.aborted) {
+    if (optionalAbortSignal?.aborted) {
         throw new AbortError();
     }
 
     const functionsFile = path.join(folder, 'functions.js');
-    if (bypassWebpack && bypassWebpack.testim) {
+    if (bypassWebpack?.testim) {
         const Module = require('module');
         // attempt to require without webpack compile - useful for puppeteer/selenium hybrid
         const originalRequire = Module.prototype.require;

package/agent/routers/playground/service.js

@@ -1,11 +1,9 @@
 'use strict';
 
-const Promise = require('bluebird');
-const util = require('util');
-const writeFileAsync = util.promisify(require('fs').writeFile);
+const fs = require('fs');
 const path = require('path');
-const { fork } = require('child_process');
 const os = require('os');
+const { fork } = require('child_process');
 const { ClientError, PlaygroundCodeError } = require('../../../errors');
 
 const CODE_TYPES = ['playwright', 'selenium', 'puppeteer'];
@@ -14,13 +12,13 @@ const runForks = {};
 
 async function createTempFile(fileName, data, encoding = 'utf8') {
     const fullPath = path.join(os.tmpdir(), fileName);
-    await writeFileAsync(fullPath, data, encoding);
+    await fs.promises.writeFile(fullPath, data, encoding);
     return fullPath;
 }
 
 const forkAsync = (fileFullPath) => {
     let gotResolved;
-    const promise = new Promise(resolve => gotResolved = resolve);
+    const promise = new Promise(resolve => { gotResolved = resolve; });
 
     const child = fork(fileFullPath, { stdio: ['inherit', 'inherit', 'inherit', 'ipc'] });
     promise.child = child;
@@ -30,7 +28,7 @@ const forkAsync = (fileFullPath) => {
         }
         const { type, error } = message;
         if (error && ['uncaughtException', 'unhandledRejection'].includes(type)) {
-            return gotResolved({ error: Object.assign(new PlaygroundCodeError(), { innerStack: message.error.stack }) });
+            gotResolved({ error: Object.assign(new PlaygroundCodeError(), { innerStack: message.error.stack }) });
         }
     });
     child.on('error', (error) => {

package/cli.js

@@ -68,14 +68,14 @@ async function main() {
         require('./commons/logger').setProjectId(processedOptions.project);
         require('./commons/runnerFileCache').setEncryptKey(typeof processedOptions.token === 'string' ? processedOptions.token : 'anonymous_encrypt_key');
 
-        if (processedOptions.initCodimMode) {
+        if (utils.isInitCodimMode(processedOptions)) {
             const codimCli = require('./codim/codim-cli');
             return codimCli.init(processedOptions.initTestProject);
         }
-        if (processedOptions.loginMode) {
+        if (utils.isLoginMode(processedOptions)) {
             return undefined;
         }
-        if (processedOptions.createPrefechedData) {
+        if (utils.isCreatePrefetchedDataMode(processedOptions)) {
             const runnerFileCache = require('./commons/runnerFileCache');
             await runnerFileCache.clear();
             await prepareRunner.initializeUserWithAuth(processedOptions);
@@ -85,14 +85,14 @@ async function main() {
             }
             const res = await runnerFileCache.waitForSave();
             if (res.success) {
-                console.log(`created prefeched data at ${runnerFileCache.getCacheFileLocation()}`);
+                console.log(`created prefetched data at ${runnerFileCache.getCacheFileLocation()}`);
             } else {
-                console.error('failed to create prefech data', res.error);
+                console.error('failed to create prefetch data', res.error);
             }
             return undefined;
         }
 
-        if (processedOptions.tunnelOnlyMode) {
+        if (utils.isTunnelOnlyMode(processedOptions)) {
             await testRunner.init(processedOptions);
             await require('./commons/testimTunnel').serveTunneling(processedOptions);
             return undefined;

package/cliAgentMode.js

@@ -32,16 +32,14 @@ module.exports = {
 };
 
 /**
- * @param {{ agentMode: boolean; }} options
+ * @type {(options: import('./runOptions').Options) => options is import('./runOptions').AgentModeOptions}
  */
 function shouldStartAgentMode(options) {
+    // @ts-ignore should be `as any`
     return options.agentMode;
 }
 
-/**
- *
- * @param {*} options
- */
+/** @param {import('./runOptions').AgentModeOptions} options */
 async function runAgentMode(options) {
     let testimStandaloneBrowser;
 
@@ -53,7 +51,7 @@ async function runAgentMode(options) {
             // Consider moving that into the agent server and add endpoint to start browser?
             testimStandaloneBrowser = await startTestimStandaloneBrowser(options);
         } catch (e) {
-            if (e && e.message && e.message.includes('user data directory is already in use')) {
+            if (e?.message?.includes('user data directory is already in use')) {
                 throw new ArgError('Please close all chrome browsers that were opened with "testim start" and try again');
             }
             throw e;
@@ -62,7 +60,7 @@ async function runAgentMode(options) {
 
     const agentServer = require('./agent/server');
 
-    if (testimStandaloneBrowser && testimStandaloneBrowser.webdriverApi) {
+    if (testimStandaloneBrowser?.webdriverApi) {
         // if we're starting the agent here, pre-load the sessionPlayer so it loads faster
         // on first play
         const LOAD_PLAYER_DELAY = 6000;
@@ -168,6 +166,7 @@ async function startFixedVersionChromium(options, extensionBase64, downloadedExt
     };
 }
 
+/** @param {import('./runOptions').AgentModeOptions} options */
 async function startTestimStandaloneBrowser(options) {
     // After next clickim release we will have also testim-full.zip
     // const fullExtensionUrl = "https://testimstatic.blob.core.windows.net/extension/testim-full-master.zip";
@@ -221,9 +220,11 @@ async function startTestimStandaloneBrowser(options) {
     }
     await prepareUtils.prepareChromeDriver(
         { projectId: options.project },
+        // @ts-expect-error not clear where chromeBinaryLocations comes from
         { chromeBinaryLocation: options.chromeBinaryLocations },
     );
 
+    // @ts-expect-error not clear where chromeBinaryLocations comes from
     const seleniumOptions = buildSeleniumOptions(USER_DATA_DIR, extensionBase64, options.extensionPath, options.chromeBinaryLocations);
 
     const WebDriver = require('./player/webdriver');
@@ -263,7 +264,7 @@ async function startTestimStandaloneBrowser(options) {
 
 /**
  * @param {string} userDataDir
- * @param {string} fullExtensionPath
+ * @param {string | null} fullExtensionPath
  */
 function buildSeleniumOptions(userDataDir, fullExtensionPath, unpackedExtensionPath, chromeBinaryPath) {
     const extensions = fullExtensionPath ? [fullExtensionPath] : [];
@@ -355,7 +356,7 @@ async function readAndValidateChromedriverDevToolsActivePortFile() {
 
 /**
  * @param {string | import("url").URL} webSocketDebuggerUrl
- * @param {number?} timeout
+ * @param {number=} timeout
  */
 async function tryToCloseBrowserWithCDPUrl(webSocketDebuggerUrl, timeout = 100) {
     const websocketConnection = await wsConnectAndOpen(webSocketDebuggerUrl, timeout);
@@ -370,7 +371,7 @@ async function tryToCloseBrowserWithCDPUrl(webSocketDebuggerUrl, timeout = 100)
 
 /**
  * @param {string | import("url").URL} webSocketDebuggerUrl
- * @param {number?} timeout
+ * @param {number=} timeout
  */
 async function wsConnectAndOpen(webSocketDebuggerUrl, timeout = 100) {
     const websocket = new WebSocket(webSocketDebuggerUrl, { timeout });

package/codim/codim-cli.js

@@ -1,14 +1,19 @@
+// @ts-check
+
 /* eslint-disable no-console */
 
 'use strict';
 
-const { promisifyAll } = require('bluebird');
-const fse = require('fs-extra');
-const exec = promisifyAll(require('child_process')).execAsync;
+const fs = require('fs');
+const childProcess = require('child_process');
 const path = require('path');
 const validateNpmPackageName = require('validate-npm-package-name');
-const ArgError = require('../errors.js').ArgError;
+const { promisify } = require('util');
+const { ArgError } = require('../errors.js');
+
+const exec = promisify(childProcess.exec);
 
+/** @param {string} name */
 module.exports.init = async function init(name) {
     const ora = require('ora');
     const prompts = require('prompts');
@@ -25,7 +30,7 @@ module.exports.init = async function init(name) {
 
     const fullPath = path.resolve(name);
 
-    if (fse.existsSync(fullPath) && fse.readdirSync(fullPath).length !== 0) {
+    if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length !== 0) {
         console.log(`${fullPath} is not empty. Quitting...`);
         process.exit(1);
     }
@@ -57,20 +62,20 @@ module.exports.init = async function init(name) {
 
     let spinner = ora(`Creating new test project in ${dest}`).start();
 
-    await fse.copy(source, dest);
+    await fs.promises.copyFile(source, dest);
 
     const sourcePackageJson = path.join(__dirname, sourceFolder, 'package.json');
     const destPackageJson = path.join(process.cwd(), name, 'package.json');
 
-    const packageContents = await fse.readFile(sourcePackageJson);
+    const packageContents = await fs.promises.readFile(sourcePackageJson);
 
     const newPackageJson = packageContents.toString().replace('~testim-codeful-test-project~', packageName);
 
-    await fse.writeFile(destPackageJson, newPackageJson);
+    await fs.promises.writeFile(destPackageJson, newPackageJson);
 
     const gitIgnore = 'node_modules';
     const gitIgnoreFilePath = path.join(process.cwd(), name, '.gitignore');
-    await fse.writeFile(gitIgnoreFilePath, gitIgnore);
+    await fs.promises.writeFile(gitIgnoreFilePath, gitIgnore);
 
     spinner.succeed();
     spinner = ora('Installing dependencies').start();

package/commons/featureFlags.js

@@ -1,9 +1,11 @@
 'use strict';
 
-const { ROLLOUT_KEY, IS_ON_PREM, GATEWAY_URL } = require('./config');
-const logger = require('./logger').getLogger('FeatureFlagsService');
-const Promise = require('bluebird');
 const Rox = require('rox-node');
+const { getLogger } = require('./logger');
+const { promiseTimeout } = require('../utils');
+const { ROLLOUT_KEY, IS_ON_PREM, GATEWAY_URL } = require('./config');
+
+const logger = getLogger('FeatureFlagsService');
 
 // IS_UNIT_TEST = disable rollout if code run in unit test mode to ignore mocha process stuck on running
 const USE_FEATURE_FLAGS = !IS_ON_PREM && !process.env.IS_UNIT_TEST && !GATEWAY_URL;
@@ -11,6 +13,7 @@ const USE_FEATURE_FLAGS = !IS_ON_PREM && !process.env.IS_UNIT_TEST && !GATEWAY_U
 const FORCE_FETCH_TIMEOUT_MS = 20000; // rollout sometimes takes up to 15 seconds to load
 const SEC_IN_DAY = 60 * 60 * 24;
 
+/** @type {['labs', 'disabled', 'enabled'] as const} */
 const LAB_FEATURE_FLAG_VALUES = ['labs', 'disabled', 'enabled'];
 
 class LabFeatureFlag extends Rox.Variant {
@@ -18,6 +21,7 @@ class LabFeatureFlag extends Rox.Variant {
         super(initialValue, LAB_FEATURE_FLAG_VALUES);
     }
 
+    /** @returns {(typeof LAB_FEATURE_FLAG_VALUES)[number]} */
     getValue() {
         const value = super.getValue();
         if (!LAB_FEATURE_FLAG_VALUES.includes(value)) {
@@ -63,33 +67,51 @@ class FeatureFlagsService {
         Rox.register('default', this.flags);
     }
 
+    /** @param {string} projectId */
     setProjectId(projectId) {
         Rox.setCustomStringProperty('projectId', projectId);
     }
 
+    /** @param {string} projectType */
+    setProjectType(projectType) {
+        Rox.setCustomStringProperty('projectType', projectType);
+    }
+
+    /** @param {string} productType */
+    setCompanyProductType(productType) {
+        Rox.setCustomStringProperty('productType', productType);
+    }
+
+    /** @param {string} companyId */
     setCompanyId(companyId) {
         Rox.setCustomStringProperty('companyId', companyId);
     }
 
+    /** @param {string} planType */
     setPlanType(planType) {
         Rox.setCustomStringProperty('planType', planType);
     }
 
+    /** @param {boolean} isPOC */
     setIsPOC(isPOC) {
         Rox.setCustomBooleanProperty('isPOC', isPOC);
     }
+
+    /** @param {boolean} isStartUp */
     setIsStartUp(isStartUp) {
         Rox.setCustomBooleanProperty('isStartUp', isStartUp);
     }
 
+    /** @param {string} mode */
     setRunnerMode(mode) {
         Rox.setCustomStringProperty('runnerMode', mode);
     }
 
-    fetch() {
+    async fetch() {
         if (!USE_FEATURE_FLAGS) {
-            return Promise.resolve();
+            return undefined;
         }
+        /** @type {Rox.RoxSetupOptions} */
         const opts = {
             fetchIntervalInSec: SEC_IN_DAY, // we don't actually want to refresh feature flags in the CLI,
             disableNetworkFetch: false,
@@ -102,8 +124,8 @@ class FeatureFlagsService {
             opts.httpAgent = agent;
         }
 
-        return Promise.resolve(Rox.setup(ROLLOUT_KEY, opts))
-            .timeout(FORCE_FETCH_TIMEOUT_MS).catch(err => logger.error('failed to get feature flag status', err));
+        return promiseTimeout(Rox.setup(ROLLOUT_KEY, opts), FORCE_FETCH_TIMEOUT_MS)
+            .catch(err => logger.error('failed to get feature flag status', err));
     }
 }
 

package/commons/httpRequest.js

@@ -79,7 +79,7 @@ function post({
         .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
-function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry) {
+function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry = 0) {
     const request = superagent
         .post(url)
         .send(body)
@@ -215,6 +215,10 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
         .catch(logErrorAndRethrow('failed to put request', { url }));
 }
 
+/**
+ * @param {string} url
+ * @returns {Promise<Omit<superagent.Response, 'body'> & { body: Buffer }>}
+ */
 function download(url) {
     logger.info('start to download', { url });
 

package/commons/httpRequestCounters.js

@@ -1,10 +1,11 @@
-'use strit';
+'use strict';
 
-const { sum } = require('lodash');
-const Bluebird = require('bluebird');
-const dns = require('dns');
 const _ = require('lodash');
 const config = require('./config');
+const dns = require('dns').promises;
+const Bluebird = require('bluebird');
+const { sum } = require('lodash');
+const { promiseMap } = require('../utils/promiseUtils');
 
 const logger = require('./logger').getLogger('http-request-counters');
 
@@ -18,7 +19,7 @@ const testNetworkConnectivity = async () => {
     const hostnames = ['www.google.com', 'www.facebook.com', 'www.microsoft.com', 'testim.io'];
     try {
         // If any of these domains resolve we consider the connectivity to be ok
-        const result = Boolean(await Bluebird.any(hostnames.map(host => dns.promises.lookup(host))));
+        const result = Boolean(await promiseMap(hostnames, host => dns.lookup(host)));
         if (!result) {
             networkConnectivityTestFailed = true;
         }
@@ -40,18 +41,28 @@ const ttl = 60 * 1000 * 15;
 
 module.exports.makeCounters = () => {
     const counters = {
-        call: new Map(),
-        success: new Map(),
-        fail: new Map(),
+        /** @type {Map<string, number>} */ call: new Map(),
+        /** @type {Map<string, number>} */ success: new Map(),
+        /** @type {Map<string, number>} */ fail: new Map(),
     };
+    /**
+     * @param {counters[keyof counters]} counter
+     * @param {string} key
+     */
     function update(counter, key) {
         const result = counter.get(key) || 0;
         counter.set(key, result + 1);
         setTimeout(() => {
-            const result = counter.get(key) || 1;
-            counter.set(key, result - 1);
+            const _result = counter.get(key) || 1;
+            counter.set(key, _result - 1);
         }, ttl);
     }
+    /**
+     * @template T, TArgs
+     * @param {(...args: TArgs) => T} fn
+     * @param {string=} name
+     * @return {(...args: TArgs) => Bluebird<Awaited<T>>}
+     */
     function wrapWithMonitoring(fn, name = fn.name) {
         return Bluebird.method(async function (...args) {
             update(counters.call, name);

package/commons/initializeUserWithAuth.js

@@ -1,7 +1,7 @@
 
 const perf = require('./performance-logger');
 const localRunnerCache = require('./runnerFileCache');
-const servicesApi = require('./testimServicesApi.js');
+const servicesApi = require('./testimServicesApi');
 const testimCustomToken = require('./testimCustomToken');
 const { CLI_MODE } = require('./constants');
 
@@ -24,12 +24,15 @@ function preloadSlowRequires(mode) {
     });
 }
 
+/**
+ * @param {import('../runOptions').RunnerOptions} options
+ */
 async function initializeUserWithAuth(options) {
     const { project, token, lightweightMode, useLocalChromeDriver, useChromeLauncher, mode } = options;
 
-    const lightweightModeGenral = Boolean(lightweightMode && lightweightMode.general);
+    const lightweightModeGeneral = Boolean(lightweightMode?.general);
     const localGrid = Boolean(useLocalChromeDriver || useChromeLauncher);
-    const memoizationTTL = lightweightModeGenral ? TEN_HOURS_MS : FIVE_MINUTES_MS;
+    const memoizationTTL = lightweightModeGeneral ? TEN_HOURS_MS : FIVE_MINUTES_MS;
 
     perf.log('before initializeUserWithAuth');
     const result = await localRunnerCache.memoize(async () => {
@@ -41,7 +44,7 @@ async function initializeUserWithAuth(options) {
             lightweightMode,
             localGrid,
         });
-    }, 'initializeUserWithAuth', memoizationTTL, { project, token, branchName: options.branch, lightweightModeGenral, localGrid })();
+    }, 'initializeUserWithAuth', memoizationTTL, { project, token, branchName: options.branch, lightweightModeGeneral, localGrid })();
     perf.log('after initializeUserWithAuth');
 
     testimCustomToken.initFromData(result.authData, options.project, options.token);

package/commons/lazyRequire.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Bluebird = require('bluebird');
 const npmWrapper = require('./npmWrapper');
 const ora = require('ora');
 const path = require('path');
@@ -76,10 +75,12 @@ async function lazyRequireImpl(dependency) {
     return requireWithFallback(dependency);
 }
 
-function installAllLazyDependencies() {
+async function installAllLazyDependencies() {
     const allLazyDependencies = Object.keys(packageJson.lazyDependencies);
 
-    return Bluebird.each(allLazyDependencies, dep => lazyRequireImpl(dep));
+    for (const dep of allLazyDependencies) {
+        await lazyRequireImpl(dep);
+    }
 }
 
 if (require.main === module) {