@hubspot/cli 7.9.0-experimental.0 → 7.9.1-experimental.0

package/lib/mcp/__tests__/setup.test.js

@@ -0,0 +1,127 @@
+import { execAsync } from '../../../mcp-server/utils/command.js';
+import { setupCodex, supportedTools } from '../setup.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+import { logError } from '../../errorHandlers/index.js';
+import { commands } from '../../../lang/en.js';
+// Mock dependencies
+vi.mock('../../../mcp-server/utils/command.js');
+vi.mock('../../ui/SpinniesManager.js');
+vi.mock('../../ui/logger.js');
+vi.mock('../../errorHandlers/index.js');
+vi.mock('../../../lang/en.js', () => ({
+    commands: {
+        mcp: {
+            setup: {
+                codex: 'Codex CLI',
+                claudeCode: 'Claude Code',
+                cursor: 'Cursor',
+                vsCode: 'VS Code',
+                windsurf: 'Windsurf',
+                success: vi.fn(targets => `Success message for ${targets.join(', ')}`),
+                spinners: {
+                    configuringCodex: 'Configuring Codex...',
+                    configuredCodex: 'Configured Codex',
+                    codexNotFound: 'Codex command not found - skipping configuration',
+                    codexInstallFailed: 'Failed to configure Codex',
+                },
+            },
+        },
+    },
+}));
+const mockedExecAsync = vi.mocked(execAsync);
+const mockedSpinniesManager = vi.mocked(SpinniesManager);
+const mockedLogError = vi.mocked(logError);
+describe('lib/mcp/setup', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('supportedTools', () => {
+        it('should include Codex in the supported tools list', () => {
+            const codexTool = supportedTools.find(tool => tool.value === 'codex');
+            expect(codexTool).toBeDefined();
+            expect(codexTool?.name).toBe(commands.mcp.setup.codex);
+            expect(codexTool?.value).toBe('codex');
+        });
+        it('should have Codex as the first tool in the list', () => {
+            expect(supportedTools[0].value).toBe('codex');
+        });
+        it('should contain all expected tools', () => {
+            const toolValues = supportedTools.map(tool => tool.value);
+            expect(toolValues).toContain('codex');
+            expect(toolValues).toContain('claude');
+            expect(toolValues).toContain('cursor');
+            expect(toolValues).toContain('vscode');
+            expect(toolValues).toContain('windsurf');
+        });
+    });
+    describe('setupCodex', () => {
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1', '--arg2'],
+        };
+        it('should successfully configure Codex when command is available', async () => {
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            }); // version check
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' }); // mcp add command
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.configuringCodex,
+            });
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex --version');
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --arg2 --ai-agent codex');
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.configuredCodex,
+            });
+        });
+        it('should use default mcp command when none provided', async () => {
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            }); // version check
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' }); // mcp add command
+            const result = await setupCodex();
+            expect(result).toBe(true);
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- hs mcp start --ai-agent codex');
+        });
+        it('should handle codex command not found', async () => {
+            const error = new Error('Command not found: codex');
+            mockedExecAsync.mockRejectedValueOnce(error);
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexNotFound,
+            });
+        });
+        it('should handle codex installation failure', async () => {
+            const error = new Error('Some other error');
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            }); // version check passes
+            mockedExecAsync.mockRejectedValueOnce(error); // mcp add fails
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexInstallFailed,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+        it('should handle unexpected errors during spinner setup', async () => {
+            const error = new Error('Unexpected error');
+            mockedSpinniesManager.add.mockImplementationOnce(() => {
+                throw error;
+            });
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexInstallFailed,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+    });
+    // Note: addMcpServerToConfig integration tests would require mocking many dependencies
+    // and complex setup. The setupCodex function tests above cover the new functionality.
+});

package/lib/mcp/setup.d.ts

