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

package/commands/account/use.js

@@ -0,0 +1,93 @@
+import { getConfigFilePath, setConfigAccountAsDefault, getConfigAccountIfExists, getConfigAccountByName, getConfigAccountById, globalConfigFileExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { getDefaultAccountOverrideAccountId, getDefaultAccountOverrideFilePath, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { selectAccountFromConfig, AUTHENTICATE_NEW_ACCOUNT_VALUE, } from '../../lib/prompts/accountsPrompt.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { authenticateNewAccount } from '../../lib/accountAuth.js';
+import { PromptExitError } from '../../lib/errors/PromptExitError.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+const command = 'use [account]';
+const describe = commands.account.subcommands.use.describe;
+async function handler(args) {
+    let newDefaultAccount = args.account;
+    const usingGlobalConfig = globalConfigFileExists();
+    if (!newDefaultAccount) {
+        newDefaultAccount = await selectAccountFromConfig('', usingGlobalConfig);
+    }
+    else {
+        const account = getConfigAccountIfExists(newDefaultAccount);
+        if (!account) {
+            uiLogger.error(commands.account.subcommands.use.errors.accountNotFound(newDefaultAccount, getConfigFilePath()));
+            newDefaultAccount = await selectAccountFromConfig('', usingGlobalConfig);
+        }
+    }
+    if (newDefaultAccount === AUTHENTICATE_NEW_ACCOUNT_VALUE) {
+        let updatedConfig;
+        try {
+            updatedConfig = await authenticateNewAccount({
+                env: args.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD,
+                setAsDefaultAccount: true,
+            });
+        }
+        catch (e) {
+            if (e instanceof PromptExitError) {
+                process.exit(e.exitCode);
+            }
+            throw e;
+        }
+        if (!updatedConfig) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+        trackCommandUsage('accounts-use', undefined, updatedConfig.accountId);
+        return;
+    }
+    let account;
+    if (!isNaN(Number(newDefaultAccount))) {
+        account = getConfigAccountById(Number(newDefaultAccount));
+    }
+    else {
+        account = getConfigAccountByName(String(newDefaultAccount));
+    }
+    trackCommandUsage('accounts-use', undefined, account?.accountId);
+    const accounts = getAllConfigAccounts();
+    const accountOverride = getDefaultAccountOverrideAccountId(accounts);
+    const overrideFilePath = getDefaultAccountOverrideFilePath();
+    if (accountOverride && overrideFilePath) {
+        uiLogger.warn(commands.account.subcommands.use.accountOverride(accountOverride.toString()));
+        uiLogger.log(commands.account.subcommands.use.accountOverrideCommands);
+        uiLogger.log('');
+    }
+    setConfigAccountAsDefault(String(newDefaultAccount));
+    return uiLogger.success(commands.account.subcommands.use.success.defaultAccountUpdated(account.name));
+}
+function accountUseBuilder(yargs) {
+    yargs.positional('account', {
+        describe: commands.account.subcommands.use.options.account.describe,
+        type: 'string',
+    });
+    yargs.example([
+        ['$0 accounts use', commands.account.subcommands.use.examples.default],
+        [
+            '$0 accounts use MyAccount',
+            commands.account.subcommands.use.examples.nameBased,
+        ],
+        [
+            '$0 accounts use 1234567',
+            commands.account.subcommands.use.examples.idBased,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(accountUseBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const accountUseCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default accountUseCommand;

package/commands/account.d.ts

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

package/commands/account.js

@@ -0,0 +1,35 @@
+import { commands } from '../lang/en.js';
+import auth from './account/auth.js';
+import list from './account/list.js';
+import rename from './account/rename.js';
+import use from './account/use.js';
+import info from './account/info.js';
+import remove from './account/remove.js';
+import clean from './account/clean.js';
+import createOverride from './account/createOverride.js';
+import removeOverride from './account/removeOverride.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+const command = ['account', 'accounts'];
+const describe = commands.account.describe;
+function accountBuilder(yargs) {
+    yargs
+        .command(auth)
+        .command(list)
+        .command(rename)
+        .command(use)
+        .command(info)
+        .command(remove)
+        .command(clean)
+        .command(createOverride)
+        .command(removeOverride)
+        .demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(accountBuilder, command, describe);
+const accountCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default accountCommand;

package/commands/app/__tests__/migrate.test.d.ts

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

package/commands/app/__tests__/migrate.test.js

@@ -0,0 +1,111 @@
+import yargs from 'yargs';
+import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { migrateApp } from '../../../lib/app/migrate.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import migrateCommand from '../migrate.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/app/migrate');
+vi.mock('../../../lib/projects/config.js');
+const mockYargs = yargs;
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedmigrateApp = migrateApp;
+const mockedUiLogger = uiLogger;
+const optionsSpy = vi.spyOn(mockYargs, 'options');
+const exampleSpy = vi.spyOn(mockYargs, 'example');
+const exitSpy = vi
+    .spyOn(process, 'exit')
+    .mockImplementation(() => undefined);
+describe('commands/app/migrate', () => {
+    const mockAccountId = 123;
+    const mockAccountConfig = {
+        accountId: mockAccountId,
+        name: 'Test Account',
+        env: 'prod',
+        authType: 'personalaccesskey',
+        personalAccessKey: 'test-key',
+    };
+    beforeEach(() => {
+        mockedGetConfigAccountById.mockReturnValue(mockAccountConfig);
+        exitSpy.mockClear();
+    });
+    afterEach(() => {
+        exitSpy.mockClear();
+    });
+    describe('handler', () => {
+        it('should exit with error when no account config is found', async () => {
+            mockedGetConfigAccountById.mockReturnValue(null);
+            await migrateCommand.handler({
+                derivedAccountId: mockAccountId,
+            });
+            expect(mockedUiLogger.error).toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should call migrateApp for platform version 2025.2', async () => {
+            const options = {
+                derivedAccountId: mockAccountId,
+                platformVersion: PLATFORM_VERSIONS.v2025_2,
+            };
+            await migrateCommand.handler(options);
+            expect(mockedmigrateApp).toHaveBeenCalledWith(mockAccountId, options);
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should call migrateApp when unstable is true', async () => {
+            const options = {
+                derivedAccountId: mockAccountId,
+                unstable: true,
+            };
+            await migrateCommand.handler(options);
+            expect(mockedmigrateApp).toHaveBeenCalledWith(mockAccountId, options);
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle errors during migration', async () => {
+            const mockError = new Error('Migration failed');
+            mockedmigrateApp.mockRejectedValue(mockError);
+            await migrateCommand.handler({
+                derivedAccountId: mockAccountId,
+                platformVersion: PLATFORM_VERSIONS.v2025_2,
+            });
+            expect(mockedUiLogger.error).toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+    describe('builder', () => {
+        it('should add required options', async () => {
+            await migrateCommand.builder(mockYargs);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                name: expect.objectContaining({
+                    type: 'string',
+                    describe: expect.any(String),
+                }),
+                dest: expect.objectContaining({
+                    type: 'string',
+                    describe: expect.any(String),
+                }),
+                'app-id': expect.objectContaining({
+                    type: 'number',
+                    describe: expect.any(String),
+                }),
+                'platform-version': expect.objectContaining({
+                    type: 'string',
+                    default: '2026.03',
+                }),
+            }));
+        });
+        it('should set default platform version to 2025.2', async () => {
+            await migrateCommand.builder(mockYargs);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                'platform-version': expect.objectContaining({
+                    default: '2026.03',
+                }),
+            }));
+        });
+        it('should add example command', async () => {
+            await migrateCommand.builder(mockYargs);
+            expect(exampleSpy).toHaveBeenCalledWith([
+                ['$0 app migrate', expect.any(String)],
+            ]);
+        });
+    });
+});

package/commands/app/migrate.d.ts

@@ -0,0 +1,6 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { YargsCommandModule } from '../../types/Yargs.js';
+import { MigrateAppArgs } from '../../lib/app/migrate.js';
+export declare function handlerGenerator(commandTrackingName: string): (args: ArgumentsCamelCase<MigrateAppArgs>) => Promise<void>;
+declare const migrateCommand: YargsCommandModule<unknown, MigrateAppArgs>;
+export default migrateCommand;

package/commands/app/migrate.js

@@ -0,0 +1,96 @@
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
+import { trackCommandMetadataUsage, trackCommandUsage, } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { ApiErrorContext, logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { migrateApp } from '../../lib/app/migrate.js';
+import { getIsInProject } from '../../lib/projects/config.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const { v2025_2, v2026_03_beta, v2026_03 } = PLATFORM_VERSIONS;
+const command = 'migrate';
+const describe = commands.project.migrateApp.describe;
+export function handlerGenerator(commandTrackingName) {
+    return async function handler(args) {
+        const { derivedAccountId, platformVersion, unstable } = args;
+        await trackCommandUsage(commandTrackingName, {}, derivedAccountId);
+        const accountConfig = getConfigAccountById(derivedAccountId);
+        if (!accountConfig) {
+            uiLogger.error(commands.project.migrateApp.errors.noAccountConfig);
+            return process.exit(EXIT_CODES.ERROR);
+        }
+        uiLogger.log('');
+        uiLogger.log(commands.project.migrateApp.header);
+        uiLogger.log('');
+        try {
+            if (getIsInProject()) {
+                uiLogger.error(commands.project.migrateApp.errors.notAllowedWithinProject);
+                return process.exit(EXIT_CODES.ERROR);
+            }
+            args.platformVersion = unstable
+                ? PLATFORM_VERSIONS.unstable
+                : platformVersion;
+            await migrateApp(derivedAccountId, args);
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'errors' in error &&
+                Array.isArray(error.errors)) {
+                error.errors.forEach(err => logError(err));
+            }
+            else {
+                logError(error, new ApiErrorContext({ accountId: derivedAccountId }));
+            }
+            await trackCommandMetadataUsage(commandTrackingName, { successful: false }, derivedAccountId);
+            return process.exit(EXIT_CODES.ERROR);
+        }
+        await trackCommandMetadataUsage(commandTrackingName, { successful: true }, derivedAccountId);
+        return process.exit(EXIT_CODES.SUCCESS);
+    };
+}
+const handler = handlerGenerator('app-migrate');
+function appMigrateBuilder(yargs) {
+    yargs.options({
+        name: {
+            describe: commands.project.migrateApp.options.name.describe,
+            type: 'string',
+        },
+        dest: {
+            describe: commands.project.migrateApp.options.dest.describe,
+            type: 'string',
+        },
+        'app-id': {
+            describe: commands.project.migrateApp.options.appId.describe,
+            type: 'number',
+        },
+        'platform-version': {
+            type: 'string',
+            choices: [v2025_2, v2026_03_beta, v2026_03],
+            default: v2026_03,
+        },
+        unstable: {
+            type: 'boolean',
+            default: false,
+            hidden: true,
+        },
+    });
+    yargs.example([
+        [`$0 app migrate`, commands.project.migrateApp.examples.default],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(appMigrateBuilder, command, commands.project.migrateApp.describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const migrateCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default migrateCommand;

package/commands/app/secret/__tests__/add.test.d.ts

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

package/commands/app/secret/__tests__/add.test.js

@@ -0,0 +1,140 @@
+import yargs from 'yargs';
+import { addAppSecret } from '@hubspot/local-dev-lib/api/devSecrets';
+import { secretNamePrompt, secretValuePrompt, } from '../../../../lib/prompts/secretPrompt.js';
+import { selectAppPrompt } from '../../../../lib/prompts/selectAppPrompt.js';
+import { trackCommandUsage } from '../../../../lib/usageTracking.js';
+import { logError } from '../../../../lib/errorHandlers/index.js';
+import { uiLogger } from '../../../../lib/ui/logger.js';
+import { EXIT_CODES } from '../../../../lib/enums/exitCodes.js';
+import addAppSecretCommand from '../add.js';
+vi.mock('../../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/api/devSecrets');
+vi.mock('../../../../lib/prompts/secretPrompt.js');
+vi.mock('../../../../lib/prompts/selectAppPrompt.js');
+vi.mock('../../../../lib/errorHandlers/index.js');
+const addAppSecretMock = vi.mocked(addAppSecret);
+const secretNamePromptMock = vi.mocked(secretNamePrompt);
+const secretValuePromptMock = vi.mocked(secretValuePrompt);
+const selectAppPromptMock = vi.mocked(selectAppPrompt);
+const trackCommandUsageMock = vi.mocked(trackCommandUsage);
+const logErrorMock = vi.mocked(logError);
+const processExitSpy = vi.spyOn(process, 'exit');
+describe('commands/app/secret/add', () => {
+    const yargsMock = yargs;
+    const mockApp = { id: 12345, name: 'Test App' };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        selectAppPromptMock.mockResolvedValue(mockApp);
+        secretValuePromptMock.mockResolvedValue({ secretValue: 'test-value' });
+        // @ts-expect-error
+        addAppSecretMock.mockResolvedValue(undefined);
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(addAppSecretCommand.command).toEqual('add [name]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(addAppSecretCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            addAppSecretCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(yargsMock.positional).toHaveBeenCalledWith('name', expect.objectContaining({
+                type: 'string',
+            }));
+            expect(yargsMock.option).toHaveBeenCalledWith('app', expect.objectContaining({
+                type: 'number',
+            }));
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                name: 'test-secret',
+                derivedAccountId: 123456,
+                d: false,
+                debug: false,
+            };
+        });
+        it('should track command usage', async () => {
+            await addAppSecretCommand.handler(args);
+            expect(trackCommandUsageMock).toHaveBeenCalledWith('app-secret-add', {}, 123456);
+        });
+        it('should prompt for app selection', async () => {
+            await addAppSecretCommand.handler(args);
+            expect(selectAppPromptMock).toHaveBeenCalledWith(123456, undefined);
+        });
+        it('should use provided app ID when specified', async () => {
+            args.app = 99999;
+            await addAppSecretCommand.handler(args);
+            expect(selectAppPromptMock).toHaveBeenCalledWith(123456, 99999);
+        });
+        it('should error if no app is selected', async () => {
+            selectAppPromptMock.mockResolvedValue(null);
+            await addAppSecretCommand.handler(args);
+            expect(uiLogger.log).toHaveBeenCalledWith('');
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('create a new app'));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(addAppSecretMock).not.toHaveBeenCalled();
+        });
+        it('should prompt for secret name when not provided', async () => {
+            delete args.name;
+            secretNamePromptMock.mockResolvedValue({ secretName: 'prompted-name' });
+            await addAppSecretCommand.handler(args);
+            expect(secretNamePromptMock).toHaveBeenCalledTimes(1);
+            expect(addAppSecretMock).toHaveBeenCalledWith(123456, 12345, 'prompted-name', 'test-value');
+        });
+        it('should use provided secret name', async () => {
+            await addAppSecretCommand.handler(args);
+            expect(secretNamePromptMock).not.toHaveBeenCalled();
+            expect(addAppSecretMock).toHaveBeenCalledWith(123456, 12345, 'test-secret', 'test-value');
+        });
+        it('should prompt for secret value', async () => {
+            await addAppSecretCommand.handler(args);
+            expect(secretValuePromptMock).toHaveBeenCalledTimes(1);
+        });
+        it('should add app secret successfully', async () => {
+            await addAppSecretCommand.handler(args);
+            expect(addAppSecretMock).toHaveBeenCalledWith(123456, 12345, 'test-secret', 'test-value');
+            expect(uiLogger.success).toHaveBeenCalledWith(expect.stringContaining('Test App'));
+            expect(uiLogger.success).toHaveBeenCalledWith(expect.stringContaining('test-secret'));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle errors when adding app secret', async () => {
+            const error = new Error('API error');
+            addAppSecretMock.mockRejectedValue(error);
+            await addAppSecretCommand.handler(args);
+            expect(logErrorMock).toHaveBeenCalledWith(error);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle errors when selecting app', async () => {
+            const error = new Error('App selection error');
+            selectAppPromptMock.mockRejectedValue(error);
+            await addAppSecretCommand.handler(args);
+            expect(logErrorMock).toHaveBeenCalledWith(error);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle errors when prompting for name', async () => {
+            delete args.name;
+            const error = new Error('Name prompt error');
+            secretNamePromptMock.mockRejectedValue(error);
+            await addAppSecretCommand.handler(args);
+            expect(logErrorMock).toHaveBeenCalledWith(error);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle errors when prompting for value', async () => {
+            const error = new Error('Value prompt error');
+            secretValuePromptMock.mockRejectedValue(error);
+            await addAppSecretCommand.handler(args);
+            expect(logErrorMock).toHaveBeenCalledWith(error);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+});

package/commands/app/secret/__tests__/delete.test.d.ts

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

package/commands/app/secret/__tests__/delete.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import deleteAppSecretCommand from '../delete.js';
+vi.mock('../../../../lib/commonOpts');
+describe('commands/app/secret/delete', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(deleteAppSecretCommand.command).toEqual('delete [name]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(deleteAppSecretCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            deleteAppSecretCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(yargsMock.positional).toHaveBeenCalledWith('name', expect.objectContaining({
+                type: 'string',
+            }));
+            expect(yargsMock.option).toHaveBeenCalledWith('app', expect.objectContaining({
+                type: 'number',
+            }));
+        });
+    });
+});

