@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -0,0 +1,146 @@
+import { Separator } from '@inquirer/prompts';
+import { lib } from '../../lang/en.js';
+import { promptUser } from './promptUtils.js';
+const hubs = {
+    MARKETING: 'marketingLevel',
+    OPS: 'opsLevel',
+    SERVICE: 'serviceLevel',
+    SALES: 'salesLevel',
+    CONTENT: 'contentLevel',
+};
+const AccountTiers = {
+    FREE: 'FREE',
+    STARTER: 'STARTER',
+    PROFESSIONAL: 'PROFESSIONAL',
+    ENTERPRISE: 'ENTERPRISE',
+};
+const makeHubTiers = (hubKey) => {
+    const hubTypeKey = hubKey.toLowerCase();
+    const hubName = lib.prompts.createDeveloperTestAccountConfigPrompt.hubTypes[hubTypeKey];
+    return [
+        {
+            name: `${hubName} [${AccountTiers.FREE}]`,
+            value: { hub: hubKey, tier: AccountTiers.FREE },
+        },
+        {
+            name: `${hubName} [${AccountTiers.STARTER}]`,
+            value: { hub: hubKey, tier: AccountTiers.STARTER },
+        },
+        {
+            name: `${hubName} [${AccountTiers.PROFESSIONAL}]`,
+            value: { hub: hubKey, tier: AccountTiers.PROFESSIONAL },
+        },
+        {
+            name: `${hubName} [${AccountTiers.ENTERPRISE}]`,
+            value: { hub: hubKey, tier: AccountTiers.ENTERPRISE },
+        },
+    ];
+};
+const TEST_ACCOUNT_TIERS = [
+    ...makeHubTiers('MARKETING'),
+    new Separator(),
+    ...makeHubTiers('OPS'),
+    new Separator(),
+    ...makeHubTiers('SERVICE'),
+    new Separator(),
+    ...makeHubTiers('SALES'),
+    new Separator(),
+    ...makeHubTiers('CONTENT'),
+    new Separator(),
+];
+export async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
+    const { name, description } = args;
+    let accountName = name;
+    let accountDescription = description;
+    let accountLevelsArray = [];
+    if (!accountName) {
+        const namePromptResult = await promptUser({
+            name: 'accountName',
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
+            type: 'input',
+            validate: value => {
+                if (!value) {
+                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                        .nameRequired;
+                }
+                return true;
+            },
+        });
+        accountName = namePromptResult.accountName;
+    }
+    if (!accountDescription) {
+        const descriptionPromptResult = await promptUser({
+            name: 'description',
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
+            type: 'input',
+        });
+        accountDescription = descriptionPromptResult.description;
+    }
+    const useDefaultAccountLevelsPromptResult = await promptUser({
+        name: 'useDefaultAccountLevels',
+        message: lib.prompts.createDeveloperTestAccountConfigPrompt
+            .useDefaultAccountLevelsPrompt.message,
+        type: 'list',
+        choices: [
+            {
+                name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                    .useDefaultAccountLevelsPrompt.default,
+                value: 'default',
+            },
+            {
+                name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                    .useDefaultAccountLevelsPrompt.manual,
+                value: 'manual',
+            },
+        ],
+    });
+    if (useDefaultAccountLevelsPromptResult.useDefaultAccountLevels === 'default') {
+        accountLevelsArray = [
+            { hub: 'MARKETING', tier: AccountTiers.ENTERPRISE },
+            { hub: 'OPS', tier: AccountTiers.ENTERPRISE },
+            { hub: 'SERVICE', tier: AccountTiers.ENTERPRISE },
+            { hub: 'SALES', tier: AccountTiers.ENTERPRISE },
+            { hub: 'CONTENT', tier: AccountTiers.ENTERPRISE },
+        ];
+    }
+    else {
+        const accountLevelsPromptResult = await promptUser({
+            name: 'testAccountLevels',
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
+            type: 'checkbox',
+            pageSize: 13,
+            choices: TEST_ACCOUNT_TIERS,
+            loop: false,
+            validate: choices => {
+                if (choices?.length < Object.keys(hubs).length) {
+                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                        .allHubsRequired;
+                }
+                else {
+                    const hubMap = {};
+                    for (const choice of choices) {
+                        const { hub } = choice.value;
+                        if (hubMap[hub]) {
+                            return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                                .tiersError;
+                        }
+                        hubMap[hub] = true;
+                    }
+                }
+                return true;
+            },
+        });
+        accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
+    }
+    const accountLevels = accountLevelsArray.reduce((acc, level) => {
+        const { hub: hubName, tier: hubTier } = level;
+        const hubLevel = hubs[hubName];
+        acc[hubLevel] = hubTier;
+        return acc;
+    }, {});
+    return {
+        accountName: accountName,
+        description: accountDescription,
+        ...accountLevels,
+    };
+}

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

