@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,11 +1,12 @@
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { HUBSPOT_ACCOUNT_TYPE_STRINGS, HUBSPOT_ACCOUNT_TYPES, } from '@hubspot/local-dev-lib/constants/config';
 import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { promptUser } from './promptUtils.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 import { uiAccountDescription } from '../ui/index.js';
 import { isSandbox } from '../accountTypes.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 function mapNestedAccount(accountConfig) {
     const parentAccountId = accountConfig.parentAccountId ?? null;
@@ -23,20 +24,18 @@ function getNonConfigDeveloperTestAccountName(account) {
 }
 export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let choices = [];
     let sandboxUsage = {
         STANDARD: { used: 0, available: 0, limit: 0 },
         DEVELOPER: { used: 0, available: 0, limit: 0 },
     };
     try {
-        if (defaultAccountId) {
-            const { data } = await getSandboxUsageLimits(defaultAccountId);
-            sandboxUsage = data.usage;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await getSandboxUsageLimits(defaultAccountId);
+        sandboxUsage = data.usage;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch sandbox usage limits: ', err);
@@ -83,19 +82,18 @@ export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountC
 }
 export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let devTestAccountsResponse;
     try {
-        if (defaultAccountId) {
-            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
-            devTestAccountsResponse = data;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
+        devTestAccountsResponse = data;
     }
     catch (err) {
-        uiLogger.debug('Unable to fetch developer test account usage limits: ', err);
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.fetchDeveloperTestAccountsError);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.fetchDeveloperTestAccountsError, EXIT_CODES.ERROR);
     }
     let disabledMessage = false;
     if (devTestAccountsResponse &&
@@ -167,3 +165,13 @@ export async function confirmUseExistingDeveloperTestAccountPrompt(account) {
     ]);
     return confirmUseExistingDeveloperTestAccount;
 }
+export async function confirmLinkExistingDeveloperTestAccountPrompt(accountName) {
+    const { confirmLinkExistingDeveloperTestAccount } = await promptUser([
+        {
+            name: 'confirmLinkExistingDeveloperTestAccount',
+            type: 'confirm',
+            message: lib.prompts.projectDevTargetAccountPrompt.confirmLinkExistingDeveloperTestAccount(accountName),
+        },
+    ]);
+    return confirmLinkExistingDeveloperTestAccount;
+}

package/lib/prompts/projectProfilePrompt.d.ts

@@ -0,0 +1,2 @@
+import { ProjectConfig } from '../../types/Projects.js';
+export declare function projectProfilePrompt(projectDir: string, projectConfig: ProjectConfig, profileName?: string, exitIfMissing?: boolean): Promise<string | null>;

package/lib/prompts/projectProfilePrompt.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
+import { listPrompt } from './promptUtils.js';
+import { loadProfile } from '../projects/projectProfiles.js';
+import { lib } from '../../lang/en.js';
+function generateProfilePromptOption(projectDir, projectConfig, profileName) {
+    const choice = {
+        name: profileName,
+        value: profileName,
+    };
+    try {
+        const profile = loadProfile(projectConfig, projectDir, profileName);
+        choice.name = `${profileName} [${profile.accountId}]`;
+    }
+    catch (e) {
+        choice.name = `${profileName} [Invalid profile]`;
+        choice.disabled = true;
+    }
+    return choice;
+}
+export async function projectProfilePrompt(projectDir, projectConfig, profileName, exitIfMissing) {
+    if (profileName) {
+        return profileName;
+    }
+    const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
+    if (existingProfiles.length !== 0) {
+        if (existingProfiles.length === 1) {
+            return existingProfiles[0];
+        }
+        // In automated workflows exit instead of prompting
+        if (exitIfMissing) {
+            throw new Error(lib.prompts.projectProfilePrompt.exitMessage);
+        }
+        const listOptions = existingProfiles.map(p => generateProfilePromptOption(projectDir, projectConfig, p));
+        const hasAnyValidProfiles = listOptions.some(option => typeof option === 'object' && 'name' in option && !option.disabled);
+        // Exit early if the user has no valid profiles for us to show in the prompt
+        if (!hasAnyValidProfiles) {
+            throw new Error(lib.prompts.projectProfilePrompt.noValidProfilesMessage);
+        }
+        const profileNameFromPrompt = await listPrompt(lib.prompts.projectProfilePrompt.message, {
+            choices: listOptions,
+        });
+        return profileNameFromPrompt;
+    }
+    return null;
+}

