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

package/api/migrate.d.ts

@@ -0,0 +1,77 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
+import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
+interface BaseMigrationApp {
+    appId: number;
+    appName: string;
+    isMigratable: boolean;
+    migrationComponents: ListAppsMigrationComponent[];
+    projectName?: string;
+}
+export interface MigratableApp extends BaseMigrationApp {
+    isMigratable: true;
+    unmigratableReason?: undefined;
+}
+export declare const CLI_UNMIGRATABLE_REASONS: {
+    readonly PART_OF_PROJECT_ALREADY: "PART_OF_PROJECT_ALREADY";
+};
+export interface UnmigratableApp extends BaseMigrationApp {
+    isMigratable: false;
+    unmigratableReason: keyof typeof UNMIGRATABLE_REASONS | keyof typeof CLI_UNMIGRATABLE_REASONS;
+}
+export type MigrationApp = MigratableApp | UnmigratableApp;
+export interface ListAppsResponse {
+    migratableApps: MigratableApp[];
+    unmigratableApps: UnmigratableApp[];
+}
+export interface ListThemesResponse {
+    migratableThemes: {
+        THEME: string[];
+        REACT_THEME: string[];
+    };
+}
+export interface InitializeAppMigrationResponse {
+    migrationId: number;
+}
+export interface ListAppsMigrationComponent {
+    id: string;
+    componentType: string;
+    isSupported: boolean;
+}
+export type ContinueAppMigrationResponse = {
+    migrationId: number;
+};
+export interface MigrationBaseStatus {
+    id: number;
+}
+export interface MigrationInProgress extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.IN_PROGRESS;
+}
+export interface MigrationInputRequired extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.INPUT_REQUIRED;
+    componentsRequiringUids: Record<string, {
+        componentType: string;
+        componentHint: string;
+    }>;
+}
+export interface MigrationSuccess extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.SUCCESS;
+    buildId: number;
+}
+interface ComponentError {
+    componentType: string;
+    developerSymbol?: string;
+    errorMessage: string;
+}
+export interface MigrationFailed extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.FAILURE;
+    projectErrorDetail: string;
+    componentErrors: ComponentError[];
+}
+export type MigrationStatus = MigrationInProgress | MigrationInputRequired | MigrationSuccess | MigrationFailed;
+export declare function isMigrationStatus(error: unknown): error is MigrationStatus;
+export declare function listAppsForMigration(accountId: number, platformVersion: string, appId: number | undefined): HubSpotPromise<ListAppsResponse>;
+export declare function initializeAppMigration(accountId: number, applicationId: number, platformVersion: string): HubSpotPromise<InitializeAppMigrationResponse>;
+export declare function continueAppMigration(portalId: number, migrationId: number, componentUids: Record<string, string>, projectName: string): HubSpotPromise<ContinueAppMigrationResponse>;
+export declare function checkMigrationStatusV2(accountId: number, id: number): HubSpotPromise<MigrationStatus>;
+export {};

package/api/migrate.js

@@ -0,0 +1,55 @@
+import { PLATFORM_VERSIONS, } from '@hubspot/local-dev-lib/constants/projects';
+import { http } from '@hubspot/local-dev-lib/http';
+const MIGRATIONS_API_PATH_V2 = 'dfs/migrations/v2';
+export const CLI_UNMIGRATABLE_REASONS = {
+    PART_OF_PROJECT_ALREADY: 'PART_OF_PROJECT_ALREADY',
+};
+export function isMigrationStatus(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'id' in error &&
+        'status' in error);
+}
+export async function listAppsForMigration(accountId, platformVersion, appId) {
+    return http.get(accountId, {
+        url: `${MIGRATIONS_API_PATH_V2}/list-apps`,
+        params: {
+            platformVersion: mapPlatformVersionToEnum(platformVersion),
+            appId,
+        },
+    });
+}
+function mapPlatformVersionToEnum(platformVersion) {
+    if (platformVersion === PLATFORM_VERSIONS.unstable) {
+        return PLATFORM_VERSIONS.unstable.toUpperCase();
+    }
+    const reformattedPlatformVersion = platformVersion
+        .replaceAll('.', '_')
+        .replaceAll('-', '_')
+        .toUpperCase();
+    return `V${reformattedPlatformVersion}`;
+}
+export async function initializeAppMigration(accountId, applicationId, platformVersion) {
+    return http.post(accountId, {
+        url: `${MIGRATIONS_API_PATH_V2}/migrations`,
+        data: {
+            applicationId,
+            platformVersion: mapPlatformVersionToEnum(platformVersion),
+        },
+    });
+}
+export async function continueAppMigration(portalId, migrationId, componentUids, projectName) {
+    return http.post(portalId, {
+        url: `${MIGRATIONS_API_PATH_V2}/migrations/continue`,
+        data: {
+            migrationId,
+            projectName,
+            componentUids,
+        },
+    });
+}
+export async function checkMigrationStatusV2(accountId, id) {
+    return http.get(accountId, {
+        url: `${MIGRATIONS_API_PATH_V2}/migrations/${id}/status`,
+    });
+}