@@ -1,36 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunctionPrompt = createFunctionPrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
 const FUNCTIONS_FOLDER_PROMPT = {
     name: 'functionsFolder',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.enterFolder`),
+    message: i18n(`lib.prompts.createFunctionPrompt.enterFolder`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.invalid`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.invalid`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.blank`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.blank`);
         }
         else if (val.indexOf(' ') >= 0) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.space`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.space`);
         }
         return true;
     },
 };
 const FUNCTION_FILENAME_PROMPT = {
     name: 'filename',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.enterFilename`),
+    message: i18n(`lib.prompts.createFunctionPrompt.enterFilename`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.invalid`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.invalid`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.blank`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.blank`);
         }
         else if (val.indexOf(' ') >= 0) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.space`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.space`);
         }
         return true;
     },
@@ -38,31 +35,60 @@ const FUNCTION_FILENAME_PROMPT = {
 const ENDPOINT_METHOD_PROMPT = {
     type: 'list',
     name: 'endpointMethod',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.selectEndpointMethod`),
+    message: i18n(`lib.prompts.createFunctionPrompt.selectEndpointMethod`),
     default: 'GET',
     choices: ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'],
 };
 const ENDPOINT_PATH_PROMPT = {
     name: 'endpointPath',
-    message: (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.enterEndpointPath`),
+    message: i18n(`lib.prompts.createFunctionPrompt.enterEndpointPath`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.invalid`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.invalid`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.blank`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.blank`);
         }
         else if (val.indexOf(' ') >= 0) {
-            return (0, lang_1.i18n)(`lib.prompts.createFunctionPrompt.errors.space`);
+            return i18n(`lib.prompts.createFunctionPrompt.errors.space`);
         }
         return true;
     },
 };
