@hubspot/cli 7.0.0-experimental.1 → 7.0.1-experimental.0

package/lib/prompts/selectHubDBTablePrompt.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectHubDBTablePrompt = selectHubDBTablePrompt;
+const fs_1 = __importDefault(require("fs"));
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
+const index_1 = require("../errorHandlers/index");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const hubdb_1 = require("@hubspot/local-dev-lib/api/hubdb");
+const exitCodes_1 = require("../enums/exitCodes");
+const path_1 = require("@hubspot/local-dev-lib/path");
+const i18nKey = 'lib.prompts.selectHubDBTablePrompt';
+async function fetchHubDBOptions(accountId) {
+    try {
+        const { data: { results: tables }, } = await (0, hubdb_1.fetchTables)(accountId);
+        if (tables.length === 0) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.errors.noTables`, { accountId }));
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        }
+        return tables;
+    }
+    catch (error) {
+        (0, index_1.debugError)(error, { accountId });
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.errorFetchingTables`, { accountId }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+}
+async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
+    const hubdbTables = (await fetchHubDBOptions(accountId)) || [];
+    const id = options.tableId?.toString();
+    const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
+    return (0, promptUtils_1.promptUser)([
+        {
+            name: 'tableId',
+            message: (0, lang_1.i18n)(`${i18nKey}.selectTable`),
+            when: !id && !isValidTable,
+            type: 'list',
+            choices: hubdbTables.map(table => {
+                return {
+                    name: `${table.label} (${table.id})`,
+                    value: table.id,
+                };
+            }),
+        },
+        {
+            name: 'dest',
+            message: (0, lang_1.i18n)(`${i18nKey}.enterDest`),
+            when: !options.dest && !skipDestPrompt,
+            validate: (input) => {
+                if (!input) {
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.destRequired`);
+                }
+                if (fs_1.default.existsSync(input)) {
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.invalidDest`);
+                }
+                if (!(0, path_1.isValidPath)(input)) {
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.invalidCharacters`);
+                }
+                return true;
+            },
+            filter: (input) => {
+                return (0, path_1.untildify)(input);
+            },
+        },
+    ]);
+}

package/lib/prompts/selectPublicAppPrompt.d.ts

@@ -1 +1,9 @@
+type PublicAppPromptResponse = {
+    appId: number;
+};
+export declare function selectPublicAppPrompt({ accountId, accountName, isMigratingApp, }: {
+    accountId: number | null;
+    accountName: string;
+    isMigratingApp?: boolean;
+}): Promise<PublicAppPromptResponse>;
 export {};

package/lib/prompts/selectPublicAppPrompt.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { promptUser } = require('./promptUtils');
-const { i18n } = require('../lang');
-const { uiLine } = require('../ui');
-const { logError } = require('../errorHandlers/index');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { fetchPublicAppsForPortal, } = require('@hubspot/local-dev-lib/api/appsDev');
-const { EXIT_CODES } = require('../enums/exitCodes');
+exports.selectPublicAppPrompt = selectPublicAppPrompt;
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
+const ui_1 = require("../ui");
+const index_1 = require("../errorHandlers/index");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
+const exitCodes_1 = require("../enums/exitCodes");
 const i18nKey = 'lib.prompts.selectPublicAppPrompt';
-const fetchPublicAppOptions = async (accountId, accountName, isMigratingApp = false) => {
+async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
     try {
-        const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
+        if (!accountId) {
+            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noAccountId`));
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        const { data: { results: publicApps }, } = await (0, appsDev_1.fetchPublicAppsForPortal)(accountId);
         const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
         if (!filteredPublicApps.length ||
             (isMigratingApp &&
@@ -22,29 +26,29 @@ const fetchPublicAppOptions = async (accountId, accountName, isMigratingApp = fa
             const messageTranslationKey = isMigratingApp
                 ? 'noAppsMigrationMessage'
                 : 'noAppsCloneMessage';
-            uiLine();
-            logger.error(i18n(`${i18nKey}.errors.${headerTranslationKey}`));
-            logger.log(i18n(`${i18nKey}.errors.${messageTranslationKey}`, { accountName }));
-            uiLine();
-            process.exit(EXIT_CODES.SUCCESS);
+            (0, ui_1.uiLine)();
+            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.${headerTranslationKey}`));
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.errors.${messageTranslationKey}`, { accountName }));
+            (0, ui_1.uiLine)();
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
         }
         return filteredPublicApps;
     }
     catch (error) {
-        logError(error, { accountId });
-        logger.error(i18n(`${i18nKey}.errors.errorFetchingApps`));
-        process.exit(EXIT_CODES.ERROR);
+        (0, index_1.logError)(error, accountId ? { accountId } : undefined);
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.errorFetchingApps`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-};
-const selectPublicAppPrompt = async ({ accountId, accountName, isMigratingApp = false, }) => {
+}
+async function selectPublicAppPrompt({ accountId, accountName, isMigratingApp = false, }) {
     const publicApps = await fetchPublicAppOptions(accountId, accountName, isMigratingApp);
     const translationKey = isMigratingApp
         ? 'selectAppIdMigrate'
         : 'selectAppIdClone';
-    return promptUser([
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'appId',
-            message: i18n(`${i18nKey}.${translationKey}`, {
+            message: (0, lang_1.i18n)(`${i18nKey}.${translationKey}`, {
                 accountName,
             }),
             type: 'list',
@@ -53,7 +57,7 @@ const selectPublicAppPrompt = async ({ accountId, accountName, isMigratingApp =
                 if (isMigratingApp && preventProjectMigrations && listingInfo) {
                     return {
                         name: `${app.name} (${app.id})`,
-                        disabled: i18n(`${i18nKey}.errors.cannotBeMigrated`),
+                        disabled: (0, lang_1.i18n)(`${i18nKey}.errors.cannotBeMigrated`),
                     };
                 }
                 return {
@@ -63,7 +67,4 @@ const selectPublicAppPrompt = async ({ accountId, accountName, isMigratingApp =
             }),
         },
     ]);
-};
-module.exports = {
-    selectPublicAppPrompt,
-};
+}

package/lib/prompts/setAsDefaultAccountPrompt.d.ts

@@ -1 +1 @@
-export {};
+export declare function setAsDefaultAccountPrompt(accountName: string): Promise<boolean>;

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { getConfig, updateDefaultAccount, } = require('@hubspot/local-dev-lib/config');
-const { promptUser } = require('./promptUtils');
-const { i18n } = require('../lang');
+exports.setAsDefaultAccountPrompt = setAsDefaultAccountPrompt;
+const config_1 = require("@hubspot/local-dev-lib/config");
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
 const i18nKey = 'lib.prompts.setAsDefaultAccountPrompt';
-const setAsDefaultAccountPrompt = async (accountName) => {
-    const config = getConfig();
-    const { setAsDefault } = await promptUser([
+async function setAsDefaultAccountPrompt(accountName) {
+    // Accounts for deprecated and new config
+    const defaultAccount = (0, config_1.getConfigDefaultAccount)();
+    const { setAsDefault } = await (0, promptUtils_1.promptUser)([
         {
             name: 'setAsDefault',
             type: 'confirm',
-            when: config.defaultPortal !== accountName,
-            message: i18n(`${i18nKey}.setAsDefaultAccountMessage`),
+            when: defaultAccount !== accountName,
+            message: (0, lang_1.i18n)(`${i18nKey}.setAsDefaultAccountMessage`),
         },
     ]);
     if (setAsDefault) {
-        updateDefaultAccount(accountName);
+        (0, config_1.updateDefaultAccount)(accountName);
     }
     return setAsDefault;
-};
-module.exports = {
-    setAsDefaultAccountPrompt,
-};
+}

package/lib/prompts/uploadPrompt.d.ts

@@ -1 +1,9 @@
+type UploadPromptResponse = {
+    src: string;
+    dest: string;
+};
+export declare function uploadPrompt(promptOptions?: {
+    src?: string;
+    dest?: string;
+}): Promise<UploadPromptResponse>;
 export {};

package/lib/prompts/uploadPrompt.js

@@ -1,39 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const path = require('path');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
-const { promptUser } = require('./promptUtils');
-const { i18n } = require('../lang');
+exports.uploadPrompt = uploadPrompt;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("@hubspot/local-dev-lib/path");
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
 const i18nKey = 'lib.prompts.uploadPrompt';
-const uploadPrompt = (promptOptions = {}) => {
-    return promptUser([
+async function uploadPrompt(promptOptions = {}) {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'src',
-            message: i18n(`${i18nKey}.enterSrc`),
+            message: (0, lang_1.i18n)(`${i18nKey}.enterSrc`),
             when: !promptOptions.src,
             default: '.',
-            validate: input => {
+            validate: (input) => {
                 if (!input) {
-                    return i18n(`${i18nKey}.errors.srcRequired`);
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.srcRequired`);
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: i18n(`${i18nKey}.enterDest`),
+            message: (0, lang_1.i18n)(`${i18nKey}.enterDest`),
             when: !promptOptions.dest,
-            default: path.basename(getCwd()),
-            validate: input => {
+            default: path_1.default.basename((0, path_2.getCwd)()),
+            validate: (input) => {
                 if (!input) {
-                    return i18n(`${i18nKey}.errors.destRequired`);
+                    return (0, lang_1.i18n)(`${i18nKey}.errors.destRequired`);
                 }
                 return true;
             },
         },
     ]);