@@ -1,16 +1,7 @@
-export declare const supportedTools: ({
-    name: "Claude Code";
+export declare const supportedTools: {
+    name: string;
     value: string;
-} | {
-    name: "Cursor";
-    value: string;
-} | {
-    name: "Windsurf";
-    value: string;
-} | {
-    name: "VSCode";
-    value: string;
-})[];
+}[];
 interface McpCommand {
     command: string;
     args: string[];
@@ -20,4 +11,5 @@ export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupCursor(mcpCommand?: McpCommand): boolean;
 export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export declare function setupCodex(mcpCommand?: McpCommand): Promise<boolean>;
 export {};

package/lib/mcp/setup.js

@@ -13,11 +13,13 @@ const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
 const vscode = 'vscode';
+const codex = 'codex';
 export const supportedTools = [
+    { name: commands.mcp.setup.codex, value: codex },
     { name: commands.mcp.setup.claudeCode, value: claudeCode },
     { name: commands.mcp.setup.cursor, value: cursor },
-    { name: commands.mcp.setup.windsurf, value: windsurf },
     { name: commands.mcp.setup.vsCode, value: vscode },
+    { name: commands.mcp.setup.windsurf, value: windsurf },
 ];
 const defaultMcpCommand = {
     command: 'hs',
@@ -56,6 +58,9 @@ export async function addMcpServerToConfig(targets) {
         if (derivedTargets.includes(vscode)) {
             await runSetupFunction(setupVsCode);
         }
+        if (derivedTargets.includes(codex)) {
+            await runSetupFunction(setupCodex);
+        }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
     }
@@ -231,6 +236,34 @@ export function setupWindsurf(mcpCommand = defaultMcpCommand) {
         mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
     });
 }