package/commands/app/secret/__tests__/list.test.d.ts

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

package/commands/app/secret/__tests__/list.test.js

@@ -0,0 +1,25 @@
+import yargs from 'yargs';
+import listAppSecretsCommand from '../list.js';
+vi.mock('../../../../lib/commonOpts');
+describe('commands/app/secret/list', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(listAppSecretsCommand.command).toEqual('list');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(listAppSecretsCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            listAppSecretsCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(yargsMock.option).toHaveBeenCalledWith('app', expect.objectContaining({
+                type: 'number',
+            }));
+        });
+    });
+});

package/commands/app/secret/__tests__/update.test.d.ts

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

package/commands/app/secret/__tests__/update.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import updateAppSecretCommand from '../update.js';
+vi.mock('../../../../lib/commonOpts');
+describe('commands/app/secret/update', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(updateAppSecretCommand.command).toEqual('update [name]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(updateAppSecretCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            updateAppSecretCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(yargsMock.positional).toHaveBeenCalledWith('name', expect.objectContaining({
+                type: 'string',
+            }));
+            expect(yargsMock.option).toHaveBeenCalledWith('app', expect.objectContaining({
+                type: 'number',
+            }));
+        });
+    });
+});

package/commands/app/secret/add.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type AddAppSecretArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    app?: number;
+};
+declare const addAppSecretCommand: YargsCommandModule<unknown, AddAppSecretArgs>;
+export default addAppSecretCommand;

