@hubspot/cli 7.10.0 → 7.10.1-experimental.0

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/fireAlarmMiddleware.js

@@ -2,7 +2,6 @@ import chalk from 'chalk';
 import { fetchFireAlarms } from '@hubspot/local-dev-lib/api/fireAlarm';
 import { debugError } from '../errorHandlers/index.js';
 import { pkg } from '../jsonLoader.js';
-import { logInBox } from '../ui/boxen.js';
 import { renderInline } from '../../ui/index.js';
 import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 /*
@@ -100,20 +99,10 @@ async function logFireAlarms(accountId, command, version) {
             }
             return acc;
         }, '');
-        if (!process.env.HUBSPOT_ENABLE_INK) {
-            await logInBox({
-                contents: notifications,
-                options: {
-                    title: 'Notifications',
-                },
-            });
-        }
-        else {
-            await renderInline(getWarningBox({
-                title: 'Notifications',
-                message: notifications,
-            }));
-        }
+        await renderInline(getWarningBox({
+            title: 'Notifications',
+            message: notifications,
+        }));
     }
 }
 export async function checkFireAlarms(argv) {

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,

package/lib/projectProfiles.d.ts

@@ -2,6 +2,7 @@ import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { ProjectConfig } from '../types/Projects.js';
 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>;
+export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | never;
+export declare function enforceProfileUsage(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string | undefined, silent?: boolean): Promise<number | undefined>;
+export declare function validateProjectForProfile(projectConfig: ProjectConfig, projectDir: string, profileName: string, derivedAccountId: number, indentSpinners?: boolean): Promise<(string | Error)[]>;

package/lib/projectProfiles.js

@@ -1,9 +1,12 @@
 import path from 'path';
 import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
-import { lib } from '../lang/en.js';
+import { commands, lib } from '../lang/en.js';
 import { uiBetaTag, uiLine } from './ui/index.js';
 import { uiLogger } from './ui/logger.js';
-import { EXIT_CODES } from './enums/exitCodes.js';
+import { validateProfileVariables } from '@hubspot/project-parsing-lib/src/index.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import SpinniesManager from './ui/SpinniesManager.js';
+import { handleTranslate } from './projects/upload.js';
 export function logProfileHeader(profileName) {
     uiLine();
     uiBetaTag(lib.projectProfiles.logs.usingProfile(getHsProfileFilename(profileName)));
@@ -23,51 +26,94 @@ export function logProfileFooter(profile, includeVariables = false) {
 }
 export function loadProfile(projectConfig, projectDir, profileName) {
     if (!projectConfig || !projectDir) {
-        uiLogger.error(lib.projectProfiles.loadProfile.errors.noProjectConfig);
-        return;
+        throw new Error(lib.projectProfiles.loadProfile.errors.noProjectConfig);
     }
     const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
     const profileFilename = getHsProfileFilename(profileName);
+    let profile;
     try {
-        const profile = loadHsProfileFile(projectSourceDir, profileName);
-        if (!profile) {
-            uiLogger.error(lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
-            return;
-        }
-        if (!profile.accountId) {
-            uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
-            return;
-        }
-        return profile;
+        profile = loadHsProfileFile(projectSourceDir, profileName);
     }
     catch (e) {
-        uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
-        return;
+        throw new Error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
+    }
+    if (!profile) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
+    }
+    if (!profile.accountId) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
     }
+    try {
+        getConfigAccountById(profile.accountId);
+    }
+    catch (error) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.listedAccountNotFound(profile.accountId, profileFilename));
+    }
+    return profile;
 }
-export async function exitIfUsingProfiles(projectConfig, projectDir) {
+export async function enforceProfileUsage(projectConfig, projectDir) {
     if (projectConfig && projectDir) {
         const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
         if (existingProfiles.length > 0) {
-            uiLogger.error(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
-    if (argsProfile) {
-        logProfileHeader(argsProfile);
-        const profile = loadProfile(projectConfig, projectDir, argsProfile);
-        if (!profile) {
-            uiLine();
-            process.exit(EXIT_CODES.ERROR);
-        }
+export async function loadAndValidateProfile(projectConfig, projectDir, profileName, silent = false) {
+    if (!profileName) {
+        await enforceProfileUsage(projectConfig, projectDir);
+        return;
+    }
+    if (!silent) {
+        logProfileHeader(profileName);
+    }
+    const profile = loadProfile(projectConfig, projectDir, profileName);
+    if (!silent) {
         logProfileFooter(profile, true);
-        return profile.accountId;
     }
-    else {
-        // A profile must be specified if this project has profiles configured
-        await exitIfUsingProfiles(projectConfig, projectDir);
+    if (profile.variables) {
+        const validationResult = validateProfileVariables(profile.variables, profileName);
+        if (!validationResult.success) {
+            throw new Error(lib.projectProfiles.loadProfile.errors.profileNotValid(getHsProfileFilename(profileName), validationResult.errors));
+        }
+    }
+    return profile.accountId;
+    // A profile must be specified if this project has profiles configured
+}
+export async function validateProjectForProfile(projectConfig, projectDir, profileName, derivedAccountId, indentSpinners = false) {
+    let targetAccountId = derivedAccountId;
+    const spinnerName = `validatingProfile-${profileName}`;
+    const profileFilename = getHsProfileFilename(profileName);
+    SpinniesManager.init();
+    SpinniesManager.add(spinnerName, {
+        text: commands.project.validate.spinners.validatingProfile(profileFilename),
+        indent: indentSpinners ? 4 : 0,
+    });
+    try {
+        const accountId = await loadAndValidateProfile(projectConfig, projectDir, profileName, true);
+        targetAccountId = accountId || derivedAccountId;
+    }
+    catch (error) {
+        SpinniesManager.fail(spinnerName, {
+            text: commands.project.validate.spinners.profileValidationFailed(profileFilename),
+        });
+        return [error instanceof Error ? error.message : `${error}`];
+    }
+    try {
+        await handleTranslate(projectDir, projectConfig, targetAccountId, false, profileName);
+    }
+    catch (error) {
+        SpinniesManager.fail(spinnerName, {
+            text: commands.project.validate.spinners.invalidWithProfile(profileFilename, projectConfig.name),
+        });
+        const errors = [
+            commands.project.validate.failure(projectConfig.name),
+        ];
+        errors.push(error instanceof Error ? error : `${error}`);
+        return errors;
     }
-    return undefined;
+    SpinniesManager.succeed(spinnerName, {
+        text: commands.project.validate.spinners.profileValidationSucceeded(profileFilename),
+    });
+    return [];
 }

package/lib/projects/__tests__/AppDevModeInterface.test.js

@@ -12,7 +12,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => {
 });
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import AppDevModeInterface from '../localDev/AppDevModeInterface.js';
 import LocalDevState from '../localDev/LocalDevState.js';
 import LocalDevLogger from '../localDev/LocalDevLogger.js';
@@ -121,7 +121,7 @@ describe('AppDevModeInterface', () => {
                 previouslyAuthorizedScopeGroups: [],
             },
         });
-        getAccountConfig.mockReturnValue({
+        getConfigAccountById.mockReturnValue({
             parentAccountId: 12345,
         });
         isDeveloperTestAccount.mockReturnValue(true);
@@ -290,13 +290,14 @@ describe('AppDevModeInterface', () => {
         });
         it('should handle app reinstallation', async () => {
             // Set up conditions for non-automatic installation
-            getAccountConfig.mockReturnValue(null);
             fetchAppInstallationData.mockResolvedValue({
                 data: {
                     isInstalledWithScopeGroups: false,
                     previouslyAuthorizedScopeGroups: ['old-scope'],
                 },
             });
+            // Make it not automatically installable by making it not a test account
+            isDeveloperTestAccount.mockReturnValue(false);
             await appDevModeInterface.setup();
             expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
         });
@@ -308,7 +309,7 @@ describe('AppDevModeInterface', () => {
         });
         it('should exit if user declines auto-install', async () => {
             // Set up conditions for automatic installation
-            getAccountConfig.mockReturnValue({
+            getConfigAccountById.mockReturnValue({
                 parentAccountId: 12345, // matches targetProjectAccountId
             });
             isDeveloperTestAccount.mockReturnValue(true);
@@ -375,6 +376,15 @@ describe('AppDevModeInterface', () => {
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
+            getConfigAccountById.mockReturnValue({
+                parentAccountId: 12345,
+            });
+            isDeveloperTestAccount.mockReturnValue(true);
+            isSandbox.mockReturnValue(false);
+            installAppAutoPrompt.mockResolvedValue(true);
+            confirmPrompt.mockResolvedValue(true);
+            installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
+            isServerRunningAtUrl.mockResolvedValue(true);
             installAppBrowserPrompt.mockImplementation(async () => {
                 const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
                 if (addListenerCall) {
@@ -387,8 +397,8 @@ describe('AppDevModeInterface', () => {
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
             mockLocalDevState.addListener = vi.fn();
-            // Target account config is missing
-            getAccountConfig.mockReturnValue(null);
+            // Target account config is missing - make it not a test account so isAutomaticallyInstallable returns false
+            isDeveloperTestAccount.mockReturnValue(false);
             // App is not installed
             fetchAppInstallationData.mockResolvedValue({
                 data: {
@@ -401,6 +411,7 @@ describe('AppDevModeInterface', () => {
                 localDevState: mockLocalDevState,
                 localDevLogger: mockLocalDevLogger,
             });
+            // Remove the spy to see if that's causing the timeout
             await newAppDevModeInterface.setup();
             expect(installAppBrowserPrompt).toHaveBeenCalled();
         });

package/lib/projects/__tests__/DevServerManager.test.js

@@ -28,6 +28,7 @@ vi.mock('@hubspot/local-dev-lib/config', () => ({
     getAccountId: vi.fn().mockReturnValue(123),
     hasLocalStateFlag: vi.fn().mockReturnValue(false),
     getConfigDefaultAccount: vi.fn().mockReturnValue({ accountId: 123 }),
+    globalConfigFileExists: vi.fn().mockReturnValue(true),
 }));
 vi.mock('@hubspot/local-dev-lib/urls', () => ({
     getHubSpotApiOrigin: vi.fn().mockReturnValue('https://api.hubspot.com'),

package/lib/projects/__tests__/LocalDevProcess.test.js

@@ -26,6 +26,7 @@ vi.mock('../deploy');
 vi.mock('../config');
 vi.mock('@hubspot/local-dev-lib/api/projects');
 vi.mock('@hubspot/local-dev-lib/errors/index');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../localDev/LocalDevLogger');
 vi.mock('../localDev/DevServerManager');
 // Tests for LocalDevProcess and LocalDevState

package/lib/projects/__tests__/deploy.test.js

@@ -8,6 +8,7 @@ import { pollDeployStatus } from '../pollProjectBuildAndDeploy.js';
 // Mock external dependencies
 vi.mock('../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../pollProjectBuildAndDeploy.js');
 const mockUiLogger = vi.mocked(uiLogger);
 const mockDeployProject = vi.mocked(deployProject);