-};
-module.exports = {
-    uploadPrompt,
-};
+}

package/lib/sandboxSync.js

@@ -11,6 +11,7 @@ const { debugError, logError, ApiErrorContext, } = require('./errorHandlers/inde
 const { isSpecifiedError } = require('@hubspot/local-dev-lib/errors/index');
 const { getSandboxTypeAsString } = require('./sandboxes');
 const { getAccountId } = require('@hubspot/local-dev-lib/config');
+const { getAccountIdentifier, } = require('@hubspot/local-dev-lib/config/getAccountIdentifier');
 const { uiAccountDescription, uiLine, uiLink, uiCommandDisabledBanner, } = require('./ui');
 const { isDevelopmentSandbox } = require('./accountTypes');
 const i18nKey = 'lib.sandbox.sync';
@@ -22,8 +23,10 @@ const i18nKey = 'lib.sandbox.sync';
  * @returns
  */
 const syncSandbox = async ({ accountConfig, parentAccountConfig, env, syncTasks, slimInfoMessage = false, }) => {
-    const accountId = getAccountId(accountConfig.portalId);
-    const parentAccountId = getAccountId(parentAccountConfig.portalId);
+    const id = getAccountIdentifier(accountConfig);
+    const accountId = getAccountId(id);
+    const parentId = getAccountIdentifier(parentAccountConfig);
+    const parentAccountId = getAccountId(parentId);
     const isDevSandbox = isDevelopmentSandbox(accountConfig);
     SpinniesManager.init({
         succeedColor: 'white',

package/lib/sandboxes.js

@@ -5,11 +5,12 @@ const { i18n } = require('./lang');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { getSandboxUsageLimits, } = require('@hubspot/local-dev-lib/api/sandboxHubs');
 const { fetchTypes } = require('@hubspot/local-dev-lib/api/sandboxSync');
-const { getConfig, getAccountId, getEnv, } = require('@hubspot/local-dev-lib/config');
+const { getAccountId, getEnv, getConfigAccounts, } = require('@hubspot/local-dev-lib/config');
 const { promptUser } = require('./prompts/promptUtils');
 const { isDevelopmentSandbox } = require('./accountTypes');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
 const { HUBSPOT_ACCOUNT_TYPES, } = require('@hubspot/local-dev-lib/constants/config');
+const { getAccountIdentifier, } = require('@hubspot/local-dev-lib/config/getAccountIdentifier');
 const { uiAccountDescription } = require('./ui');
 const { isMissingScopeError, isSpecifiedError, } = require('@hubspot/local-dev-lib/errors/index');
 const { getValidEnv } = require('@hubspot/local-dev-lib/environment');
@@ -34,9 +35,10 @@ const getSandboxTypeAsString = accountType => {
     return 'standard';
 };
 function getHasSandboxesByType(parentAccountConfig, type) {
-    const config = getConfig();
-    const parentPortalId = getAccountId(parentAccountConfig.portalId);
-    for (const portal of config.portals) {
+    const id = getAccountIdentifier(parentAccountConfig);
+    const parentPortalId = getAccountId(id);
+    const accountsList = getConfigAccounts();
+    for (const portal of accountsList) {
         if ((portal.parentAccountId !== null ||
             portal.parentAccountId !== undefined) &&
             portal.parentAccountId === parentPortalId &&
@@ -54,8 +56,10 @@ function getSandboxLimit(error) {
 }
 // Fetches available sync types for a given sandbox portal
 async function getAvailableSyncTypes(parentAccountConfig, config) {
-    const parentPortalId = getAccountId(parentAccountConfig.portalId);
-    const portalId = getAccountId(config.portalId);
+    const parentId = getAccountIdentifier(parentAccountConfig);
+    const parentPortalId = getAccountId(parentId);
+    const id = getAccountIdentifier(config);
+    const portalId = getAccountId(id);
     const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
     if (!syncTypes) {
         throw new Error('Unable to fetch available sandbox sync types. Please try again.');
@@ -98,7 +102,8 @@ const getSyncTypesWithContactRecordsPrompt = async (accountConfig, syncTasks, sk
  * @returns {null}
  */
 const validateSandboxUsageLimits = async (accountConfig, sandboxType, env) => {
-    const accountId = getAccountId(accountConfig.portalId);
+    const id = getAccountIdentifier(accountConfig);
+    const accountId = getAccountId(id);
     const { data: { usage }, } = await getSandboxUsageLimits(accountId);
     if (!usage) {
         throw new Error('Unable to fetch sandbox usage limits. Please try again.');

package/lib/ui/index.d.ts

@@ -5,7 +5,7 @@ export declare const UI_COLORS: {
 };
 export declare function uiLine(): void;
 export declare function uiLink(linkText: string, url: string): string;
-export declare function uiAccountDescription(accountId: number, bold?: boolean): string;
+export declare function uiAccountDescription(accountId?: number | null, bold?: boolean): string;
 export declare function uiInfoSection(title: string, logContent: () => void): void;
 export declare function uiCommandReference(command: string): string;
 export declare function uiFeatureHighlight(commands: string[], title: string): void;

package/lib/ui/index.js

@@ -55,7 +55,7 @@ function uiLink(linkText, url) {
         : `${linkText}: ${encodedUrl}`;
 }
 function uiAccountDescription(accountId, bold = true) {
-    const account = (0, config_1.getAccountConfig)(accountId);
+    const account = (0, config_1.getAccountConfig)(accountId || undefined);
     let message;
     if (account && account.accountType) {
         message = `${account.name} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType]}] (${accountId})`;

package/lib/usageTracking.d.ts

@@ -1,2 +1,21 @@
-export declare function trackCommandUsage(command: any, meta: {} | undefined, accountId: any): void;
-export declare function trackCommandMetadataUsage(command: any, meta: {} | undefined, accountId: any): void;
+type Meta = {
+    action?: string;
+    os?: string;
+    nodeVersion?: string;
+    nodeMajorVersion?: string;
+    version?: string;
+    command?: string;
+    authType?: string;
+    step?: string;
+    assetType?: string;
+    mode?: string;
+    type?: string | number;
+    file?: boolean;
+    successful?: boolean;
+};
+export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export declare function trackHelpUsage(command: string): Promise<void>;
+export declare function trackConvertFieldsUsage(command: string): Promise<void>;
+export declare function trackAuthAction(command: string, authType: string, step: string, accountId: number): Promise<void>;
+export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export {};

package/lib/usageTracking.js

@@ -1,43 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trackCommandUsage = trackCommandUsage;
+exports.trackHelpUsage = trackHelpUsage;
+exports.trackConvertFieldsUsage = trackConvertFieldsUsage;
+exports.trackAuthAction = trackAuthAction;
 exports.trackCommandMetadataUsage = trackCommandMetadataUsage;
-// @ts-nocheck
-const { trackUsage } = require('@hubspot/local-dev-lib/trackUsage');
-const { isTrackingAllowed, getAccountConfig, } = require('@hubspot/local-dev-lib/config');
-const { API_KEY_AUTH_METHOD, } = require('@hubspot/local-dev-lib/constants/auth');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { version } = require('../package.json');
-const { setLogLevel } = require('./commonOpts');
-/* **
-Available tracking meta properties
-
-  - action: "The specific action taken in the CLI"
-  - os: "The user's OS"
-  - nodeVersion: "The user's version of node.js"
-  - nodeMajorVersion: "The user's major version of node.js"
-  - version: "The user's version of the CLI"
-  - command: "The specific command that the user ran in this interaction"
-  - authType: "The configured auth type the user has for the CLI"
-  - step: "The specific step in the auth process"
-  - assetType: "The CMS asset type"
-  - mode: "The CLI mode (draft or publish"
-  - type: "The upload type (file or folder)"
-  - file: "Whether or not the 'file' flag was used"
-  - successful: "Whether or not the CLI interaction was successful"
-
-*/
+const trackUsage_1 = require("@hubspot/local-dev-lib/trackUsage");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const package_json_1 = require("../package.json");
+const errorHandlers_1 = require("./errorHandlers");
 const EventClass = {
     USAGE: 'USAGE',
     INTERACTION: 'INTERACTION',
     VIEW: 'VIEW',
     ACTIVATION: 'ACTIVATION',
 };
-const getNodeVersionData = () => ({
-    nodeVersion: process.version,
-    nodeMajorVersion: (process.version || '').split('.')[0],
-});
-const getPlatform = () => {
+function getNodeVersionData() {
+    return {
+        nodeVersion: process.version,
+        nodeMajorVersion: (process.version || '').split('.')[0],
+    };
+}
+function getPlatform() {
     switch (process.platform) {
         case 'darwin':
             return 'macos';
@@ -46,144 +32,130 @@ const getPlatform = () => {
         default:
             return process.platform;
     }
-};
-function trackCommandUsage(command, meta = {}, accountId) {
-    if (!isTrackingAllowed()) {
+}
+async function trackCommandUsage(command, meta = {}, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
-    logger.debug('Attempting to track usage of "%s" command', command);
+    logger_1.logger.debug('Attempting to track usage of "%s" command', command);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = (0, config_1.getAccountConfig)(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
-                : API_KEY_AUTH_METHOD.value;
+                : auth_1.API_KEY_AUTH_METHOD.value;
     }
     setImmediate(async () => {
         const usageTrackingEvent = {
             action: 'cli-command',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
             authType,
             ...meta,
         };
         try {
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+            await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
         }
         catch (e) {
-            logger.debug('Usage tracking failed: %s', e.message);
+            (0, errorHandlers_1.debugError)(e);
         }
     });
 }
 async function trackHelpUsage(command) {
-    if (!isTrackingAllowed()) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
     try {
         if (command) {
-            logger.debug('Tracking help usage of "%s" sub-command', command);
+            logger_1.logger.debug('Tracking help usage of "%s" sub-command', command);
         }
         else {
-            logger.debug('Tracking help usage of main command');
+            logger_1.logger.debug('Tracking help usage of main command');
         }
-        await trackUsage('cli-interaction', EventClass.INTERACTION, {
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
             action: 'cli-help',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
         });
     }
     catch (e) {
-        logger.debug('Usage tracking failed: %s', e.message);
+        (0, errorHandlers_1.debugError)(e);
     }
 }
 async function trackConvertFieldsUsage(command) {
-    if (!isTrackingAllowed()) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
     try {
-        logger.debug('Attempting to track usage of "%s" command', command);
-        await trackUsage('cli-interaction', EventClass.INTERACTION, {
+        logger_1.logger.debug('Attempting to track usage of "%s" command', command);
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
             action: 'cli-process-fields',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
         });
     }
     catch (e) {
-        logger.debug('Usage tracking failed: %s', e.message);
+        (0, errorHandlers_1.debugError)(e);
     }
 }
-const addHelpUsageTracking = (program, command) => {
-    program.on('--help', () => {
-        setLogLevel(program);
-        trackHelpUsage(command);
-    });
-};
-const trackAuthAction = async (command, authType, step, accountId) => {
-    if (!isTrackingAllowed()) {
+async function trackAuthAction(command, authType, step, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
     const usageTrackingEvent = {
         action: 'cli-auth',
         os: getPlatform(),
         ...getNodeVersionData(),
-        version,
+        version: package_json_1.version,
         command,
         authType,
         step,
     };
     try {
-        await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+        logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
     }
     catch (e) {
-        logger.debug('Auth action tracking failed: %s', e.message);
+        (0, errorHandlers_1.debugError)(e);
     }
-};
-function trackCommandMetadataUsage(command, meta = {}, accountId) {
-    if (!isTrackingAllowed()) {
+}
+async function trackCommandMetadataUsage(command, meta = {}, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
-    logger.debug('Attempting to track metadata usage of "%s" command', command);
+    logger_1.logger.debug('Attempting to track metadata usage of "%s" command', command);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = (0, config_1.getAccountConfig)(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
-                : API_KEY_AUTH_METHOD.value;
+                : auth_1.API_KEY_AUTH_METHOD.value;
     }
     setImmediate(async () => {
         const usageTrackingEvent = {
             action: 'cli-command-metadata',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
             authType,
             ...meta,
         };
         try {
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+            await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
         }
         catch (e) {
-            logger.debug('Metadata usage tracking failed: %s', e.message);
+            (0, errorHandlers_1.debugError)(e);
         }
     });
 }
-module.exports = {
-    trackCommandUsage,
-    trackHelpUsage,
-    addHelpUsageTracking,
-    trackConvertFieldsUsage,
-    trackAuthAction,
-    trackCommandMetadataUsage,
-};