@hubspot/cli 7.8.0-experimental.0 → 7.8.0

package/lib/errorHandlers/index.js

@@ -1,15 +1,14 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { isHubSpotHttpError, isValidationError, } from '@hubspot/local-dev-lib/errors/index';
 import { getConfig } from '@hubspot/local-dev-lib/config';
 import { shouldSuppressError } from './suppressError.js';
-import { i18n } from '../lang.js';
+import { lib } from '../../lang/en.js';
 import util from 'util';
-import { uiCommandReference } from '../ui/index.js';
 import { isProjectValidationError } from '../errors/ProjectValidationError.js';
 export function logError(error, context) {
     debugError(error, context);
     if (isProjectValidationError(error)) {
-        logger.error(error.message);
+        uiLogger.error(error.message);
         return;
     }
     if (shouldSuppressError(error, context)) {
@@ -24,7 +23,7 @@ export function logError(error, context) {
         error.updateContext(context);
     }
     if (isHubSpotHttpError(error) && isValidationError(error)) {
-        logger.error(error.formattedValidationErrors());
+        uiLogger.error(error.formattedValidationErrors());
     }
     else if (isErrorWithMessageOrReason(error)) {
         const message = [];
@@ -33,44 +32,37 @@ export function logError(error, context) {
                 message.push(msg);
             }
         });
-        logger.error(message.join(' '));
+        uiLogger.error(message.join(' '));
     }
     else {
         // Unknown errors
-        logger.error(i18n(`lib.errorHandlers.index.unknownErrorOccurred`));
+        uiLogger.error(lib.errorHandlers.index.unknownErrorOccurred);
     }
     if (isHubSpotHttpError(error) && error.code === 'ETIMEDOUT') {
         const config = getConfig();
         const defaultTimeout = config?.httpTimeout;
         // Timeout was caused by the default timeout
         if (error.timeout && defaultTimeout === error.timeout) {
-            logger.error(i18n(`lib.errorHandlers.index.configTimeoutErrorOccurred`, {
-                timeout: error.timeout,
-                configSetCommand: uiCommandReference('hs config set'),
-            }));
+            uiLogger.error(lib.errorHandlers.index.configTimeoutErrorOccurred(error.timeout, 'hs config set'));
         }
         // Timeout was caused by a custom timeout set by the CLI or LDL
         else {
-            logger.error(i18n(`lib.errorHandlers.index.genericTimeoutErrorOccurred`));
+            uiLogger.error(lib.errorHandlers.index.genericTimeoutErrorOccurred);
         }
     }
 }
 export function debugError(error, context) {
     if (isHubSpotHttpError(error)) {
-        logger.debug(error.toString());
+        uiLogger.debug(error.toString());
     }
     else {
-        logger.debug(i18n(`lib.errorHandlers.index.errorOccurred`, { error: String(error) }));
+        uiLogger.debug(lib.errorHandlers.index.errorOccurred(String(error)));
     }
     if (error instanceof Error && error.cause && !isHubSpotHttpError(error)) {
-        logger.debug(i18n(`lib.errorHandlers.index.errorCause`, {
-            cause: util.inspect(error.cause, false, null, true),
-        }));
+        uiLogger.debug(lib.errorHandlers.index.errorCause(util.inspect(error.cause, false, null, true)));
     }
     if (context) {
-        logger.debug(i18n(`lib.errorHandlers.index.errorContext`, {
-            context: util.inspect(context, false, null, true),
-        }));
+        uiLogger.debug(lib.errorHandlers.index.errorContext(util.inspect(context, false, null, true)));
     }
 }
 export class ApiErrorContext {

package/lib/errorHandlers/suppressError.js

@@ -1,8 +1,8 @@
 import { isSpecifiedError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { PLATFORM_VERSION_ERROR_TYPES } from '../constants.js';
-import { i18n } from '../lang.js';
-import { uiAccountDescription, uiLine, uiLink, uiCommandReference, } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+import { uiAccountDescription, uiLine, uiLink } from '../ui/index.js';
 function createPlatformVersionError(err, subCategory) {
     let translationKey = 'unspecifiedPlatformVersion';
     let platformVersion = 'unspecified platformVersion';
@@ -17,25 +17,18 @@ function createPlatformVersionError(err, subCategory) {
         translationKey = 'nonExistentPlatformVersion';
     }
     uiLine();
-    logger.error(i18n(`lib.errorHandlers.suppressErrors.platformVersionErrors.header`));
-    logger.log(i18n(`lib.errorHandlers.suppressErrors.platformVersionErrors.${translationKey}`, {
-        platformVersion,
-    }));
-    logger.log(i18n(`lib.errorHandlers.suppressErrors.platformVersionErrors.updateProject`));
-    logger.log(i18n(`lib.errorHandlers.suppressErrors.platformVersionErrors.betaLink`, {
-        docsLink: uiLink(i18n(`lib.errorHandlers.suppressErrors.platformVersionErrors.docsLink`), 'https://developers.hubspot.com/docs/platform/platform-versioning'),
-    }));
+    uiLogger.error(lib.errorHandlers.suppressErrors.platformVersionErrors.header);
+    const errorMessage = lib.errorHandlers.suppressErrors.platformVersionErrors[translationKey];
+    uiLogger.log(typeof errorMessage === 'function'
+        ? errorMessage(platformVersion)
+        : errorMessage);
+    uiLogger.log(lib.errorHandlers.suppressErrors.platformVersionErrors.updateProject);
+    uiLogger.log(lib.errorHandlers.suppressErrors.platformVersionErrors.betaLink(uiLink(lib.errorHandlers.suppressErrors.platformVersionErrors.docsLink, 'https://developers.hubspot.com/docs/developer-tooling/platform/versioning')));
     uiLine();
 }
 export function shouldSuppressError(err, context) {
     if (isMissingScopeError(err)) {
-        logger.error(i18n(`lib.errorHandlers.suppressErrors.missingScopeError`, {
-            accountName: context?.accountId
-                ? uiAccountDescription(context.accountId)
-                : '',
-            request: context?.request || 'request',
-            authCommand: uiCommandReference('hs auth'),
-        }));
+        uiLogger.error(lib.errorHandlers.suppressErrors.missingScopeError(context?.request || 'request', context?.accountId ? uiAccountDescription(context.accountId) : ''));
         return true;
     }
     if (isSpecifiedError(err, {

package/lib/hasFeature.js

@@ -1,7 +1,13 @@
 import { http } from '@hubspot/local-dev-lib/http';
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { FEATURES } from './constants.js';
+const FEATURES_THAT_DEFAULT_ON = [FEATURES.APPS_HOME];
 export async function hasFeature(accountId, feature) {
     const { data: { enabledFeatures }, } = await fetchEnabledFeatures(accountId);
+    if (enabledFeatures[feature] === undefined &&
+        FEATURES_THAT_DEFAULT_ON.includes(feature)) {
+        return true;
+    }
     return Boolean(enabledFeatures[feature]);
 }
 export async function hasUnfiedAppsAccess(accountId) {

package/lib/lang.js

@@ -2,7 +2,7 @@ import util from 'util';
 import path, { dirname } from 'path';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { interpolate } from './interpolation.js';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
@@ -22,10 +22,11 @@ function loadLanguageFromYaml() {
         // Fall back to using the default language file
         locale = languageFileExists ? nodeLocale : 'en';
         languageObj = yaml.load(fs.readFileSync(path.join(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
-        logger.debug('Loaded language data: ', util.inspect(languageObj, true, 999, true));
+        uiLogger.debug('Loaded language data: ' + util.inspect(languageObj, true, 999, true));
     }
     catch (e) {
-        logger.error('Error loading language data: ', e);
+        uiLogger.error('Error loading language data: ' +
+            (e instanceof Error ? e.message : String(e)));
     }
 }
 function getTextValue(lookupDotNotation) {
@@ -42,8 +43,8 @@ function getTextValue(lookupDotNotation) {
         });
     }
     catch (e) {
-        logger.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
-        logger.error('Unable to access language property.');
+        uiLogger.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
+        uiLogger.error('Unable to access language property.');
         return missingTextData;
     }
     if (!textValue) {

package/lib/links.d.ts

@@ -7,4 +7,5 @@ type SiteLink = {
 export declare function getSiteLinksAsArray(accountId: number): SiteLink[];
 export declare function logSiteLinks(accountId: number): void;
 export declare function openLink(accountId: number, shortcut: string): void;
+export declare function getProductUpdatesUrl(rolloutId: string, accountId?: number): string;
 export {};

package/lib/links.js

@@ -2,9 +2,9 @@ import open from 'open';
 import { getEnv } from '@hubspot/local-dev-lib/config';
 import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { getTableContents, getTableHeader } from './ui/table.js';
-const SITE_LINKS = {
+const COMMON_SITE_LINKS = {
     APPS_MARKETPLACE: {
         shortcut: 'apps-marketplace',
         alias: 'apm',
@@ -76,7 +76,7 @@ const SITE_LINKS = {
 };
 export function getSiteLinksAsArray(accountId) {
     const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
-    return Object.values(SITE_LINKS)
+    return Object.values(COMMON_SITE_LINKS)
         .sort((a, b) => (a.shortcut < b.shortcut ? -1 : 1))
         .map(l => ({ ...l, url: l.getUrl(accountId, baseUrl) }));
 }
@@ -87,15 +87,22 @@ export function logSiteLinks(accountId) {
         l.url,
     ]);
     linksAsArray.unshift(getTableHeader(['Shortcut', '', 'Url']));
-    logger.log(getTableContents(linksAsArray));
+    uiLogger.log(getTableContents(linksAsArray));
 }
 export function openLink(accountId, shortcut) {
-    const match = Object.values(SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
+    const match = Object.values(COMMON_SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
     if (!match) {
-        logger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
+        uiLogger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
         return;
     }
     const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
     open(match.getUrl(accountId, baseUrl), { url: true });
-    logger.success(`We opened ${match.getUrl(accountId, baseUrl)} in your browser`);
+    uiLogger.success(`We opened ${match.getUrl(accountId, baseUrl)} in your browser`);
+}
+export function getProductUpdatesUrl(rolloutId, accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    if (accountId) {
+        return `${baseUrl}/product-updates/${accountId}/in-beta?rollout=${rolloutId}`;
+    }
+    return `${baseUrl}/l/product-updates/in-beta?rollout=${rolloutId}`;
 }

package/lib/mcp/setup.js

@@ -8,7 +8,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { existsSync } from 'fs';
-const mcpServerName = 'hubspot-cli-mcp';
+const mcpServerName = 'HubSpotDev';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';

package/lib/middleware/__test__/commandTargetingUtils.test.js

@@ -0,0 +1,99 @@
+import * as cliConfig from '@hubspot/local-dev-lib/config';
+import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from '../commandTargetingUtils.js';
+vi.mock('@hubspot/local-dev-lib/config');
+const configFileExistsSpy = vi.spyOn(cliConfig, 'configFileExists');
+const targetCommandMap = {
+    init: true,
+    account: {
+        use: true,
+    },
+    project: {
+        deploy: true,
+    },
+};
+describe('lib/middleware/commandTargetingUtils', () => {
+    describe('isTargetedCommand()', () => {
+        it('should return true for a direct target command', () => {
+            const result = isTargetedCommand(['init'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command with a subcommand', () => {
+            const result = isTargetedCommand(['account'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return true for a nested target command', () => {
+            const result = isTargetedCommand(['project', 'deploy'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a non-existent command', () => {
+            const result = isTargetedCommand(['nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-targeted command', () => {
+            const result = isTargetedCommand(['auth'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a command with a targeted subcommand', () => {
+            const result = isTargetedCommand(['project'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-existent subcommand', () => {
+            const result = isTargetedCommand(['auth', 'nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for an empty command array', () => {
+            const result = isTargetedCommand([], targetCommandMap);
+            expect(result).toBe(false);
+        });
+    });
+    describe('shouldLoadConfigForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldLoadConfigForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require a config file', () => {
+            const result = shouldLoadConfigForCommand(['init']);
+            expect(result).toBe(false);
+        });
+        it('should return false when the user is trying to migrate the global config', () => {
+            configFileExistsSpy.mockReturnValue(false);
+            const result = shouldLoadConfigForCommand(['config', 'migrate']);
+            expect(result).toBe(false);
+        });
+        it('should return true when the global config file does exist', () => {
+            configFileExistsSpy.mockReturnValue(true);
+            const result = shouldLoadConfigForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+    });
+    describe('shouldRunAccountValidationForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldRunAccountValidationForCommand([
+                'project',
+                'upload',
+            ]);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require account validation', () => {
+            const result1 = shouldRunAccountValidationForCommand(['init']);
+            const result2 = shouldRunAccountValidationForCommand(['auth']);
+            const result3 = shouldRunAccountValidationForCommand([
+                'accounts',
+                'list',
+            ]);
+            expect(result1).toBe(false);
+            expect(result2).toBe(false);
+            expect(result3).toBe(false);
+        });
+    });
+    describe('shouldRunConfigValidationForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldRunConfigValidationForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require config validation', () => {
+            const result = shouldRunConfigValidationForCommand(['init']);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/middleware/__test__/configMiddleware.test.js

@@ -1,10 +1,10 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../ui/logger.js';
 import * as cliConfig from '@hubspot/local-dev-lib/config';
 import * as validation from '../../validation.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { handleDeprecatedEnvVariables, injectAccountIdMiddleware, loadConfigMiddleware, validateAccountOptions, } from '../configMiddleware.js';
-vi.mock('@hubspot/local-dev-lib/logger', () => ({
-    logger: {
+import { handleDeprecatedEnvVariables, injectAccountIdMiddleware, loadAndValidateConfigMiddleware, validateAccountOptions, } from '../configMiddleware.js';
+vi.mock('../../ui/logger.js', () => ({
+    uiLogger: {
         error: vi.fn(),
         log: vi.fn(),
     },
@@ -39,7 +39,7 @@ describe('lib/middleware/configMiddleware', () => {
                 $0: 'hs',
             };
             handleDeprecatedEnvVariables(argv);
-            expect(logger.log).toHaveBeenCalledWith(expect.stringContaining('The HUBSPOT_PORTAL_ID environment variable is deprecated. Please use HUBSPOT_ACCOUNT_ID instead.'));
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('The HUBSPOT_PORTAL_ID environment variable is deprecated. Please use HUBSPOT_ACCOUNT_ID instead.'));
             expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('123');
             process.env = originalEnv;
         });
@@ -56,7 +56,7 @@ describe('lib/middleware/configMiddleware', () => {
                 $0: 'hs',
             };
             handleDeprecatedEnvVariables(argv);
-            expect(logger.log).not.toHaveBeenCalled();
+            expect(uiLogger.log).not.toHaveBeenCalled();
             expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('456');
             process.env = originalEnv;
         });
@@ -93,7 +93,7 @@ describe('lib/middleware/configMiddleware', () => {
             expect(getAccountIdSpy).toHaveBeenCalledWith('test-account');
         });
     });
-    describe('loadConfigMiddleware()', () => {
+    describe('loadAndValidateConfigMiddleware()', () => {
         it('should exit with error when config file exists and --config flag is used', async () => {
             configFileExistsSpy.mockReturnValue(true);
             const argv = {
@@ -101,9 +101,9 @@ describe('lib/middleware/configMiddleware', () => {
                 config: 'custom-config.json',
                 $0: 'hs',
             };
-            await expect(loadConfigMiddleware(argv)).rejects.toThrow();
+            await expect(loadAndValidateConfigMiddleware(argv)).rejects.toThrow();
             expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith('A configuration file already exists at /path/to/config. To specify a new configuration file, delete the existing one and try again.');
+            expect(uiLogger.error).toHaveBeenCalledWith('A configuration file already exists at /path/to/config. To specify a new configuration file, delete the existing one and try again.');
         });
         it('should load config and validate for non-init commands', async () => {
             configFileExistsSpy.mockReturnValue(false);
@@ -113,7 +113,7 @@ describe('lib/middleware/configMiddleware', () => {
                 _: ['some-command'],
                 $0: 'hs',
             };
-            await loadConfigMiddleware(argv);
+            await loadAndValidateConfigMiddleware(argv);
             expect(loadConfigSpy).toHaveBeenCalled();
             expect(validateConfigSpy).toHaveBeenCalled();
         });
@@ -123,7 +123,7 @@ describe('lib/middleware/configMiddleware', () => {
                 _: ['init'],
                 $0: 'hs',
             };
-            await loadConfigMiddleware(argv);
+            await loadAndValidateConfigMiddleware(argv);
             expect(loadConfigSpy).not.toHaveBeenCalled();
             expect(validateConfigSpy).not.toHaveBeenCalled();
         });

package/lib/middleware/__test__/yargsChecksMiddleware.test.js

@@ -1,16 +1,14 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import * as projectsConfig from '../../projects/config.js';
 import { performChecks } from '../yargsChecksMiddleware.js';
-vi.mock('@hubspot/local-dev-lib/logger', () => ({
-    logger: {
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+vi.mock('../../ui/logger', () => ({
+    uiLogger: {
         error: vi.fn(),
     },
 }));
 vi.mock('../../projects/config');
-vi.mock('../../lang', () => ({
-    i18n: vi.fn(key => key),
-}));
 const getIsInProjectSpy = vi.spyOn(projectsConfig, 'getIsInProject');
 const processExitSpy = vi.spyOn(process, 'exit');
 describe('lib/middleware/yargsChecksMiddleware', () => {
@@ -29,7 +27,7 @@ describe('lib/middleware/yargsChecksMiddleware', () => {
             getIsInProjectSpy.mockReturnValue(true);
             expect(() => performChecks(argv)).toThrow();
             expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith('commands.generalErrors.srcIsProject');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.generalErrors.srcIsProject(argv.src, argv._.toString()));
         });
         it('should return true when no checks fail', () => {
             const argv = {
@@ -40,7 +38,7 @@ describe('lib/middleware/yargsChecksMiddleware', () => {
             getIsInProjectSpy.mockReturnValue(false);
             expect(performChecks(argv)).toBe(true);
             expect(processExitSpy).not.toHaveBeenCalled();
-            expect(logger.error).not.toHaveBeenCalled();
+            expect(uiLogger.error).not.toHaveBeenCalled();
         });
     });
 });

package/lib/middleware/commandTargetingUtils.d.ts

@@ -0,0 +1,8 @@
+type TargetCommandMap = {
+    [key: string]: boolean | TargetCommandMap;
+};
+export declare function isTargetedCommand(commandParts: (string | number)[], targetCommandMap: TargetCommandMap): boolean;
+export declare function shouldLoadConfigForCommand(commandParts: (string | number)[]): boolean;
+export declare function shouldRunConfigValidationForCommand(commandParts: (string | number)[]): boolean;
+export declare function shouldRunAccountValidationForCommand(commandParts: (string | number)[]): boolean;
+export {};

package/lib/middleware/commandTargetingUtils.js

@@ -0,0 +1,74 @@
+import { configFileExists } from '@hubspot/local-dev-lib/config';
+export function isTargetedCommand(commandParts, targetCommandMap) {
+    const currentCommandPart = commandParts[0];
+    if (!targetCommandMap[currentCommandPart]) {
+        return false;
+    }
+    if (typeof targetCommandMap[currentCommandPart] === 'boolean' &&
+        targetCommandMap[currentCommandPart]) {
+        return true;
+    }
+    if (commandParts.length > 1) {
+        const targetSubCommandMap = targetCommandMap[currentCommandPart];
+        if (!targetSubCommandMap) {
+            return false;
+        }
+        return isTargetedCommand(commandParts.slice(1), targetSubCommandMap);
+    }
+    return false;
+}
+const SKIP_CONFIG_LOADING_COMMANDS = {
+    init: true,
+    feedback: true,
+};
+// Returns true if the command requires a config file to be present
+export function shouldLoadConfigForCommand(commandParts) {
+    const globalConfigExists = configFileExists(true);
+    // the user is trying to migrate the global config
+    const isGlobalConfigMigration = !globalConfigExists &&
+        isTargetedCommand(commandParts, {
+            account: { auth: true },
+            config: { migrate: true },
+        });
+    return (!isGlobalConfigMigration &&
+        !isTargetedCommand(commandParts, SKIP_CONFIG_LOADING_COMMANDS));
+}
+const SKIP_CONFIG_VALIDATION_COMMANDS = {
+    auth: true,
+    mcp: {
+        setup: true,
+        start: true,
+    },
+};
+// Returns true if the command requires a valid config file to be present
+// Should only run if config has been loaded
+export function shouldRunConfigValidationForCommand(commandParts) {
+    return (shouldLoadConfigForCommand(commandParts) &&
+        !isTargetedCommand(commandParts, SKIP_CONFIG_VALIDATION_COMMANDS));
+}
+const accountsSubCommands = {
+    auth: true,
+    clean: true,
+    list: true,
+    ls: true,
+    remove: true,
+    use: true,
+};
+const sandboxesSubCommands = {
+    delete: true,
+};
+const SKIP_ACCOUNT_VALIDATION_COMMANDS = {
+    account: accountsSubCommands,
+    accounts: accountsSubCommands,
+    sandbox: sandboxesSubCommands,
+    sandboxes: sandboxesSubCommands,
+    config: {
+        migrate: true,
+    },
+};
+// Returns true if the command requires a valid account to be set in the config
+// Should only run if config has been loaded and validated
+export function shouldRunAccountValidationForCommand(commandParts) {
+    return (shouldRunConfigValidationForCommand(commandParts) &&
+        !isTargetedCommand(commandParts, SKIP_ACCOUNT_VALIDATION_COMMANDS));
+}

package/lib/middleware/configMiddleware.d.ts

@@ -9,5 +9,5 @@ export declare function handleDeprecatedEnvVariables(argv: Arguments<{
 export declare function injectAccountIdMiddleware(argv: Arguments<{
     account?: string;
 }>): Promise<void>;
-export declare function loadConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
+export declare function loadAndValidateConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
 export declare function validateAccountOptions(argv: Arguments): Promise<void>;