package/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/cli.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { logError } from '../lib/errorHandlers/index.js';
+import { setCLILogLevel, getCommandName } from '../lib/commonOpts.js';
+import { trackHelpUsage, trackConvertFieldsUsage, } from '../lib/usageTracking.js';
+import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { validateConfigMiddleware, injectAccountIdMiddleware, validateAccountOptions, handleCustomConfigLocationMiddleware, } from '../lib/middleware/configMiddleware.js';
+import { autoUpdateCLI } from '../lib/middleware/autoUpdateMiddleware.js';
+import { checkAndWarnGitInclusionMiddleware } from '../lib/middleware/gitMiddleware.js';
+import { performChecks } from '../lib/middleware/yargsChecksMiddleware.js';
+import { setRequestHeaders } from '../lib/middleware/requestMiddleware.js';
+import { checkFireAlarms } from '../lib/middleware/fireAlarmMiddleware.js';
+import { handleDisableUsageTracking } from '../lib/middleware/usageTrackingMiddleware.js';
+import initCommand from '../commands/init.js';
+import hubdbCommand from '../commands/hubdb.js';
+import authCommand from '../commands/auth.js';
+import filemanagerCommand from '../commands/filemanager.js';
+import secretCommands from '../commands/secret.js';
+import customObjectCommand from '../commands/customObject.js';
+import openCommand from '../commands/open.js';
+import projectCommands from '../commands/project.js';
+import configCommand from '../commands/config.js';
+import accountCommands from '../commands/account.js';
+import sandboxesCommand from '../commands/sandbox.js';
+import cmsCommand from '../commands/cms.js';
+import feedbackCommand from '../commands/feedback.js';
+import doctorCommand from '../commands/doctor.js';
+import completionCommand from '../commands/completion.js';
+import appCommand from '../commands/app.js';
+import testAccountCommands from '../commands/testAccount.js';
+import getStartedCommand from '../commands/getStarted.js';
+import mcpCommand from '../commands/mcp.js';
+import upgradeCommand from '../commands/upgrade.js';
+import { uiLogger } from '../lib/ui/logger.js';
+import { initializeSpinniesManager } from '../lib/middleware/spinniesMiddleware.js';
+import { addCommandSuggestions } from '../lib/commandSuggestion.js';
+function getTerminalWidth() {
+    const width = yargs().terminalWidth();
+    if (width >= 100)
+        return width * 0.9;
+    return width;
+}
+function handleFailure(msg, err, yargs) {
+    if (msg) {
+        uiLogger.error(msg);
+    }
+    else if (err) {
+        logError(err);
+    }
+    if (msg === null && !err) {
+        // Required so running `hs` without a command shows the help
+        yargs.showHelp('log');
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else {
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+const argv = yargs(process.argv.slice(2))
+    .usage('The command line interface to interact with HubSpot.')
+    .middleware([
+    setCLILogLevel,
+    setRequestHeaders,
+    handleCustomConfigLocationMiddleware,
+    handleDisableUsageTracking,
+    injectAccountIdMiddleware,
+    validateConfigMiddleware,
+    autoUpdateCLI,
+    checkAndWarnGitInclusionMiddleware,
+    validateAccountOptions,
+    checkFireAlarms,
+    initializeSpinniesManager,
+])
+    .exitProcess(false)
+    .fail(handleFailure)
+    .option('noHyperlinks', {
+    default: false,
+    describe: 'prevent hyperlinks from displaying in the ui',
+    hidden: true,
+    type: 'boolean',
+})
+    .option('noColor', {
+    default: false,
+    describe: 'prevent color from displaying in the ui',
+    hidden: true,
+    type: 'boolean',
+})
+    .option('disable-usage-tracking', {
+    default: false,
+    hidden: true,
+    type: 'boolean',
+})
+    .check(performChecks)
+    // Getting started / important
+    .command(getStartedCommand)
+    .command(feedbackCommand)
+    // Config/Account management
+    .command(authCommand)
+    .command(initCommand)
+    .command(configCommand)
+    .command(accountCommands)
+    .command(testAccountCommands)
+    .command(sandboxesCommand)
+    .command(secretCommands)
+    .command(openCommand)
+    // Project commands
+    .command(projectCommands)
+    .command(appCommand)
+    // CMS Commands
+    .command(cmsCommand)
+    .command(hubdbCommand)
+    .command(filemanagerCommand)
+    // Misc commands
+    .command(customObjectCommand)
+    .command(completionCommand)
+    .command(doctorCommand)
+    .command(mcpCommand)
+    .command(upgradeCommand);
+const argvWithSuggestions = addCommandSuggestions(argv)
+    .help()
+    .alias('h', 'help')
+    .recommendCommands()
+    .demandCommand(1, '')
+    .wrap(getTerminalWidth())
+    .strict().argv;
+if ('help' in argvWithSuggestions && argvWithSuggestions.help !== undefined) {
+    (async () => {
+        await trackHelpUsage(getCommandName(argvWithSuggestions));
+    })();
+}
+if ('convertFields' in argvWithSuggestions &&
+    argvWithSuggestions.convertFields !== undefined) {
+    (async () => {
+        await trackConvertFieldsUsage(getCommandName(argvWithSuggestions));
+    })();
+}

package/bin/hs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/hscms.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/silenceErrors.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/silenceErrors.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const SILENCED_ERRORS = ['DeprecationWarning:'];
+const originalConsoleError = console.error;
+console.error = msg => {
+    const isSilencedError = SILENCED_ERRORS.some(error => typeof msg === 'string' && msg.includes(error));
+    if (isSilencedError) {
+        return;
+    }
+    originalConsoleError(msg);
+};
+export {};

package/commands/account/auth.d.ts

@@ -0,0 +1,8 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type AccountAuthArgs = CommonArgs & ConfigArgs & {
+    disableTracking?: boolean;
+} & {
+    personalAccessKey?: string;
+};
+declare const accountAuthCommand: YargsCommandModule<unknown, AccountAuthArgs>;
+export default accountAuthCommand;

package/commands/account/auth.js

@@ -0,0 +1,102 @@
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { deleteConfigFileIfEmpty } from '@hubspot/local-dev-lib/config';
+import { handleExit } from '../../lib/process.js';
+import { trackCommandUsage, trackAuthAction } from '../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiFeatureHighlight } from '../../lib/ui/index.js';
+import { parseStringToNumber } from '../../lib/parsing.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { authenticateNewAccount } from '../../lib/accountAuth.js';
+import { PromptExitError } from '../../lib/errors/PromptExitError.js';
+const TRACKING_STATUS = {
+    STARTED: 'started',
+    ERROR: 'error',
+    COMPLETE: 'complete',
+};
+const authType = PERSONAL_ACCESS_KEY_AUTH_METHOD.value;
+const describe = commands.account.subcommands.auth.describe;
+const command = 'auth';
+async function handler(args) {
+    const { disableTracking, personalAccessKey: providedPersonalAccessKey, userProvidedAccount, } = args;
+    let parsedUserProvidedAccountId;
+    if (userProvidedAccount) {
+        try {
+            parsedUserProvidedAccountId = parseStringToNumber(userProvidedAccount);
+        }
+        catch (err) {
+            uiLogger.error(commands.account.subcommands.auth.errors.invalidAccountIdProvided);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    if (!disableTracking) {
+        trackCommandUsage('account-auth', {}, parsedUserProvidedAccountId);
+        await trackAuthAction('account-auth', authType, TRACKING_STATUS.STARTED);
+    }
+    handleExit(deleteConfigFileIfEmpty);
+    let updatedConfig;
+    try {
+        updatedConfig = await authenticateNewAccount({
+            env: args.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD,
+            providedPersonalAccessKey,
+            accountId: parsedUserProvidedAccountId,
+        });
+    }
+    catch (e) {
+        if (e instanceof PromptExitError) {
+            process.exit(e.exitCode);
+        }
+        throw e;
+    }
+    if (!updatedConfig) {
+        if (!disableTracking) {
+            await trackAuthAction('account-auth', authType, TRACKING_STATUS.ERROR);
+        }
+        return process.exit(EXIT_CODES.ERROR);
+    }
+    const { accountId } = updatedConfig;
+    uiFeatureHighlight([
+        'getStartedCommand',
+        'helpCommand',
+        'accountAuthCommand',
+        'accountsListCommand',
+    ]);
+    if (!disableTracking) {
+        await trackAuthAction('account-auth', authType, TRACKING_STATUS.COMPLETE, accountId);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function accountAuthBuilder(yargs) {
+    yargs.options({
+        account: {
+            describe: commands.account.subcommands.auth.options.account,
+            type: 'number',
+            alias: 'a',
+        },
+        'disable-tracking': {
+            type: 'boolean',
+            hidden: true,
+            default: false,
+        },
+        'personal-access-key': {
+            describe: commands.account.subcommands.auth.options.personalAccessKey,
+            type: 'string',
+            hidden: false,
+            alias: 'pak',
+        },
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(accountAuthBuilder, command, commands.account.subcommands.auth.verboseDescribe, {
+    useGlobalOptions: true,
+    useTestingOptions: true,
+});
+const accountAuthCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountAuthCommand;

package/commands/account/clean.d.ts

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

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;