+export async function setupCodex(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('codexSpinner', {
+            text: commands.mcp.setup.spinners.configuringCodex,
+        });
+        // Check if codex command is available
+        await execAsync('codex --version');
+        await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommand.command} ${mcpCommand.args.join(' ')} --ai-agent codex`);
+        SpinniesManager.succeed('codexSpinner', {
+            text: commands.mcp.setup.spinners.configuredCodex,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('codex')) {
+            SpinniesManager.fail('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexNotFound,
+            });
+        }
+        else {
+            SpinniesManager.fail('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexInstallFailed,
+            });
+            logError(error);
+        }
+        return false;
+    }
+}
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);
     mcpCommandCopy.args.push('--ai-agent', agent);

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

@@ -1,7 +1,7 @@
 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 globalConfigFileExistsSpy = vi.spyOn(cliConfig, 'globalConfigFileExists');
 const targetCommandMap = {
     init: true,
     account: {
@@ -56,12 +56,12 @@ describe('lib/middleware/commandTargetingUtils', () => {
             expect(result).toBe(false);
         });
         it('should return false when the user is trying to migrate the global config', () => {
-            configFileExistsSpy.mockReturnValue(false);
+            globalConfigFileExistsSpy.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);
+            globalConfigFileExistsSpy.mockReturnValue(true);
             const result = shouldLoadConfigForCommand(['account', 'use']);
             expect(result).toBe(true);
         });

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

@@ -2,7 +2,7 @@ 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, loadAndValidateConfigMiddleware, validateAccountOptions, } from '../configMiddleware.js';
+import { handleDeprecatedEnvVariables, injectAccountIdMiddleware, validateConfigMiddleware, validateAccountOptions, } from '../configMiddleware.js';
 vi.mock('../../ui/logger.js', () => ({
     uiLogger: {
         error: vi.fn(),
@@ -12,10 +12,10 @@ vi.mock('../../ui/logger.js', () => ({
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../validation');
 const validateAccountSpy = vi.spyOn(validation, 'validateAccount');
-const loadConfigSpy = vi.spyOn(cliConfig, 'loadConfig');
-const getAccountIdSpy = vi.spyOn(cliConfig, 'getAccountId');
+const getConfigAccountIfExistsSpy = vi.spyOn(cliConfig, 'getConfigAccountIfExists');
+const globalConfigFileExistsSpy = vi.spyOn(cliConfig, 'globalConfigFileExists');
 const configFileExistsSpy = vi.spyOn(cliConfig, 'configFileExists');
-const getConfigPathSpy = vi.spyOn(cliConfig, 'getConfigPath');
+const getConfigFilePathSpy = vi.spyOn(cliConfig, 'getConfigFilePath');
 const validateConfigSpy = vi.spyOn(cliConfig, 'validateConfig');
 const processExitSpy = vi.spyOn(process, 'exit');
 describe('lib/middleware/configMiddleware', () => {
@@ -23,7 +23,7 @@ describe('lib/middleware/configMiddleware', () => {
         processExitSpy.mockImplementation(code => {
             throw new Error(`Process.exit called with code ${code}`);
         });
-        getConfigPathSpy.mockReturnValue('/path/to/config');
+        getConfigFilePathSpy.mockReturnValue('/path/to/config');
     });
     describe('handleDeprecatedEnvVariables()', () => {
         it('should handle deprecated HUBSPOT_PORTAL_ID environment variable', () => {
@@ -76,11 +76,13 @@ describe('lib/middleware/configMiddleware', () => {
             await injectAccountIdMiddleware(argv);
             expect(argv.userProvidedAccount).toBeUndefined();
             expect(argv.derivedAccountId).toBe(123);
-            expect(getAccountIdSpy).not.toHaveBeenCalled();
+            expect(getConfigAccountIfExistsSpy).not.toHaveBeenCalled();
             process.env = originalEnv;
         });
         it('should use getAccountId when useEnv is false', async () => {
-            getAccountIdSpy.mockReturnValue(456);
+            getConfigAccountIfExistsSpy.mockReturnValue({
+                accountId: 456,
+            });
             const argv = {
                 _: ['some-command'],
                 account: 'test-account',
@@ -90,41 +92,40 @@ describe('lib/middleware/configMiddleware', () => {
             await injectAccountIdMiddleware(argv);
             expect(argv.userProvidedAccount).toBe('test-account');
             expect(argv.derivedAccountId).toBe(456);
-            expect(getAccountIdSpy).toHaveBeenCalledWith('test-account');
+            expect(getConfigAccountIfExistsSpy).toHaveBeenCalledWith('test-account');
         });
     });
-    describe('loadAndValidateConfigMiddleware()', () => {
-        it('should exit with error when config file exists and --config flag is used', async () => {
+    describe('validateConfigMiddleware()', () => {
+        it('should allow using --config flag', async () => {
             configFileExistsSpy.mockReturnValue(true);
+            validateConfigSpy.mockReturnValue({ isValid: true, errors: [] });
             const argv = {
                 _: ['some-command'],
                 config: 'custom-config.json',
                 $0: 'hs',
             };
-            await expect(loadAndValidateConfigMiddleware(argv)).rejects.toThrow();
-            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            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.');
+            await validateConfigMiddleware(argv);
+            // Should not throw or exit - this is now allowed
+            expect(processExitSpy).not.toHaveBeenCalled();
+            expect(uiLogger.error).not.toHaveBeenCalled();
         });
-        it('should load config and validate for non-init commands', async () => {
-            configFileExistsSpy.mockReturnValue(false);
-            loadConfigSpy.mockReturnValue({});
-            validateConfigSpy.mockReturnValue(true);
+        it('should validate config for non-init commands', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            validateConfigSpy.mockReturnValue({ isValid: true, errors: [] });
             const argv = {
                 _: ['some-command'],
                 $0: 'hs',
             };
-            await loadAndValidateConfigMiddleware(argv);
-            expect(loadConfigSpy).toHaveBeenCalled();
+            await validateConfigMiddleware(argv);
             expect(validateConfigSpy).toHaveBeenCalled();
         });
         it('should skip validation for init command', async () => {
-            configFileExistsSpy.mockReturnValue(false);
+            globalConfigFileExistsSpy.mockReturnValue(false);
             const argv = {
                 _: ['init'],
                 $0: 'hs',
             };
-            await loadAndValidateConfigMiddleware(argv);
-            expect(loadConfigSpy).not.toHaveBeenCalled();
+            await validateConfigMiddleware(argv);
             expect(validateConfigSpy).not.toHaveBeenCalled();
         });
     });

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

@@ -3,19 +3,19 @@ import * as gitUI from '../../ui/git.js';
 import { checkAndWarnGitInclusionMiddleware } from '../gitMiddleware.js';
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../ui/git');
-const getConfigPathSpy = vi.spyOn(config, 'getConfigPath');
+const getConfigFilePathSpy = vi.spyOn(config, 'getConfigFilePath');
 const checkAndWarnGitInclusionSpy = vi.spyOn(gitUI, 'checkAndWarnGitInclusion');
 describe('lib/middleware/gitMiddleware', () => {
     describe('checkAndWarnGitInclusionMiddleware()', () => {
         it('should call checkAndWarnGitInclusion when command is provided and config path exists', () => {
             const mockConfigPath = '/path/to/config.js';
-            getConfigPathSpy.mockReturnValue(mockConfigPath);
+            getConfigFilePathSpy.mockReturnValue(mockConfigPath);
             const argv = {
                 _: ['some-command'],
                 $0: 'hs',
             };
             checkAndWarnGitInclusionMiddleware(argv);
-            expect(getConfigPathSpy).toHaveBeenCalledTimes(1);
+            expect(getConfigFilePathSpy).toHaveBeenCalledTimes(1);
             expect(checkAndWarnGitInclusionSpy).toHaveBeenCalledWith(mockConfigPath);
         });
         it('should not call checkAndWarnGitInclusion when no command is provided', () => {
@@ -24,17 +24,19 @@ describe('lib/middleware/gitMiddleware', () => {
                 $0: 'hs',
             };
             checkAndWarnGitInclusionMiddleware(argv);
-            expect(getConfigPathSpy).not.toHaveBeenCalled();
+            expect(getConfigFilePathSpy).not.toHaveBeenCalled();
             expect(checkAndWarnGitInclusionSpy).not.toHaveBeenCalled();
         });
-        it('should not call checkAndWarnGitInclusion when config path is null', () => {
-            getConfigPathSpy.mockReturnValue(null);
+        it('should not call checkAndWarnGitInclusion when config path does not exist', () => {
+            getConfigFilePathSpy.mockImplementation(() => {
+                throw new Error('Config path does not exist');
+            });
             const argv = {
                 _: ['some-command'],
                 $0: 'hs',
             };
             checkAndWarnGitInclusionMiddleware(argv);
-            expect(getConfigPathSpy).toHaveBeenCalledTimes(1);
+            expect(getConfigFilePathSpy).toHaveBeenCalledTimes(1);
             expect(checkAndWarnGitInclusionSpy).not.toHaveBeenCalled();
         });
     });

package/lib/middleware/autoUpdateMiddleware.d.ts

@@ -1,2 +1,4 @@
 import { Arguments } from 'yargs';
-export declare function autoUpdateCLI(argv: Arguments): Promise<void>;
+export declare function autoUpdateCLI(argv: Arguments<{
+    useEnv?: boolean;
+}>): Promise<void>;

package/lib/middleware/autoUpdateMiddleware.js

@@ -1,5 +1,5 @@
 import updateNotifier from 'update-notifier';
-import { isConfigFlagEnabled } from '@hubspot/local-dev-lib/config';
+import { getConfig } from '@hubspot/local-dev-lib/config';
 import { pkg } from '../jsonLoader.js';
 import { UI_COLORS } from '../ui/index.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
@@ -45,10 +45,18 @@ const preventAutoUpdateForCommand = (commandParts) => {
 export async function autoUpdateCLI(argv) {
     // This lets us back to default update-notifier behavior
     let showManualInstallHelp = true;
+    let config;
+    try {
+        config = getConfig();
+    }
+    catch (e) {
+        debugError(e);
+    }
     if (notifier &&
         notifier.update &&
+        !argv.useEnv &&
         !process.env.SKIP_HUBSPOT_CLI_AUTO_UPDATES &&
-        isConfigFlagEnabled('allowAutoUpdates') &&
+        config?.allowAutoUpdates !== false &&
         !preventAutoUpdateForCommand(argv._)) {
         // Ignore all update notifications if the current version is a pre-release
         if (!notifier.update.current.includes('-')) {

package/lib/middleware/commandTargetingUtils.js

@@ -1,4 +1,4 @@
-import { configFileExists } from '@hubspot/local-dev-lib/config';
+import { globalConfigFileExists } from '@hubspot/local-dev-lib/config';
 export function isTargetedCommand(commandParts, targetCommandMap) {
     const currentCommandPart = commandParts[0];
     if (!targetCommandMap[currentCommandPart]) {
@@ -23,7 +23,7 @@ const SKIP_CONFIG_LOADING_COMMANDS = {
 };
 // Returns true if the command requires a config file to be present
 export function shouldLoadConfigForCommand(commandParts) {
-    const globalConfigExists = configFileExists(true);
+    const globalConfigExists = globalConfigFileExists();
     // the user is trying to migrate the global config
     const isGlobalConfigMigration = !globalConfigExists &&
         isTargetedCommand(commandParts, {

package/lib/middleware/configMiddleware.d.ts

@@ -3,11 +3,16 @@ import { CLIOptions } from '@hubspot/local-dev-lib/types/CLIOptions';
 export declare function handleDeprecatedEnvVariables(argv: Arguments<{
     useEnv?: boolean;
 }>): void;
+export declare function handleCustomConfigLocationMiddleware(argv: Arguments<{
+    useEnv?: boolean;
+    config?: string;
+}>): void;
 /**
  * Auto-injects the derivedAccountId flag into all commands
  */
 export declare function injectAccountIdMiddleware(argv: Arguments<{
     account?: string;
+    config?: string;
 }>): Promise<void>;
-export declare function loadAndValidateConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
+export declare function validateConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
 export declare function validateAccountOptions(argv: Arguments): Promise<void>;

package/lib/middleware/configMiddleware.js

@@ -1,9 +1,11 @@
-import { loadConfig, getAccountId, configFileExists, getConfigPath, validateConfig, } from '@hubspot/local-dev-lib/config';
+import path from 'path';
+import { getConfigAccountIfExists, validateConfig, getConfigDefaultAccountIfExists, configFileExists, } from '@hubspot/local-dev-lib/config';
+import { getCwd } from '@hubspot/local-dev-lib/path';
 import { validateAccount } from '../validation.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { commands } from '../../lang/en.js';
 import { uiDeprecatedTag } from '../ui/index.js';
-import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
+import { shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
 import { parseStringToNumber } from '../parsing.js';
 import { uiLogger } from '../ui/logger.js';
 import { lib } from '../../lang/en.js';
@@ -17,6 +19,18 @@ export function handleDeprecatedEnvVariables(argv) {
         process.env.HUBSPOT_ACCOUNT_ID = process.env.HUBSPOT_PORTAL_ID;
     }
 }
+export function handleCustomConfigLocationMiddleware(argv) {
+    const { useEnv, config } = argv;
+    if (useEnv) {
+        process.env.USE_ENVIRONMENT_HUBSPOT_CONFIG = 'true';
+    }
+    else if (config && typeof config === 'string') {
+        const absoluteConfigPath = path.isAbsolute(config)
+            ? config
+            : path.join(getCwd(), config);
+        process.env.HUBSPOT_CONFIG_PATH = absoluteConfigPath;
+    }
+}
 /**
  * Auto-injects the derivedAccountId flag into all commands
  */
@@ -33,10 +47,23 @@ export async function injectAccountIdMiddleware(argv) {
         }
     }
     else {
-        argv.derivedAccountId = getAccountId(account);
+        // Wrap in try-catch to handle cases where config file doesn't exist yet (e.g., during hs init)
+        try {
+            let accountInConfig = account
+                ? getConfigAccountIfExists(account)
+                : undefined;
+            if (!accountInConfig) {
+                accountInConfig = getConfigDefaultAccountIfExists();
+            }
+            argv.derivedAccountId = accountInConfig?.accountId;
+        }
+        catch (err) {
+            // Config file doesn't exist yet, which is fine for commands like hs init
+            argv.derivedAccountId = undefined;
+        }
     }
 }
-export async function loadAndValidateConfigMiddleware(argv) {
+export async function validateConfigMiddleware(argv) {
     // Skip this when no command is provided
     if (!argv._.length || argv.help) {
         return;
@@ -45,23 +72,17 @@ export async function loadAndValidateConfigMiddleware(argv) {
     if (!shouldLoadConfigForCommand(argv._)) {
         return;
     }
-    // If the config file exists and the --config flag is used, exit with an error
-    if (configFileExists(true) &&
-        argv.config &&
-        !isTargetedCommand(argv._, { config: { migrate: true } })) {
-        uiLogger.error(commands.generalErrors.loadConfigMiddleware.configFileExists(getConfigPath()));
-        process.exit(EXIT_CODES.ERROR);
-    }
-    const config = loadConfig(argv.config, argv);
     // We don't run validation for auth because users should be able to run it when
     // no accounts are configured, but we still want to exit if the config file is not found
-    if (isTargetedCommand(argv._, { auth: true }) && !config) {
+    if (!process.env.USE_ENVIRONMENT_HUBSPOT_CONFIG && !configFileExists()) {
+        console.error('Config file not found, run hs account auth to configure your account');
         process.exit(EXIT_CODES.ERROR);
     }
     // Only validate the config if the command requires it
     if (shouldRunConfigValidationForCommand(argv._)) {
-        const configIsValid = validateConfig();
-        if (!configIsValid) {
+        const { isValid, errors } = validateConfig();
+        if (!isValid) {
+            uiLogger.error(commands.generalErrors.validateConfigMiddleware.configValidationFailed(errors));
             process.exit(EXIT_CODES.ERROR);
         }
     }

package/lib/middleware/gitMiddleware.js

@@ -1,15 +1,19 @@
-import { getConfigPath, configFileExists } from '@hubspot/local-dev-lib/config';
+import { getConfigFilePath, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
 import { checkAndWarnGitInclusion } from '../ui/git.js';
+import { debugError } from '../errorHandlers/index.js';
 export function checkAndWarnGitInclusionMiddleware(argv) {
     // Skip this when no command is provided
     if (argv._.length) {
         // Skip if using global config
-        if (configFileExists(true)) {
+        if (globalConfigFileExists()) {
             return;
         }
-        const configPath = getConfigPath();
-        if (configPath) {
+        try {
+            const configPath = getConfigFilePath();
             checkAndWarnGitInclusion(configPath);
         }
+        catch (error) {
+            debugError(error);
+        }
     }
 }

package/lib/oauth.d.ts

@@ -1,2 +1,2 @@
-import { OAuth2ManagerAccountConfig } from '@hubspot/local-dev-lib/types/Accounts';
-export declare function authenticateWithOauth(accountConfig: OAuth2ManagerAccountConfig): Promise<void>;
+import { OAuthConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function authenticateWithOauth(accountConfig: OAuthConfigAccount): Promise<void>;

package/lib/oauth.js

@@ -1,8 +1,7 @@
 import express from 'express';
 import open from 'open';
 import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { uiLogger } from './ui/logger.js';
@@ -14,15 +13,15 @@ import { EXIT_CODES } from './enums/exitCodes.js';
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
 function buildAuthUrl(oauthManager) {
-    const { env: accountEnv, clientId, scopes: accountScopes, } = oauthManager.account;
+    const { env: accountEnv, auth } = oauthManager.account;
     const env = accountEnv || ENVIRONMENTS.PROD;
-    const scopes = accountScopes || DEFAULT_OAUTH_SCOPES;
-    if (!clientId) {
+    const scopes = auth.scopes.length > 0 ? auth.scopes : DEFAULT_OAUTH_SCOPES;
+    if (!auth.clientId) {
         uiLogger.error(lib.oauth.missingClientId);
         process.exit(EXIT_CODES.ERROR);
     }
     return (`${getHubSpotWebsiteOrigin(env)}/oauth/${oauthManager.account.accountId}/authorize` +
-        `?client_id=${encodeURIComponent(clientId)}` + // app's client ID
+        `?client_id=${encodeURIComponent(auth.clientId)}` + // app's client ID
         `&scope=${encodeURIComponent(scopes.join(' '))}` + // scopes being requested by the app
         `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
     );
@@ -45,8 +44,8 @@ async function authorize(oauthManager) {
             if (req.query.code) {
                 const authCodeProof = {
                     grant_type: 'authorization_code',
-                    client_id: oauthManager.account.clientId,
-                    client_secret: oauthManager.account.clientSecret,
+                    client_id: oauthManager.account.auth.clientId,
+                    client_secret: oauthManager.account.auth.clientSecret,
                     redirect_uri: redirectUri,
                     code: req.query.code,
                 };
@@ -82,8 +81,7 @@ async function authorize(oauthManager) {
     });
 }
 function setupOauth(accountConfig) {
-    const accountId = getAccountIdentifier(accountConfig);
-    const config = getAccountConfig(accountId);
+    const config = getConfigAccountById(accountConfig.accountId);
     return new OAuth2Manager({
         ...accountConfig,
         env: accountConfig.env || config?.env || ENVIRONMENTS.PROD,