@hubspot/cli 7.7.0-experimental.2 → 7.7.0

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

@@ -0,0 +1,32 @@
+import yargs from 'yargs';
+import testAccountCreateConfigCommand from '../createConfig.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/testAccount/createConfig', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(testAccountCreateConfigCommand.command).toEqual('create-config');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(testAccountCreateConfigCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            const optionSpy = vi.spyOn(yargsMock, 'option');
+            testAccountCreateConfigCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(optionSpy).toHaveBeenCalledWith('name', expect.objectContaining({
+                type: 'string',
+            }));
+            expect(optionSpy).toHaveBeenCalledWith('description', expect.objectContaining({
+                type: 'string',
+            }));
+            expect(optionSpy).toHaveBeenCalledWith('path', expect.objectContaining({
+                type: 'string',
+            }));
+        });
+    });
+});

package/commands/testAccount/__tests__/delete.test.d.ts

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

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

@@ -0,0 +1,29 @@
+import yargs from 'yargs';
+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]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(testAccountDeleteCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            testAccountDeleteCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(addTestingOptions).toHaveBeenCalledTimes(1);
+            expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/testAccount/__tests__/importData.test.d.ts

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

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

@@ -0,0 +1,93 @@
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import testAccountImportDataCommand from '../importData.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../../../lib/importData.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getImportDataRequest } from '@hubspot/local-dev-lib/crm';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { importDataFilePathPrompt } from '../../../lib/prompts/importDataFilePathPrompt.js';
+import { confirmImportDataPrompt } from '../../../lib/prompts/confirmImportDataPrompt.js';
+vi.mock('../../../lib/commonOpts');
+vi.mock('../../../lib/importData');
+vi.mock('../../../lib/usageTracking');
+vi.mock('@hubspot/local-dev-lib/crm');
+vi.mock('../../../lib/errorHandlers/index');
+vi.mock('../../../lib/prompts/importDataFilePathPrompt');
+vi.mock('../../../lib/prompts/confirmImportDataPrompt');
+describe('commands/testAccount/importData', () => {
+    const yargsMock = yargs;
+    const mockExit = vi
+        .spyOn(process, 'exit')
+        .mockImplementation(() => undefined);
+    const mockHandleImportData = vi.mocked(handleImportData);
+    const mockHandleTargetTestAccountSelectionFlow = vi.mocked(handleTargetTestAccountSelectionFlow);
+    const mockTrackCommandUsage = vi.mocked(trackCommandUsage);
+    const mockGetImportDataRequest = vi.mocked(getImportDataRequest);
+    const mockLogError = vi.mocked(logError);
+    const mockImportDataFilePathPrompt = vi.mocked(importDataFilePathPrompt);
+    const mockConfirmImportDataPrompt = vi.mocked(confirmImportDataPrompt);
+    beforeEach(() => {
+        mockExit.mockReset();
+        mockHandleImportData.mockReset();
+        mockHandleTargetTestAccountSelectionFlow.mockReset();
+        mockTrackCommandUsage.mockReset();
+        mockGetImportDataRequest.mockReset();
+        mockLogError.mockReset();
+        mockImportDataFilePathPrompt.mockReset();
+        mockConfirmImportDataPrompt.mockReset();
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(testAccountImportDataCommand.command).toEqual('import-data');
+        });
+    });
+    // describe('describe', () => {
+    //   it('should provide a description', () => {
+    //     expect(testAccountImportDataCommand.describe).toBeDefined();
+    //   });
+    // });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            testAccountImportDataCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(yargsMock.options).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+    describe('handler', () => {
+        it('should complete the flow given the correct args', async () => {
+            const targetAccountId = 123456789;
+            const mockArgs = {
+                d: false,
+                debug: false,
+                _: [],
+                $0: 'hs',
+                derivedAccountId: targetAccountId,
+                userProvidedAccount: 'test-account',
+                filePath: 'test-file.json',
+                skipConfirm: true,
+            };
+            mockHandleTargetTestAccountSelectionFlow.mockResolvedValue(targetAccountId);
+            mockGetImportDataRequest.mockReturnValue({
+                importRequest: {},
+                dataFileNames: ['test-file.json'],
+            });
+            mockHandleImportData.mockResolvedValue();
+            await testAccountImportDataCommand.handler(mockArgs);
+            expect(mockHandleTargetTestAccountSelectionFlow).toHaveBeenCalledWith(123456789, 'test-account');
+            expect(mockGetImportDataRequest).toHaveBeenCalledWith('test-file.json');
+            expect(mockHandleImportData).toHaveBeenCalledTimes(1);
+            expect(mockTrackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(mockLogError).not.toHaveBeenCalled();
+            expect(mockImportDataFilePathPrompt).not.toHaveBeenCalled();
+            expect(mockConfirmImportDataPrompt).not.toHaveBeenCalled();
+            expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+    });
+});

package/commands/testAccount/create.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, TestingArgs, YargsCommandModule, EnvironmentArgs, JSONOutputArgs } from '../../types/Yargs.js';
+type CreateTestAccountArgs = CommonArgs & AccountArgs & ConfigArgs & TestingArgs & EnvironmentArgs & JSONOutputArgs & {
+    configPath?: string;
+};
+declare const createTestAccountCommand: YargsCommandModule<unknown, CreateTestAccountArgs>;
+export default createTestAccountCommand;

package/commands/testAccount/create.js

@@ -0,0 +1,130 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { getEnv } 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 SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { createDeveloperTestAccountV3, saveAccountToConfig, } from '../../lib/buildAccount.js';
+const command = 'create';
+const describe = commands.testAccount.create.describe;
+async function handler(args) {
+    const { derivedAccountId, configPath, formatOutputAsJson } = args;
+    trackCommandUsage('test-account-create', {}, derivedAccountId);
+    const env = getValidEnv(getEnv(derivedAccountId));
+    let accountConfigPath = configPath;
+    let testAccountConfig;
+    if (!accountConfigPath) {
+        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',
+            });
+            accountConfigPath = configPathPromptResult.configPath;
+        }
+    }
+    if (accountConfigPath) {
+        const absoluteConfigPath = path.resolve(getCwd(), accountConfigPath);
+        if (!fileExists(absoluteConfigPath)) {
+            uiLogger.error(commands.testAccount.create.errors.configFileNotFound(absoluteConfigPath));
+            process.exit(EXIT_CODES.ERROR);
+        }
+        try {
+            testAccountConfig = JSON.parse(fs.readFileSync(absoluteConfigPath, 'utf8'));
+        }
+        catch (err) {
+            uiLogger.error(commands.testAccount.create.errors.configFileParseFailed(absoluteConfigPath));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        testAccountConfig = await createDeveloperTestAccountConfigPrompt();
+    }
+    const resultJson = {};
+    SpinniesManager.init({
+        succeedColor: 'white',
+    });
+    SpinniesManager.add('createTestAccount', {
+        text: commands.testAccount.create.polling.start(testAccountConfig.accountName),
+    });
+    try {
+        const createResult = await createDeveloperTestAccountV3(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),
+    });
+    if (formatOutputAsJson) {
+        uiLogger.json(resultJson);
+    }
+    else {
+        // Only save to config if not using json output
+        try {
+            await saveAccountToConfig(resultJson.accountId, testAccountConfig.accountName, env, resultJson.personalAccessKey);
+        }
+        catch (e) {
+            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.example([
+        [
+            '$0 create --config-path ./test-account-config.json',
+            commands.testAccount.create.example('./test-account-config.json'),
+        ],
+    ]);
+    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,187 @@
+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 { 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 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
+            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', {
+        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 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: "Import data into the CRM";
+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;