@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/projects/watch.js

@@ -1,23 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatcher = createWatcher;
-const chokidar_1 = __importDefault(require("chokidar"));
-const path_1 = __importDefault(require("path"));
-const chalk_1 = __importDefault(require("chalk"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const path_2 = require("@hubspot/local-dev-lib/path");
-const extensions_1 = require("@hubspot/local-dev-lib/constants/extensions");
-const ignoreRules_1 = require("@hubspot/local-dev-lib/ignoreRules");
-const projects_1 = require("@hubspot/local-dev-lib/api/projects");
-const index_1 = require("@hubspot/local-dev-lib/errors/index");
-const errorHandlers_1 = require("../errorHandlers");
-const constants_1 = require("../constants");
-const en_1 = require("../../lang/en");
-const logger_1 = require("../ui/logger");
-const queue = new p_queue_1.default({
+import chokidar from 'chokidar';
+import path from 'path';
+import chalk from 'chalk';
+import PQueue from 'p-queue';
+import { isAllowedExtension } from '@hubspot/local-dev-lib/path';
+import { JSR_ALLOWED_EXTENSIONS } from '@hubspot/local-dev-lib/constants/extensions';
+import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
+import { cancelStagedBuild, provisionBuild, uploadFileToBuild, deleteFileFromBuild, queueBuild, } from '@hubspot/local-dev-lib/api/projects';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { PROJECT_ERROR_TYPES } from '../constants.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+const queue = new PQueue({
     concurrency: 10,
 });
 const standbyQueue = [];
@@ -43,22 +37,22 @@ function debounceQueueBuild(accountId, projectName, platformVersion) {
         clearTimeout(timer);
     }
     timer = setTimeout(async () => {
-        logger_1.uiLogger.debug(en_1.commands.project.watch.debug.pause);
+        uiLogger.debug(commands.project.watch.debug.pause);
         queue.pause();
         await queue.onIdle();
         try {
-            await (0, projects_1.queueBuild)(accountId, projectName, platformVersion);
-            logger_1.uiLogger.debug(en_1.commands.project.watch.debug.buildStarted);
+            await queueBuild(accountId, projectName, platformVersion);
+            uiLogger.debug(commands.project.watch.debug.buildStarted);
         }
         catch (err) {
-            if ((0, index_1.isSpecifiedError)(err, {
-                subCategory: constants_1.PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
+            if (isSpecifiedError(err, {
+                subCategory: PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
             })) {
-                logger_1.uiLogger.log(en_1.commands.project.watch.logs.watchCancelledFromUi);
+                uiLogger.log(commands.project.watch.logs.watchCancelledFromUi);
                 process.exit(0);
             }
             else {
-                (0, errorHandlers_1.logError)(err, new errorHandlers_1.ApiErrorContext({ accountId }));
+                logError(err, new ApiErrorContext({ accountId }));
             }
             return;
         }
@@ -68,63 +62,63 @@ function debounceQueueBuild(accountId, projectName, platformVersion) {
             await processStandByQueue(accountId, projectName, platformVersion);
         }
         queue.start();
-        logger_1.uiLogger.log(en_1.commands.project.watch.logs.resuming);
-        logger_1.uiLogger.log(`\n> Press ${chalk_1.default.bold('q')} to quit watching\n`);
+        uiLogger.log(commands.project.watch.logs.resuming);
+        uiLogger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
     }, 2000);
 }
 async function queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action) {
     if (action === 'upload' &&
-        !(0, path_2.isAllowedExtension)(filePath, Array.from(extensions_1.JSR_ALLOWED_EXTENSIONS))) {
-        logger_1.uiLogger.debug(en_1.commands.project.watch.debug.extensionNotAllowed(filePath));
+        !isAllowedExtension(filePath, Array.from(JSR_ALLOWED_EXTENSIONS))) {
+        uiLogger.debug(commands.project.watch.debug.extensionNotAllowed(filePath));
         return;
     }
-    if ((0, ignoreRules_1.shouldIgnoreFile)(filePath, true)) {
-        logger_1.uiLogger.debug(en_1.commands.project.watch.debug.ignored(filePath));
+    if (shouldIgnoreFile(filePath, true)) {
+        uiLogger.debug(commands.project.watch.debug.ignored(filePath));
         return;
     }
     if (!queue.isPaused) {
         debounceQueueBuild(accountId, projectName, platformVersion);
     }
-    logger_1.uiLogger.debug(en_1.commands.project.watch.debug.uploading(filePath, remotePath));
+    uiLogger.debug(commands.project.watch.debug.uploading(filePath, remotePath));
     return queue.add(async () => {
         try {
             if (action === 'upload') {
-                await (0, projects_1.uploadFileToBuild)(accountId, projectName, filePath, remotePath);
+                await uploadFileToBuild(accountId, projectName, filePath, remotePath);
             }
             else if (action === 'deleteFile' || action === 'deleteFolder') {
-                await (0, projects_1.deleteFileFromBuild)(accountId, projectName, remotePath);
+                await deleteFileFromBuild(accountId, projectName, remotePath);
             }
-            logger_1.uiLogger.log(
+            uiLogger.log(
             // @ts-expect-error
-            en_1.commands.project.watch.logs[`${action}Succeeded`](remotePath, filePath));
+            commands.project.watch.logs[`${action}Succeeded`](remotePath, filePath));
         }
         catch (err) {
-            logger_1.uiLogger.debug(
+            uiLogger.debug(
             // @ts-expect-error
-            en_1.commands.project.watch.errors[`${action}Failed`](remotePath, filePath));
+            commands.project.watch.errors[`${action}Failed`](remotePath, filePath));
         }
     });
 }
 async function createNewBuild(accountId, projectName, platformVersion) {
     try {
-        logger_1.uiLogger.debug(en_1.commands.project.watch.debug.attemptNewBuild);
-        const { data: { buildId }, } = await (0, projects_1.provisionBuild)(accountId, projectName, platformVersion);
+        uiLogger.debug(commands.project.watch.debug.attemptNewBuild);
+        const { data: { buildId }, } = await provisionBuild(accountId, projectName, platformVersion);
         return buildId;
     }
     catch (err) {
-        (0, errorHandlers_1.logError)(err, new errorHandlers_1.ApiErrorContext({ accountId }));
-        if ((0, index_1.isSpecifiedError)(err, { subCategory: constants_1.PROJECT_ERROR_TYPES.PROJECT_LOCKED })) {
-            await (0, projects_1.cancelStagedBuild)(accountId, projectName);
-            logger_1.uiLogger.log(en_1.commands.project.watch.logs.previousStagingBuildCancelled);
+        logError(err, new ApiErrorContext({ accountId }));
+        if (isSpecifiedError(err, { subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED })) {
+            await cancelStagedBuild(accountId, projectName);
+            uiLogger.log(commands.project.watch.logs.previousStagingBuildCancelled);
         }
         process.exit(1);
     }
 }
 async function handleWatchEvent(accountId, projectName, platformVersion, projectSourceDir, filePath, action = 'upload') {
-    const remotePath = path_1.default.relative(projectSourceDir, filePath);
+    const remotePath = path.relative(projectSourceDir, filePath);
     if (queue.isPaused) {
         if (standbyQueue.find(file => file.filePath === filePath)) {
-            logger_1.uiLogger.debug(en_1.commands.project.watch.debug.fileAlreadyQueued(filePath));
+            uiLogger.debug(commands.project.watch.debug.fileAlreadyQueued(filePath));
         }
         else {
             standbyQueue.push({
@@ -138,18 +132,18 @@ async function handleWatchEvent(accountId, projectName, platformVersion, project
         await queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action);
     }
 }
-async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn) {
-    const projectSourceDir = path_1.default.join(projectDir, projectConfig.srcDir);
+export async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn) {
+    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
     handleBuildStatus = handleBuildStatusFn;
     handleUserInput = handleUserInputFn;
     await createNewStagingBuild(accountId, projectConfig.name, projectConfig.platformVersion);
-    const watcher = chokidar_1.default.watch(projectSourceDir, {
+    const watcher = chokidar.watch(projectSourceDir, {
         ignoreInitial: true,
-        ignored: file => (0, ignoreRules_1.shouldIgnoreFile)(file),
+        ignored: file => shouldIgnoreFile(file),
     });
     watcher.on('ready', async () => {
-        logger_1.uiLogger.log(en_1.commands.project.watch.logs.watching(projectDir));
-        logger_1.uiLogger.log(`\n> Press ${chalk_1.default.bold('q')} to quit watching\n`);
+        uiLogger.log(commands.project.watch.logs.watching(projectDir));
+        uiLogger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
     });
     watcher.on('add', async (path) => {
         handleWatchEvent(accountId, projectConfig.name, projectConfig.platformVersion, projectSourceDir, path);

package/lib/prompts/__tests__/createFunctionPrompt.test.d.ts

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

package/lib/prompts/__tests__/createFunctionPrompt.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createFunctionPrompt } from '../createFunctionPrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createFunctionPrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when all parameters are provided', () => {
+        it('should return provided values without prompting', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointMethod: 'POST',
+                endpointPath: '/api/test',
+            };
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointMethod: 'POST',
+                endpointPath: '/api/test',
+            });
+        });
+        it('should use default GET method when endpointMethod not provided', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointPath: '/api/test',
+            };
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                functionsFolder: 'my-functions',
+                filename: 'my-function',
+                endpointMethod: 'GET',
+                endpointPath: '/api/test',
+            });
+        });
+    });
+    describe('when some parameters are missing', () => {
+        it('should only prompt for missing parameters', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-functions',
+                endpointMethod: 'POST',
+            };
+            mockPromptUser.mockResolvedValue({
+                filename: 'prompted-function',
+                endpointPath: '/prompted-path',
+            });
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'filename' }),
+                expect.objectContaining({ name: 'endpointPath' }),
+            ]);
+            expect(result).toEqual({
+                functionsFolder: 'my-functions',
+                filename: 'prompted-function',
+                endpointMethod: 'POST',
+                endpointPath: '/prompted-path',
+            });
+        });
+    });
+    describe('when no parameters are provided', () => {
+        it('should prompt for all parameters', async () => {
+            mockPromptUser.mockResolvedValue({
+                functionsFolder: 'prompted-functions',
+                filename: 'prompted-function',
+                endpointMethod: 'GET',
+                endpointPath: '/prompted-path',
+            });
+            const result = await createFunctionPrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'functionsFolder' }),
+                expect.objectContaining({ name: 'filename' }),
+                expect.objectContaining({ name: 'endpointMethod' }),
+                expect.objectContaining({ name: 'endpointPath' }),
+            ]);
+            expect(result).toEqual({
+                functionsFolder: 'prompted-functions',
+                filename: 'prompted-function',
+                endpointMethod: 'GET',
+                endpointPath: '/prompted-path',
+            });
+        });
+    });
+    describe('parameter precedence', () => {
+        it('should prioritize command args over prompted values', async () => {
+            const commandArgs = {
+                functionsFolder: 'arg-functions',
+            };
+            mockPromptUser.mockResolvedValue({
+                filename: 'prompted-function',
+                endpointMethod: 'POST',
+                endpointPath: '/prompted-path',
+            });
+            const result = await createFunctionPrompt(commandArgs);
+            expect(result).toEqual({
+                functionsFolder: 'arg-functions', // from commandArgs
+                filename: 'prompted-function', // from prompt
+                endpointMethod: 'POST', // from prompt
+                endpointPath: '/prompted-path', // from prompt
+            });
+        });
+        it('should handle mixed scenario with partial command args and prompting', async () => {
+            const commandArgs = {
+                functionsFolder: 'my-funcs',
+                endpointMethod: 'DELETE',
+            };
+            mockPromptUser.mockResolvedValue({
+                filename: 'delete-handler',
+                endpointPath: '/api/delete',
+            });
+            const result = await createFunctionPrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'filename' }),
+                expect.objectContaining({ name: 'endpointPath' }),
+            ]);
+            expect(result).toEqual({
+                functionsFolder: 'my-funcs', // from commandArgs
+                filename: 'delete-handler', // from prompt
+                endpointMethod: 'DELETE', // from commandArgs
+                endpointPath: '/api/delete', // from prompt
+            });
+        });
+    });
+});

