@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/lib/app/migrate.js

@@ -0,0 +1,389 @@
+import path from 'path';
+import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
+import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import chalk from 'chalk';
+import { validateUid } from '@hubspot/project-parsing-lib/uid';
+import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
+import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
+import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
+import { downloadProject, fetchProjectComponentsMetadata, } from '@hubspot/local-dev-lib/api/projects';
+import { Separator } from '@inquirer/prompts';
+import { confirmPrompt, inputPrompt, listPrompt, } from '../prompts/promptUtils.js';
+import { uiAccountDescription, uiCommandReference, uiLine, uiLink, } from '../ui/index.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { DEFAULT_POLLING_STATUS_LOOKUP, poll } from '../polling.js';
+import { checkMigrationStatusV2, CLI_UNMIGRATABLE_REASONS, continueAppMigration, initializeAppMigration, isMigrationStatus, listAppsForMigration, } from '../../api/migrate.js';
+import fs from 'fs';
+import { lib } from '../../lang/en.js';
+import { hasUnfiedAppsAccess } from '../hasFeature.js';
+import { getProjectBuildDetailUrl, getProjectDetailUrl, } from '../projects/urls.js';
+import { uiLogger } from '../ui/logger.js';
+export function getUnmigratableReason(reasonCode, projectName, accountId) {
+    switch (reasonCode) {
+        case UNMIGRATABLE_REASONS.UP_TO_DATE:
+            return lib.migrate.errors.unmigratableReasons.upToDate;
+        case UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP:
+            return lib.migrate.errors.unmigratableReasons.isPrivateApp;
+        case UNMIGRATABLE_REASONS.LISTED_IN_MARKETPLACE:
+            return lib.migrate.errors.unmigratableReasons.listedInMarketplace;
+        case UNMIGRATABLE_REASONS.PROJECT_CONNECTED_TO_GITHUB:
+            return lib.migrate.errors.unmigratableReasons.projectConnectedToGitHub(projectName, accountId);
+        case CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY:
+            return lib.migrate.errors.unmigratableReasons.partOfProjectAlready;
+        default:
+            return lib.migrate.errors.unmigratableReasons.generic(reasonCode);
+    }
+}
+export function generateFilterAppsByProjectNameFunction(projectConfig) {
+    return (app) => {
+        if (projectConfig) {
+            return app.projectName === projectConfig?.projectConfig?.name;
+        }
+        return true;
+    };
+}
+export function buildErrorMessageFromMigrationStatus(error) {
+    const { componentErrors, projectErrorDetail } = error;
+    if (!componentErrors || !componentErrors.length) {
+        return projectErrorDetail;
+    }
+    return `${projectErrorDetail}: \n\t- ${componentErrors
+        .map(componentError => {
+        const { componentType, errorMessage, developerSymbol: uid, } = componentError;
+        return `${componentType}${uid ? ` (${uid})` : ''}: ${errorMessage}`;
+    })
+        .join('\n\t- ')}`;
+}
+export async function fetchMigrationApps(derivedAccountId, platformVersion, options) {
+    const { data: { migratableApps, unmigratableApps }, } = await listAppsForMigration(derivedAccountId, platformVersion, options.appId);
+    const filteredMigratableApps = migratableApps.filter(generateFilterAppsByProjectNameFunction(options.projectConfig));
+    const filteredUnmigratableApps = unmigratableApps.filter(generateFilterAppsByProjectNameFunction(options.projectConfig));
+    return {
+        migratableApps: filteredMigratableApps,
+        unmigratableApps: filteredUnmigratableApps,
+    };
+}
+export async function validateMigrationApps(appId, derivedAccountId, { migratableApps, unmigratableApps, }, projectConfig) {
+    const allApps = [...migratableApps, ...unmigratableApps];
+    if (allApps.length > 1 && projectConfig) {
+        throw new Error(lib.migrate.errors.project.multipleApps);
+    }
+    if (!projectConfig?.projectConfig) {
+        allApps.forEach(app => {
+            if (app.projectName) {
+                app.isMigratable = false;
+                app.unmigratableReason =
+                    CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY;
+            }
+        });
+    }
+    if (allApps.length === 0 && projectConfig) {
+        throw new Error(lib.migrate.errors.noAppsForProject(projectConfig?.projectConfig?.name || ''));
+    }
+    if (allApps.length === 0 || !allApps.some(app => app.isMigratable)) {
+        const reasons = unmigratableApps.map(app => `${chalk.bold(app.appName)}: ${getUnmigratableReason(app.unmigratableReason, app.projectName, derivedAccountId)}`);
+        throw new Error(lib.migrate.errors.noAppsEligible(uiAccountDescription(derivedAccountId), reasons));
+    }
+    if (appId &&
+        !allApps.some(app => {
+            return app.appId === appId;
+        })) {
+        throw new Error(lib.migrate.errors.appWithAppIdNotFound(appId));
+    }
+}
+export async function promptForAppToMigrate(allApps, derivedAccountId) {
+    const appChoices = allApps.map(app => ({
+        name: app.isMigratable
+            ? app.appName
+            : `[${chalk.yellow('DISABLED')}] ${app.appName} `,
+        value: app,
+        disabled: app.isMigratable
+            ? false
+            : getUnmigratableReason(app.unmigratableReason, app.projectName, derivedAccountId),
+    }));
+    const enabledChoices = appChoices.filter(app => !app.disabled);
+    const disabledChoices = appChoices.filter(app => app.disabled);
+    const { appId: selectedAppId } = await listPrompt(lib.migrate.prompt.chooseApp, {
+        choices: [...enabledChoices, new Separator(), ...disabledChoices],
+    });
+    return selectedAppId;
+}
+export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
+    if (appId &&
+        !allApps.some(app => {
+            return app.appId === appId;
+        })) {
+        throw new Error(lib.migrate.errors.appWithAppIdNotFound(appId));
+    }
+    let appIdToMigrate = appId;
+    if (!appIdToMigrate) {
+        appIdToMigrate = await promptForAppToMigrate(allApps, derivedAccountId);
+    }
+    const selectedApp = allApps.find(app => app.appId === appIdToMigrate);
+    const migratableComponents = new Set();
+    const unmigratableComponents = new Set();
+    selectedApp?.migrationComponents.forEach(component => {
+        const userFacingComponentType = mapToUserFacingType(component.componentType);
+        const shouldDisplayComponent = !AUTO_GENERATED_COMPONENT_TYPES.includes(userFacingComponentType);
+        if (shouldDisplayComponent) {
+            if (component.isSupported) {
+                migratableComponents.add(userFacingComponentType);
+            }
+            else {
+                unmigratableComponents.add(userFacingComponentType);
+            }
+        }
+    });
+    if (migratableComponents.size !== 0) {
+        uiLogger.log(lib.migrate.componentsToBeMigrated(`\n - ${[...migratableComponents].join('\n - ')}`));
+    }
+    if (unmigratableComponents.size !== 0) {
+        uiLogger.log(lib.migrate.componentsThatWillNotBeMigrated(`\n - ${[...unmigratableComponents].join('\n - ')}`));
+    }
+    uiLogger.log('');
+    const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
+        defaultAnswer: false,
+    });
+    return {
+        proceed,
+        appIdToMigrate,
+    };
+}
+export async function handleMigrationSetup(derivedAccountId, options, projectConfig) {
+    SpinniesManager.add('checkingForMigratableComponents', {
+        text: lib.migrate.spinners.checkingForMigratableComponents,
+    });
+    const { name, dest, appId } = options;
+    const { migratableApps, unmigratableApps } = await fetchMigrationApps(derivedAccountId, options.platformVersion, { appId, projectConfig });
+    SpinniesManager.remove('checkingForMigratableComponents');
+    await validateMigrationApps(appId, derivedAccountId, { migratableApps, unmigratableApps }, projectConfig);
+    const allApps = [...migratableApps, ...unmigratableApps];
+    const { proceed, appIdToMigrate } = await selectAppToMigrate(allApps, derivedAccountId, appId);
+    if (!proceed) {
+        return {};
+    }
+    // If it's a project we don't want to prompt for dest and name, so just return early
+    if (projectConfig &&
+        projectConfig?.projectConfig &&
+        projectConfig?.projectDir) {
+        return {
+            appIdToMigrate,
+            projectName: projectConfig.projectConfig.name,
+            projectDest: projectConfig.projectDir,
+        };
+    }
+    const projectName = name ||
+        (await inputPrompt(lib.migrate.prompt.inputName, {
+            validate: async (input) => {
+                const { projectExists } = await ensureProjectExists(derivedAccountId, input, { allowCreate: false, noLogs: true });
+                if (projectExists) {
+                    return lib.migrate.errors.project.alreadyExists(input);
+                }
+                return true;
+            },
+        }));
+    const { projectExists } = await ensureProjectExists(derivedAccountId, projectName, { allowCreate: false, noLogs: true });
+    if (projectExists) {
+        throw new Error(lib.migrate.errors.project.alreadyExists(projectName));
+    }
+    const projectDest = dest ||
+        (await inputPrompt(lib.migrate.prompt.inputDest, {
+            defaultAnswer: path.resolve(getCwd(), sanitizeFileName(projectName)),
+        }));
+    return { appIdToMigrate, projectName, projectDest };
+}
+export async function beginAppMigration(derivedAccountId, appId, platformVersion) {
+    SpinniesManager.add('beginningMigration', {
+        text: lib.migrate.spinners.beginningMigration,
+    });
+    const uidMap = {};
+    const { data } = await initializeAppMigration(derivedAccountId, appId, platformVersion);
+    const { migrationId } = data;
+    let pollResponse;
+    try {
+        pollResponse = await pollMigrationStatus(derivedAccountId, migrationId, [
+            MIGRATION_STATUS.INPUT_REQUIRED,
+        ]);
+    }
+    catch (error) {
+        SpinniesManager.fail('beginningMigration', {
+            text: lib.migrate.spinners.unableToStartMigration,
+        });
+        if (isMigrationStatus(error) && error.status === MIGRATION_STATUS.FAILURE) {
+            throw new Error(buildErrorMessageFromMigrationStatus(error));
+        }
+        throw new Error(lib.migrate.errors.migrationFailed, {
+            cause: error,
+        });
+    }
+    if (pollResponse.status !== MIGRATION_STATUS.INPUT_REQUIRED) {
+        SpinniesManager.fail('beginningMigration', {
+            text: lib.migrate.spinners.unableToStartMigration,
+        });
+        return;
+    }
+    const { componentsRequiringUids } = pollResponse;
+    SpinniesManager.remove('beginningMigration');
+    if (Object.values(componentsRequiringUids).length !== 0) {
+        for (const [componentId, component] of Object.entries(componentsRequiringUids)) {
+            const { componentHint, componentType } = component;
+            // Extract the internal ID from the base64-encoded ComponentExternalId
+            let internalId;
+            try {
+                const decoded = Buffer.from(componentId, 'base64').toString('utf8');
+                const parts = decoded.split('$$');
+                internalId = parts[1] || componentId;
+            }
+            catch {
+                // If decoding fails, use the componentId as the internalId
+                internalId = componentId;
+            }
+            const promptText = componentHint
+                ? `${mapToUserFacingType(componentType)} '${componentHint}' (ID: ${internalId})`
+                : `${mapToUserFacingType(componentType)} (ID: ${internalId})`;
+            uidMap[componentId] = await inputPrompt(lib.migrate.prompt.uidForComponent(promptText), {
+                validate: (uid) => {
+                    const result = validateUid(uid);
+                    return result === undefined ? true : result;
+                },
+                defaultAnswer: componentHint
+                    ? componentHint.replace(/[^A-Za-z0-9_\-.]/g, '')
+                    : undefined,
+            });
+        }
+    }
+    return { migrationId, uidMap };
+}
+export async function pollMigrationStatus(derivedAccountId, migrationId, successStates = []) {
+    return poll(() => checkMigrationStatusV2(derivedAccountId, migrationId), {
+        successStates: [...successStates],
+        errorStates: [...DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
+    }, 300_000);
+}
+export async function finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectName) {
+    let pollResponse;
+    try {
+        SpinniesManager.add('finishingMigration', {
+            text: lib.migrate.spinners.finishingMigration,
+        });
+        await continueAppMigration(derivedAccountId, migrationId, uidMap, projectName);
+        pollResponse = await pollMigrationStatus(derivedAccountId, migrationId, [
+            MIGRATION_STATUS.SUCCESS,
+        ]);
+    }
+    catch (error) {
+        SpinniesManager.fail('finishingMigration', {
+            text: lib.migrate.spinners.migrationFailed,
+        });
+        if (isMigrationStatus(error) && error.status === MIGRATION_STATUS.FAILURE) {
+            throw new Error(buildErrorMessageFromMigrationStatus(error));
+        }
+        throw new Error(lib.migrate.errors.migrationFailed, {
+            cause: error,
+        });
+    }
+    if (pollResponse.status !== MIGRATION_STATUS.SUCCESS) {
+        throw new Error(lib.migrate.errors.migrationFailed);
+    }
+    if (pollResponse.status === MIGRATION_STATUS.SUCCESS) {
+        SpinniesManager.succeed('finishingMigration', {
+            text: lib.migrate.spinners.migrationComplete,
+        });
+    }
+    return pollResponse.buildId;
+}
+export async function downloadProjectFiles(derivedAccountId, projectName, buildId, projectDest, projectConfig) {
+    try {
+        SpinniesManager.add('fetchingMigratedProject', {
+            text: lib.migrate.spinners.downloadingProjectContents,
+        });
+        const { data: zippedProject } = await downloadProject(derivedAccountId, projectName, buildId);
+        let absoluteDestPath;
+        if (projectConfig?.projectConfig && projectConfig?.projectDir) {
+            const { projectDir } = projectConfig;
+            absoluteDestPath = projectDir;
+            const { srcDir } = projectConfig.projectConfig;
+            const archiveDest = srcDir === '.'
+                ? path.join(path.dirname(projectDir), `${path.basename(projectDir)}-archive`)
+                : path.join(projectDir, 'archive');
+            // Move the existing source directory to archive
+            fs.renameSync(path.join(projectDir, srcDir), archiveDest);
+            uiLogger.info(lib.migrate.sourceContentsMoved(archiveDest));
+        }
+        else {
+            absoluteDestPath = projectDest
+                ? path.resolve(getCwd(), projectDest)
+                : getCwd();
+        }
+        await extractZipArchive(zippedProject, sanitizeFileName(projectName), absoluteDestPath, {
+            includesRootDir: true,
+            hideLogs: true,
+        });
+        SpinniesManager.succeed('fetchingMigratedProject', {
+            text: lib.migrate.spinners.downloadingProjectContentsComplete,
+        });
+        uiLogger.success(lib.migrate.success.downloadedProject(projectName, projectDest));
+    }
+    catch (error) {
+        SpinniesManager.fail('fetchingMigratedProject', {
+            text: lib.migrate.spinners.downloadingProjectContentsFailed,
+        });
+        throw error;
+    }
+}
+function getAppIdFromComponents(topLevelComponentMetadata) {
+    const appComponent = topLevelComponentMetadata.find(c => (c.type && c.type.name === 'PUBLIC_APP') || 'APP');
+    if (!appComponent) {
+        return undefined;
+    }
+    const { deployOutput } = appComponent;
+    if (deployOutput &&
+        typeof deployOutput === 'object' &&
+        'appId' in deployOutput) {
+        return deployOutput.appId;
+    }
+    return undefined;
+}
+export async function migrateApp(derivedAccountId, options, projectConfig) {
+    const ungatedForUnifiedApps = await hasUnfiedAppsAccess(derivedAccountId);
+    if (!ungatedForUnifiedApps) {
+        throw new Error(lib.migrate.errors.notUngatedForUnifiedApps(uiAccountDescription(derivedAccountId)));
+    }
+    if (projectConfig) {
+        if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
+            throw new Error(lib.migrate.errors.project.invalidConfig);
+        }
+        const { projectExists, project } = await ensureProjectExists(derivedAccountId, projectConfig.projectConfig.name, { allowCreate: false, noLogs: true });
+        if (projectExists && project) {
+            const { data: { topLevelComponentMetadata }, } = await fetchProjectComponentsMetadata(derivedAccountId, project.id);
+            const appId = getAppIdFromComponents(topLevelComponentMetadata);
+            if (appId) {
+                options.appId = appId;
+            }
+        }
+        if (!projectExists) {
+            throw new Error(lib.migrate.errors.project.doesNotExist(derivedAccountId));
+        }
+    }
+    const { appIdToMigrate, projectName, projectDest } = await handleMigrationSetup(derivedAccountId, options, projectConfig);
+    if (!appIdToMigrate || !projectName || !projectDest) {
+        return;
+    }
+    const migrationInProgress = await beginAppMigration(derivedAccountId, appIdToMigrate, options.platformVersion);
+    if (!migrationInProgress) {
+        return;
+    }
+    const { migrationId, uidMap } = migrationInProgress;
+    const buildId = await finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectConfig?.projectConfig?.name || projectName);
+    await downloadProjectFiles(derivedAccountId, projectName, buildId, projectDest, projectConfig);
+    uiLogger.log(uiLink('Project Details', getProjectDetailUrl(projectName, derivedAccountId)));
+    uiLogger.log(uiLink('Build Details', getProjectBuildDetailUrl(projectName, buildId, derivedAccountId)));
+}
+export function logInvalidAccountError() {
+    uiLine();
+    uiLogger.error(lib.migrate.errors.invalidAccountTypeTitle);
+    uiLogger.log(lib.migrate.errors.invalidAccountTypeDescription(uiCommandReference('hs account use')));
+    uiLine();
+}

