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

package/commands/testAccount/create.js

@@ -0,0 +1,232 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { promptUser, listPrompt } from '../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { fileExists } from '../../lib/validation.js';
+import { commands } from '../../lang/en.js';
+import { createDeveloperTestAccountConfigPrompt } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
+import { debugError, logError } from '../../lib/errorHandlers/index.js';
+import { PromptExitError } from '../../lib/errors/PromptExitError.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { createDeveloperTestAccountV2, saveAccountToConfig, } from '../../lib/buildAccount.js';
+import { ACCOUNT_LEVEL_CHOICES, ACCOUNT_LEVELS } from '../../lib/constants.js';
+const command = 'create';
+const describe = commands.testAccount.create.describe;
+function hasAnyFlags(args) {
+    const { name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, commerceLevel, } = args;
+    return !!(name ||
+        description ||
+        marketingLevel ||
+        opsLevel ||
+        serviceLevel ||
+        salesLevel ||
+        contentLevel ||
+        commerceLevel);
+}
+async function readConfigFile(configPath) {
+    const absoluteConfigPath = path.resolve(getCwd(), configPath);
+    if (!fileExists(absoluteConfigPath)) {
+        uiLogger.error(commands.testAccount.create.errors.configFileNotFound(absoluteConfigPath));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        return JSON.parse(fs.readFileSync(absoluteConfigPath, 'utf8'));
+    }
+    catch (err) {
+        uiLogger.error(commands.testAccount.create.errors.configFileParseFailed(absoluteConfigPath));
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+async function promptForConfigPath() {
+    const createTestAccountFromConfig = await listPrompt(commands.testAccount.create.createTestAccountFromConfigPrompt, {
+        choices: [
+            {
+                name: commands.testAccount.create.createFromConfigOption,
+                value: true,
+            },
+            {
+                name: commands.testAccount.create.createFromScratchOption,
+                value: false,
+            },
+        ],
+    });
+    if (createTestAccountFromConfig) {
+        const configPathPromptResult = await promptUser({
+            name: 'configPath',
+            message: commands.testAccount.create.configPathPrompt,
+            type: 'input',
+        });
+        return configPathPromptResult.configPath;
+    }
+    return undefined;
+}
+async function buildTestAccountConfig(args) {
+    const { configPath, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, commerceLevel, } = args;
+    if (configPath) {
+        return readConfigFile(configPath);
+    }
+    let accountConfigPath;
+    if (!hasAnyFlags(args)) {
+        accountConfigPath = await promptForConfigPath();
+    }
+    if (accountConfigPath) {
+        return readConfigFile(accountConfigPath);
+    }
+    return createDeveloperTestAccountConfigPrompt({
+        name,
+        description,
+        marketingLevel,
+        opsLevel,
+        serviceLevel,
+        salesLevel,
+        contentLevel,
+        commerceLevel,
+    });
+}
+async function handler(args) {
+    const { derivedAccountId, formatOutputAsJson } = args;
+    trackCommandUsage('test-account-create', {}, derivedAccountId);
+    const env = getValidEnv(getConfigAccountEnvironment(derivedAccountId));
+    const testAccountConfig = await buildTestAccountConfig(args);
+    const resultJson = {};
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    SpinniesManager.add('createTestAccount', {
+        text: commands.testAccount.create.polling.start(testAccountConfig.accountName),
+    });
+    try {
+        const createResult = await createDeveloperTestAccountV2(derivedAccountId, testAccountConfig);
+        resultJson.accountName = createResult.accountName;
+        resultJson.accountId = createResult.accountId;
+        resultJson.personalAccessKey = createResult.personalAccessKey;
+    }
+    catch (err) {
+        logError(err);
+        SpinniesManager.fail('createTestAccount', {
+            text: commands.testAccount.create.polling.createFailure,
+        });
+        process.exit(EXIT_CODES.ERROR);
+    }
+    SpinniesManager.succeed('createTestAccount', {
+        text: commands.testAccount.create.polling.success(testAccountConfig.accountName, resultJson.accountId, derivedAccountId),
+    });
+    if (formatOutputAsJson) {
+        uiLogger.json(resultJson);
+    }
+    else {
+        // Only save to config if not using json output
+        try {
+            const savedAccountName = await saveAccountToConfig(resultJson.accountId, testAccountConfig.accountName, env, resultJson.personalAccessKey);
+            // Inform user if the account name was normalized
+            if (savedAccountName !== testAccountConfig.accountName) {
+                uiLogger.log('');
+                uiLogger.info(commands.testAccount.create.savedAccountNameDiffers(testAccountConfig.accountName, savedAccountName));
+            }
+        }
+        catch (e) {
+            if (e instanceof PromptExitError) {
+                process.exit(e.exitCode);
+            }
+            debugError(e);
+            uiLogger.error(commands.testAccount.create.errors.saveAccountToConfigFailure(testAccountConfig.accountName));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function createTestAccountBuilder(yargs) {
+    yargs.option('config-path', {
+        type: 'string',
+        description: commands.testAccount.create.options.configPath,
+    });
+    yargs.option('name', {
+        type: 'string',
+        description: commands.testAccount.create.options.accountName,
+    });
+    yargs.option('description', {
+        type: 'string',
+        description: commands.testAccount.create.options.description,
+    });
+    yargs.option('marketing-level', {
+        type: 'string',
+        description: commands.testAccount.create.options.marketingLevel,
+        choices: ACCOUNT_LEVEL_CHOICES,
+    });
+    yargs.option('ops-level', {
+        type: 'string',
+        description: commands.testAccount.create.options.opsLevel,
+        choices: ACCOUNT_LEVEL_CHOICES,
+    });
+    yargs.option('service-level', {
+        type: 'string',
+        description: commands.testAccount.create.options.serviceLevel,
+        choices: ACCOUNT_LEVEL_CHOICES,
+    });
+    yargs.option('sales-level', {
+        type: 'string',
+        description: commands.testAccount.create.options.salesLevel,
+        choices: ACCOUNT_LEVEL_CHOICES,
+    });
+    yargs.option('content-level', {
+        type: 'string',
+        description: commands.testAccount.create.options.contentLevel,
+        choices: ACCOUNT_LEVEL_CHOICES,
+    });
+    yargs.option('commerce-level', {
+        type: 'string',
+        description: commands.testAccount.create.options.commerceLevel,
+        choices: ACCOUNT_LEVEL_CHOICES.filter(level => level !== ACCOUNT_LEVELS.STARTER),
+    });
+    yargs.conflicts('config-path', [
+        'name',
+        'description',
+        'marketing-level',
+        'ops-level',
+        'service-level',
+        'sales-level',
+        'content-level',
+        'commerce-level',
+    ]);
+    yargs.example([
+        ['$0 test-account create', 'Interactive mode - prompts for all options'],
+        [
+            '$0 test-account create --name "MyTestAccount"',
+            'Provide name via flag, prompt for description and tier selection',
+        ],
+        [
+            '$0 test-account create --name "MyTestAccount" --description "Test account"',
+            'Provide name and description, prompt for tier selection',
+        ],
+        [
+            '$0 test-account create --name "MyTestAccount" --marketing-level PROFESSIONAL',
+            'Specify marketing tier, other tiers default to ENTERPRISE',
+        ],
+        [
+            '$0 test-account create --config-path ./test-account-config.json',
+            'Create from config file (mutually exclusive with other flags)',
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(createTestAccountBuilder, command, describe, {
+    useGlobalOptions: true,
+    useEnvironmentOptions: true,
+    useAccountOptions: true,
+    useConfigOptions: true,
+    useTestingOptions: true,
+    useJSONOutputOptions: true,
+});
+const createTestAccountCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default createTestAccountCommand;

package/commands/testAccount/createConfig.d.ts

@@ -0,0 +1,8 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type CreateTestAccountConfigArgs = CommonArgs & {
+    name?: string;
+    description?: string;
+    path?: string;
+};
+declare const createTestAccountConfigCommand: YargsCommandModule<unknown, CreateTestAccountConfigArgs>;
+export default createTestAccountConfigCommand;

package/commands/testAccount/createConfig.js

@@ -0,0 +1,92 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { promptUser } from '../../lib/prompts/promptUtils.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';
+import { createDeveloperTestAccountConfigPrompt } from '../../lib/prompts/createDeveloperTestAccountConfigPrompt.js';
+import { fileExists } from '../../lib/validation.js';
+const command = 'create-config';
+const describe = commands.testAccount.createConfig.describe;
+async function handler(args) {
+    const { derivedAccountId, name, description, path: configPath } = args;
+    trackCommandUsage('test-account-create-config', {}, derivedAccountId);
+    let accountConfigPath = configPath;
+    const testAccountConfig = await createDeveloperTestAccountConfigPrompt({
+        name,
+        description,
+    });
+    if (!accountConfigPath) {
+        const pathPromptResult = await promptUser({
+            name: 'path',
+            message: commands.testAccount.createConfig.pathPrompt,
+            type: 'input',
+            default: testAccountConfig.accountName.toLowerCase().replace(/\s+/g, '-') +
+                '.json',
+            validate: path => {
+                if (!path) {
+                    return commands.testAccount.createConfig.errors.pathError;
+                }
+                else if (!path.endsWith('.json')) {
+                    return commands.testAccount.createConfig.errors.pathFormatError;
+                }
+                else if (fileExists(path)) {
+                    return commands.testAccount.createConfig.errors.pathExistsError;
+                }
+                return true;
+            },
+        });
+        accountConfigPath = pathPromptResult.path;
+    }
+    if (!accountConfigPath) {
+        uiLogger.error(commands.testAccount.createConfig.errors.pathError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (fileExists(accountConfigPath)) {
+        uiLogger.error(commands.testAccount.createConfig.errors.pathExistsError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        fs.writeFileSync(path.resolve(getCwd(), accountConfigPath), JSON.stringify(testAccountConfig, null, 2), 'utf8');
+    }
+    catch (err) {
+        uiLogger.error(commands.testAccount.createConfig.errors.failedToCreate);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.success(commands.testAccount.createConfig.success.configFileCreated(accountConfigPath));
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function createTestAccountConfigBuilder(yargs) {
+    yargs.option('name', {
+        type: 'string',
+        description: commands.testAccount.createConfig.options.name,
+    });
+    yargs.option('description', {
+        type: 'string',
+        description: commands.testAccount.createConfig.options.description,
+    });
+    yargs.option('path', {
+        type: 'string',
+        description: commands.testAccount.createConfig.options.path,
+    });
+    yargs.example([
+        [
+            '$0 test-account create-config --name my-account',
+            commands.testAccount.createConfig.example('my-account'),
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(createTestAccountConfigBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const createTestAccountConfigCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default createTestAccountConfigCommand;

package/commands/testAccount/delete.d.ts

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

@@ -0,0 +1,188 @@
+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';
+import { removeAccountFromConfig, getConfigAccountById, getConfigAccountIfExists, setConfigAccountAsDefault, getConfigDefaultAccountIfExists, } 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 getAccountPromptOptions(derivedAccountId) {
+    try {
+        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.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
+            const defaultAccount = getConfigDefaultAccountIfExists();
+            const defaultAccountId = defaultAccount?.accountId;
+            removeAccountFromConfig(account.accountId);
+            uiLogger.success(commands.testAccount.delete.success.testAccountDeletedFromConfig(testAccountId));
+            if (testAccountId === defaultAccountId) {
+                setConfigAccountAsDefault(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 = getConfigAccountById(testAccountId);
+    if (!testAccountConfig) {
+        uiLogger.error(commands.testAccount.delete.errors.testAccountNotFound(testAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const parentAccountConfig = getConfigAccountById(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 account = getConfigAccountIfExists(testAccount);
+        const accountId = account?.accountId || null;
+        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', {
+        type: 'string',
+        description: commands.testAccount.delete.options.id,
+        required: false,
+    });
+    yargs.option('force', {
+        describe: commands.testAccount.delete.options.force,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.example([
+        [
+            '$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,
+    useConfigOptions: true,
+    useTestingOptions: true,
+});
+const deleteTestAccountCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default deleteTestAccountCommand;

package/commands/testAccount/importData.d.ts

@@ -0,0 +1,9 @@
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export declare const command = "import-data";
+export declare const describe: string;
+type CrmImportDataArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    filePath: string | undefined;
+    skipConfirm: boolean | undefined;
+};
+declare const crmImportDataCommand: YargsCommandModule<unknown, CrmImportDataArgs>;
+export default crmImportDataCommand;

package/commands/testAccount/importData.js

@@ -0,0 +1,61 @@
+import { getImportDataRequest } from '@hubspot/local-dev-lib/crm';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { importDataFilePathPrompt } from '../../lib/prompts/importDataFilePathPrompt.js';
+import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../../lib/importData.js';
+import { confirmImportDataPrompt } from '../../lib/prompts/confirmImportDataPrompt.js';
+import { commands } from '../../lang/en.js';
+export const command = 'import-data';
+export const describe = commands.testAccount.subcommands.importData.describe;
+async function handler(args) {
+    const { derivedAccountId, userProvidedAccount, filePath: providedFilePath, skipConfirm, } = args;
+    trackCommandUsage('crm-import-data', {}, derivedAccountId);
+    let targetAccountId;
+    try {
+        targetAccountId = await handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccount);
+        const filePath = providedFilePath || (await importDataFilePathPrompt());
+        const { importRequest, dataFileNames } = getImportDataRequest(filePath);
+        const confirmImportData = skipConfirm ||
+            (await confirmImportDataPrompt(targetAccountId, dataFileNames));
+        if (!confirmImportData) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        await handleImportData(targetAccountId, dataFileNames, importRequest);
+    }
+    catch (error) {
+        logError(error);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function crmImportDataBuilder(yargs) {
+    yargs.example([['$0 test-account import-data']]);
+    yargs.options({
+        'file-path': {
+            type: 'string',
+            describe: commands.testAccount.subcommands.importData.options.filePath.describe,
+            positional: false,
+        },
+        'skip-confirm': {
+            type: 'boolean',
+            describe: commands.testAccount.subcommands.importData.options.skipConfirm
+                .describe,
+        },
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(crmImportDataBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const crmImportDataCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default crmImportDataCommand;

package/commands/testAccount.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../types/Yargs.js';
+declare const testAccountCommand: YargsCommandModuleBucket;
+export default testAccountCommand;

package/commands/testAccount.js

@@ -0,0 +1,25 @@
+import createTestAccountCommand from './testAccount/create.js';
+import createTestAccountConfigCommand from './testAccount/createConfig.js';
+import importDataCommand from './testAccount/importData.js';
+import deleteTestAccountCommand from './testAccount/delete.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+import { commands } from '../lang/en.js';
+const command = ['test-account', 'test-accounts'];
+const describe = commands.testAccount.describe;
+function testAccountBuilder(yargs) {
+    yargs
+        .command(createTestAccountCommand)
+        .command(createTestAccountConfigCommand)
+        .command(deleteTestAccountCommand)
+        .command(importDataCommand)
+        .demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(testAccountBuilder, command, commands.testAccount.describe);
+const testAccountCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default testAccountCommand;

package/commands/upgrade.d.ts

@@ -0,0 +1,8 @@
+import { CommonArgs, YargsCommandModule } from '../types/Yargs.js';
+export type UpgradeArgs = CommonArgs & {
+    version?: string;
+    force?: boolean;
+    beta?: boolean;
+};
+declare const upgradeCommand: YargsCommandModule<unknown, UpgradeArgs>;
+export default upgradeCommand;