@hubspot/cli 7.5.11-experimental.0 → 7.6.0-beta.1

package/lib/marketplaceValidate.js

@@ -10,8 +10,7 @@ exports.processValidationErrors = processValidationErrors;
 exports.displayValidationResults = displayValidationResults;
 const chalk_1 = __importDefault(require("chalk"));
 const marketplaceValidation_1 = require("@hubspot/local-dev-lib/api/marketplaceValidation");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const lang_1 = require("./lang");
+const logger_1 = require("./ui/logger");
 const exitCodes_1 = require("./enums/exitCodes");
 const SLEEP_TIME = 2000;
 async function kickOffValidation(accountId, assetType, src) {
@@ -25,7 +24,7 @@ async function kickOffValidation(accountId, assetType, src) {
         return requestResult;
     }
     catch (err) {
-        logger_1.logger.debug(err);
+        logger_1.uiLogger.debug(err);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
@@ -43,7 +42,7 @@ async function pollForValidationFinish(accountId, validationId) {
         await checkValidationStatus();
     }
     catch (err) {
-        logger_1.logger.debug(err);
+        logger_1.uiLogger.debug(err);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
@@ -55,69 +54,63 @@ async function fetchValidationResults(accountId, validationId) {
         return validationResults;
     }
     catch (err) {
-        logger_1.logger.debug(err);
+        logger_1.uiLogger.debug(err);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-function processValidationErrors(i18nKey, validationResults) {
+function processValidationErrors(invalidPathError, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
             if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
-                logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidPath`, {
-                    path: assetPath,
-                }));
+                logger_1.uiLogger.error(invalidPathError(assetPath));
             }
             else {
-                logger_1.logger.error(`${err.context}`);
+                logger_1.uiLogger.error(`${err.context}`);
             }
         });
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-function displayFileInfo(file, line, i18nKey) {
+function displayFileInfo(file, line, resultsCopy) {
     if (file) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.file`, {
-            file,
-        }));
+        logger_1.uiLogger.log(resultsCopy.warnings.file(file));
     }
     if (line) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.lineNumber`, {
-            line,
-        }));
+        logger_1.uiLogger.log(resultsCopy.warnings.lineNumber(line.toString()));
     }
 }
-function displayResults(checks, i18nKey) {
+function displayResults(checks, resultsCopy) {
     if (checks) {
         const { status, results } = checks;
         if (status === 'FAIL') {
             const failedValidations = results.filter(test => test.status === 'FAIL');
             const warningValidations = results.filter(test => test.status === 'WARN');
             failedValidations.forEach(val => {
-                logger_1.logger.error(`${val.message}`);
-                displayFileInfo(val.file, val.line, i18nKey);
+                logger_1.uiLogger.error(`${val.message}`);
+                displayFileInfo(val.file, val.line, resultsCopy);
             });
             warningValidations.forEach(val => {
-                logger_1.logger.warn(`${val.message}`);
-                displayFileInfo(val.file, val.line, i18nKey);
+                logger_1.uiLogger.warn(`${val.message}`);
+                displayFileInfo(val.file, val.line, resultsCopy);
             });
         }
         if (status === 'PASS') {
-            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.results.noErrors`));
+            logger_1.uiLogger.success(resultsCopy.noErrors);
             results.forEach(test => {
                 if (test.status === 'WARN') {
-                    logger_1.logger.warn(`${test.message}`);
-                    displayFileInfo(test.file, test.line, i18nKey);
+                    logger_1.uiLogger.warn(`${test.message}`);
+                    displayFileInfo(test.file, test.line, resultsCopy);
                 }
             });
         }
     }
     return;
 }