package/lib/app/urls.d.ts

@@ -0,0 +1,17 @@
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+type PrivateAppInstallUrlArgs = {
+    targetAccountId: number;
+    env: Environment;
+    appId: number;
+};
+type PublicAppInstallUrlArgs = {
+    targetAccountId: number;
+    env: Environment;
+    clientId: string;
+    scopes: string[];
+    redirectUrls: string[];
+};
+export declare function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }: PublicAppInstallUrlArgs): string;
+export declare function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
+export declare function getAppCardSetupUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
+export {};

package/lib/app/urls.js

@@ -0,0 +1,16 @@
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+export function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    return (`${websiteOrigin}/oauth/${targetAccountId}/authorize` +
+        `?client_id=${encodeURIComponent(clientId)}` +
+        `&scope=${encodeURIComponent(scopes.join(' '))}` +
+        `&redirect_uri=${encodeURIComponent(redirectUrls[0])}`);
+}
+export function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    return `${websiteOrigin}/static-token/${targetAccountId}/authorize?appId=${appId}`;
+}
+export function getAppCardSetupUrl({ targetAccountId, env, appId, }) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    return `${websiteOrigin}/integrations-settings/${targetAccountId}/installed/framework/${appId}/app-cards?tourId=get-started`;
+}

package/lib/buildAccount.d.ts