package/lib/prompts/projectsLogsPrompt.js

@@ -4,6 +4,9 @@ export async function projectLogsPrompt({ functionChoices, promptOptions, projec
     if (!functionChoices) {
         return {};
     }
+    if (promptOptions?.function) {
+        return { functionName: promptOptions.function };
+    }
     if (functionChoices.length === 1) {
         return { functionName: functionChoices[0] };
     }

package/lib/prompts/promptUtils.js

@@ -3,6 +3,7 @@ import { EXIT_CODES } from '../enums/exitCodes.js';
 import chalk from 'chalk';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
 export const Separator = new _Separator();
 export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
 export const CHECKBOX_PROMPT_THEME = {
@@ -19,14 +20,14 @@ function isNoSelectableChoicesError(error) {
 }
 function handlePromptError(config, error) {
     if (isUserCancellationError(error)) {
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new PromptExitError(lib.prompts.promptUtils.errors.userCancelled, EXIT_CODES.SUCCESS);
     }
     if (isNoSelectableChoicesError(error)) {
         if (!Array.isArray(config)) {
             uiLogger.log(config.message);
         }
         uiLogger.error(lib.prompts.promptUtils.errors.noSelectableChoices);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.promptUtils.errors.noSelectableChoices, EXIT_CODES.ERROR);
     }
     throw error;
 }
@@ -41,6 +42,7 @@ function mapPromptChoicesToChoices(choices) {
         return {
             value: choice.value,
             name: choice.name,
+            short: choice.short,
             disabled: choice.disabled,
             checked: choice.checked,
         };

package/lib/prompts/selectAppPrompt.js

@@ -27,6 +27,7 @@ export async function selectAppPrompt(accountId, appId) {
             uiLogger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
         }
     }
+    availableApps.sort((a, b) => a.name.localeCompare(b.name));
     const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
         choices: availableApps.map(app => ({
             name: `${app.name} (${app.id})`,

package/lib/prompts/selectHubDBTablePrompt.js

@@ -4,25 +4,29 @@ import { lib } from '../../lang/en.js';
 import { debugError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+import { isPromptExitError, PromptExitError, } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchHubDBOptions(accountId) {
     try {
         const { data: { results: tables }, } = await fetchTables(accountId);
         if (tables.length === 0) {
             uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
         }
         return tables;
     }
     catch (error) {
+        if (isPromptExitError(error)) {
+            throw error;
+        }
         debugError(error, { accountId });
         uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
     }
 }
 export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
-    const hubdbTables = (await fetchHubDBOptions(accountId)) || [];
+    const hubdbTables = await fetchHubDBOptions(accountId);
     const id = options.tableId?.toString();
     const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
     return promptUser([

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -4,13 +4,14 @@ import { uiLine } from '../ui/index.js';
 import { logError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { isPromptExitError, PromptExitError, } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
+    if (!accountId) {
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
+    }
     try {
-        if (!accountId) {
-            uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
         const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
         const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
         if (!filteredPublicApps.length ||
@@ -24,14 +25,19 @@ async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = fa
                 uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
             }
             uiLine();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
+                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
         }
         return filteredPublicApps;
     }
     catch (error) {
+        if (isPromptExitError(error)) {
+            throw error;
+        }
         logError(error, accountId ? { accountId } : undefined);
         uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
     }
 }
 export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -11,7 +11,8 @@ export async function setAsDefaultAccountPrompt(accountName) {
             name: 'setAsDefault',
             type: 'confirm',
             when: accounts.length >= 1 && defaultAccount?.name !== accountName,
-            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage,
+            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage(accountName),
+            default: false,
         },
     ]);
     uiLogger.log('');

package/lib/sandboxes.d.ts

@@ -1,22 +1,14 @@
 import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxSyncTask, SandboxAccountType } from '../types/Sandboxes.js';
-export declare const SYNC_TYPES: {
-    readonly OBJECT_RECORDS: "object-records";
-};
+import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare const SANDBOX_TYPE_MAP: {
     [key: string]: SandboxAccountType;
 };
-export declare const SANDBOX_API_TYPE_MAP: {
-    readonly STANDARD_SANDBOX: 1;
-    readonly DEVELOPMENT_SANDBOX: 2;
-};
 export declare const SANDBOX_TYPE_MAP_V2: {
     readonly STANDARD_SANDBOX: "STANDARD";
     readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
 };
 export declare function getSandboxTypeAsString(accountType?: AccountType): string;
 export declare function getHasSandboxesByType(parentAccountConfig: HubSpotConfigAccount, type: AccountType): boolean;
-export declare function getAvailableSyncTypes(parentAccountConfig: HubSpotConfigAccount, config: HubSpotConfigAccount): Promise<Array<SandboxSyncTask>>;
 export declare function validateSandboxUsageLimits(accountConfig: HubSpotConfigAccount, sandboxType: AccountType, env: Environment): Promise<void>;
 export declare function handleSandboxCreateError(err: unknown, env: Environment, name: string, accountId: number): never;

package/lib/sandboxes.js

@@ -1,5 +1,4 @@
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
 import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
@@ -8,19 +7,12 @@ import { uiLogger } from './ui/logger.js';
 import { lib } from '../lang/en.js';
 import { logError } from './errorHandlers/index.js';
 import { uiAccountDescription } from './ui/index.js';
-export const SYNC_TYPES = {
-    OBJECT_RECORDS: 'object-records',
-};
 export const SANDBOX_TYPE_MAP = {
     dev: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     developer: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     development: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     standard: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
 };
-export const SANDBOX_API_TYPE_MAP = {
-    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
-    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
-};
 export const SANDBOX_TYPE_MAP_V2 = {
     [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
     [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
@@ -45,19 +37,6 @@ export function getHasSandboxesByType(parentAccountConfig, type) {
     }
     return false;
 }
-// Fetches available sync types for a given sandbox portal
-export async function getAvailableSyncTypes(parentAccountConfig, config) {
-    const parentPortalId = parentAccountConfig.accountId;
-    const portalId = config.accountId;
-    if (!parentPortalId || !portalId) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
-    if (!syncTypes) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    return syncTypes.map(t => ({ type: t.name }));
-}
 export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
     const accountId = accountConfig.accountId;
     if (!accountId) {

package/lib/serverlessLogs.js

@@ -2,11 +2,11 @@ import https from 'https';
 import chalk from 'chalk';
 import { uiLogger } from './ui/logger.js';
 import { isHubSpotHttpError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
-import { SCOPE_GROUPS, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD, SCOPE_GROUPS, } from '@hubspot/local-dev-lib/constants/auth';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { fetchScopeData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { outputLogs } from './ui/serverlessFunctionLogs.js';
-import { logError, ApiErrorContext } from './errorHandlers/index.js';
+import { ApiErrorContext, logError } from './errorHandlers/index.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { handleExit, handleKeypress } from './process.js';
 import { lib } from '../lang/en.js';

package/lib/theme/cmsDevServerProcess.d.ts

@@ -1,4 +1,5 @@
 import { ChildProcess } from 'child_process';
+import { ExitFunction } from '../../types/Yargs.js';
 interface DevServerOptions {
     absoluteSrc: string;
     accountName?: string;
@@ -7,6 +8,7 @@ interface DevServerOptions {
     generateFieldsTypes?: boolean;
     resetSession?: boolean;
     dest: string;
+    exit: ExitFunction;
 }
 export declare function spawnDevServer(options: DevServerOptions): Promise<ChildProcess>;
 export {};

package/lib/theme/cmsDevServerProcess.js

@@ -6,10 +6,11 @@ import { fileURLToPath } from 'url';
 import { getConfigFilePath } from '@hubspot/local-dev-lib/config';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { lib } from '../../lang/en.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // cms-dev-server version to install to isolated cache
-const TARGET_CMS_DEV_SERVER_VERSION = '1.2.16';
+const TARGET_CMS_DEV_SERVER_VERSION = '1.2.44';
 /**
  * Ensures cms-dev-server is installed in an isolated cache directory.
  * This prevents React version conflicts with the CLI.
@@ -83,7 +84,7 @@ async function ensureCmsDevServerCache(targetVersion) {
     return cacheDir;
 }
 export async function spawnDevServer(options) {
-    const { absoluteSrc, accountName, noSsl, port, generateFieldsTypes, resetSession, dest, } = options;
+    const { absoluteSrc, accountName, noSsl, port, generateFieldsTypes, resetSession, dest, exit, } = options;
     // Ensure cms-dev-server is installed in isolated cache
     const cacheDir = await ensureCmsDevServerCache(TARGET_CMS_DEV_SERVER_VERSION);
     // Get config path to pass to createDevServer
@@ -123,18 +124,18 @@ export async function spawnDevServer(options) {
         cwd: cacheDir,
     });
     // Handle process events
-    devServer.on('error', error => {
+    devServer.on('error', async (error) => {
         console.error(lib.theme.cmsDevServerProcess.serverStartError(error));
-        process.exit(1);
+        await exit(EXIT_CODES.ERROR);
     });
-    devServer.on('exit', (code, signal) => {
+    devServer.on('exit', async (code, signal) => {
         if (code !== 0 && code !== null) {
             console.error(lib.theme.cmsDevServerProcess.serverExit(code));
-            process.exit(code);
+            await exit(code);
         }
         if (signal) {
             console.error(lib.theme.cmsDevServerProcess.serverKill(signal));
-            process.exit(1);
+            await exit(EXIT_CODES.ERROR);
         }
     });
     // Handle CLI termination

package/lib/theme/migrate.d.ts

@@ -10,4 +10,4 @@ export declare function getHasMigratableThemes(projectConfig?: LoadedProjectConf
 }>;
 export declare function validateMigrationAppsAndThemes(hasApps: number, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function handleThemesMigration(projectConfig: LoadedProjectConfig, platformVersion: string): Promise<void>;
-export declare function migrateThemes2025_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateThemesArgs>, themeCount: number, projectConfig: LoadedProjectConfig): Promise<void>;
+export declare function migrateThemesV2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateThemesArgs>, themeCount: number, projectConfig: LoadedProjectConfig): Promise<void>;

package/lib/theme/migrate.js

@@ -7,11 +7,10 @@ import { lib } from '../../lang/en.js';
 import { PROJECT_CONFIG_FILE } from '../constants.js';
 import { uiLogger } from '../ui/logger.js';
 import { debugError } from '../errorHandlers/index.js';
-import { isV2Project } from '../projects/platformVersion.js';
 import { confirmPrompt } from '../prompts/promptUtils.js';
 import { fetchMigrationApps } from '../app/migrate.js';
 export async function getHasMigratableThemes(projectConfig) {
-    if (!projectConfig?.projectConfig?.name || !projectConfig?.projectDir) {
+    if (!projectConfig) {
         return { hasMigratableThemes: false, migratableThemesCount: 0 };
     }
     const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
@@ -22,9 +21,6 @@ export async function getHasMigratableThemes(projectConfig) {
     };
 }
 export async function validateMigrationAppsAndThemes(hasApps, projectConfig) {
-    if (isV2Project(projectConfig?.projectConfig?.platformVersion)) {
-        throw new Error(lib.migrate.errors.project.themesAlreadyMigrated);
-    }
     if (hasApps > 0 && projectConfig) {
         throw new Error(lib.migrate.errors.project.themesAndAppsNotAllowed);
     }
@@ -33,9 +29,6 @@ export async function validateMigrationAppsAndThemes(hasApps, projectConfig) {
     }
 }
 export async function handleThemesMigration(projectConfig, platformVersion) {
-    if (!projectConfig?.projectDir || !projectConfig?.projectConfig?.srcDir) {
-        throw new Error(lib.migrate.errors.project.invalidConfig);
-    }
     const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
     let migrated = false;
     let failureReason;
@@ -61,7 +54,7 @@ export async function handleThemesMigration(projectConfig, platformVersion) {
     uiLogger.log('');
     uiLogger.log(lib.migrate.success.themesMigrationSuccess(platformVersion));
 }
-export async function migrateThemes2025_2(derivedAccountId, options, themeCount, projectConfig) {
+export async function migrateThemesV2(derivedAccountId, options, themeCount, projectConfig) {
     if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
         throw new Error(lib.migrate.errors.project.invalidConfig);
     }

package/lib/ui/SpinniesManager.d.ts

@@ -12,6 +12,7 @@ declare class SpinniesManager {
     private lineCount;
     private currentFrameIndex;
     private spin;
+    private sigintHandler;
     constructor();
     init(options?: Partial<SpinnerState>): void;
     private resetState;

package/lib/ui/SpinniesManager.js

@@ -10,7 +10,8 @@ The above copyright notice and this permission notice shall be included in all c
 import readline from 'readline';
 import chalk from 'chalk';
 import cliCursor from 'cli-cursor';
-import { breakText, cleanStream, colorOptions, getLinesLength, prefixOptions, purgeSpinnerOptions, purgeSpinnersOptions, SPINNERS, terminalSupportsUnicode, writeStream, } from './spinniesUtils.js';
+import { breakText, cleanStream, colorOptions, getLinesLength, prefixOptions, purgeSpinnerOptions, purgeSpinnersOptions, SPINNERS, writeStream, } from './spinniesUtils.js';
+import { isUnicodeSupported } from '@hubspot/local-dev-lib/isUnicodeSupported';
 import { uiLogger } from './logger.js';
 function safeColor(text, color) {
     const chalkFn = chalk[color];
@@ -29,6 +30,7 @@ class SpinniesManager {
     lineCount = 0;
     currentFrameIndex = 0;
     spin;
+    sigintHandler = null;
     constructor() {
         this.resetState();
     }
@@ -37,7 +39,7 @@ class SpinniesManager {
             spinnerColor: 'greenBright',
             succeedColor: 'green',
             failColor: 'red',
-            spinner: terminalSupportsUnicode() ? SPINNERS.dots : SPINNERS.dashes,
+            spinner: isUnicodeSupported() ? SPINNERS.dots : SPINNERS.dashes,
             disableSpins: false,
             ...purgeSpinnersOptions(options),
         };
@@ -103,6 +105,8 @@ class SpinniesManager {
             return;
         }
         delete this.spinners[name];
+        // Update the spinner state to clean up the deleted spinner
+        this.updateSpinnerState();
     }
     stopAll(newStatus = 'stopped') {
         Object.keys(this.spinners).forEach(name => {
@@ -245,12 +249,24 @@ class SpinniesManager {
         }
     }
     bindSigint() {
-        process.removeAllListeners('SIGINT');
-        process.on('SIGINT', () => {
+        if (this.sigintHandler) {
+            process.removeListener('SIGINT', this.sigintHandler);
+        }
+        this.sigintHandler = () => {
             cliCursor.show();
             readline.moveCursor(process.stderr, 0, this.lineCount);
-            process.exit(0);
-        });
+            const remainingListeners = process
+                .listeners('SIGINT')
+                .filter(l => l !== this.sigintHandler);
+            if (remainingListeners.length === 0) {
+                // process.exit is intentionally used here rather than the command-level
+                // exit() function because this SIGINT handler runs outside of a command
+                // context and needs to force-terminate the process when no other SIGINT
+                // listeners remain to handle it.
+                process.exit(0);
+            }
+        };
+        process.on('SIGINT', this.sigintHandler);
     }
 }
 const toExport = new SpinniesManager();

package/lib/ui/accountTable.d.ts

@@ -0,0 +1,8 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function sortAndMapAccounts(accounts: HubSpotConfigAccount[]): {
+    [key: string]: HubSpotConfigAccount[];
+};
+export declare function getAccountData(mappedAccountData: {
+    [key: string]: HubSpotConfigAccount[];
+}): string[][];
+export declare function renderAccountTable(showAllLabel?: boolean): void;

package/lib/ui/accountTable.js

@@ -0,0 +1,67 @@
+import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { isSandbox, isDeveloperTestAccount } from '../accountTypes.js';
+import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
+import { uiLogger } from './logger.js';
+export function sortAndMapAccounts(accounts) {
+    const mappedAccountData = {};
+    // Standard and app developer accounts
+    accounts
+        .filter(p => p.accountType &&
+        (p.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD ||
+            p.accountType === HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER))
+        .forEach(account => {
+        mappedAccountData[account.accountId] = [account];
+    });
+    // Non-standard accounts (sandbox, developer test account)
+    accounts
+        .filter(p => p.accountType && (isSandbox(p) || isDeveloperTestAccount(p)))
+        .forEach(p => {
+        if (p.parentAccountId) {
+            mappedAccountData[p.parentAccountId] = [
+                ...(mappedAccountData[p.parentAccountId] || []),
+                p,
+            ];
+        }
+        else {
+            mappedAccountData[p.accountId] = [p];
+        }
+    });
+    return mappedAccountData;
+}
+export function getAccountData(mappedAccountData) {
+    const accountData = [];
+    Object.entries(mappedAccountData).forEach(([key, set]) => {
+        const hasParentAccount = set.filter(p => p.accountId === parseInt(key, 10))[0];
+        set.forEach(account => {
+            let name = `${account.name} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType]}]`;
+            if (isSandbox(account)) {
+                if (hasParentAccount && set.length > 1) {
+                    name = `↳ ${name}`;
+                }
+            }
+            else if (isDeveloperTestAccount(account)) {
+                if (hasParentAccount && set.length > 1) {
+                    name = `↳ ${name}`;
+                }
+            }
+            accountData.push([name, String(account.accountId), account.authType]);
+        });
+    });
+    return accountData;
+}
+export function renderAccountTable(showAllLabel = false) {
+    const accountsList = getAllConfigAccounts();
+    const mappedAccountData = sortAndMapAccounts(accountsList);
+    const accountData = getAccountData(mappedAccountData);
+    const tableHeader = [
+        commands.account.subcommands.list.labels.name,
+        commands.account.subcommands.list.labels.accountId,
+        commands.account.subcommands.list.labels.authType,
+    ];
+    uiLogger.log(showAllLabel
+        ? commands.account.subcommands.list.allAccounts
+        : commands.account.subcommands.list.accounts);
+    renderTable(tableHeader, accountData, true);
+}

package/lib/ui/appLogs.d.ts

@@ -0,0 +1,32 @@
+import { AppLogDetails } from '@hubspot/local-dev-lib/types/AppLogs';
+type AppLogEntry = {
+    id: string;
+    createdAt: number;
+    executionTimeMillis?: number;
+    portalId?: number;
+    traceId?: string;
+    status: 'SUCCESS' | 'ERROR';
+    errorType?: string;
+    errorMessage?: string;
+};
+type AppLogsSearchResponse = {
+    results: AppLogEntry[];
+    hasMore: boolean;
+    offset: number;
+    total: number;
+};
+type OutputOptions = {
+    compact?: boolean;
+    tail?: boolean;
+    accountId: number;
+    appId: number;
+    systemType: string;
+    typeName: string;
+};
+export declare function outputAppLogs(response: AppLogsSearchResponse, options: OutputOptions): Promise<void>;
+type LogDetailsOutputOptions = {
+    accountId: number;
+    appId: number;
+};
+export declare function outputAppLogDetails(details: AppLogDetails, options: LogDetailsOutputOptions): void;
+export {};