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

package/commands/cms/__tests__/upload.test.js

@@ -0,0 +1,312 @@
+import yargs from 'yargs';
+import fs from 'fs';
+import path from 'path';
+import * as uploadFolderLib from '@hubspot/local-dev-lib/cms/uploadFolder';
+import * as fileMapperLib from '@hubspot/local-dev-lib/api/fileMapper';
+import * as pathLib from '@hubspot/local-dev-lib/path';
+import * as modulesLib from '@hubspot/local-dev-lib/cms/modules';
+import * as ignoreRulesLib from '@hubspot/local-dev-lib/ignoreRules';
+import * as themesLib from '@hubspot/local-dev-lib/cms/themes';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as handleFieldsJSLib from '@hubspot/local-dev-lib/cms/handleFieldsJS';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import * as errorHandlers from '../../../lib/errorHandlers/index.js';
+import * as commonOpts from '../../../lib/commonOpts.js';
+import * as uploadPromptLib from '../../../lib/prompts/uploadPrompt.js';
+import * as promptUtilsLib from '../../../lib/prompts/promptUtils.js';
+import * as validationLib from '../../../lib/validation.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import * as uploadLib from '../../../lib/upload.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import uploadCommand from '../upload.js';
+vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/cms/uploadFolder');
+vi.mock('@hubspot/local-dev-lib/api/fileMapper');
+vi.mock('@hubspot/local-dev-lib/path');
+vi.mock('@hubspot/local-dev-lib/cms/modules');
+vi.mock('@hubspot/local-dev-lib/ignoreRules');
+vi.mock('@hubspot/local-dev-lib/cms/themes');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/cms/handleFieldsJS');
+vi.mock('../../../lib/errorHandlers/index.js');
+vi.mock('../../../lib/commonOpts.js');
+vi.mock('../../../lib/prompts/uploadPrompt.js');
+vi.mock('../../../lib/prompts/promptUtils.js');
+vi.mock('../../../lib/validation.js');
+vi.mock('../../../lib/upload.js');
+const uploadFolderSpy = vi.spyOn(uploadFolderLib, 'uploadFolder');
+const uploadSpy = vi.spyOn(fileMapperLib, 'upload');
+const deleteFileSpy = vi.spyOn(fileMapperLib, 'deleteFile');
+const statSyncSpy = vi.spyOn(fs, 'statSync');
+const validateSrcAndDestPathsSpy = vi.spyOn(modulesLib, 'validateSrcAndDestPaths');
+const shouldIgnoreFileSpy = vi.spyOn(ignoreRulesLib, 'shouldIgnoreFile');
+const isAllowedExtensionSpy = vi.spyOn(pathLib, 'isAllowedExtension');
+const getCwdSpy = vi.spyOn(pathLib, 'getCwd');
+const convertToUnixPathSpy = vi.spyOn(pathLib, 'convertToUnixPath');
+const uploadPromptSpy = vi.spyOn(uploadPromptLib, 'uploadPrompt');
+const confirmPromptSpy = vi.spyOn(promptUtilsLib, 'confirmPrompt');
+const validateCmsPublishModeSpy = vi.spyOn(validationLib, 'validateCmsPublishMode');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const getUploadableFileListSpy = vi.spyOn(uploadLib, 'getUploadableFileList');
+const getCmsPublishModeSpy = vi.spyOn(commonOpts, 'getCmsPublishMode');
+const getThemePreviewUrlSpy = vi.spyOn(themesLib, 'getThemePreviewUrl');
+const getThemeJSONPathSpy = vi.spyOn(themesLib, 'getThemeJSONPath');
+const hasUploadErrorsSpy = vi.spyOn(uploadFolderLib, 'hasUploadErrors');
+const processExitSpy = vi.spyOn(process, 'exit');
+const logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
+const isConvertableFieldJsSpy = vi.spyOn(handleFieldsJSLib, 'isConvertableFieldJs');
+describe('commands/cms/upload', () => {
+    beforeEach(() => {
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        getCwdSpy.mockReturnValue('/test/cwd');
+        convertToUnixPathSpy.mockImplementation(p => p.replace(/\\/g, '/'));
+        validateCmsPublishModeSpy.mockReturnValue(true);
+        getCmsPublishModeSpy.mockReturnValue('publish');
+        uploadPromptSpy.mockResolvedValue({ src: '', dest: '' });
+        validateSrcAndDestPathsSpy.mockResolvedValue([]);
+        getThemeJSONPathSpy.mockReturnValue(null);
+        getThemePreviewUrlSpy.mockReturnValue(undefined);
+        // Mock config to prevent reading actual config file in CI
+        getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+        isConvertableFieldJsSpy.mockReturnValue(false);
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(uploadCommand.command).toEqual('upload [src] [dest]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(uploadCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            const optionsSpy = vi.spyOn(yargs, 'option');
+            const positionalSpy = vi.spyOn(yargs, 'positional');
+            uploadCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('src', expect.objectContaining({ type: 'string' }));
+            expect(positionalSpy).toHaveBeenCalledWith('dest', expect.objectContaining({ type: 'string' }));
+            expect(optionsSpy).toHaveBeenCalledWith('field-options', expect.objectContaining({ type: 'array' }));
+            expect(optionsSpy).toHaveBeenCalledWith('save-output', expect.objectContaining({ type: 'boolean' }));
+            expect(optionsSpy).toHaveBeenCalledWith('convert-fields', expect.objectContaining({ type: 'boolean' }));
+            expect(optionsSpy).toHaveBeenCalledWith('clean', expect.objectContaining({ type: 'boolean' }));
+            expect(optionsSpy).toHaveBeenCalledWith('force', expect.objectContaining({ type: 'boolean' }));
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                src: 'test.js',
+                dest: '/dest/test.js',
+                derivedAccountId: 123456,
+            };
+        });
+        describe('validation', () => {
+            it('should exit if CMS publish mode validation fails', async () => {
+                validateCmsPublishModeSpy.mockReturnValue(false);
+                await uploadCommand.handler(args);
+                expect(validateCmsPublishModeSpy).toHaveBeenCalledWith(args);
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.WARNING);
+            });
+            it('should prompt for src and dest when not provided', async () => {
+                delete args.src;
+                delete args.dest;
+                uploadPromptSpy.mockResolvedValue({
+                    src: 'prompted.js',
+                    dest: '/prompted/dest.js',
+                });
+                statSyncSpy.mockReturnValue({
+                    isFile: () => true,
+                    isDirectory: () => false,
+                });
+                isAllowedExtensionSpy.mockReturnValue(true);
+                shouldIgnoreFileSpy.mockReturnValue(false);
+                // @ts-expect-error Mock return value doesn't need full type implementation
+                uploadSpy.mockResolvedValue({});
+                await uploadCommand.handler(args);
+                expect(uploadPromptSpy).toHaveBeenCalledWith(args);
+                expect(uploadSpy).toHaveBeenCalled();
+            });
+            it('should error if dest is not provided', async () => {
+                args.dest = '';
+                uploadPromptSpy.mockResolvedValue({ src: 'test.js', dest: '' });
+                await uploadCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('destination'));
+            });
+            it('should error if src path is invalid', async () => {
+                statSyncSpy.mockImplementation(() => {
+                    throw new Error('File not found');
+                });
+                await uploadCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('path to a file or folder'));
+            });
+            it('should error if src path is not a file or directory', async () => {
+                statSyncSpy.mockReturnValue({
+                    isFile: () => false,
+                    isDirectory: () => false,
+                });
+                await uploadCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('path to a file or folder'));
+            });
+            it('should exit if src/dest validation fails', async () => {
+                statSyncSpy.mockReturnValue({
+                    isFile: () => true,
+                    isDirectory: () => false,
+                });
+                validateSrcAndDestPathsSpy.mockResolvedValue([
+                    { id: '1', message: 'Invalid path' },
+                ]);
+                await uploadCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith('Invalid path');
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.WARNING);
+            });
+        });
+        describe('file upload', () => {
+            beforeEach(() => {
+                statSyncSpy.mockReturnValue({
+                    isFile: () => true,
+                    isDirectory: () => false,
+                });
+                isAllowedExtensionSpy.mockReturnValue(true);
+                shouldIgnoreFileSpy.mockReturnValue(false);
+            });
+            it('should track command usage for file uploads', async () => {
+                // @ts-expect-error Mock return value doesn't need full type implementation
+                uploadSpy.mockResolvedValue({});
+                await uploadCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('upload', { mode: 'publish', type: 'file' }, 123456);
+            });
+            it('should upload a file successfully', async () => {
+                // @ts-expect-error Mock return value doesn't need full type implementation
+                uploadSpy.mockResolvedValue({});
+                await uploadCommand.handler(args);
+                expect(uploadSpy).toHaveBeenCalledWith(123456, path.resolve('/test/cwd', 'test.js'), '/dest/test.js', expect.any(Object));
+                expect(uiLogger.success).toHaveBeenCalledWith(expect.stringMatching(/uploaded/i));
+            });
+            it('should error if file has disallowed extension', async () => {
+                isAllowedExtensionSpy.mockReturnValue(false);
+                await uploadCommand.handler(args);
+                expect(uploadSpy).not.toHaveBeenCalled();
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('path to a file or folder'));
+            });
+            it('should error if file is ignored', async () => {
+                shouldIgnoreFileSpy.mockReturnValue(true);
+                await uploadCommand.handler(args);
+                expect(uploadSpy).not.toHaveBeenCalled();
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('ignored'));
+            });
+            it('should handle upload errors', async () => {
+                vi.useFakeTimers();
+                const error = new Error('Upload failed');
+                uploadSpy.mockRejectedValue(error);
+                await uploadCommand.handler(args);
+                await vi.runAllTimersAsync();
+                expect(uiLogger.error).toHaveBeenCalled();
+                expect(logErrorSpy).toHaveBeenCalledWith(error, expect.any(errorHandlers.ApiErrorContext));
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.WARNING);
+                vi.useRealTimers();
+            });
+            it('should log theme preview URL if available', async () => {
+                getThemePreviewUrlSpy.mockReturnValue('http://preview.url');
+                // @ts-expect-error Mock return value doesn't need full type implementation
+                uploadSpy.mockResolvedValue({});
+                await uploadCommand.handler(args);
+                expect(getThemePreviewUrlSpy).toHaveBeenCalledWith('test.js', 123456);
+                expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('http://preview.url'));
+            });
+        });
+        describe('folder upload', () => {
+            beforeEach(() => {
+                statSyncSpy.mockReturnValue({
+                    isFile: () => false,
+                    isDirectory: () => true,
+                });
+                getUploadableFileListSpy.mockResolvedValue([]);
+                uploadFolderSpy.mockResolvedValue([]);
+                hasUploadErrorsSpy.mockReturnValue(false);
+            });
+            it('should track command usage for folder uploads', async () => {
+                await uploadCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('upload', { mode: 'publish', type: 'folder' }, 123456);
+            });
+            it('should upload a folder successfully', async () => {
+                await uploadCommand.handler(args);
+                expect(uploadFolderSpy).toHaveBeenCalledWith(123456, path.resolve('/test/cwd', 'test.js'), '/dest/test.js', {}, expect.objectContaining({
+                    convertFields: undefined,
+                    saveOutput: undefined,
+                }), []);
+                expect(uiLogger.success).toHaveBeenCalledWith(expect.stringContaining('complete'));
+            });
+            it('should handle clean upload with confirmation', async () => {
+                args.clean = true;
+                confirmPromptSpy.mockResolvedValue(true);
+                // @ts-expect-error Mock return value doesn't need full type implementation
+                deleteFileSpy.mockResolvedValue({});
+                await uploadCommand.handler(args);
+                expect(confirmPromptSpy).toHaveBeenCalled();
+                expect(deleteFileSpy).toHaveBeenCalledWith(123456, '/dest/test.js');
+                // Check that log was called multiple times (upload message + cleaning message)
+                expect(uiLogger.log).toHaveBeenCalled();
+            });
+            it('should skip clean upload if not confirmed', async () => {
+                args.clean = true;
+                confirmPromptSpy.mockResolvedValue(false);
+                await uploadCommand.handler(args);
+                expect(deleteFileSpy).not.toHaveBeenCalled();
+            });
+            it('should force clean upload without confirmation', async () => {
+                args.clean = true;
+                args.force = true;
+                // @ts-expect-error Mock return value doesn't need full type implementation
+                deleteFileSpy.mockResolvedValue({});
+                await uploadCommand.handler(args);
+                expect(confirmPromptSpy).not.toHaveBeenCalled();
+                expect(deleteFileSpy).toHaveBeenCalledWith(123456, '/dest/test.js');
+            });
+            it('should handle delete errors during clean upload', async () => {
+                args.clean = true;
+                args.force = true;
+                const error = new Error('Delete failed');
+                deleteFileSpy.mockRejectedValue(error);
+                await uploadCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Deleting'));
+            });
+            it('should error if folder upload has errors', async () => {
+                hasUploadErrorsSpy.mockReturnValue(true);
+                await uploadCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('failed'));
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.WARNING);
+            });
+            it('should handle folder upload errors', async () => {
+                vi.useFakeTimers();
+                const error = new Error('Folder upload failed');
+                uploadFolderSpy.mockRejectedValue(error);
+                await uploadCommand.handler(args);
+                await vi.runAllTimersAsync();
+                expect(uiLogger.error).toHaveBeenCalled();
+                expect(logErrorSpy).toHaveBeenCalledWith(error, {
+                    accountId: 123456,
+                });
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.WARNING);
+                vi.useRealTimers();
+            });
+            it('should pass convertFields option to uploadFolder', async () => {
+                args.convertFields = true;
+                await uploadCommand.handler(args);
+                expect(uploadFolderSpy).toHaveBeenCalledWith(123456, expect.any(String), expect.any(String), {}, expect.objectContaining({
+                    convertFields: true,
+                }), expect.any(Array));
+            });
+            it('should generate uploadable file list with convertFields', async () => {
+                args.convertFields = true;
+                getUploadableFileListSpy.mockResolvedValue(['file1.js', 'file2.js']);
+                await uploadCommand.handler(args);
+                expect(getUploadableFileListSpy).toHaveBeenCalledWith(path.resolve('/test/cwd', 'test.js'), true);
+            });
+        });
+    });
+});