package/commands/app/secret/add.js

@@ -0,0 +1,63 @@
+import { addAppSecret } from '@hubspot/local-dev-lib/api/devSecrets';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { secretValuePrompt, secretNamePrompt, } from '../../../lib/prompts/secretPrompt.js';
+import { selectAppPrompt } from '../../../lib/prompts/selectAppPrompt.js';
+import { commands } from '../../../lang/en.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { uiBetaTag } from '../../../lib/ui/index.js';
+const command = 'add [name]';
+const describe = uiBetaTag(commands.app.subcommands.secret.subcommands.add.describe, false);
+async function handler(args) {
+    const { derivedAccountId } = args;
+    trackCommandUsage('app-secret-add', {}, derivedAccountId);
+    try {
+        const appSecretApp = await selectAppPrompt(derivedAccountId, args.app);
+        if (!appSecretApp) {
+            uiLogger.log('');
+            uiLogger.log(commands.app.subcommands.secret.subcommands.add.errors.noApps);
+            return process.exit(EXIT_CODES.ERROR);
+        }
+        let appSecretName = args.name;
+        if (!appSecretName) {
+            const { secretName: name } = await secretNamePrompt();
+            appSecretName = name;
+        }
+        const { secretValue } = await secretValuePrompt();
+        await addAppSecret(derivedAccountId, appSecretApp.id, appSecretName, secretValue);
+        uiLogger.log('');
+        uiLogger.success(commands.app.subcommands.secret.subcommands.add.success(appSecretApp.name, appSecretName));
+    }
+    catch (err) {
+        logError(err);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function addAppSecretBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.app.subcommands.secret.subcommands.add.positionals.name,
+        type: 'string',
+    });
+    yargs.option('app', {
+        describe: commands.app.subcommands.secret.subcommands.add.options.app,
+        type: 'number',
+    });
+    yargs.example('add my-secret --app=1234567890', commands.app.subcommands.secret.subcommands.add.example);
+    return yargs;
+}
+const builder = makeYargsBuilder(addAppSecretBuilder, command, describe, {
+    useGlobalOptions: true,
+    useAccountOptions: true,
+    useConfigOptions: true,
+    useEnvironmentOptions: true,
+});
+const addAppSecretCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default addAppSecretCommand;