@hubspot/cli 7.6.2-beta.0 → 7.7.0-beta.0

package/commands/config/set.d.ts

@@ -1,7 +1,7 @@
 import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
 import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
 type ConfigSetArgs = CommonArgs & ConfigArgs & {
-    defaultCmsPublishMode: CmsPublishMode;
+    defaultCmsPublishMode?: CmsPublishMode;
     allowUsageTracking?: boolean;
     httpTimeout?: string;
     allowAutoUpdates?: boolean;

package/commands/config/set.js

@@ -4,7 +4,9 @@ import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { setDefaultCmsPublishMode, setHttpTimeout, setAllowUsageTracking, setAllowAutoUpdates, setAutoOpenBrowser, } from '../../lib/configOptions.js';
 import { commands } from '../../lang/en.js';
-import { makeYargsBuilder, getExclusiveConflicts, } from '../../lib/yargsUtils.js';
+import { makeYargsBuilder, strictEnforceBoolean, } from '../../lib/yargsUtils.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { uiLogger } from '../../lib/ui/logger.js';
 const command = 'set';
 const describe = commands.config.subcommands.set.describe;
 async function selectOptions() {
@@ -29,35 +31,41 @@ async function selectOptions() {
 }
 async function handleConfigUpdate(accountId, args) {
     const { allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
-    if (typeof defaultCmsPublishMode !== 'undefined') {
-        await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
-        return true;
-    }
-    else if (typeof httpTimeout !== 'undefined') {
-        await setHttpTimeout({ httpTimeout, accountId });
-        return true;
+    if (allowAutoUpdates !== undefined) {
+        await setAllowAutoUpdates({ allowAutoUpdates, accountId });
     }
-    else if (typeof allowUsageTracking !== 'undefined') {
+    if (allowUsageTracking !== undefined) {
         await setAllowUsageTracking({ allowUsageTracking, accountId });
-        return true;
     }
-    else if (typeof allowAutoUpdates !== 'undefined') {
-        await setAllowAutoUpdates({ allowAutoUpdates, accountId });
-        return true;
-    }
-    else if (typeof autoOpenBrowser !== 'undefined') {
+    if (autoOpenBrowser !== undefined) {
         await setAutoOpenBrowser({ autoOpenBrowser, accountId });
-        return true;
     }
-    return false;
+    if (defaultCmsPublishMode !== undefined) {
+        await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
+    }
+    if (httpTimeout !== undefined) {
+        await setHttpTimeout({ httpTimeout, accountId });
+    }
 }
 async function handler(args) {
-    const { derivedAccountId } = args;
+    const { derivedAccountId, allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
     trackCommandUsage('config-set', {}, derivedAccountId);
-    const configUpdated = await handleConfigUpdate(derivedAccountId, args);
-    if (!configUpdated) {
-        const selectedOptions = await selectOptions();
-        await handleConfigUpdate(derivedAccountId, selectedOptions);
+    try {
+        if (allowAutoUpdates !== undefined ||
+            allowUsageTracking !== undefined ||
+            autoOpenBrowser !== undefined ||
+            defaultCmsPublishMode !== undefined ||
+            httpTimeout !== undefined) {
+            await handleConfigUpdate(derivedAccountId, args);
+        }
+        else {
+            const selectedOptions = await selectOptions();
+            await handleConfigUpdate(derivedAccountId, selectedOptions);
+        }
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
     }
     process.exit(EXIT_CODES.SUCCESS);
 }
@@ -67,15 +75,23 @@ function configSetBuilder(yargs) {
         'default-cms-publish-mode': {
             describe: commands.config.subcommands.set.options.defaultMode.describe,
             type: 'string',
+            choices: ['draft', 'publish'],
+        },
+        'http-timeout': {
+            describe: commands.config.subcommands.set.options.httpTimeout.describe,
+            type: 'number',
+            coerce: (value) => {
+                if (isNaN(value) || value < 3000) {
+                    uiLogger.error(commands.config.subcommands.set.errors.invalidHTTPTimeout);
+                    process.exit(EXIT_CODES.ERROR);
+                }
+                return value;
+            },
         },
         'allow-usage-tracking': {
             describe: commands.config.subcommands.set.options.allowUsageTracking.describe,
             type: 'boolean',
         },
-        'http-timeout': {
-            describe: commands.config.subcommands.set.options.httpTimeout.describe,
-            type: 'string',
-        },
         'allow-auto-updates': {
             describe: commands.config.subcommands.set.options.allowAutoUpdates.describe,
             type: 'boolean',
@@ -86,18 +102,34 @@ function configSetBuilder(yargs) {
             type: 'boolean',
         },
     })
-        .conflicts(getExclusiveConflicts([
-        'default-cms-publish-mode',
-        'allow-usage-tracking',
-        'http-timeout',
-        'allow-auto-updates',
-        'auto-open-browser',
-    ]))
+        .check(() => {
+        // Use process.argv directly because yargs argv has already been parsed/coerced,
+        // but we need to validate the exact format the user provided (e.g., --flag=true vs --flag)
+        return strictEnforceBoolean(process.argv, [
+            'allow-usage-tracking',
+            'allow-auto-updates',
+            'auto-open-browser',
+        ]);
+    })
         .example([
         [
             '$0 config set',
             i18n(`commands.config.subcommands.set.examples.default`),
         ],
+        ['$0 config set --allow-usage-tracking=false', 'Disable usage tracking'],
+        ['$0 config set --http-timeout=5000', 'Set HTTP timeout to 5000ms'],
+        [
+            '$0 config set --default-cms-publish-mode=draft',
+            'Set default CMS publish mode to draft',
+        ],
+        [
+            '$0 config set --http-timeout=3000 --allow-usage-tracking=false',
+            'Set HTTP timeout and disable usage tracking',
+        ],
+        [
+            '$0 config set --default-cms-publish-mode=draft --http-timeout=4000 --allow-usage-tracking=true',
+            'Configure multiple settings at once',
+        ],
     ]);
     return yargs;
 }

package/commands/init.js

@@ -99,7 +99,6 @@ async function handler(args) {
         uiLogger.error(commands.init.errors.bothConfigFilesNotAllowed(path));
         process.exit(EXIT_CODES.ERROR);
     }
-    trackAuthAction('init', authType, TRACKING_STATUS.STARTED, parsedUserProvidedAccountId);
     createEmptyConfigFile({ path: configPath }, useHiddenConfig);
     //Needed to load deprecated config
     loadConfig(configPath, args);

package/commands/project/__tests__/validate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/project/__tests__/validate.test.js

@@ -0,0 +1,98 @@
+import path from 'path';
+import { vi } from 'vitest';
+import { validateSourceDirectory } from '../../../lib/projects/upload.js';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { loadAndValidateProfile } from '../../../lib/projectProfiles.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { handleTranslate } from '../../../lib/projects/upload.js';
+import projectValidateCommand from '../validate.js';
+// Mock dependencies
+vi.mock('../../../lib/projects/upload.js');
+vi.mock('../../../lib/projects/config.js');
+vi.mock('../../../lib/ui/logger.js');
+vi.mock('../../../lib/usageTracking.js');
+vi.mock('../../../lib/projectProfiles.js');
+vi.mock('../../../lib/errorHandlers/index.js');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/projects/platformVersion.js');
+describe('commands/project/validate', () => {
+    const projectDir = '/test/project';
+    let exitSpy;
+    beforeEach(() => {
+        // Mock process.exit to throw to stop execution
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation(code => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        exitSpy.mockRestore();
+    });
+    describe('project configuration validation', () => {
+        it('should exit with error when project config is null', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            await expect(
+            // @ts-expect-error partial mock
+            projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.mustBeRanWithinAProject);
+        });
+        it('should exit with error when project directory is null', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: {
+                    name: 'test',
+                    srcDir: 'src',
+                    platformVersion: '2025.2',
+                },
+                projectDir: null,
+            });
+            await expect(
+            // @ts-expect-error partial mock
+            projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.mustBeRanWithinAProject);
+        });
+    });
+    it('should call validateSourceDirectory with correct parameters', async () => {
+        const mockProjectConfig = {
+            name: 'test-project',
+            srcDir: 'src',
+            platformVersion: '2025.2',
+        };
+        vi.mocked(getProjectConfig).mockResolvedValue({
+            projectConfig: mockProjectConfig,
+            projectDir,
+        });
+        vi.mocked(useV3Api).mockReturnValue(true);
+        vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+        vi.mocked(loadAndValidateProfile).mockResolvedValue(123);
+        vi.mocked(getAccountConfig).mockReturnValue({
+            accountType: 'STANDARD',
+            accountId: 123,
+            env: 'prod',
+        });
+        vi.mocked(trackCommandUsage);
+        vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+        vi.mocked(handleTranslate).mockResolvedValue(undefined);
+        await expect(projectValidateCommand.handler({
+            derivedAccountId: 123,
+            d: false,
+            debug: false,
+        })).rejects.toThrow('Process exited with code 0');
+        const expectedSrcDir = path.resolve(projectDir, mockProjectConfig.srcDir);
+        expect(validateSourceDirectory).toHaveBeenCalledWith(expectedSrcDir, mockProjectConfig, projectDir);
+    });
+});

package/commands/project/validate.js

@@ -3,10 +3,10 @@ import { getAccountConfig } from '@hubspot/local-dev-lib/config';
 import { useV3Api } from '../../lib/projects/platformVersion.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { getProjectConfig, validateProjectConfig as validateProjectConfig, } from '../../lib/projects/config.js';
+import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { validateSourceDirectory as validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
+import { validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
 import { commands } from '../../lang/en.js';
 import { loadAndValidateProfile } from '../../lib/projectProfiles.js';
 import { logError } from '../../lib/errorHandlers/index.js';
@@ -15,7 +15,7 @@ const describe = commands.project.validate.describe;
 async function handler(args) {
     const { derivedAccountId, profile } = args;
     const { projectConfig, projectDir } = await getProjectConfig();
-    if (!projectConfig) {
+    if (!projectConfig || !projectDir) {
         uiLogger.error(commands.project.validate.mustBeRanWithinAProject);
         process.exit(EXIT_CODES.ERROR);
     }
@@ -31,7 +31,7 @@ async function handler(args) {
     trackCommandUsage('project-validate', { type: accountType }, targetAccountId);
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
     try {
-        validateSourceDirectory(srcDir, projectConfig);
+        await validateSourceDirectory(srcDir, projectConfig, projectDir);
     }
     catch (e) {
         logError(e);

package/commands/testAccount/__tests__/delete.test.js

@@ -1,12 +1,12 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
+import { addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
 import testAccountDeleteCommand from '../delete.js';
 vi.mock('../../../lib/commonOpts');
 describe('commands/testAccount/delete', () => {
     const yargsMock = yargs;
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(testAccountDeleteCommand.command).toEqual('delete <test-account-id>');
+            expect(testAccountDeleteCommand.command).toEqual('delete [test-account]');
         });
     });
     describe('describe', () => {
@@ -20,8 +20,6 @@ describe('commands/testAccount/delete', () => {
             expect(yargsMock.example).toHaveBeenCalledTimes(1);
             expect(addTestingOptions).toHaveBeenCalledTimes(1);
             expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
             expect(addConfigOptions).toHaveBeenCalledTimes(1);
             expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
             expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);

package/commands/testAccount/delete.d.ts

@@ -1,6 +1,7 @@
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs, YargsCommandModule } from '../../types/Yargs.js';
-type DeleteTestAccountArgs = CommonArgs & AccountArgs & ConfigArgs & TestingArgs & EnvironmentArgs & {
-    testAccountId: number;
+import { CommonArgs, ConfigArgs, EnvironmentArgs, TestingArgs, YargsCommandModule } from '../../types/Yargs.js';
+type DeleteTestAccountArgs = CommonArgs & ConfigArgs & TestingArgs & EnvironmentArgs & {
+    testAccount?: string | number;
+    force?: boolean;
 };
 declare const deleteTestAccountCommand: YargsCommandModule<unknown, DeleteTestAccountArgs>;
 export default deleteTestAccountCommand;

package/commands/testAccount/delete.js

@@ -1,39 +1,180 @@
-import { deleteDeveloperTestAccount } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { fetchDeveloperTestAccounts, deleteDeveloperTestAccount, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { commands } from '../../lang/en.js';
-const command = 'delete <test-account-id>';
+import { deleteAccount, getAccountConfig, getAccountId, getConfigPath, loadConfig, updateDefaultAccount, } from '@hubspot/local-dev-lib/config';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { debugError } from '../../lib/errorHandlers/index.js';
+const command = 'delete [test-account]';
 const describe = commands.testAccount.delete.describe;
-async function handler(args) {
-    const { derivedAccountId, testAccountId } = args;
-    trackCommandUsage('test-account-delete', {}, derivedAccountId);
+async function getAccountPromptOptions(derivedAccountId) {
     try {
-        await deleteDeveloperTestAccount(derivedAccountId, testAccountId, true);
-        uiLogger.success(commands.testAccount.delete.success.testAccountDeleted(testAccountId));
+        const { data } = await fetchDeveloperTestAccounts(derivedAccountId);
+        return data.results.map(testAccount => ({
+            name: `${testAccount.accountName} (${testAccount.id})`,
+            value: testAccount.id,
+        }));
     }
     catch (err) {
-        uiLogger.error(commands.testAccount.delete.errors.failedToDelete);
+        uiLogger.error(commands.testAccount.delete.errors.failedToFetchTestAccounts);
+        throw err;
+    }
+}
+async function accountToDeleteSelectionPrompt(derivedAccountId) {
+    const accountData = await getAccountPromptOptions(derivedAccountId);
+    if (accountData.length === 0) {
+        uiLogger.error(commands.testAccount.delete.errors.noAccountsToDelete(derivedAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const { testAccountToDelete } = await promptUser([
+        {
+            type: 'list',
+            name: 'testAccountToDelete',
+            pageSize: 20,
+            message: commands.testAccount.delete.prompts.selectTestAccounts,
+            choices: accountData,
+        },
+    ]);
+    return testAccountToDelete;
+}
+async function confirmDeletion() {
+    const { shouldDelete } = await promptUser([
+        {
+            type: 'confirm',
+            name: 'shouldDelete',
+            message: commands.testAccount.delete.prompts.confirmDeletion,
+        },
+    ]);
+    return shouldDelete;
+}
+async function deleteTestAccountInHubSpot(derivedAccountId, accountId) {
+    try {
+        await deleteDeveloperTestAccount(derivedAccountId, accountId, true);
+        uiLogger.success(commands.testAccount.delete.success.testAccountDeletedFromHubSpot(accountId));
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.error(commands.testAccount.delete.errors.failedToDelete(accountId));
+    }
+}
+async function deleteTestAccountFromConfig(testAccountId, parentAccountName, account) {
+    try {
+        // If the account isn't in the local config then it wasn't auth'd on the local machine
+        if (account && account.name && account.accountType) {
+            // If the deleted test account was the default account, replace the default account with the parent account
+            loadConfig(getConfigPath()); // Get updated version of the config
+            const defaultAccountId = getAccountId(); // We need to get the current default accountId before delete the test account
+            await deleteAccount(account.name);
+            uiLogger.success(commands.testAccount.delete.success.testAccountDeletedFromConfig(testAccountId));
+            if (testAccountId === defaultAccountId) {
+                updateDefaultAccount(parentAccountName);
+                uiLogger.info(commands.testAccount.delete.info.replaceDefaultAccount(testAccountId, parentAccountName));
+            }
+        }
+    }
+    catch (e) {
+        debugError(e);
+        uiLogger.error(commands.testAccount.delete.errors.failedToDeleteFromConfig(testAccountId));
+    }
+}
+async function validateTestAccountConfigs(testAccountId) {
+    if (!testAccountId) {
+        uiLogger.error(commands.testAccount.delete.errors.testAccountNotFound(testAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const testAccountConfig = getAccountConfig(testAccountId);
+    if (!testAccountConfig) {
+        uiLogger.error(commands.testAccount.delete.errors.testAccountNotFound(testAccountId));
         process.exit(EXIT_CODES.ERROR);
     }
+    const parentAccountConfig = getAccountConfig(testAccountConfig.parentAccountId);
+    if (!parentAccountConfig) {
+        uiLogger.error(commands.testAccount.delete.errors.parentAccountNotFound(testAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const parentAccountName = parentAccountConfig.name;
+    return { testAccountConfig, parentAccountName };
+}
+async function handler(args) {
+    const { derivedAccountId, testAccount, force } = args;
+    trackCommandUsage('test-account-delete', {}, derivedAccountId);
+    let testAccountIdToDelete = 0;
+    // See if the account exists
+    if (testAccount) {
+        const accountId = getAccountId(testAccount);
+        await validateTestAccountConfigs(accountId);
+        if (accountId) {
+            testAccountIdToDelete = accountId;
+        }
+    }
+    // Prompt for selection when name or id aren't provided
+    if (!testAccountIdToDelete) {
+        try {
+            testAccountIdToDelete =
+                await accountToDeleteSelectionPrompt(derivedAccountId);
+        }
+        catch (err) {
+            debugError(err);
+            uiLogger.error(commands.testAccount.delete.errors.failedToSelectAccount);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    const { testAccountConfig, parentAccountName } = await validateTestAccountConfigs(testAccountIdToDelete);
+    // If --force, don't prompt user; else confirm deletion
+    let shouldDeleteAccount;
+    if (force) {
+        shouldDeleteAccount = true;
+    }
+    else {
+        shouldDeleteAccount = await confirmDeletion();
+    }
+    if (shouldDeleteAccount) {
+        const parentAccountId = testAccountConfig.parentAccountId;
+        await deleteTestAccountInHubSpot(parentAccountId, testAccountIdToDelete);
+        await deleteTestAccountFromConfig(testAccountIdToDelete, parentAccountName, testAccountConfig);
+    }
+    else {
+        uiLogger.info(commands.testAccount.delete.info.deletionCanceled);
+    }
     process.exit(EXIT_CODES.SUCCESS);
 }
 function deleteTestAccountBuilder(yargs) {
-    yargs.positional('test-account-id', {
-        type: 'number',
-        description: commands.testAccount.delete.positionals.testAccountId,
-        required: true,
+    yargs.positional('test-account', {
+        type: 'string',
+        description: commands.testAccount.delete.options.id,
+        required: false,
+    });
+    yargs.option('force', {
+        describe: commands.upload.options.force,
+        type: 'boolean',
+        default: false,
     });
     yargs.example([
-        ['$0 delete 1234567890', commands.testAccount.delete.example(1234567890)],
+        [
+            '$0 test-account delete 12345678',
+            commands.testAccount.delete.examples.withPositionalID(12345678),
+        ],
+        [
+            '$0 test-account delete my-test-account',
+            commands.testAccount.delete.examples.withPositionalName('my-test-account'),
+        ],
+        [
+            '$0 test-account delete --test-account=12345678',
+            commands.testAccount.delete.examples.withID(12345678),
+        ],
+        [
+            '$0 test-account delete --test-account=my-test-account',
+            commands.testAccount.delete.examples.withName('my-test-account'),
+        ],
+        ['$0 test-account delete', commands.testAccount.delete.examples.withoutId],
     ]);
     return yargs;
 }
 const builder = makeYargsBuilder(deleteTestAccountBuilder, command, describe, {
     useGlobalOptions: true,
     useEnvironmentOptions: true,
-    useAccountOptions: true,
     useConfigOptions: true,
     useTestingOptions: true,
 });

package/lang/en.d.ts

@@ -260,6 +260,10 @@ Global configuration replaces hubspot.config.yml, and you will be prompted to mi
                         readonly describe: "Enable or disable automatic opening of the browser";
                     };
                 };
+                readonly errors: {
+                    readonly invalidBoolean: (commandName: string, value: string) => string;
+                    readonly invalidHTTPTimeout: "Invalid HTTP timeout value. Must be a number greater than 3000.";
+                };
             };
         };
     };
@@ -1907,18 +1911,41 @@ ${string}`;
             readonly example: (name: string) => string;
         };
         readonly delete: {
-            readonly describe: "Delete a test account config file.";
+            readonly describe: "Delete a test account from your HubSpot account and CLI config";
             readonly pathPrompt: "[--path] What is the path to the test account config?";
+            readonly info: {
+                readonly deletionCanceled: "Deletion canceled by user";
+                readonly accountNotFoundWithId: (id: number) => string;
+                readonly replaceDefaultAccount: (testAccountId: number, parentAccountName: string) => string;
+            };
+            readonly prompts: {
+                readonly selectTestAccounts: "Select test account(s) to delete";
+                readonly confirmDeletion: "All data for the account will be permanently deleted. Any connected apps will have their access tokens revoked. Do you wish to proceed?";
+            };
             readonly errors: {
-                readonly failedToDelete: "Failed to delete test account";
+                readonly failedToDelete: (testAccountToDelete: number) => string;
+                readonly failedToSelectAccount: "Failed to select a test account to delete";
+                readonly noAccountsToDelete: (accountId: number) => string;
+                readonly failedToDeleteFromConfig: (testAccountToDelete: number) => string;
+                readonly failedToFetchTestAccounts: "Failed to fetch developer test accounts";
+                readonly testAccountNotFound: (nameOrId: string | number | null) => string;
+                readonly parentAccountNotFound: (testAccountId: number) => string;
             };
             readonly success: {
-                readonly testAccountDeleted: (testAccountId: number) => string;
+                readonly testAccountDeletedFromHubSpot: (testAccountToDelete: number) => string;
+                readonly testAccountDeletedFromConfig: (accountId: number) => string;
+            };
+            readonly options: {
+                readonly name: "The name of the test account (in your CLI config) to delete";
+                readonly id: "The id of the test account";
             };
-            readonly positionals: {
-                readonly testAccountId: "The id of the test account";
+            readonly examples: {
+                readonly withPositionalID: (testAccountToDelete: number) => string;
+                readonly withPositionalName: (testAccountToDelete: string) => string;
+                readonly withID: (testAccountToDelete: number) => string;
+                readonly withName: (testAccountToDelete: string) => string;
+                readonly withoutId: "Delete a test account via a prompt";
             };
-            readonly example: (testAccountId: number) => string;
         };
     };
     readonly secrets: {
@@ -2770,6 +2797,7 @@ Run ${string} to upgrade to version ${string}`;
             readonly compressed: (byteCount: number) => string;
             readonly compressing: (path: string) => string;
             readonly fileFiltered: (filename: string) => string;
+            readonly legacyFileDetected: (filename: string, platformVersion: string) => string;
         };
     };
     readonly boxen: {
@@ -2902,11 +2930,12 @@ Run ${string} to upgrade to version ${string}`;
         readonly setHttpTimeout: {
             readonly promptMessage: "Enter http timeout duration";
             readonly success: (timeout: string) => string;
+            readonly error: (timeout: string) => string;
         };
         readonly setAutoOpenBrowser: {
             readonly fieldName: "auto open browser";
-            readonly enabled: "Auto opening your browser has been enabled";
-            readonly disabled: "Auto opening your browser has been disabled";
+            readonly enabled: `Successfully updated ${string} to ${string}`;
+            readonly disabled: `Successfully updated ${string} to ${string}`;
         };
     };
     readonly commonOpts: {