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

package/commands/account/clean.js

@@ -0,0 +1,125 @@
+import fs from 'fs';
+import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
+import { removeAccountFromConfig, getAllConfigAccounts, getConfigDefaultAccountIfExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { selectAccountFromConfig } from '../../lib/prompts/accountsPrompt.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { uiAccountDescription } from '../../lib/ui/index.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { renderList } from '../../ui/render.js';
+const command = 'clean';
+const describe = commands.account.subcommands.clean.describe;
+async function handler(args) {
+    const { qa } = args;
+    trackCommandUsage('accounts-clean');
+    const accountsList = getAllConfigAccounts();
+    const filteredTestAccounts = accountsList.filter(p => qa ? p.env === 'qa' : p.env !== 'qa');
+    if (filteredTestAccounts && filteredTestAccounts.length === 0) {
+        uiLogger.log(commands.account.subcommands.clean.noResults);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const accountsToRemove = [];
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    SpinniesManager.add('accountsClean', {
+        text: commands.account.subcommands.clean.loading.add,
+    });
+    for (const account of filteredTestAccounts) {
+        try {
+            await accessTokenForPersonalAccessKey(account.accountId, true);
+        }
+        catch (error) {
+            if (isSpecifiedError(error, {
+                statusCode: 401,
+                category: 'INVALID_AUTHENTICATION',
+                subCategory: 'LocalDevAuthErrorType.PORTAL_NOT_ACTIVE',
+            }) ||
+                isSpecifiedError(error, {
+                    statusCode: 404,
+                    category: 'INVALID_AUTHENTICATION',
+                    subCategory: 'LocalDevAuthErrorType.INVALID_PORTAL_ID',
+                })) {
+                accountsToRemove.push(account);
+            }
+        }
+    }
+    if (accountsToRemove.length > 0) {
+        const oneAccountFound = accountsToRemove.length === 1;
+        SpinniesManager.succeed('accountsClean', {
+            text: oneAccountFound
+                ? commands.account.subcommands.clean.inactiveAccountsFound.one
+                : commands.account.subcommands.clean.inactiveAccountsFound.other(accountsToRemove.length),
+        });
+        renderList(accountsToRemove.map(p => [uiAccountDescription(p.accountId)]));
+        uiLogger.log('');
+        let promptMessage = oneAccountFound
+            ? commands.account.subcommands.clean.confirm.one
+            : commands.account.subcommands.clean.confirm.other(accountsToRemove.length);
+        const accountOverride = getDefaultAccountOverrideAccountId(accountsList);
+        const overrideFilePath = getDefaultAccountOverrideFilePath();
+        const accountOverrideMatches = accountsToRemove.some(account => account.accountId === accountOverride);
+        if (overrideFilePath && accountOverride && accountOverrideMatches) {
+            promptMessage = `${promptMessage}${commands.account.subcommands.clean.defaultAccountOverride(overrideFilePath)}`;
+        }
+        const { accountsCleanPrompt } = await promptUser([
+            {
+                name: 'accountsCleanPrompt',
+                type: 'confirm',
+                message: promptMessage,
+            },
+        ]);
+        if (accountsCleanPrompt) {
+            uiLogger.log('');
+            try {
+                if (overrideFilePath) {
+                    fs.unlinkSync(overrideFilePath);
+                }
+            }
+            catch (error) {
+                logError(error);
+            }
+            for (const accountToRemove of accountsToRemove) {
+                removeAccountFromConfig(accountToRemove.accountId);
+                uiLogger.log(commands.account.subcommands.clean.removeSuccess(accountToRemove.name));
+            }
+            const defaultAccount = getConfigDefaultAccountIfExists();
+            if (defaultAccount &&
+                accountsToRemove.some(p => p.name === defaultAccount.name)) {
+                uiLogger.log(commands.account.subcommands.clean.replaceDefaultAccount);
+                const newDefaultAccount = await selectAccountFromConfig();
+                setConfigAccountAsDefault(newDefaultAccount);
+            }
+        }
+    }
+    else {
+        SpinniesManager.succeed('accountsClean', {
+            text: commands.account.subcommands.clean.noResults,
+        });
+    }
+    uiLogger.log('');
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function accountCleanBuilder(yargs) {
+    yargs.example([['$0 accounts clean']]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountCleanBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useTestingOptions: true,
+});
+const accountCleanCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountCleanCommand;

package/commands/account/createOverride.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type AccountCreateOverrideArgs = CommonArgs & {
+    account: string | number;
+};
+declare const accountCreateOverrideCommand: YargsCommandModule<unknown, AccountCreateOverrideArgs>;
+export default accountCreateOverrideCommand;

package/commands/account/createOverride.js

@@ -0,0 +1,93 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME } from '@hubspot/local-dev-lib/constants/config';
+import { getConfigFilePath, getConfigAccountIfExists, globalConfigFileExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { selectAccountFromConfig } from '../../lib/prompts/accountsPrompt.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'create-override [account]';
+const describe = commands.account.subcommands.createOverride.describe(DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME);
+async function handler(args) {
+    let overrideDefaultAccount = args.account;
+    const globalConfigExists = globalConfigFileExists();
+    if (!globalConfigExists) {
+        uiLogger.error(commands.account.subcommands.createOverride.errors.globalConfigNotFound);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const accounts = getAllConfigAccounts();
+    const accountOverrideId = getDefaultAccountOverrideAccountId(accounts);
+    const overrideFilePath = getDefaultAccountOverrideFilePath();
+    if (accountOverrideId && overrideFilePath) {
+        uiLogger.log(commands.account.subcommands.createOverride.accountOverride(overrideFilePath, accountOverrideId.toString()));
+        const { replaceOverrideFile } = await promptUser({
+            type: 'confirm',
+            name: 'replaceOverrideFile',
+            message: commands.account.subcommands.createOverride.prompts.replaceOverrideFile,
+        });
+        uiLogger.log('');
+        if (!replaceOverrideFile) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+    }
+    if (!overrideDefaultAccount) {
+        overrideDefaultAccount = await selectAccountFromConfig();
+    }
+    else {
+        const account = getConfigAccountIfExists(overrideDefaultAccount);
+        if (!account) {
+            uiLogger.error(commands.account.subcommands.createOverride.errors.accountNotFound(getConfigFilePath() || ''));
+            overrideDefaultAccount = await selectAccountFromConfig();
+        }
+    }
+    const account = getConfigAccountIfExists(overrideDefaultAccount);
+    const accountId = account?.accountId;
+    trackCommandUsage('account-createOverride', undefined, accountId);
+    try {
+        const overrideFilePath = path.join(getCwd(), DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME);
+        await fs.writeFile(overrideFilePath, accountId.toString(), 'utf8');
+        uiLogger.success(commands.account.subcommands.createOverride.success(overrideFilePath));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function accountCreateOverrideBuilder(yargs) {
+    yargs.positional('account', {
+        describe: commands.account.subcommands.createOverride.options.account.describe,
+        type: 'string',
+    });
+    yargs.example([
+        [
+            '$0 account create-override',
+            commands.account.subcommands.createOverride.examples.default(DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME),
+        ],
+        [
+            '$0 account create-override 12345678',
+            commands.account.subcommands.createOverride.examples.idBased(DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME),
+        ],
+        [
+            '$0 account create-override MyAccount',
+            commands.account.subcommands.createOverride.examples.nameBased(DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME),
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountCreateOverrideBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const accountCreateOverrideCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountCreateOverrideCommand;

package/commands/account/info.d.ts

@@ -0,0 +1,4 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type AccountInfoArgs = CommonArgs & ConfigArgs;
+declare const accountInfoCommand: YargsCommandModule<unknown, AccountInfoArgs>;
+export default accountInfoCommand;

package/commands/account/info.js

@@ -0,0 +1,75 @@
+import { getConfigAccountById, getConfigDefaultAccount, getConfigFilePath, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideFilePath } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { getAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { indent } from '../../lib/ui/index.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { renderList } from '../../ui/render.js';
+const describe = commands.account.subcommands.info.describe;
+const command = 'info [account]';
+async function handler(args) {
+    const { derivedAccountId } = args;
+    const config = getConfigAccountById(derivedAccountId);
+    // check if the provided account is using a personal access key, if not, show an error
+    if (config && config.authType === 'personalaccesskey') {
+        const { name, personalAccessKey, env } = config;
+        let scopeGroups = [];
+        const response = await getAccessToken(personalAccessKey, env, derivedAccountId);
+        scopeGroups = response.scopeGroups.map(s => [s]);
+        // If a default account is present in the config, display it
+        const configPath = getConfigFilePath();
+        if (configPath) {
+            uiLogger.log(commands.account.subcommands.info.defaultAccountTitle);
+            uiLogger.log(`${indent(1)}${commands.account.subcommands.info.configPath(configPath)}`);
+            const defaultAccount = getConfigDefaultAccount();
+            uiLogger.log(`${indent(1)}${commands.account.subcommands.info.defaultAccount(defaultAccount.name)}`);
+        }
+        // If a default account override is present, display it
+        const overrideFilePath = getDefaultAccountOverrideFilePath();
+        if (overrideFilePath) {
+            uiLogger.log('');
+            uiLogger.log(commands.account.subcommands.info.overrideFilePathTitle);
+            uiLogger.log(`${indent(1)}${commands.account.subcommands.info.overrideFilePath(overrideFilePath)}`);
+            const defaultAccount = getConfigDefaultAccount();
+            uiLogger.log(`${indent(1)}${commands.account.subcommands.info.overrideAccount(defaultAccount.name)}`);
+        }
+        uiLogger.log('');
+        uiLogger.log(commands.account.subcommands.info.name(name));
+        uiLogger.log(commands.account.subcommands.info.accountId(derivedAccountId));
+        uiLogger.log(commands.account.subcommands.info.scopeGroups);
+        renderList(scopeGroups);
+    }
+    else {
+        uiLogger.log(commands.account.subcommands.info.errors.notUsingPersonalAccessKey);
+    }
+}
+function accountInfoBuilder(yargs) {
+    yargs.positional('account', {
+        describe: commands.account.subcommands.info.options.account.describe,
+        type: 'string',
+    });
+    yargs.example([
+        ['$0 accounts info', commands.account.subcommands.info.examples.default],
+        [
+            '$0 accounts info MyAccount',
+            commands.account.subcommands.info.examples.nameBased,
+        ],
+        [
+            '$0 accounts info 1234567',
+            commands.account.subcommands.info.examples.idBased,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountInfoBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const accountInfoCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountInfoCommand;

package/commands/account/list.d.ts

@@ -0,0 +1,4 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type AccountListArgs = CommonArgs & ConfigArgs;
+declare const accountListCommand: YargsCommandModule<unknown, AccountListArgs>;
+export default accountListCommand;

package/commands/account/list.js

@@ -0,0 +1,107 @@
+import { getConfigFilePath, getAllConfigAccounts, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideFilePath } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { indent } from '../../lib/ui/index.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { isSandbox, isDeveloperTestAccount } from '../../lib/accountTypes.js';
+import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
+const command = ['list', 'ls'];
+const describe = commands.account.subcommands.list.describe;
+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;
+}
+function getAccountData(mappedAccountData) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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, account.accountId, account.authType]);
+        });
+    });
+    return accountData;
+}
+async function handler(args) {
+    const { derivedAccountId } = args;
+    trackCommandUsage('accounts-list', undefined, derivedAccountId);
+    const configPath = getConfigFilePath();
+    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,
+    ];
+    const defaultAccount = getConfigDefaultAccountIfExists();
+    const accountId = defaultAccount?.accountId;
+    const overrideFilePath = getDefaultAccountOverrideFilePath();
+    // If a default account is present in the config, display it
+    if (configPath && accountId) {
+        uiLogger.log(commands.account.subcommands.list.defaultAccountTitle);
+        uiLogger.log(`${indent(1)}${commands.account.subcommands.list.configPath(configPath)}`);
+        uiLogger.log(`${indent(1)}${commands.account.subcommands.list.currentResolvedDefaultAccount(accountId)}`);
+        uiLogger.log('');
+    }
+    // If a default account override is present, display it
+    if (overrideFilePath && accountId) {
+        uiLogger.log(commands.account.subcommands.list.overrideFilePathTitle);
+        uiLogger.log(`${indent(1)}${commands.account.subcommands.list.overrideFilePath(overrideFilePath)}`);
+        uiLogger.log(`${indent(1)}${commands.account.subcommands.list.currentResolvedDefaultAccount(accountId)}`);
+        uiLogger.log('');
+    }
+    uiLogger.log(commands.account.subcommands.list.accounts);
+    renderTable(tableHeader, accountData, true);
+}
+function accountListBuilder(yargs) {
+    yargs.example([['$0 accounts list']]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountListBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const accountListCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountListCommand;

package/commands/account/remove.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type AccountRemoveArgs = CommonArgs & ConfigArgs & {
+    account?: string;
+};
+declare const accountRemoveCommand: YargsCommandModule<unknown, AccountRemoveArgs>;
+export default accountRemoveCommand;

package/commands/account/remove.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import { getConfigFilePath, removeAccountFromConfig, getConfigDefaultAccountIfExists, getConfigAccountIfExists, getConfigAccountById, setConfigAccountAsDefault, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { selectAccountFromConfig } from '../../lib/prompts/accountsPrompt.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+const command = 'remove [account]';
+const describe = commands.account.subcommands.remove.describe;
+async function handler(args) {
+    const { account: accountFlag } = args;
+    let accountToRemoveConfig = accountFlag
+        ? getConfigAccountIfExists(accountFlag)
+        : undefined;
+    let accountToRemoveId = accountToRemoveConfig?.accountId;
+    if (accountFlag && !accountToRemoveConfig) {
+        uiLogger.error(commands.account.subcommands.remove.errors.accountNotFound(accountFlag, getConfigFilePath()));
+    }
+    if (!accountToRemoveId) {
+        accountToRemoveId = await selectAccountFromConfig(commands.account.subcommands.remove.prompts.selectAccountToRemove);
+    }
+    accountToRemoveConfig = getConfigAccountById(accountToRemoveId);
+    trackCommandUsage('accounts-remove', undefined, accountToRemoveId);
+    const currentDefaultAccount = getConfigDefaultAccountIfExists();
+    const accounts = getAllConfigAccounts();
+    const accountOverride = getDefaultAccountOverrideAccountId(accounts);
+    const overrideFilePath = getDefaultAccountOverrideFilePath();
+    if (overrideFilePath &&
+        accountOverride &&
+        accountOverride === accountToRemoveConfig?.accountId) {
+        const { deleteOverrideFile } = await promptUser({
+            type: 'confirm',
+            name: 'deleteOverrideFile',
+            message: commands.account.subcommands.remove.prompts.deleteOverrideFile(overrideFilePath, accountToRemoveConfig.name),
+        });
+        try {
+            if (deleteOverrideFile) {
+                fs.unlinkSync(overrideFilePath);
+            }
+        }
+        catch (error) {
+            logError(error);
+        }
+    }
+    if (accountToRemoveConfig) {
+        removeAccountFromConfig(accountToRemoveConfig.accountId);
+    }
+    uiLogger.success(commands.account.subcommands.remove.success.accountRemoved(accountToRemoveConfig.name));
+    if (currentDefaultAccount &&
+        accountToRemoveConfig?.accountId === currentDefaultAccount.accountId) {
+        uiLogger.log('');
+        uiLogger.log(commands.account.subcommands.remove.logs.replaceDefaultAccount);
+        const newDefaultAccount = await selectAccountFromConfig();
+        setConfigAccountAsDefault(newDefaultAccount);
+    }
+}
+function accountRemoveBuilder(yargs) {
+    yargs.positional('account', {
+        describe: commands.account.subcommands.remove.options.account.describe,
+        type: 'string',
+    });
+    yargs.example([
+        [
+            '$0 accounts remove',
+            commands.account.subcommands.remove.examples.default,
+        ],
+        [
+            '$0 accounts remove MyAccount',
+            commands.account.subcommands.remove.examples.byName,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountRemoveBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const accountRemoveCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountRemoveCommand;

package/commands/account/removeOverride.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type RemoveOverrideArgs = CommonArgs & {
+    force?: boolean;
+};
+declare const accountRemoveOverrideCommand: YargsCommandModule<unknown, RemoveOverrideArgs>;
+export default accountRemoveOverrideCommand;

package/commands/account/removeOverride.js

@@ -0,0 +1,71 @@
+import fs from 'fs-extra';
+import { globalConfigFileExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME } from '@hubspot/local-dev-lib/constants/config';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+const command = 'remove-override';
+const describe = commands.account.subcommands.removeOverride.describe(DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME);
+async function handler(args) {
+    const { force } = args;
+    const globalConfigExists = globalConfigFileExists();
+    if (!globalConfigExists) {
+        uiLogger.error(commands.account.subcommands.removeOverride.errors.globalConfigNotFound);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const accounts = getAllConfigAccounts();
+    const accountOverride = getDefaultAccountOverrideAccountId(accounts);
+    const overrideFilePath = getDefaultAccountOverrideFilePath();
+    if (accountOverride && overrideFilePath) {
+        const accountId = accountOverride;
+        trackCommandUsage('account-removeOverride', undefined, accountId);
+        if (!force) {
+            uiLogger.log(commands.account.subcommands.removeOverride.accountOverride(overrideFilePath, accountOverride.toString()));
+            const { deleteOverrideFile } = await promptUser({
+                type: 'confirm',
+                name: 'deleteOverrideFile',
+                message: commands.account.subcommands.removeOverride.prompts
+                    .deleteOverrideFile,
+            });
+            uiLogger.log('');
+            if (!deleteOverrideFile) {
+                process.exit(EXIT_CODES.SUCCESS);
+            }
+        }
+        try {
+            fs.unlinkSync(overrideFilePath);
+            uiLogger.success(commands.account.subcommands.removeOverride.success);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        catch (error) {
+            logError(error);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        uiLogger.log(commands.account.subcommands.removeOverride.noOverrideFile);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+function accountRemoveOverrideBuilder(yargs) {
+    yargs.options('force', {
+        describe: commands.account.subcommands.removeOverride.options.force.describe,
+        type: 'boolean',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(accountRemoveOverrideBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const accountRemoveOverrideCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountRemoveOverrideCommand;

package/commands/account/rename.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type AccountRenameArgs = CommonArgs & ConfigArgs & {
+    accountName: string;
+    newName: string;
+};
+declare const accountRenameCommand: YargsCommandModule<unknown, AccountRenameArgs>;
+export default accountRenameCommand;

package/commands/account/rename.js

@@ -0,0 +1,51 @@
+import { renameConfigAccount } from '@hubspot/local-dev-lib/config';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { toKebabCase } from '@hubspot/local-dev-lib/text';
+const command = 'rename <account-name> <new-name>';
+const describe = commands.account.subcommands.rename.describe;
+async function handler(args) {
+    const { accountName, newName, derivedAccountId } = args;
+    trackCommandUsage('accounts-rename', undefined, derivedAccountId);
+    const newNameKebabCase = toKebabCase(newName);
+    const nameWasSanitized = newNameKebabCase !== newName;
+    try {
+        renameConfigAccount(accountName, newNameKebabCase);
+    }
+    catch (error) {
+        logError(error);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.success(commands.account.subcommands.rename.success.renamed(accountName, newNameKebabCase, nameWasSanitized));
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function accountRenameBuilder(yargs) {
+    yargs.positional('account-name', {
+        describe: commands.account.subcommands.rename.positionals.accountName.describe,
+        type: 'string',
+    });
+    yargs.positional('new-name', {
+        describe: commands.account.subcommands.rename.positionals.newName.describe,
+        type: 'string',
+    });
+    yargs.example([
+        ['$0 accounts rename myExistingAccountName myNewAccountName'],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountRenameBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+});
+const accountRenameCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountRenameCommand;

package/commands/account/use.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type AccountUseArgs = CommonArgs & {
+    account?: string;
+};
+declare const accountUseCommand: YargsCommandModule<unknown, AccountUseArgs>;
+export default accountUseCommand;