-function displayValidationResults(i18nKey, validationResults) {
+function displayValidationResults(resultsCopy, validationResults) {
     Object.keys(validationResults.results).forEach(type => {
-        logger_1.logger.log(chalk_1.default.bold((0, lang_1.i18n)(`${i18nKey}.results.${type.toLowerCase()}`)));
-        displayResults(validationResults.results[type], i18nKey);
-        logger_1.logger.log();
+        logger_1.uiLogger.log(chalk_1.default.bold(resultsCopy[type.toLowerCase()]));
+        displayResults(validationResults.results[type], resultsCopy);
+        logger_1.uiLogger.log('');
     });
 }

package/lib/mcp/setup.d.ts

@@ -0,0 +1,21 @@
+export declare const supportedTools: ({
+    name: "Claude Code";
+    value: string;
+} | {
+    name: "Cursor";
+    value: string;
+} | {
+    name: "Windsurf";
+    value: string;
+})[];
+interface McpCommand {
+    command: string;
+    args: string[];
+}
+export declare function addMintlifyMcpServer(installTargets: string[]): Promise<void>;
+export declare function setupMintlify(derivedTargets?: string[]): Promise<boolean>;
+export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
+export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupCursor(mcpCommand?: McpCommand): boolean;
+export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export {};

package/lib/mcp/setup.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedTools = void 0;
+exports.addMintlifyMcpServer = addMintlifyMcpServer;
+exports.setupMintlify = setupMintlify;
+exports.addMcpServerToConfig = addMcpServerToConfig;
+exports.setupClaudeCode = setupClaudeCode;
+exports.setupCursor = setupCursor;
+exports.setupWindsurf = setupWindsurf;
+const logger_1 = require("../ui/logger");
+const en_1 = require("../../lang/en");
+const promptUtils_1 = require("../prompts/promptUtils");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const errorHandlers_1 = require("../errorHandlers");
+const command_1 = require("../../mcp-server/utils/command");
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const fs_1 = require("fs");
+const mcpServerName = 'hubspot-cli-mcp';
+const claudeCode = 'claude';
+const windsurf = 'windsurf';
+const cursor = 'cursor';
+const supportedMintlifyClients = [windsurf, cursor];
+exports.supportedTools = [
+    { name: en_1.commands.mcp.setup.claudeCode, value: claudeCode },
+    { name: en_1.commands.mcp.setup.cursor, value: cursor },
+    { name: en_1.commands.mcp.setup.windsurf, value: windsurf },
+];
+const defaultMcpCommand = {
+    command: 'hs',
+    args: ['mcp', 'start'],
+};
+async function addMintlifyMcpServer(installTargets) {
+    await runSetupFunction(() => setupMintlify(installTargets));
+}
+async function setupMintlify(derivedTargets = supportedMintlifyClients) {
+    logger_1.uiLogger.info(en_1.commands.mcp.setup.installingDocSearch);
+    logger_1.uiLogger.log('');
+    return new Promise(resolve => {
+        const subcommands = ['mint-mcp', 'add', 'hubspot-migration'];
+        const docsSearchClients = derivedTargets.filter(target => supportedMintlifyClients.includes(target));
+        const childProcess = (0, child_process_1.spawn)(`npx`, docsSearchClients && docsSearchClients.length
+            ? [...subcommands, '--client', ...docsSearchClients]
+            : subcommands, {
+            stdio: 'inherit',
+        });
+        childProcess.on('exit', code => {
+            if (code !== 0) {
+                resolve(false);
+            }
+            resolve(true);
+        });
+    });
+}
+async function addMcpServerToConfig(targets) {
+    try {
+        let derivedTargets = [];
+        if (!targets || targets.length === 0) {
+            const { selectedTargets } = await (0, promptUtils_1.promptUser)({
+                name: 'selectedTargets',
+                type: 'checkbox',
+                message: en_1.commands.mcp.setup.prompts.targets,
+                choices: exports.supportedTools,
+                validate: (choices) => {
+                    return choices.length === 0
+                        ? en_1.commands.mcp.setup.prompts.targetsRequired
+                        : true;
+                },
+            });
+            derivedTargets = selectedTargets;
+        }
+        else {
+            derivedTargets = targets;
+        }
+        SpinniesManager_1.default.init();
+        if (derivedTargets.includes(claudeCode)) {
+            await runSetupFunction(setupClaudeCode);
+        }
+        if (derivedTargets.includes(cursor)) {
+            await runSetupFunction(setupCursor);
+        }
+        if (derivedTargets.includes(windsurf)) {
+            await runSetupFunction(setupWindsurf);
+        }
+        logger_1.uiLogger.info(en_1.commands.mcp.setup.success(derivedTargets));
+        return derivedTargets;
+    }
+    catch (error) {
+        SpinniesManager_1.default.fail('mcpSetup', {
+            text: en_1.commands.mcp.setup.spinners.failedToConfigure,
+        });
+        throw error;
+    }
+}
+async function runSetupFunction(func) {
+    const result = await func();
+    if (!result) {
+        throw new Error();
+    }
+}
+function setupMcpConfigFile(config) {
+    try {
+        SpinniesManager_1.default.add('spinner', {
+            text: config.configuringMessage,
+        });
+        if (!(0, fs_1.existsSync)(config.configPath)) {
+            fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
+        }
+        let mcpConfig = {};
+        try {
+            const configContent = fs_extra_1.default.readFileSync(config.configPath, 'utf8');
+            mcpConfig = JSON.parse(configContent);
+        }
+        catch (error) {
+            SpinniesManager_1.default.fail('spinner', {
+                text: config.failedMessage,
+            });
+            (0, errorHandlers_1.logError)(error);
+            return false;
+        }
+        // Initialize mcpServers if it doesn't exist
+        if (!mcpConfig.mcpServers) {
+            mcpConfig.mcpServers = {};
+        }
+        // Add or update HubSpot CLI MCP server
+        mcpConfig.mcpServers[mcpServerName] = {
+            ...config.mcpCommand,
+        };
+        // Write the updated config
+        fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
+        SpinniesManager_1.default.succeed('spinner', {
+            text: config.configuredMessage,
+        });
+        return true;
+    }
+    catch (error) {
+        SpinniesManager_1.default.fail('spinner', {
+            text: config.failedMessage,
+        });
+        (0, errorHandlers_1.logError)(error);
+        return false;
+    }
+}
+async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager_1.default.add('claudeCode', {
+            text: en_1.commands.mcp.setup.spinners.configuringClaudeCode,
+        });
+        try {
+            // Check if claude command is available
+            await (0, command_1.execAsync)('claude --version');
+            // Run claude mcp add command
+            const mcpConfig = JSON.stringify({
+                type: 'stdio',
+                ...mcpCommand,
+            });
+            const { stdout } = await (0, command_1.execAsync)('claude mcp list');
+            if (stdout.includes(mcpServerName)) {
+                SpinniesManager_1.default.update('claudeCode', {
+                    text: en_1.commands.mcp.setup.spinners.alreadyInstalled,
+                });
+                await (0, command_1.execAsync)(`claude mcp remove "${mcpServerName}" --scope user`);
+            }
+            await (0, command_1.execAsync)(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
+            SpinniesManager_1.default.succeed('claudeCode', {
+                text: en_1.commands.mcp.setup.spinners.configuredClaudeCode,
+            });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('claude: command not found')) {
+                SpinniesManager_1.default.fail('claudeCode', {
+                    text: en_1.commands.mcp.setup.spinners.claudeCodeNotFound,
+                });
+            }
+            else {
+                SpinniesManager_1.default.fail('claudeCode', {
+                    text: en_1.commands.mcp.setup.spinners.claudeCodeInstallFailed,
+                });
+                (0, errorHandlers_1.logError)(error);
+            }
+            return false;
+        }
+    }
+    catch (error) {
+        SpinniesManager_1.default.fail('claudeCode', {
+            text: en_1.commands.mcp.setup.spinners.claudeCodeInstallFailed,
+        });
+        (0, errorHandlers_1.logError)(error);
+        return false;
+    }
+}
+function setupCursor(mcpCommand = defaultMcpCommand) {
+    const cursorConfigPath = path_1.default.join(os_1.default.homedir(), '.cursor', 'mcp.json');
+    return setupMcpConfigFile({
+        configPath: cursorConfigPath,
+        configuringMessage: en_1.commands.mcp.setup.spinners.configuringCursor,
+        configuredMessage: en_1.commands.mcp.setup.spinners.configuredCursor,
+        failedMessage: en_1.commands.mcp.setup.spinners.failedToConfigureCursor,
+        mcpCommand,
+    });
+}
+function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    const windsurfConfigPath = path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    return setupMcpConfigFile({
+        configPath: windsurfConfigPath,
+        configuringMessage: en_1.commands.mcp.setup.spinners.configuringWindsurf,
+        configuredMessage: en_1.commands.mcp.setup.spinners.configuredWindsurf,
+        failedMessage: en_1.commands.mcp.setup.spinners.failedToConfigureWindsurf,
+        mcpCommand,
+    });
+}

