@hubspot/cli 7.10.0 → 7.10.1-experimental.0

package/commands/project/lint.js

@@ -0,0 +1,178 @@
+import path from 'path';
+import { getProjectPackageJsonLocations, installPackages, } from '../../lib/dependencyManagement.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { areAllLintPackagesInstalled, getMissingLintPackages, lintPackages, displayLintResults, hasEslintConfig, hasDeprecatedEslintConfig, getDeprecatedEslintConfigFiles, createEslintConfig, REQUIRED_PACKAGES_AND_MIN_VERSIONS, } from '../../lib/projects/uieLinting.js';
+const command = 'lint';
+const describe = commands.project.lint.help.describe;
+async function handler(args) {
+    const { derivedAccountId, installMissingDeps } = args;
+    try {
+        trackCommandUsage('project-lint', undefined, derivedAccountId);
+        const projectConfig = await getProjectConfig();
+        if (!projectConfig || !projectConfig.projectDir) {
+            uiLogger.error(commands.project.lint.noProjectConfig);
+            return process.exit(EXIT_CODES.ERROR);
+        }
+        SpinniesManager.init({ succeedColor: 'white' });
+        SpinniesManager.add('lintCheck', {
+            text: commands.project.lint.loading.checking,
+        });
+        const lintLocations = await getProjectPackageJsonLocations();
+        const locationsReadyToLint = [];
+        const locationsNeedingPackages = new Map();
+        for (const lintLocation of lintLocations) {
+            if (areAllLintPackagesInstalled(lintLocation)) {
+                locationsReadyToLint.push(lintLocation);
+            }
+            else {
+                const { missingPackages } = getMissingLintPackages(lintLocation);
+                if (missingPackages.length > 0) {
+                    locationsNeedingPackages.set(lintLocation, missingPackages);
+                }
+            }
+        }
+        SpinniesManager.succeed('lintCheck');
+        if (locationsNeedingPackages.size > 0) {
+            const locationsArray = Array.from(locationsNeedingPackages.keys());
+            const relativeLocations = locationsArray.map(loc => path.relative(projectConfig.projectDir, loc));
+            const allMissingPackages = [];
+            for (const packages of locationsNeedingPackages.values()) {
+                allMissingPackages.push(...packages);
+            }
+            let shouldInstallPackages;
+            if (installMissingDeps !== undefined) {
+                shouldInstallPackages = installMissingDeps;
+            }
+            else {
+                const promptResult = await promptUser([
+                    {
+                        name: 'shouldInstallPackages',
+                        type: 'confirm',
+                        message: commands.project.lint.installLintPackagesPrompt(relativeLocations, allMissingPackages),
+                        default: true,
+                    },
+                ]);
+                shouldInstallPackages = promptResult.shouldInstallPackages;
+            }
+            if (shouldInstallPackages) {
+                const packagesToInstall = Object.entries(REQUIRED_PACKAGES_AND_MIN_VERSIONS).map(([pkg, version]) => `${pkg}@^${version}`);
+                await installPackages({
+                    packages: packagesToInstall,
+                    installLocations: locationsArray,
+                    dev: true,
+                });
+                // Re-check which locations are now ready
+                for (const location of locationsArray) {
+                    if (areAllLintPackagesInstalled(location)) {
+                        locationsReadyToLint.push(location);
+                    }
+                }
+            }
+            else {
+                uiLogger.warn(commands.project.lint.skippingDirectoriesWarning(relativeLocations));
+            }
+        }
+        if (locationsReadyToLint.length > 0) {
+            // Check for config files and handle deprecated configs
+            const deprecatedConfigDetails = [];
+            const locationsNeedingConfig = [];
+            for (const location of locationsReadyToLint) {
+                const hasModernConfig = hasEslintConfig(location);
+                const hasDeprecatedConfig = hasDeprecatedEslintConfig(location);
+                if (hasDeprecatedConfig) {
+                    const relativePath = path.relative(projectConfig.projectDir, location);
+                    const deprecatedFiles = getDeprecatedEslintConfigFiles(location);
+                    deprecatedConfigDetails.push({
+                        path: relativePath,
+                        files: deprecatedFiles,
+                    });
+                }
+                if (!hasModernConfig) {
+                    locationsNeedingConfig.push(location);
+                }
+            }
+            if (deprecatedConfigDetails.length > 0) {
+                uiLogger.log('');
+                uiLogger.warn(commands.project.lint.deprecatedEslintConfigWarning(deprecatedConfigDetails));
+            }
+            if (locationsNeedingConfig.length > 0) {
+                const relativeLocations = locationsNeedingConfig.map(loc => path.relative(projectConfig.projectDir, loc));
+                const { shouldCreateConfig } = await promptUser([
+                    {
+                        name: 'shouldCreateConfig',
+                        type: 'confirm',
+                        message: commands.project.lint.createEslintConfigPrompt(relativeLocations),
+                        default: true,
+                    },
+                ]);
+                if (shouldCreateConfig) {
+                    SpinniesManager.add('lintConfigCreate', {
+                        text: commands.project.lint.loading.creatingConfig,
+                    });
+                    const createdConfigs = [];
+                    for (const location of locationsNeedingConfig) {
+                        const configPath = createEslintConfig(location);
+                        createdConfigs.push(configPath);
+                    }
+                    SpinniesManager.succeed('lintConfigCreate');
+                    createdConfigs.forEach(configPath => {
+                        uiLogger.success(commands.project.lint.eslintConfigCreated(configPath));
+                    });
+                }
+                else {
+                    uiLogger.error(commands.project.lint.eslintConfigRequired);
+                    return process.exit(EXIT_CODES.ERROR);
+                }
+            }
+            SpinniesManager.add('lintRun', {
+                text: commands.project.lint.loading.linting,
+            });
+            const { success, results } = await lintPackages(locationsReadyToLint, projectConfig.projectDir);
+            SpinniesManager.succeed('lintRun');
+            displayLintResults(results);
+            if (!success) {
+                return process.exit(EXIT_CODES.ERROR);
+            }
+        }
+    }
+    catch (e) {
+        logError(e);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+}
+function projectLintBuilder(yargs) {
+    yargs.example([
+        ['$0 project lint', commands.project.lint.help.lintProjectExample],
+        [
+            '$0 project lint --install-missing-deps',
+            commands.project.lint.help.lintProjectWithInstallExample,
+        ],
+        [
+            '$0 project lint --install-missing-deps=false',
+            commands.project.lint.help.lintProjectWithoutInstallExample,
+        ],
+    ]);
+    yargs.option('install-missing-deps', {
+        type: 'boolean',
+        describe: commands.project.lint.help.installMissingDeps,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(projectLintBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const projectLintCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectLintCommand;

package/commands/project/logs.js

@@ -1,6 +1,5 @@
-import { getEnv } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { getTableContents, getTableHeader } from '../../lib/ui/table.js';
 import { logError } from '../../lib/errorHandlers/index.js';
@@ -12,7 +11,7 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { ProjectLogsManager } from '../../lib/projects/ProjectLogsManager.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 function getPrivateAppsUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
     return `${baseUrl}/private-apps/${accountId}`;
 }
 function logTable(tableHeader, logsInfo) {

package/commands/project/migrate.js

@@ -7,7 +7,6 @@ import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { uiCommandReference } from '../../lib/ui/index.js';
 import { commands, lib } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { logInBox } from '../../lib/ui/boxen.js';
 import { renderInline } from '../../ui/index.js';
 import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 import { getHasMigratableThemes, migrateThemes2025_2, } from '../../lib/theme/migrate.js';
@@ -26,18 +25,10 @@ async function handler(args) {
         return process.exit(EXIT_CODES.ERROR);
     }
     if (projectConfig?.projectConfig) {
-        if (!process.env.HUBSPOT_ENABLE_INK) {
-            await logInBox({
-                contents: lib.migrate.projectMigrationWarning,
-                options: { title: lib.migrate.projectMigrationWarningTitle },
-            });
-        }
-        else {
-            await renderInline(getWarningBox({
-                title: lib.migrate.projectMigrationWarningTitle,
-                message: lib.migrate.projectMigrationWarning,
-            }));
-        }
+        await renderInline(getWarningBox({
+            title: lib.migrate.projectMigrationWarningTitle,
+            message: lib.migrate.projectMigrationWarning,
+        }));
     }
     try {
         const { hasMigratableThemes, migratableThemesCount } = await getHasMigratableThemes(projectConfig);

package/commands/project/profile/add.js

@@ -1,7 +1,6 @@
 import path from 'path';
 import fs from 'fs';
-import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { getConfigAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
 import { getAllHsProfiles, getHsProfileFilename, loadHsProfileFile, } from '@hubspot/project-parsing-lib';
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import { getProjectConfig } from '../../../lib/projects/config.js';
@@ -102,9 +101,9 @@ async function handler(args) {
         profileName = promptResponse.name;
     }
     if (targetAccountId) {
-        const accountId = getAccountId(targetAccountId);
-        if (accountId) {
-            targetAccountId = accountId;
+        const account = getConfigAccountIfExists(targetAccountId);
+        if (account) {
+            targetAccountId = account.accountId;
         }
         else {
             uiLogger.error(commands.project.profile.add.errors.invalidTargetAccount);
@@ -113,14 +112,14 @@ async function handler(args) {
         }
     }
     if (!targetAccountId) {
-        const configuredAccounts = getConfigAccounts();
+        const configuredAccounts = getAllConfigAccounts();
         if (!configuredAccounts || !configuredAccounts.length) {
             uiLogger.error(commands.project.profile.add.errors.noAccountsConfigured);
             process.exit(EXIT_CODES.ERROR);
         }
         const promptResponse = await listPrompt(commands.project.profile.add.prompts.targetAccountPrompt, {
             choices: configuredAccounts.map(account => {
-                const accountId = getAccountIdentifier(account);
+                const accountId = account.accountId;
                 return {
                     name: uiAccountDescription(accountId),
                     value: accountId,

package/commands/project/profile/delete.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { getAllHsProfiles, getHsProfileFilename, loadHsProfileFile, } from '@hubspot/project-parsing-lib';
 import { fetchProject, deleteProject, } from '@hubspot/local-dev-lib/api/projects';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import { getProjectConfig } from '../../../lib/projects/config.js';
 import { uiLogger } from '../../../lib/ui/logger.js';
@@ -80,7 +80,7 @@ async function handler(args) {
         catch (err) {
             debugError(err);
         }
-        const targetAccountConfig = getAccountConfig(targetAccountId);
+        const targetAccountConfig = getConfigAccountById(targetAccountId);
         if (projectExists &&
             targetAccountConfig &&
             (isDeveloperTestAccount(targetAccountConfig) ||

package/commands/project/upload.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
 import { isV2Project } from '../../lib/projects/platformVersion.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
@@ -28,11 +28,17 @@ async function handler(args) {
         process.exit(EXIT_CODES.ERROR);
     }
     let targetAccountId;
-    if (isV2Project(projectConfig.platformVersion)) {
-        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+    try {
+        if (isV2Project(projectConfig.platformVersion)) {
+            targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+        }
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
     }
     targetAccountId = targetAccountId || derivedAccountId;
-    const accountConfig = getAccountConfig(targetAccountId);
+    const accountConfig = getConfigAccountById(targetAccountId);
     const accountType = accountConfig && accountConfig.accountType;
     trackCommandUsage('project-upload', { type: accountType, assetType: projectConfig.platformVersion }, targetAccountId);
     try {

package/commands/project/validate.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { isV2Project } from '../../lib/projects/platformVersion.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { uiLogger } from '../../lib/ui/logger.js';
@@ -8,13 +8,19 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
 import { commands } from '../../lang/en.js';
-import { loadAndValidateProfile } from '../../lib/projectProfiles.js';
+import { validateProjectForProfile } from '../../lib/projectProfiles.js';
 import { logError } from '../../lib/errorHandlers/index.js';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 const command = 'validate';
 const describe = commands.project.validate.describe;
 async function handler(args) {
+    SpinniesManager.init();
     const { derivedAccountId, profile } = args;
     const { projectConfig, projectDir } = await getProjectConfig();
+    const accountConfig = getConfigAccountById(derivedAccountId);
+    const accountType = accountConfig && accountConfig.accountType;
+    trackCommandUsage('project-validate', { type: accountType }, derivedAccountId);
     if (!projectConfig || !projectDir) {
         uiLogger.error(commands.project.validate.mustBeRanWithinAProject);
         process.exit(EXIT_CODES.ERROR);
@@ -30,25 +36,79 @@ async function handler(args) {
         logError(error);
         process.exit(EXIT_CODES.ERROR);
     }
-    let targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
-    targetAccountId = targetAccountId || derivedAccountId;
-    const accountConfig = getAccountConfig(targetAccountId);
-    const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-validate', { type: accountType }, targetAccountId);
+    let validationSucceeded = true;
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
-    try {
-        await validateSourceDirectory(srcDir, projectConfig, projectDir);
+    // Get all of the profiles except the provided profile
+    const profiles = (await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir))).filter(profileName => profileName !== profile);
+    // If a profile is specified, only validate that profile
+    if (profile) {
+        const validationErrors = await validateProjectForProfile(projectConfig, projectDir, profile, derivedAccountId);
+        if (validationErrors.length) {
+            validationErrors.forEach(error => {
+                uiLogger.log('');
+                if (error instanceof Error) {
+                    logError(error);
+                }
+                else {
+                    uiLogger.error(error);
+                }
+            });
+            validationSucceeded = false;
+        }
     }
-    catch (e) {
-        logError(e);
+    else if (profiles.length > 0) {
+        // If no profile was specified and the project has profiles, validate all of them
+        SpinniesManager.add('validatingAllProfiles', {
+            text: commands.project.validate.spinners.validatingAllProfiles,
+        });
+        const errors = [];
+        for (const profileName of profiles) {
+            const validationErrors = await validateProjectForProfile(projectConfig, projectDir, profileName, derivedAccountId, true);
+            if (validationErrors.length) {
+                errors.push(...validationErrors);
+                validationSucceeded = false;
+            }
+        }
+        if (validationSucceeded) {
+            SpinniesManager.succeed('validatingAllProfiles', {
+                text: commands.project.validate.spinners.allProfilesValidationSucceeded,
+            });
+        }
+        else {
+            SpinniesManager.fail('validatingAllProfiles', {
+                text: commands.project.validate.spinners.allProfilesValidationFailed,
+            });
+        }
+        errors.forEach(error => {
+            uiLogger.log('');
+            if (error instanceof Error) {
+                logError(error);
+            }
+            else {
+                uiLogger.error(error);
+            }
+        });
+    }
+    else if (profiles.length === 0) {
+        // If the project has no profiles, validate the project without a profile
+        try {
+            await handleTranslate(projectDir, projectConfig, derivedAccountId, false, undefined);
+        }
+        catch (e) {
+            uiLogger.error(commands.project.validate.failure(projectConfig.name));
+            logError(e);
+            validationSucceeded = false;
+            uiLogger.log('');
+        }
+    }
+    if (!validationSucceeded) {
         process.exit(EXIT_CODES.ERROR);
     }
     try {
-        await handleTranslate(projectDir, projectConfig, targetAccountId, false, profile);
+        await validateSourceDirectory(srcDir, projectConfig, projectDir);
     }
     catch (e) {
         logError(e);
-        uiLogger.error(commands.project.validate.failure(projectConfig.name));
         process.exit(EXIT_CODES.ERROR);
     }
     uiLogger.success(commands.project.validate.success(projectConfig.name));

package/commands/project.js

@@ -13,6 +13,7 @@ import migrate from './project/migrate.js';
 import migrateApp from './project/migrateApp.js';
 import cloneApp from './project/cloneApp.js';
 import installDeps from './project/installDeps.js';
+import lint from './project/lint.js';
 import updateDeps from './project/updateDeps.js';
 import profile from './project/profile.js';
 import projectValidate from './project/validate.js';
@@ -37,6 +38,7 @@ function projectBuilder(yargs) {
         .command(migrate)
         .command(cloneApp)
         .command(installDeps)
+        .command(lint)
         .command(updateDeps)
         .command(profile)
         .command(projectValidate)

package/commands/sandbox/__tests__/create.test.js

@@ -14,6 +14,7 @@ import { uiLogger } from '../../../lib/ui/logger.js';
 import * as sandboxesLib from '../../../lib/sandboxes.js';
 import * as sandboxSync from '../../../lib/sandboxSync.js';
 import { vi } from 'vitest';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 vi.mock('../../../lib/ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/commonOpts');
@@ -26,12 +27,13 @@ vi.mock('../../../lib/usageTracking');
 vi.mock('../../../lib/buildAccount');
 vi.mock('../../../lib/sandboxes');
 vi.mock('../../../lib/commonOpts');
-const getAccountConfigSpy = vi.spyOn(configUtils, 'getAccountConfig');
+const getConfigAccountByIdSpy = vi.spyOn(configUtils, 'getConfigAccountById');
 const promptUserSpy = vi.spyOn(promptUtils, 'promptUser');
 const sandboxTypePromptSpy = vi.spyOn(sandboxPrompts, 'sandboxTypePrompt');
 const processExitSpy = vi.spyOn(process, 'exit');
 const buildSandboxSpy = vi.spyOn(buildAccount, 'buildSandbox');
 const buildV2SandboxSpy = vi.spyOn(buildAccount, 'buildV2Sandbox');
+const getConfigAccountEnvironmentSpy = vi.spyOn(configUtils, 'getConfigAccountEnvironment');
 const getAvailableSyncTypesSpy = vi.spyOn(sandboxesLib, 'getAvailableSyncTypes');
 const syncSandboxSpy = vi.spyOn(sandboxSync, 'syncSandbox');
 const validateSandboxUsageLimitsSpy = vi.spyOn(sandboxesLib, 'validateSandboxUsageLimits');
@@ -88,7 +90,8 @@ describe('commands/sandbox/create', () => {
             args = {
                 derivedAccountId: 1234567890,
             };
-            getAccountConfigSpy.mockReturnValue({
+            getConfigAccountByIdSpy.mockReturnValue({
+                accountId: 1234567890,
                 accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
                 env: 'prod',
             });
@@ -104,6 +107,7 @@ describe('commands/sandbox/create', () => {
             validateSandboxUsageLimitsSpy.mockResolvedValue(undefined);
             mockedHasFeatureV2Sandboxes.mockResolvedValue(false);
             mockedHasFeatureV2Cli.mockResolvedValue(false);
+            getConfigAccountEnvironmentSpy.mockReturnValue(ENVIRONMENTS.PROD);
             buildSandboxSpy.mockResolvedValue({
                 sandbox: mockSandbox,
                 personalAccessKey: 'mock-personal-access-key',
@@ -123,8 +127,8 @@ describe('commands/sandbox/create', () => {
         });
         it('should load the account config for the correct account id', async () => {
             await sandboxCreateCommand.handler(args);
-            expect(getAccountConfigSpy).toHaveBeenCalledTimes(2); // 1st is for parent account, 2nd is for sandbox account
-            expect(getAccountConfigSpy).toHaveBeenCalledWith(args.derivedAccountId);
+            expect(getConfigAccountByIdSpy).toHaveBeenCalledTimes(2); // 1st is for parent account, 2nd is for sandbox account
+            expect(getConfigAccountByIdSpy).toHaveBeenCalledWith(args.derivedAccountId);
         });
         it('should track the command usage', async () => {
             await sandboxCreateCommand.handler(args);
@@ -135,6 +139,7 @@ describe('commands/sandbox/create', () => {
             await sandboxCreateCommand.handler(args);
             expect(validateSandboxUsageLimitsSpy).toHaveBeenCalledTimes(1);
             expect(validateSandboxUsageLimitsSpy).toHaveBeenCalledWith({
+                accountId: 1234567890,
                 accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
                 env: 'prod',
             }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod');
@@ -168,6 +173,7 @@ describe('commands/sandbox/create', () => {
             await sandboxCreateCommand.handler(args);
             expect(buildSandboxSpy).toHaveBeenCalledTimes(1);
             expect(buildSandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
+                accountId: 1234567890,
                 accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
                 env: 'prod',
             }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod', undefined // force
@@ -181,6 +187,7 @@ describe('commands/sandbox/create', () => {
             await sandboxCreateCommand.handler(args);
             expect(buildSandboxSpy).toHaveBeenCalledTimes(1);
             expect(buildSandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
+                accountId: 1234567890,
                 accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
                 env: 'prod',
             }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod', undefined // force
@@ -194,6 +201,7 @@ describe('commands/sandbox/create', () => {
             await sandboxCreateCommand.handler(args);
             expect(buildV2SandboxSpy).toHaveBeenCalledTimes(1);
             expect(buildV2SandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
+                accountId: 1234567890,
                 accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
                 env: 'prod',
             }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
@@ -222,7 +230,8 @@ describe('commands/sandbox/create', () => {
             expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
         });
         it('should error out if the default account type is not standard', async () => {
-            getAccountConfigSpy.mockReturnValue({
+            getConfigAccountByIdSpy.mockReturnValue({
+                accountId: 1234567890,
                 accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 env: 'prod',
             });

package/commands/sandbox/create.js

@@ -1,9 +1,8 @@
-import { getAccountConfig, getEnv } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfigAccountEnvironment, } from '@hubspot/local-dev-lib/config';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
-import { getValidEnv } from '@hubspot/local-dev-lib/environment';
 import { commands, lib } from '../../lang/en.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiFeatureHighlight, uiBetaTag } from '../../lib/ui/index.js';
@@ -22,8 +21,8 @@ const command = 'create';
 const describe = uiBetaTag(commands.sandbox.subcommands.create.describe, false);
 async function handler(args) {
     const { name, type, force, derivedAccountId } = args;
-    const accountConfig = getAccountConfig(derivedAccountId);
-    const env = getValidEnv(getEnv(derivedAccountId));
+    const accountConfig = getConfigAccountById(derivedAccountId);
+    const env = getConfigAccountEnvironment(derivedAccountId);
     trackCommandUsage('sandbox-create', {}, derivedAccountId);
     // Check if account config exists
     if (!accountConfig) {
@@ -111,7 +110,7 @@ async function handler(args) {
         else {
             result = await buildSandbox(sandboxName, accountConfig, sandboxType, env, force);
         }
-        const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
+        const sandboxAccountConfig = getConfigAccountById(result.sandbox.sandboxHubId);
         // Check if sandbox account config exists
         if (!sandboxAccountConfig) {
             uiLogger.error(commands.sandbox.subcommands.create.failure.noSandboxAccountConfig(result.sandbox.sandboxHubId));