package/commands/cms/__tests__/watch.test.d.ts

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

package/commands/cms/__tests__/watch.test.js

@@ -0,0 +1,204 @@
+import yargs from 'yargs';
+import fs from 'fs';
+import path from 'path';
+import { AxiosError } from 'axios';
+import * as watchLib from '@hubspot/local-dev-lib/cms/watch';
+import * as pathLib from '@hubspot/local-dev-lib/path';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import * as commonOpts from '../../../lib/commonOpts.js';
+import * as uploadPromptLib from '../../../lib/prompts/uploadPrompt.js';
+import * as validationLib from '../../../lib/validation.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import * as uploadLib from '../../../lib/upload.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import watchCommand from '../watch.js';
+vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/cms/watch');
+vi.mock('@hubspot/local-dev-lib/path');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/commonOpts.js');
+vi.mock('../../../lib/prompts/uploadPrompt.js');
+vi.mock('../../../lib/validation.js');
+vi.mock('../../../lib/upload.js');
+const watchSpy = vi.spyOn(watchLib, 'watch');
+const statSyncSpy = vi.spyOn(fs, 'statSync');
+const getCwdSpy = vi.spyOn(pathLib, 'getCwd');
+const uploadPromptSpy = vi.spyOn(uploadPromptLib, 'uploadPrompt');
+const validateCmsPublishModeSpy = vi.spyOn(validationLib, 'validateCmsPublishMode');
+const getCmsPublishModeSpy = vi.spyOn(commonOpts, 'getCmsPublishMode');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const getUploadableFileListSpy = vi.spyOn(uploadLib, 'getUploadableFileList');
+const processExitSpy = vi.spyOn(process, 'exit');
+const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
+describe('commands/cms/watch', () => {
+    beforeEach(() => {
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        getCwdSpy.mockReturnValue('/test/cwd');
+        validateCmsPublishModeSpy.mockReturnValue(true);
+        getCmsPublishModeSpy.mockReturnValue('publish');
+        uploadPromptSpy.mockResolvedValue({ src: '', dest: '' });
+        // @ts-expect-error Mock return value doesn't need full type implementation
+        watchSpy.mockImplementation(() => ({}));
+        getUploadableFileListSpy.mockResolvedValue([]);
+        // Mock config to prevent reading actual config file in CI
+        getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(watchCommand.command).toEqual('watch [src] [dest]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(watchCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            const positionalSpy = vi.spyOn(yargs, 'positional');
+            const optionSpy = vi.spyOn(yargs, 'option');
+            watchCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('src', expect.objectContaining({ type: 'string' }));
+            expect(positionalSpy).toHaveBeenCalledWith('dest', expect.objectContaining({ type: 'string' }));
+            expect(optionSpy).toHaveBeenCalledWith('remove', expect.objectContaining({ type: 'boolean', alias: 'r' }));
+            expect(optionSpy).toHaveBeenCalledWith('initial-upload', expect.objectContaining({ type: 'boolean', alias: 'i' }));
+            expect(optionSpy).toHaveBeenCalledWith('notify', expect.objectContaining({ type: 'string', alias: 'n' }));
+            expect(optionSpy).toHaveBeenCalledWith('convert-fields', expect.objectContaining({ type: 'boolean' }));
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                src: 'src',
+                dest: '/dest',
+                derivedAccountId: 123456,
+                remove: false,
+                initialUpload: false,
+            };
+            statSyncSpy.mockReturnValue({
+                isFile: () => false,
+                isDirectory: () => true,
+            });
+        });
+        describe('validation', () => {
+            it('should exit if CMS publish mode validation fails', async () => {
+                validateCmsPublishModeSpy.mockReturnValue(false);
+                await watchCommand.handler(args);
+                expect(validateCmsPublishModeSpy).toHaveBeenCalledWith(args);
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+            it('should prompt for src and dest when not provided', async () => {
+                delete args.src;
+                delete args.dest;
+                uploadPromptSpy.mockResolvedValue({
+                    src: 'prompted-src',
+                    dest: '/prompted-dest',
+                });
+                await watchCommand.handler(args);
+                expect(uploadPromptSpy).toHaveBeenCalledWith(args);
+            });
+            it('should error if src path is invalid', async () => {
+                statSyncSpy.mockImplementation(() => {
+                    throw new Error('File not found');
+                });
+                await watchCommand.handler(args);
+                expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('path to a directory'));
+                expect(watchSpy).not.toHaveBeenCalled();
+            });
+            it('should error if src path is not a directory', async () => {
+                statSyncSpy.mockReturnValue({
+                    isFile: () => true,
+                    isDirectory: () => false,
+                });
+                await watchCommand.handler(args);
+                expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('path to a directory'));
+                expect(watchSpy).not.toHaveBeenCalled();
+            });
+            it('should error if dest is not provided', async () => {
+                args.dest = '';
+                uploadPromptSpy.mockResolvedValue({ src: 'src', dest: '' });
+                await watchCommand.handler(args);
+                expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('destination'));
+                expect(watchSpy).not.toHaveBeenCalled();
+            });
+        });
+        describe('watch execution', () => {
+            it('should track command usage', async () => {
+                await watchCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('watch', { mode: 'publish' }, 123456);
+            });
+            it('should start watching without initial upload by default', async () => {
+                await watchCommand.handler(args);
+                expect(getUploadableFileListSpy).not.toHaveBeenCalled();
+                expect(watchSpy).toHaveBeenCalledWith(123456, path.resolve('/test/cwd', 'src'), '/dest', expect.objectContaining({
+                    cmsPublishMode: 'publish',
+                    remove: false,
+                    disableInitial: true,
+                }), null, expect.any(Function), undefined, expect.any(Function));
+            });
+            it('should generate uploadable file list when initialUpload is true', async () => {
+                args.initialUpload = true;
+                getUploadableFileListSpy.mockResolvedValue(['file1.js', 'file2.js']);
+                await watchCommand.handler(args);
+                expect(getUploadableFileListSpy).toHaveBeenCalledWith(path.resolve('/test/cwd', 'src'), undefined);
+                expect(watchSpy).toHaveBeenCalledWith(123456, expect.any(String), expect.any(String), expect.objectContaining({
+                    disableInitial: false,
+                    filePaths: ['file1.js', 'file2.js'],
+                }), null, expect.any(Function), undefined, expect.any(Function));
+            });
+            it('should pass remove option to watch', async () => {
+                args.remove = true;
+                await watchCommand.handler(args);
+                expect(watchSpy).toHaveBeenCalledWith(123456, expect.any(String), expect.any(String), expect.objectContaining({
+                    remove: true,
+                }), null, expect.any(Function), undefined, expect.any(Function));
+            });
+            it('should pass notify option to watch', async () => {
+                args.notify = 'http://notify.url';
+                await watchCommand.handler(args);
+                expect(watchSpy).toHaveBeenCalledWith(123456, expect.any(String), expect.any(String), expect.objectContaining({
+                    notify: 'http://notify.url',
+                }), null, expect.any(Function), undefined, expect.any(Function));
+            });
+            it('should pass convertFields to getUploadableFileList', async () => {
+                args.initialUpload = true;
+                args.convertFields = true;
+                await watchCommand.handler(args);
+                expect(getUploadableFileListSpy).toHaveBeenCalledWith(expect.any(String), true);
+            });
+            it('should pass command options to watch', async () => {
+                args.saveOutput = true;
+                args.fieldOptions = ['option1'];
+                await watchCommand.handler(args);
+                expect(watchSpy).toHaveBeenCalledWith(123456, expect.any(String), expect.any(String), expect.objectContaining({
+                    commandOptions: expect.objectContaining({
+                        saveOutput: true,
+                        fieldOptions: ['option1'],
+                    }),
+                }), null, expect.any(Function), undefined, expect.any(Function));
+            });
+        });
+        describe('error handlers', () => {
+            it('should provide error handler for folder errors', async () => {
+                await watchCommand.handler(args);
+                const folderErrorHandler = watchSpy.mock.calls[0][5];
+                const error = new AxiosError('Folder error');
+                // @ts-expect-error Axios version mismatch between test and implementation
+                folderErrorHandler?.(error);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('failures'));
+            });
+            it('should provide error handler factory for file errors', async () => {
+                await watchCommand.handler(args);
+                const fileErrorHandlerFactory = watchSpy.mock.calls[0][7];
+                const fileErrorHandler = fileErrorHandlerFactory?.('test.js', '/dest/test.js', 123456);
+                const error = new AxiosError('File error');
+                // @ts-expect-error Axios version mismatch between test and implementation
+                fileErrorHandler?.(error);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('test.js'));
+            });
+        });
+    });
+});