package/lib/middleware/autoUpdateMiddleware.d.ts

@@ -0,0 +1 @@
+export declare function autoUpdateCLI(): Promise<void>;

package/lib/middleware/autoUpdateMiddleware.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoUpdateCLI = autoUpdateCLI;
+// Update-notifier is CommonJS, so we need to use require
+const updateNotifier = require('update-notifier');
+const config_1 = require("@hubspot/local-dev-lib/config");
+const package_json_1 = __importDefault(require("../../package.json"));
+const ui_1 = require("../ui");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const en_1 = require("../../lang/en");
+const npm_1 = require("../npm");
+const errorHandlers_1 = require("../errorHandlers");
+const logger_1 = require("../ui/logger");
+// Default behavior is to check for notifications at most once per day
+// update-notifier stores the last checked date in the user's home directory
+const notifier = updateNotifier({
+    pkg: { ...package_json_1.default, name: '@hubspot/cli' },
+    distTag: 'latest',
+    shouldNotifyInNpmScript: true,
+});
+const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
+function updateNotification() {
+    notifier.notify({
+        message: package_json_1.default.name === CMS_CLI_PACKAGE_NAME
+            ? en_1.lib.middleware.updateNotification.cmsUpdateNotification(CMS_CLI_PACKAGE_NAME)
+            : en_1.lib.middleware.updateNotification.cliUpdateNotification,
+        defer: false,
+        boxenOptions: {
+            borderColor: ui_1.UI_COLORS.MARIGOLD_DARK,
+            margin: 1,
+            padding: 1,
+            textAlignment: 'center',
+            borderStyle: 'round',
+            title: package_json_1.default.name === CMS_CLI_PACKAGE_NAME
+                ? null
+                : en_1.lib.middleware.updateNotification.notifyTitle,
+        },
+    });
+}
+async function autoUpdateCLI() {
+    // This lets us back to default update-notifier behavior
+    let showManualInstallHelp = true;
+    if (notifier &&
+        notifier.update &&
+        !process.env.SKIP_HUBSPOT_CLI_AUTO_UPDATES &&
+        (0, config_1.isConfigFlagEnabled)('allowAutoUpdates')) {
+        // Ignore all update notifications if the current version is a pre-release
+        if (!notifier.update.current.includes('-')) {
+            // Attempt auto-update if the current version is not the latest version
+            // Never auto-update for major version updates b/c they are breaking
+            if (!['major', 'latest'].includes(notifier.update.type)) {
+                SpinniesManager_1.default.init({
+                    succeedColor: 'white',
+                });
+                SpinniesManager_1.default.add('cliAutoUpdate', {
+                    text: en_1.lib.middleware.autoUpdateCLI.updateAvailable(notifier.update.latest),
+                });
+                try {
+                    if ((await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER)) &&
+                        (await (0, npm_1.isGloballyInstalled)('hs'))) {
+                        await (0, npm_1.executeInstall)(['@hubspot/cli@latest'], '-g');
+                        showManualInstallHelp = false;
+                        SpinniesManager_1.default.succeed('cliAutoUpdate', {
+                            text: en_1.lib.middleware.autoUpdateCLI.updateSucceeded(notifier.update.latest),
+                        });
+                        logger_1.uiLogger.log('');
+                    }
+                    else {
+                        SpinniesManager_1.default.fail('cliAutoUpdate', {
+                            text: en_1.lib.middleware.autoUpdateCLI.notInstalledGlobally,
+                        });
+                    }
+                }
+                catch (e) {
+                    (0, errorHandlers_1.debugError)(e);
+                    SpinniesManager_1.default.fail('cliAutoUpdate', {
+                        text: en_1.lib.middleware.autoUpdateCLI.updateFailed(notifier.update.latest),
+                    });
+                }
+            }
+        }
+    }
+    if (showManualInstallHelp) {
+        updateNotification();
+    }
+}