-function createFunctionPrompt() {
-    return (0, promptUtils_1.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

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModulePrompt = createModulePrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
 const MODULE_LABEL_PROMPT = {
     name: 'moduleLabel',
-    message: (0, lang_1.i18n)(`lib.prompts.createModulePrompt.enterLabel`),
+    message: i18n(`lib.prompts.createModulePrompt.enterLabel`),
     validate(val) {
         if (typeof val !== 'string') {
-            return (0, lang_1.i18n)(`lib.prompts.createModulePrompt.errors.invalidLabel`);
+            return i18n(`lib.prompts.createModulePrompt.errors.invalidLabel`);
         }
         else if (!val.length) {
-            return (0, lang_1.i18n)(`lib.prompts.createModulePrompt.errors.labelRequired`);
+            return i18n(`lib.prompts.createModulePrompt.errors.labelRequired`);
         }
         return true;
     },
@@ -19,16 +16,15 @@ const MODULE_LABEL_PROMPT = {
 const REACT_TYPE_PROMPT = {
     type: 'confirm',
     name: 'reactType',
-    message: (0, lang_1.i18n)(`lib.prompts.createModulePrompt.selectReactType`),
+    message: i18n(`lib.prompts.createModulePrompt.selectReactType`),
     default: false,
 };
 const CONTENT_TYPES_PROMPT = {
     type: 'checkbox',
     name: 'contentTypes',
-    message: (0, lang_1.i18n)(`lib.prompts.createModulePrompt.selectContentType`),
-    default: ['ANY'],
+    message: i18n(`lib.prompts.createModulePrompt.selectContentType`),
     choices: [
-        { name: 'Any', value: 'ANY' },
+        { name: 'Any', value: 'ANY', checked: true },
         { name: 'Landing page', value: 'LANDING_PAGE' },
         { name: 'Site page', value: 'SITE_PAGE' },
         { name: 'Blog post', value: 'BLOG_POST' },
@@ -46,24 +42,71 @@ const CONTENT_TYPES_PROMPT = {
             if (input.length > 0) {
                 resolve(true);
             }
-            reject((0, lang_1.i18n)(`lib.prompts.createModulePrompt.errors.contentTypeRequired`));
+            reject(i18n(`lib.prompts.createModulePrompt.errors.contentTypeRequired`));
         });
     },
 };
 const GLOBAL_PROMPT = {
     type: 'confirm',
     name: 'global',
-    message: (0, lang_1.i18n)(`lib.prompts.createModulePrompt.confirmGlobal`),
+    message: i18n(`lib.prompts.createModulePrompt.confirmGlobal`),
     default: false,
 };
 const AVAILABLE_FOR_NEW_CONTENT = {
     type: 'confirm',
     name: 'availableForNewContent',
-    message: (0, lang_1.i18n)(`lib.prompts.createModulePrompt.availableForNewContent`),
+    message: i18n(`lib.prompts.createModulePrompt.availableForNewContent`),
     default: true,
 };
-function createModulePrompt() {
-    return (0, promptUtils_1.promptUser)([
+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,
         CONTENT_TYPES_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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTemplatePrompt = createTemplatePrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
 const templateTypeChoices = [
     { name: 'page', value: 'page-template' },
     { name: 'email', value: 'email-template' },
@@ -11,14 +8,22 @@ 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',
     name: 'templateType',
-    message: (0, lang_1.i18n)(`lib.prompts.createTemplatePrompt.selectTemplate`),
+    message: i18n(`lib.prompts.createTemplatePrompt.selectTemplate`),
     default: 'page',
     choices: templateTypeChoices,
 };
-function createTemplatePrompt() {
-    return (0, promptUtils_1.promptUser)([TEMPLATE_TYPE_PROMPT]);
+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/downloadProjectPrompt.js

@@ -1,41 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadProjectPrompt = downloadProjectPrompt;
-const promptUtils_1 = require("./promptUtils");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const projects_1 = require("@hubspot/local-dev-lib/api/projects");
-const index_1 = require("../errorHandlers/index");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const exitCodes_1 = require("../enums/exitCodes");
-const lang_1 = require("../lang");
+import { promptUser } from './promptUtils.js';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { i18n } from '../lang.js';
 async function createProjectsList(accountId) {
     try {
         if (accountId) {
-            const { data: projects } = await (0, projects_1.fetchProjects)(accountId);
+            const { data: projects } = await fetchProjects(accountId);
             return projects.results;
         }
-        logger_1.logger.error((0, lang_1.i18n)(`lib.prompts.downloadProjectPrompt.errors.accountIdRequired`));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        logger.error(i18n(`lib.prompts.downloadProjectPrompt.errors.accountIdRequired`));
+        process.exit(EXIT_CODES.ERROR);
     }
     catch (e) {
-        (0, index_1.logError)(e, accountId ? new index_1.ApiErrorContext({ accountId }) : undefined);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        logError(e, accountId ? new ApiErrorContext({ accountId }) : undefined);
+        process.exit(EXIT_CODES.ERROR);
     }
 }
-async function downloadProjectPrompt(promptOptions) {
-    const accountId = (0, config_1.getAccountId)(promptOptions.account);
+export async function downloadProjectPrompt(promptOptions) {
+    const accountId = getAccountId(promptOptions.account);
     const projectsList = await createProjectsList(accountId);
-    const response = await (0, promptUtils_1.promptUser)([
+    const response = await promptUser([
         {
             name: 'project',
             message: () => {
                 return promptOptions.project &&
                     !projectsList.find(p => p.name === promptOptions.name)
-                    ? (0, lang_1.i18n)(`lib.prompts.downloadProjectPrompt.errors.projectNotFound`, {
+                    ? i18n(`lib.prompts.downloadProjectPrompt.errors.projectNotFound`, {
                         projectName: promptOptions.project,
                         accountId: accountId || '',
                     })
-                    : (0, lang_1.i18n)(`lib.prompts.downloadProjectPrompt.selectProject`);
+                    : i18n(`lib.prompts.downloadProjectPrompt.selectProject`);
             },
             when: !promptOptions.project ||
                 !projectsList.find(p => p.name === promptOptions.project),

package/lib/prompts/importDataFilePathPrompt.d.ts

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

package/lib/prompts/importDataFilePathPrompt.js

@@ -0,0 +1,26 @@
+import { validateImportRequestFile } from '@hubspot/local-dev-lib/crm';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+import { isErrorWithMessageOrReason } from '../errorHandlers/index.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) {
+                if (isErrorWithMessageOrReason(error) && error.message) {
+                    return error.message;
+                }
+                return false;
+            }
+        },
+    });
+    return filePath;
+}

package/lib/prompts/importDataTestAccountSelectPrompt.d.ts

@@ -0,0 +1,3 @@
+export declare function importDataTestAccountSelectPrompt(parentAccountId: number): Promise<{
+    selectedAccountId: number;
+}>;

package/lib/prompts/importDataTestAccountSelectPrompt.js

@@ -0,0 +1,29 @@
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { promptUser } from './promptUtils.js';
+import { getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { uiAccountDescription } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+export async function importDataTestAccountSelectPrompt(parentAccountId) {
+    const accounts = getConfigAccounts();
+    if (!accounts) {
+        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noAccountsFound);
+    }
+    const childAccounts = accounts
+        .filter(account => account.parentAccountId === parentAccountId)
+        .map(account => {
+        return {
+            name: uiAccountDescription(getAccountIdentifier(account)),
+            value: getAccountIdentifier(account),
+        };
+    })
+        .filter(account => account.value !== undefined && account.name !== undefined);
+    if (childAccounts.length === 0) {
+        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noChildTestAccountsFound(parentAccountId));
+    }
+    return promptUser({
+        type: 'list',
+        name: 'selectedAccountId',
+        message: '[--account] Select a developer test account:',
+        choices: childAccounts,
+    });
+}

package/lib/prompts/installAppPrompt.d.ts

@@ -1 +1,7 @@
-export declare function installAppPrompt(installUrl: string, isReinstall?: boolean): Promise<void>;
+export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean, staticAuthInstallOptions?: {
+    testingAccountId: number;
+    projectAccountId: number;
+    projectName: string;
+    appUid: string;
+}): Promise<void>;
+export declare function installAppAutoPrompt(): Promise<boolean>;