package/commands/cms/app/create.d.ts

@@ -0,0 +1,9 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type AppCreateArgs = CommonArgs & ConfigArgs & {
+    type: string;
+    name?: string;
+    dest?: string;
+    internal?: boolean;
+};
+declare const appCreateCommand: YargsCommandModule<unknown, AppCreateArgs>;
+export default appCreateCommand;

package/commands/cms/app/create.js

@@ -0,0 +1,81 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const APP_ASSET_TYPES = ['api-sample', 'app', 'react-app', 'vue-app'];
+const command = 'create <type> [name] [dest]';
+const describe = commands.cms.subcommands.app.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, name, internal: getInternalVersion, type, dest, } = args;
+    const assetType = type.toLowerCase();
+    if (!assetType || !APP_ASSET_TYPES.includes(assetType)) {
+        uiLogger.error(commands.cms.subcommands.app.subcommands.create.errors.unsupportedAssetType(assetType, APP_ASSET_TYPES.filter(t => !assets[t].hidden).join(', ')));
+        return;
+    }
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        name,
+        dest,
+        getInternalVersion: getInternalVersion || false,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.app.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    if (asset.validate && !asset.validate(argsToPass))
+        return;
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function appCreateBuilder(yargs) {
+    yargs.positional('type', {
+        describe: commands.cms.subcommands.app.subcommands.create.positionals.type,
+        type: 'string',
+        choices: APP_ASSET_TYPES,
+    });
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.app.subcommands.create.positionals.name,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.app.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('internal', {
+        describe: 'Internal HubSpot version of creation command',
+        type: 'boolean',
+        hidden: true,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(appCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const appCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default appCreateCommand;

package/commands/cms/app.d.ts

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

package/commands/cms/app.js

@@ -0,0 +1,17 @@
+import createCommand from './app/create.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = ['app', 'apps'];
+const describe = commands.cms.subcommands.app.describe;
+function appBuilder(yargs) {
+    yargs.command(createCommand).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(appBuilder, command, describe);
+const appCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default appCommand;

package/commands/cms/convertFields.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ConvertFieldsArgs = CommonArgs & {
+    src: string;
+    fieldOptions: string[];
+};
+declare const convertFieldsCommand: YargsCommandModule<unknown, ConvertFieldsArgs>;
+export default convertFieldsCommand;