package/lib/middleware/configMiddleware.js

@@ -40,6 +40,13 @@ async function injectAccountIdMiddleware(argv) {
 const SKIP_CONFIG_VALIDATION = {
     init: { target: true },
     auth: { target: true },
+    mcp: {
+        target: false,
+        subCommands: {
+            setup: { target: true },
+            start: { target: true },
+        },
+    },
 };
 async function loadConfigMiddleware(argv) {
     // Skip this when no command is provided
@@ -55,6 +62,7 @@ async function loadConfigMiddleware(argv) {
     if (!(0, config_1.configFileExists)(true) &&
         (0, utils_1.isTargetedCommand)(argv._, {
             account: { target: false, subCommands: { auth: { target: true } } },
+            config: { target: false, subCommands: { migrate: { target: true } } },
         })) {
         return;
     }
@@ -86,6 +94,7 @@ const accountsSubCommands = {
         list: { target: true },
         ls: { target: true },
         remove: { target: true },
+        use: { target: true },
     },
 };
 const sandboxesSubCommands = {
@@ -94,13 +103,27 @@ const sandboxesSubCommands = {
         delete: { target: true },
     },
 };
+const configSubCommands = {
+    target: false,
+    subCommands: {
+        migrate: { target: true },
+    },
+};
 const SKIP_ACCOUNT_VALIDATION = {
     init: { target: true },
     auth: { target: true },
+    mcp: {
+        target: false,
+        subCommands: {
+            setup: { target: true },
+            start: { target: true },
+        },
+    },
     account: accountsSubCommands,
     accounts: accountsSubCommands,
     sandbox: sandboxesSubCommands,
     sandboxes: sandboxesSubCommands,
+    config: configSubCommands,
 };
 async function validateAccountOptions(argv) {
     // Skip this when no command is provided

package/lib/middleware/fireAlarmMiddleware.d.ts

@@ -1,4 +1,4 @@
 import { Arguments } from 'yargs';
-export declare function checkFireAlarms(args: Arguments<{
-    derivedAccountId: number;
+export declare function checkFireAlarms(argv: Arguments<{
+    derivedAccountId?: number;
 }>): Promise<void>;

package/lib/middleware/fireAlarmMiddleware.js

@@ -112,10 +112,12 @@ async function logFireAlarms(accountId, command, version) {
         });
     }
 }
-async function checkFireAlarms(args) {
-    const { derivedAccountId } = args;
+async function checkFireAlarms(argv) {
+    const { derivedAccountId } = argv;
     try {
-        await logFireAlarms(derivedAccountId, args._.join(' '), package_json_1.default.version);
+        if (derivedAccountId) {
+            await logFireAlarms(derivedAccountId, argv._.join(' '), package_json_1.default.version);
+        }
     }
     catch (error) {
         (0, errorHandlers_1.debugError)(error);

package/lib/npm.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_PACKAGE_MANAGER = "npm";
+export declare function isGloballyInstalled(packageName: string): Promise<boolean>;
+export declare function getLatestCliVersion(): Promise<{
+    latest: string;
+    next: string;
+}>;
+export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
+    cwd?: string;
+}): Promise<void>;

package/lib/npm.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PACKAGE_MANAGER = void 0;
+exports.isGloballyInstalled = isGloballyInstalled;
+exports.getLatestCliVersion = getLatestCliVersion;
+exports.executeInstall = executeInstall;
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const package_json_1 = __importDefault(require("../package.json"));
+exports.DEFAULT_PACKAGE_MANAGER = 'npm';
+async function isGloballyInstalled(packageName) {
+    const exec = util_1.default.promisify(child_process_1.exec);
+    try {
+        await exec(`${packageName} --version`);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+async function getLatestCliVersion() {
+    const exec = util_1.default.promisify(child_process_1.exec);
+    const { stdout } = await exec(`npm info ${package_json_1.default.name} dist-tags --json`);
+    const { latest, next } = JSON.parse(stdout);
+    return { latest, next };
+}
+async function executeInstall(packages = [], flags, options) {
+    const installCommand = `${exports.DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
+    logger_1.logger.debug('Running ', installCommand);
+    const exec = util_1.default.promisify(child_process_1.exec);
+    await exec(installCommand, options);
+}

package/lib/projectProfiles.d.ts

@@ -0,0 +1,7 @@
+import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types';
+import { ProjectConfig } from '../types/Projects';
+export declare function logProfileHeader(profileName: string): void;
+export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
+export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
+export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logProfileHeader = logProfileHeader;
+exports.logProfileFooter = logProfileFooter;
+exports.loadProfile = loadProfile;
+exports.exitIfUsingProfiles = exitIfUsingProfiles;
+exports.loadAndValidateProfile = loadAndValidateProfile;
+const path_1 = __importDefault(require("path"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const en_1 = require("../lang/en");
+const ui_1 = require("./ui");
+const logger_1 = require("./ui/logger");
+const exitCodes_1 = require("./enums/exitCodes");
+function logProfileHeader(profileName) {
+    (0, ui_1.uiLine)();
+    (0, ui_1.uiBetaTag)(en_1.lib.projectProfiles.logs.usingProfile((0, project_parsing_lib_1.getHsProfileFilename)(profileName)));
+    logger_1.uiLogger.log('');
+}
+function logProfileFooter(profile, includeVariables = false) {
+    logger_1.uiLogger.log(en_1.lib.projectProfiles.logs.profileTargetAccount(profile.accountId));
+    if (includeVariables) {
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.projectProfiles.logs.profileVariables);
+        Object.entries(profile.variables ?? {}).forEach(([key, value]) => {
+            logger_1.uiLogger.log(`  ${key}: ${value}`);
+        });
+    }
+    (0, ui_1.uiLine)();
+    logger_1.uiLogger.log('');
+}
+function loadProfile(projectConfig, projectDir, profileName) {
+    if (!projectConfig || !projectDir) {
+        logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        return;
+    }
+    const projectSourceDir = path_1.default.join(projectDir, projectConfig.srcDir);
+    const profileFilename = (0, project_parsing_lib_1.getHsProfileFilename)(profileName);
+    try {
+        const profile = (0, project_parsing_lib_1.loadHsProfileFile)(projectSourceDir, profileName);
+        if (!profile) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
+            return;
+        }
+        if (!profile.accountId) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
+            return;
+        }
+        return profile;
+    }
+    catch (e) {
+        logger_1.uiLogger.error(en_1.lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
+        return;
+    }
+}
+async function exitIfUsingProfiles(projectConfig, projectDir) {
+    if (projectConfig && projectDir) {
+        const existingProfiles = await (0, project_parsing_lib_1.getAllHsProfiles)(path_1.default.join(projectDir, projectConfig.srcDir));
+        if (existingProfiles.length > 0) {
+            logger_1.uiLogger.error(en_1.lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+}
+async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
+    if (argsProfile) {
+        logProfileHeader(argsProfile);
+        const profile = loadProfile(projectConfig, projectDir, argsProfile);
+        if (!profile) {
+            (0, ui_1.uiLine)();
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        logProfileFooter(profile, true);
+        return profile.accountId;
+    }
+    else {
+        // A profile must be specified if this project has profiles configured
+        await exitIfUsingProfiles(projectConfig, projectDir);
+    }
+    return undefined;
+}