package/lib/prompts/__tests__/createModulePrompt.test.d.ts

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

package/lib/prompts/__tests__/createModulePrompt.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createModulePrompt } from '../createModulePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createModulePrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when all parameters are provided', () => {
+        it('should return provided values without prompting', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: 'LANDING_PAGE,SITE_PAGE',
+                global: false,
+                availableForNewContent: true,
+            };
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: ['LANDING_PAGE', 'SITE_PAGE'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+        it('should use default values when optional parameters not provided', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+        it('should parse contentTypes string correctly', async () => {
+            const commandArgs = {
+                moduleLabel: 'Test Module',
+                contentTypes: 'BLOG_POST, EMAIL, LANDING_PAGE',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(result.contentTypes).toEqual([
+                'BLOG_POST',
+                'EMAIL',
+                'LANDING_PAGE',
+            ]);
+        });
+    });
+    describe('when some parameters are missing', () => {
+        it('should only prompt for missing parameters', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+                reactType: true,
+            };
+            mockPromptUser.mockResolvedValue({
+                contentTypes: ['SITE_PAGE'],
+                global: true,
+                availableForNewContent: false,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: ['SITE_PAGE'],
+                global: true,
+                availableForNewContent: false,
+            });
+        });
+    });
+    describe('when no parameters are provided', () => {
+        it('should prompt for all parameters', async () => {
+            mockPromptUser.mockResolvedValue({
+                moduleLabel: 'Prompted Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'moduleLabel' }),
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'Prompted Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+    });
+    describe('parameter precedence', () => {
+        it('should prioritize command args over prompted values', async () => {
+            const commandArgs = {
+                moduleLabel: 'Args Module',
+                global: true,
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                contentTypes: ['EMAIL'],
+                availableForNewContent: false,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(result).toEqual({
+                moduleLabel: 'Args Module', // from commandArgs
+                reactType: false, // from prompt
+                contentTypes: ['EMAIL'], // from prompt
+                global: true, // from commandArgs
+                availableForNewContent: false, // from prompt
+            });
+        });
+        it('should handle boolean false values correctly', async () => {
+            const commandArgs = {
+                moduleLabel: 'Test Module',
+                reactType: false,
+                contentTypes: 'ANY',
+                global: false,
+                availableForNewContent: false,
+            };
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                moduleLabel: 'Test Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: false,
+            });
+        });
+        it('should handle mixed scenario with partial command args and prompting', async () => {
+            const commandArgs = {
+                moduleLabel: 'Partial Module',
+                contentTypes: 'BLOG_POST,BLOG_LISTING',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: true,
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'Partial Module', // from commandArgs
+                reactType: true, // from prompt
+                contentTypes: ['BLOG_POST', 'BLOG_LISTING'], // from commandArgs (parsed)
+                global: false, // from prompt
+                availableForNewContent: true, // from prompt
+            });
+        });
+    });
+});

package/lib/prompts/__tests__/createTemplatePrompt.test.d.ts

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

package/lib/prompts/__tests__/createTemplatePrompt.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTemplatePrompt } from '../createTemplatePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createTemplatePrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when templateType is provided', () => {
+        it('should return provided templateType without prompting', async () => {
+            const commandArgs = {
+                templateType: 'page-template',
+            };
+            const result = await createTemplatePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                templateType: 'page-template',
+            });
+        });
+        it('should work with different template types', async () => {
+            const testCases = [
+                'email-template',
+                'partial',
+                'global-partial',
+                'blog-listing-template',
+                'blog-post-template',
+                'search-template',
+                'section',
+            ];
+            for (const templateType of testCases) {
+                const commandArgs = { templateType };
+                const result = await createTemplatePrompt(commandArgs);
+                expect(mockPromptUser).not.toHaveBeenCalled();
+                expect(result).toEqual({ templateType });
+                vi.resetAllMocks();
+            }
+        });
+    });
+    describe('when templateType is not provided', () => {
+        it('should prompt for templateType', async () => {
+            mockPromptUser.mockResolvedValue({
+                templateType: 'page-template',
+            });
+            const result = await createTemplatePrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'templateType',
+                    type: 'list',
+                    choices: expect.any(Array),
+                }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'page-template',
+            });
+        });
+        it('should prompt when commandArgs is empty', async () => {
+            mockPromptUser.mockResolvedValue({
+                templateType: 'email-template',
+            });
+            const result = await createTemplatePrompt({});
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'templateType' }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'email-template',
+            });
+        });
+        it('should prompt when templateType is undefined', async () => {
+            const commandArgs = {
+                templateType: undefined,
+            };
+            mockPromptUser.mockResolvedValue({
+                templateType: 'partial',
+            });
+            const result = await createTemplatePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'templateType' }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'partial',
+            });
+        });
+    });
+    describe('integration scenarios', () => {
+        it('should handle mixed usage patterns', async () => {
+            // First call with templateType provided
+            let result = await createTemplatePrompt({
+                templateType: 'blog-post-template',
+            });
+            expect(result.templateType).toBe('blog-post-template');
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            // Second call without templateType
+            mockPromptUser.mockResolvedValue({
+                templateType: 'section',
+            });
+            result = await createTemplatePrompt();
+            expect(result.templateType).toBe('section');
+            expect(mockPromptUser).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/lib/prompts/__tests__/downloadProjectPrompt.test.d.ts

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

package/lib/prompts/__tests__/downloadProjectPrompt.test.js

@@ -0,0 +1,28 @@
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
+import { downloadProjectPrompt } from '../downloadProjectPrompt.js';
+vi.mock('../promptUtils', () => ({
+    promptUser: vi.fn().mockResolvedValue({ project: 'test-project' }),
+}));
+vi.mock('@hubspot/local-dev-lib/api/projects', () => ({
+    fetchProjects: vi.fn().mockResolvedValue({
+        data: { results: [] },
+    }),
+}));
+vi.mock('@hubspot/local-dev-lib/config', () => ({
+    getAccountId: vi.fn().mockImplementation(() => 123456789),
+}));
+describe('lib/prompts/downloadProjectPrompt', () => {
+    it('should honor the account passed as an option', async () => {
+        const account = 'Prod';
+        await downloadProjectPrompt({ account });
+        expect(getAccountId).toHaveBeenCalledTimes(1);
+        expect(getAccountId).toHaveBeenCalledWith(account);
+    });
+    it('should fetch the projects for the correct accountId', async () => {
+        const account = 'Prod';
+        await downloadProjectPrompt({ account });
+        expect(fetchProjects).toHaveBeenCalledTimes(1);
+        expect(fetchProjects).toHaveBeenCalledWith(123456789);
+    });
+});

package/lib/prompts/__tests__/projectAddPrompt.test.d.ts

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