@@ -0,0 +1,15 @@
+import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
+import { SandboxAccountType } from '../types/Sandboxes.js';
+export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
+export declare function createDeveloperTestAccountV2(parentAccountId: number, testAccountConfig: DeveloperTestAccountConfig): Promise<{
+    accountName: string;
+    accountId?: number;
+    personalAccessKey?: string;
+}>;
+export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: HubSpotConfigAccount, env: Environment, portalLimit: number, useV2?: boolean): Promise<number>;
+export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
+    sandbox: V2Sandbox;
+}>;

package/lib/buildAccount.js

@@ -0,0 +1,184 @@
+import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-dev-lib/config';
+import { uiLogger } from './ui/logger.js';
+import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { PromptExitError } from './errors/PromptExitError.js';
+import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { createDeveloperTestAccountConfigPrompt } from './prompts/createDeveloperTestAccountConfigPrompt.js';
+import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
+import SpinniesManager from './ui/SpinniesManager.js';
+import { debugError, logError } from './errorHandlers/index.js';
+import { SANDBOX_TYPE_MAP_V2, handleSandboxCreateError } from './sandboxes.js';
+import { handleDeveloperTestAccountCreateError } from './developerTestAccounts.js';
+import { lib } from '../lang/en.js';
+import { poll } from './polling.js';
+export async function saveAccountToConfig(accountId, accountName, env, personalAccessKey, force = false) {
+    if (!personalAccessKey) {
+        const configData = await personalAccessKeyPrompt({
+            env,
+            account: accountId,
+        });
+        personalAccessKey = configData.personalAccessKey;
+    }
+    const token = await getAccessToken(personalAccessKey, env);
+    const updatedConfig = await updateConfigWithAccessToken(token, personalAccessKey, env);
+    let validName = updatedConfig?.name || '';
+    if (!updatedConfig?.name) {
+        const nameForConfig = accountName.toLowerCase().split(' ').join('-');
+        validName = nameForConfig;
+        const existingAccount = getConfigAccountIfExists(nameForConfig);
+        if (existingAccount) {
+            if (!force) {
+                uiLogger.log('');
+                uiLogger.warn(lib.prompts.accountNamePrompt.errors.accountNameExists(nameForConfig));
+                const { name: promptName } = await cliAccountNamePrompt(nameForConfig + `_${accountId}`);
+                validName = promptName;
+            }
+            else {
+                // Basic invalid name handling when force flag is passed
+                validName = nameForConfig + `_${accountId}`;
+            }
+        }
+    }
+    updateConfigAccount({
+        ...updatedConfig,
+        name: validName,
+    });
+    uiLogger.log('');
+    return validName;
+}
+export async function createDeveloperTestAccountV2(parentAccountId, testAccountConfig) {
+    const result = {
+        accountName: testAccountConfig.accountName,
+    };
+    const { data } = await createDeveloperTestAccount(parentAccountId, testAccountConfig);
+    result.accountId = data.id;
+    try {
+        await poll(() => fetchDeveloperTestAccountGateSyncStatus(parentAccountId, result.accountId), {
+            successStates: ['SUCCESS'],
+            errorStates: [],
+        });
+    }
+    catch (err) {
+        debugError(err);
+        throw new Error(lib.buildAccount.createDeveloperTestAccountV2.syncFailure);
+    }
+    // HACK: The status endpoint sometimes returns an early success status.
+    // Sleep for an extra 5 seconds to make sure the sync is actually complete.
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    try {
+        // Attempt to generate a new personal access key for the test account now that gate sync is complete.
+        const { data } = await generateDeveloperTestAccountPersonalAccessKey(parentAccountId, result.accountId);
+        result.personalAccessKey = data.personalAccessKey;
+    }
+    catch (err) {
+        debugError(err);
+        throw new Error(lib.buildAccount.createDeveloperTestAccountV2.pakFailure);
+    }
+    return result;
+}
+export async function buildDeveloperTestAccount(testAccountName, parentAccountConfig, env, portalLimit, useV2 = false) {
+    const parentAccountId = parentAccountConfig.accountId;
+    let testAccountConfig = {
+        accountName: testAccountName,
+    };
+    if (!parentAccountId) {
+        throw new Error(lib.developerTestAccount.create.loading.fail(''));
+    }
+    if (useV2) {
+        testAccountConfig = await createDeveloperTestAccountConfigPrompt({
+            name: testAccountConfig.accountName,
+            description: 'Test Account created by the HubSpot CLI',
+        }, false);
+    }
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    uiLogger.log('');
+    SpinniesManager.add('buildDeveloperTestAccount', {
+        text: lib.developerTestAccount.create.loading.add(testAccountName),
+    });
+    let developerTestAccountId;
+    let developerTestAccountPersonalAccessKey;
+    try {
+        if (useV2) {
+            const result = await createDeveloperTestAccountV2(parentAccountId, testAccountConfig);
+            developerTestAccountId = result.accountId;
+            developerTestAccountPersonalAccessKey = result.personalAccessKey;
+        }
+        else {
+            const { data } = await createDeveloperTestAccount(parentAccountId, testAccountName);
+            developerTestAccountId = data.id;
+            developerTestAccountPersonalAccessKey = data.personalAccessKey;
+        }
+        SpinniesManager.succeed('buildDeveloperTestAccount', {
+            text: lib.developerTestAccount.create.loading.succeed(testAccountName, developerTestAccountId.toString()),
+        });
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('buildDeveloperTestAccount', {
+            text: lib.developerTestAccount.create.loading.fail(testAccountName),
+        });
+        handleDeveloperTestAccountCreateError(e, parentAccountId, env, portalLimit);
+    }
+    try {
+        await saveAccountToConfig(developerTestAccountId, testAccountName, env, developerTestAccountPersonalAccessKey);
+    }
+    catch (err) {
+        if (err instanceof PromptExitError) {
+            throw err;
+        }
+        logError(err);
+        throw err;
+    }
+    return developerTestAccountId;
+}
+export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxType, syncObjectRecords, env, force = false) {
+    const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
+        ? 'standard'
+        : 'developer';
+    const parentAccountId = parentAccountConfig.accountId;
+    if (!parentAccountId) {
+        throw new Error(lib.sandbox.create[sandboxTypeKey].loading.fail(''));
+    }
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    uiLogger.log('');
+    SpinniesManager.add('buildV2Sandbox', {
+        text: lib.sandbox.create[sandboxTypeKey].loading.add(sandboxName),
+    });
+    let sandbox;
+    let pak;
+    try {
+        const sandboxTypeV2 = SANDBOX_TYPE_MAP_V2[sandboxType];
+        const { data } = await createV2Sandbox(parentAccountId, sandboxName, sandboxTypeV2, syncObjectRecords);
+        sandbox = { ...data };
+        const { data: { personalAccessKey }, } = await getSandboxPersonalAccessKey(parentAccountId, sandbox.sandboxHubId);
+        pak = personalAccessKey.encodedOAuthRefreshToken;
+        SpinniesManager.succeed('buildV2Sandbox', {
+            text: lib.sandbox.create[sandboxTypeKey].loading.succeed(sandboxName, sandbox.sandboxHubId.toString()),
+        });
+    }
+    catch (e) {
+        debugError(e);
+        SpinniesManager.fail('buildV2Sandbox', {
+            text: lib.sandbox.create[sandboxTypeKey].loading.fail(sandboxName),
+        });
+        handleSandboxCreateError(e, env, sandboxName, parentAccountId);
+    }
+    try {
+        await saveAccountToConfig(sandbox.sandboxHubId, sandboxName, env, pak, force);
+    }
+    catch (err) {
+        if (err instanceof PromptExitError) {
+            throw err;
+        }
+        logError(err);
+        throw err;
+    }
+    return { sandbox };
+}

package/lib/cliUpgradeUtils.d.ts

@@ -0,0 +1,22 @@
+export type CLIUpgradeInfo = {
+    current?: string;
+    latest?: string;
+    type?: string;
+};
+export declare const isCliGloballyInstalled: () => Promise<boolean>;
+/**
+ * Check if the CLI is globally installed via npm
+ */
+export declare function canCliBeAutoUpgraded(): Promise<boolean>;
+export declare function getLatestCliVersion(): Promise<{
+    latest: string | null;
+    next: string | null;
+}>;
+/**
+ * Get update information using update-notifier
+ */
+export declare function getCliUpgradeInfo(): CLIUpgradeInfo;
+/**
+ * Install a specific version of the CLI globally
+ */
+export declare function installCliVersion(version?: string): Promise<void>;