@hubspot/cli 8.0.10-experimental.5 → 8.0.10-experimental.6

package/lib/app/migrate.js

@@ -1,384 +0,0 @@
-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 { 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 => {
-        if (component.isSupported) {
-            migratableComponents.add(mapToUserFacingType(component.componentType));
-        }
-        else {
-            unmigratableComponents.add(mapToUserFacingType(component.componentType));
-        }
-    });
-    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

@@ -1,17 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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>;