@hubspot/cli 7.7.27-experimental.2 → 7.7.29-experimental.0

package/lib/projects/urls.d.ts

@@ -6,3 +6,4 @@ export declare function getProjectActivityUrl(projectName: string, accountId: nu
 export declare function getProjectBuildDetailUrl(projectName: string, buildId: number, accountId: number): string;
 export declare function getProjectDeployDetailUrl(projectName: string, deployId: number, accountId: number): string;
 export declare function getLocalDevUiUrl(accountId: number, showWelcomeScreen?: boolean): string;
+export declare function getAccountHomeUrl(accountId: number): string;

package/lib/projects/urls.js

@@ -37,3 +37,7 @@ export function getProjectDeployDetailUrl(projectName, deployId, accountId) {
 export function getLocalDevUiUrl(accountId, showWelcomeScreen) {
     return `${getBaseUrl(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
 }
+export function getAccountHomeUrl(accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    return `${baseUrl}/home?portalId=${accountId}`;
+}

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/confirmImportDataPrompt.d.ts

@@ -0,0 +1 @@
+export declare function confirmImportDataPrompt(targetAccountId: number, dataFileNames: string[]): Promise<boolean>;

package/lib/prompts/confirmImportDataPrompt.js

@@ -0,0 +1,12 @@
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export async function confirmImportDataPrompt(targetAccountId, dataFileNames) {
+    const account = getAccountConfig(targetAccountId);
+    const { confirmImportData } = await promptUser({
+        type: 'confirm',
+        name: 'confirmImportData',
+        message: lib.prompts.confirmImportDataPrompt.message(dataFileNames, account),
+    });
+    return confirmImportData;
+}

package/lib/prompts/createFunctionPrompt.d.ts

@@ -1,8 +1,9 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateFunctionPromptResponse = {
     functionsFolder: string;
     filename: string;
     endpointMethod: string;
     endpointPath: string;
 };
-export declare function createFunctionPrompt(): Promise<CreateFunctionPromptResponse>;
+export declare function createFunctionPrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateFunctionPromptResponse>;
 export {};

package/lib/prompts/createFunctionPrompt.js

@@ -55,11 +55,40 @@ const ENDPOINT_PATH_PROMPT = {
         return true;
     },
 };
-export function createFunctionPrompt() {
-    return promptUser([
-        FUNCTIONS_FOLDER_PROMPT,
-        FUNCTION_FILENAME_PROMPT,
-        ENDPOINT_METHOD_PROMPT,
-        ENDPOINT_PATH_PROMPT,
-    ]);
+export function createFunctionPrompt(commandArgs = {}) {
+    // Check if all required parameters are provided (endpointMethod has default)
+    const hasAllRequired = commandArgs.functionsFolder &&
+        commandArgs.filename &&
+        commandArgs.endpointPath;
+    if (hasAllRequired) {
+        return Promise.resolve({
+            functionsFolder: commandArgs.functionsFolder,
+            filename: commandArgs.filename,
+            endpointMethod: commandArgs.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath,
+        });
+    }
+    const prompts = [];
+    // Only prompt for missing parameters
+    if (!commandArgs.functionsFolder) {
+        prompts.push(FUNCTIONS_FOLDER_PROMPT);
+    }
+    if (!commandArgs.filename) {
+        prompts.push(FUNCTION_FILENAME_PROMPT);
+    }
+    if (!commandArgs.endpointMethod) {
+        prompts.push(ENDPOINT_METHOD_PROMPT);
+    }
+    if (!commandArgs.endpointPath) {
+        prompts.push(ENDPOINT_PATH_PROMPT);
+    }
+    return promptUser(prompts).then(promptResponse => {
+        // Merge prompted values with provided commandArgs
+        return {
+            functionsFolder: commandArgs.functionsFolder || promptResponse.functionsFolder,
+            filename: commandArgs.filename || promptResponse.filename,
+            endpointMethod: commandArgs.endpointMethod || promptResponse.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath || promptResponse.endpointPath,
+        };
+    });
 }

package/lib/prompts/createModulePrompt.d.ts

@@ -1,3 +1,4 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateModulePromptResponse = {
     moduleLabel: string;
     reactType: boolean;
@@ -5,5 +6,5 @@ type CreateModulePromptResponse = {
     global: boolean;
     availableForNewContent: boolean;
 };
-export declare function createModulePrompt(): Promise<CreateModulePromptResponse>;
+export declare function createModulePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateModulePromptResponse>;
 export {};

package/lib/prompts/createModulePrompt.js

@@ -58,7 +58,54 @@ const AVAILABLE_FOR_NEW_CONTENT = {
     message: i18n(`lib.prompts.createModulePrompt.availableForNewContent`),
     default: true,
 };
-export function createModulePrompt() {
+export function createModulePrompt(commandArgs = {}) {
+    // Check if moduleLabel is provided (main requirement to skip full prompting)
+    // but still allow individual parameter prompting for enhanced UX
+    if (commandArgs.moduleLabel) {
+        const prompts = [];
+        // Only prompt for parameters not explicitly provided
+        if (commandArgs.reactType === undefined) {
+            prompts.push(REACT_TYPE_PROMPT);
+        }
+        if (!commandArgs.contentTypes) {
+            prompts.push(CONTENT_TYPES_PROMPT);
+        }
+        if (commandArgs.global === undefined) {
+            prompts.push(GLOBAL_PROMPT);
+        }
+        if (commandArgs.availableForNewContent === undefined) {
+            prompts.push(AVAILABLE_FOR_NEW_CONTENT);
+        }
+        // If no additional prompts needed, return with defaults
+        if (prompts.length === 0) {
+            const contentTypesArray = commandArgs.contentTypes
+                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
+                : ['ANY'];
+            return Promise.resolve({
+                moduleLabel: commandArgs.moduleLabel,
+                reactType: commandArgs.reactType ?? false,
+                contentTypes: contentTypesArray,
+                global: commandArgs.global ?? false,
+                availableForNewContent: commandArgs.availableForNewContent ?? true,
+            });
+        }
+        // Prompt only for missing optional parameters
+        return promptUser(prompts).then(promptResponse => {
+            const contentTypesArray = commandArgs.contentTypes
+                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
+                : promptResponse.contentTypes || ['ANY'];
+            return {
+                moduleLabel: commandArgs.moduleLabel,
+                reactType: commandArgs.reactType ?? promptResponse.reactType ?? false,
+                contentTypes: contentTypesArray,
+                global: commandArgs.global ?? promptResponse.global ?? false,
+                availableForNewContent: commandArgs.availableForNewContent ??
+                    promptResponse.availableForNewContent ??
+                    true,
+            };
+        });
+    }
+    // No moduleLabel provided, prompt for everything (original behavior)
     return promptUser([
         MODULE_LABEL_PROMPT,
         REACT_TYPE_PROMPT,

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,27 +1,6 @@
-declare const templateTypeChoices: [{
-    readonly name: "page";
-    readonly value: "page-template";
-}, {
-    readonly name: "email";
-    readonly value: "email-template";
-}, {
-    readonly name: "partial";
-    readonly value: "partial";
-}, {
-    readonly name: "global partial";
-    readonly value: "global-partial";
-}, {
-    readonly name: "blog listing";
-    readonly value: "blog-listing-template";
-}, {
-    readonly name: "blog post";
-    readonly value: "blog-post-template";
-}, {
-    readonly name: "search results";
-    readonly value: "search-template";
-}];
+import { CreateArgs, TemplateType } from '../../types/Cms.js';
 interface CreateTemplatePromptResponse {
-    templateType: (typeof templateTypeChoices)[number]['value'];
+    templateType: TemplateType;
 }
-export declare function createTemplatePrompt(): Promise<CreateTemplatePromptResponse>;
+export declare function createTemplatePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateTemplatePromptResponse>;
 export {};

package/lib/prompts/createTemplatePrompt.js

@@ -8,6 +8,7 @@ const templateTypeChoices = [
     { name: 'blog listing', value: 'blog-listing-template' },
     { name: 'blog post', value: 'blog-post-template' },
     { name: 'search results', value: 'search-template' },
+    { name: 'section', value: 'section' },
 ];
 const TEMPLATE_TYPE_PROMPT = {
     type: 'list',
@@ -16,6 +17,13 @@ const TEMPLATE_TYPE_PROMPT = {
     default: 'page',
     choices: templateTypeChoices,
 };
-export function createTemplatePrompt() {
+export function createTemplatePrompt(commandArgs = {}) {
+    // If templateType is provided, return it directly
+    if (commandArgs.templateType) {
+        return Promise.resolve({
+            templateType: commandArgs.templateType,
+        });
+    }
+    // No templateType provided, prompt for it (original behavior)
     return promptUser([TEMPLATE_TYPE_PROMPT]);
 }

package/lib/prompts/importDataFilePathPrompt.d.ts

@@ -0,0 +1 @@
+export declare function importDataFilePathPrompt(): Promise<string>;

package/lib/prompts/importDataFilePathPrompt.js

@@ -0,0 +1,24 @@
+import { validateImportRequestFile } from '@hubspot/local-dev-lib/crm';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { logError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+export async function importDataFilePathPrompt() {
+    uiLogger.log(lib.prompts.importDataFilePathPrompt.promptContext);
+    const { filePath } = await promptUser({
+        type: 'input',
+        name: 'filePath',
+        message: lib.prompts.importDataFilePathPrompt.promptMessage,
+        validate: (filePath) => {
+            try {
+                validateImportRequestFile(filePath);
+                return true;
+            }
+            catch (error) {
+                logError(error);
+                return false;
+            }
+        },
+    });
+    return filePath;
+}