@hubspot/cli 7.5.11-experimental.0 → 7.6.0-beta.1

package/lib/projects/upload.js

@@ -4,21 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleProjectUpload = handleProjectUpload;
+exports.validateSourceDirectory = validateSourceDirectory;
+exports.validateNoHSMetaMismatch = validateNoHSMetaMismatch;
+exports.handleTranslate = handleTranslate;
 const archiver_1 = __importDefault(require("archiver"));
 const tmp_1 = __importDefault(require("tmp"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const projects_1 = require("@hubspot/local-dev-lib/api/projects");
 const ignoreRules_1 = require("@hubspot/local-dev-lib/ignoreRules");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
 const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
 const ui_1 = require("../ui");
-const exitCodes_1 = require("../enums/exitCodes");
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
 const errorHandlers_1 = require("../errorHandlers");
 const node_util_1 = __importDefault(require("node:util"));
 const en_1 = require("../../lang/en");
 const ensureProjectExists_1 = require("./ensureProjectExists");
 const logger_1 = require("../ui/logger");
+const buildAndDeploy_1 = require("./buildAndDeploy");
+const exitCodes_1 = require("../enums/exitCodes");
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     SpinniesManager_1.default.init({});
     const accountIdentifier = (0, ui_1.uiAccountDescription)(accountId);
@@ -46,12 +50,21 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
     }
     return { buildId, error };
 }
-async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
+async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
     const srcDir = path_1.default.resolve(projectDir, projectConfig.srcDir);
-    const filenames = fs_extra_1.default.readdirSync(srcDir);
-    if (!filenames || filenames.length === 0) {
-        logger_1.uiLogger.log(en_1.lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    try {
+        validateSourceDirectory(srcDir, projectConfig);
+    }
+    catch (e) {
+        (0, errorHandlers_1.logError)(e);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    try {
+        await validateNoHSMetaMismatch(srcDir, projectConfig);
+    }
+    catch (e) {
+        (0, errorHandlers_1.logError)(e);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     const tempFile = tmp_1.default.fileSync({ postfix: '.zip' });
     logger_1.uiLogger.debug(en_1.lib.projectUpload.handleProjectUpload.compressing(tempFile.name));
@@ -62,21 +75,11 @@ async function handleProjectUpload({ accountId, projectConfig, projectDir, callb
         let intermediateRepresentation;
         if (sendIR) {
             try {
-                intermediateRepresentation = await (0, project_parsing_lib_1.translate)({
-                    projectSourceDir: path_1.default.join(projectDir, projectConfig.srcDir),
-                    platformVersion: projectConfig.platformVersion,
-                    accountId,
-                }, { skipValidation });
-                logger_1.uiLogger.debug(node_util_1.default.inspect(intermediateRepresentation, false, null, true));
+                intermediateRepresentation = await handleTranslate(projectDir, projectConfig, accountId, skipValidation, profile);
             }
             catch (e) {
-                if ((0, project_parsing_lib_1.isTranslationError)(e)) {
-                    logger_1.uiLogger.error(e.toString());
-                }
-                else {
-                    (0, errorHandlers_1.logError)(e);
-                }
-                return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+                (0, errorHandlers_1.logError)(e);
+                process.exit(exitCodes_1.EXIT_CODES.ERROR);
             }
         }
         await (0, ensureProjectExists_1.ensureProjectExists)(accountId, projectConfig.name, {
@@ -110,3 +113,40 @@ async function handleProjectUpload({ accountId, projectConfig, projectDir, callb
     archive.finalize();
     return result;
 }
+function validateSourceDirectory(srcDir, projectConfig) {
+    const filenames = fs_extra_1.default.readdirSync(srcDir);
+    if (!filenames || filenames.length === 0) {
+        const validationError = new Error(en_1.lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
+        validationError.name = 'ProjectValidationError';
+        throw validationError;
+    }
+}
+async function validateNoHSMetaMismatch(srcDir, projectConfig) {
+    const hasHsMetaFiles = await (0, project_parsing_lib_1.projectContainsHsMetaFiles)(srcDir);
+    if (!(0, buildAndDeploy_1.useV3Api)(projectConfig.platformVersion) && hasHsMetaFiles) {
+        const validationError = new Error(en_1.lib.projectUpload.wrongPlatformVersionMetaFiles);
+        validationError.name = 'ProjectValidationError';
+        throw validationError;
+    }
+}
+async function handleTranslate(projectDir, projectConfig, accountId, skipValidation, profile) {
+    try {
+        const intermediateRepresentation = await (0, project_parsing_lib_1.translate)({
+            projectSourceDir: path_1.default.join(projectDir, projectConfig.srcDir),
+            platformVersion: projectConfig.platformVersion,
+            accountId,
+        }, { skipValidation, profile });
+        logger_1.uiLogger.debug(node_util_1.default.inspect(intermediateRepresentation, false, null, true));
+        return intermediateRepresentation;
+    }
+    catch (e) {
+        if ((0, project_parsing_lib_1.isTranslationError)(e)) {
+            const validationError = new Error(e.toString());
+            validationError.name = 'ProjectValidationError';
+            throw validationError;
+        }
+        else {
+            (0, errorHandlers_1.logError)(e);
+        }
+    }
+}

package/lib/projects/urls.d.ts

@@ -1,5 +1,8 @@
+export declare function getProjectComponentDistributionUrl(projectName: string, componentName: string, accountId: number): string;
+export declare function getDeveloperOverviewUrl(accountId: number): string;
 export declare function getProjectDetailUrl(projectName: string, accountId: number): string | undefined;
 export declare function getProjectSettingsUrl(projectName: string, accountId: number): string | undefined;
 export declare function getProjectActivityUrl(projectName: string, accountId: number): string;
 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): string;

package/lib/projects/urls.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectComponentDistributionUrl = getProjectComponentDistributionUrl;
+exports.getDeveloperOverviewUrl = getDeveloperOverviewUrl;
 exports.getProjectDetailUrl = getProjectDetailUrl;
 exports.getProjectSettingsUrl = getProjectSettingsUrl;
 exports.getProjectActivityUrl = getProjectActivityUrl;
 exports.getProjectBuildDetailUrl = getProjectBuildDetailUrl;
 exports.getProjectDeployDetailUrl = getProjectDeployDetailUrl;
+exports.getLocalDevUiUrl = getLocalDevUiUrl;
 const urls_1 = require("@hubspot/local-dev-lib/urls");
 const config_1 = require("@hubspot/local-dev-lib/config");
 const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+function getBaseUrl(accountId) {
+    return (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
+}
 function getProjectHomeUrl(accountId) {
+    return `${getBaseUrl(accountId)}/developer-projects/${accountId}`;
+}
+function getProjectComponentDistributionUrl(projectName, componentName, accountId) {
     const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
-    return `${baseUrl}/developer-projects/${accountId}`;
+    return `${baseUrl}/developer-projects/${accountId}/project/${projectName}/component/${componentName}/distribution`;
+}
+function getDeveloperOverviewUrl(accountId) {
+    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
+    return `${baseUrl}/developer-overview/${accountId}`;
 }
 function getProjectDetailUrl(projectName, accountId) {
     if (!projectName)
@@ -31,3 +44,6 @@ function getProjectBuildDetailUrl(projectName, buildId, accountId) {
 function getProjectDeployDetailUrl(projectName, deployId, accountId) {
     return `${getProjectActivityUrl(projectName, accountId)}/deploy/${deployId}`;
 }
+function getLocalDevUiUrl(accountId) {
+    return `${getBaseUrl(accountId)}/developer-projects-local-dev/${accountId}`;
+}

package/lib/prompts/createApiSamplePrompt.d.ts

@@ -1,12 +1,4 @@
-type SampleChoice = {
-    name: string;
-    description: string;
-    id: string;
-    languages: string[];
-};
-type SampleConfig = {
-    samples: SampleChoice[];
-};
+import { ApiSampleConfig } from '../../types/Cms';
 type SampleTypePromptResponse = {
     sampleType?: string;
 };
@@ -14,5 +6,5 @@ type LanguagePromptResponse = {
     sampleLanguage?: string;
 };
 type CreateApiSamplePromptResponse = SampleTypePromptResponse & LanguagePromptResponse;
-export declare function createApiSamplePrompt(samplesConfig: SampleConfig): Promise<CreateApiSamplePromptResponse>;
+export declare function createApiSamplePrompt(samplesConfig: ApiSampleConfig): Promise<CreateApiSamplePromptResponse>;
 export {};

package/lib/prompts/createDeveloperTestAccountConfigPrompt.d.ts

@@ -0,0 +1,17 @@
+import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
+declare const hubs: {
+    readonly MARKETING: "marketingLevel";
+    readonly OPS: "opsLevel";
+    readonly SERVICE: "serviceLevel";
+    readonly SALES: "salesLevel";
+    readonly CONTENT: "contentLevel";
+};
+type HubName = keyof typeof hubs;
+type HubTier = 'STARTER' | 'PROFESSIONAL' | 'ENTERPRISE';
+export type HubConfig = `${HubName}:${HubTier}`;
+export declare function createDeveloperTestAccountConfigPrompt(args?: {
+    name?: string;
+    description?: string;
+    tiers?: HubConfig[];
+}): Promise<DeveloperTestAccountConfig>;
+export {};

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeveloperTestAccountConfigPrompt = createDeveloperTestAccountConfigPrompt;
+const en_1 = require("../../lang/en");
+const promptUtils_1 = require("./promptUtils");
+const hubs = {
+    MARKETING: 'marketingLevel',
+    OPS: 'opsLevel',
+    SERVICE: 'serviceLevel',
+    SALES: 'salesLevel',
+    CONTENT: 'contentLevel',
+};
+const TEST_ACCOUNT_TIERS = [
+    { name: 'Marketing STARTER', value: 'MARKETING:STARTER' },
+    {
+        name: 'Marketing PROFESSIONAL',
+        value: 'MARKETING:PROFESSIONAL',
+    },
+    { name: 'Marketing ENTERPRISE', value: 'MARKETING:ENTERPRISE' },
+    promptUtils_1.Separator,
+    { name: 'Ops STARTER', value: 'OPS:STARTER' },
+    { name: 'Ops PROFESSIONAL', value: 'OPS:PROFESSIONAL' },
+    { name: 'Ops ENTERPRISE', value: 'OPS:ENTERPRISE' },
+    promptUtils_1.Separator,
+    { name: 'Service STARTER', value: 'SERVICE:STARTER' },
+    { name: 'Service PROFESSIONAL', value: 'SERVICE:PROFESSIONAL' },
+    { name: 'Service ENTERPRISE', value: 'SERVICE:ENTERPRISE' },
+    promptUtils_1.Separator,
+    { name: 'Sales STARTER', value: 'SALES:STARTER' },
+    { name: 'Sales PROFESSIONAL', value: 'SALES:PROFESSIONAL' },
+    { name: 'Sales ENTERPRISE', value: 'SALES:ENTERPRISE' },
+    promptUtils_1.Separator,
+    { name: 'Content STARTER', value: 'CONTENT:STARTER' },
+    { name: 'Content PROFESSIONAL', value: 'CONTENT:PROFESSIONAL' },
+    { name: 'Content ENTERPRISE', value: 'CONTENT:ENTERPRISE' },
+    promptUtils_1.Separator,
+];
+async function createDeveloperTestAccountConfigPrompt(args = {}) {
+    const { name, description, tiers } = args;
+    let accountName = name;
+    let accountDescription = description;
+    let accountLevelsArray = tiers;
+    if (!accountName) {
+        const namePromptResult = await (0, promptUtils_1.promptUser)({
+            name: 'accountName',
+            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt,
+            type: 'input',
+        });
+        accountName = namePromptResult.accountName;
+    }
+    if (!accountDescription) {
+        const descriptionPromptResult = await (0, promptUtils_1.promptUser)({
+            name: 'description',
+            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt,
+            type: 'input',
+        });
+        accountDescription = descriptionPromptResult.description;
+    }
+    if (!accountLevelsArray) {
+        const accountLevelsPromptResult = await (0, promptUtils_1.promptUser)({
+            name: 'testAccountLevels',
+            message: en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
+            type: 'checkbox',
+            choices: TEST_ACCOUNT_TIERS,
+            validate: choices => {
+                if (choices?.length > 1) {
+                    const hubMap = {};
+                    for (const choice of choices) {
+                        const hub = choice.split(':')[0];
+                        if (hubMap[hub]) {
+                            return en_1.lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                                .tiersError;
+                        }
+                        hubMap[hub] = true;
+                    }
+                }
+                return true;
+            },
+        });
+        accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
+    }
+    if (!accountLevelsArray) {
+        accountLevelsArray = [];
+    }
+    const accountLevels = accountLevelsArray.reduce((acc, level) => {
+        const [hubName, hubTier] = level.split(':');
+        const hubLevel = hubs[hubName];
+        acc[hubLevel] = hubTier;
+        return acc;
+    }, {});
+    return {
+        accountName: accountName,
+        description: accountDescription,
+        ...accountLevels,
+    };
+}

package/lib/prompts/createProjectPrompt.d.ts

@@ -1,19 +1,28 @@
-import { ProjectTemplate } from '../../types/Projects';
-type CreateProjectPromptResponseWithTemplate = {
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects';
+export type CreateProjectPromptResponse = {
+    name: string;
+    dest: string;
+    projectTemplate?: ProjectTemplate;
+    componentTemplates?: ComponentTemplate[];
+};
+type CreateProjectPromptResponseProjectTemplate = {
     name: string;
     dest: string;
     projectTemplate: ProjectTemplate;
+    componentTemplates: undefined;
 };
-type CreateProjectPromptResponseWithoutTemplate = {
+type CreateProjectPromptResponseComponentTemplates = {
     name: string;
     dest: string;
     projectTemplate?: undefined;
+    componentTemplates?: ComponentTemplate[];
 };
 type PromptOptionsArg = {
     name?: string;
     dest?: string;
     template?: string;
+    features?: string[];
 };
-export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates: ProjectTemplate[]): Promise<CreateProjectPromptResponseWithTemplate>;
-export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined): Promise<CreateProjectPromptResponseWithoutTemplate>;
+export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<CreateProjectPromptResponseProjectTemplate>;
+export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: ComponentTemplateChoice[]): Promise<CreateProjectPromptResponseComponentTemplates>;
 export {};

package/lib/prompts/createProjectPrompt.js

@@ -8,43 +8,58 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const path_2 = require("@hubspot/local-dev-lib/path");
 const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
 const constants_1 = require("../constants");
+const en_1 = require("../../lang/en");
 function validateProjectDirectory(input) {
     if (!input) {
-        return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.destRequired`);
+        return en_1.lib.prompts.createProjectPrompt.errors.destRequired;
     }
     if (fs_1.default.existsSync(path_1.default.resolve((0, path_2.getCwd)(), path_1.default.join(input, constants_1.PROJECT_CONFIG_FILE)))) {
-        return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.invalidDest`);
+        return en_1.lib.prompts.createProjectPrompt.errors.invalidDest;
     }
     if (!(0, path_2.isValidPath)(input)) {
-        return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.invalidCharacters`);
+        return en_1.lib.prompts.createProjectPrompt.errors.invalidCharacters;
     }
     return true;
 }
 function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
     return projectTemplates.find(t => t.name === templateNameOrLabel || t.label === templateNameOrLabel);
 }
-async function createProjectPrompt(promptOptions, projectTemplates) {
+async function createProjectPrompt(promptOptions, projectTemplates, componentTemplates) {
     const createProjectFromTemplate = !!projectTemplates && projectTemplates.length > 0;
+    const createProjectFromComponents = Array.isArray(componentTemplates) && componentTemplates?.length > 0;
+    const selectedComponents = [];
+    if (createProjectFromComponents && promptOptions.features) {
+        componentTemplates.forEach(template => {
+            if (!template.value) {
+                return;
+            }
+            if (promptOptions.features?.includes(template.value.type)) {
+                if (template.disabled) {
+                    throw new Error(`Cannot create project with template '${template.value.type}'. Reasons: ${template.disabled}`);
+                }
+                selectedComponents.push(template.value);
+            }
+        });
+    }
     const providedTemplateIsValid = createProjectFromTemplate &&
         !!promptOptions.template &&
         !!findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
     const result = await (0, promptUtils_1.promptUser)([
         {
             name: 'name',
-            message: (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.enterName`),
+            message: en_1.lib.prompts.createProjectPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.nameRequired`);
+                    return en_1.lib.prompts.createProjectPrompt.errors.nameRequired;
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.enterDest`),
+            message: en_1.lib.prompts.createProjectPrompt.enterDest,
             when: !promptOptions.dest,
             default: answers => {
                 const projectName = (0, path_2.sanitizeFileName)(promptOptions.name || answers.name);
@@ -59,10 +74,8 @@ async function createProjectPrompt(promptOptions, projectTemplates) {
             name: 'projectTemplate',
             message: () => {
                 return promptOptions.template && !providedTemplateIsValid
-                    ? (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.invalidTemplate`, {
-                        template: promptOptions.template,
-                    })
-                    : (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.selectTemplate`);
+                    ? en_1.lib.prompts.createProjectPrompt.errors.invalidTemplate(promptOptions.template)
+                    : en_1.lib.prompts.createProjectPrompt.selectTemplate;
             },
             when: createProjectFromTemplate && !providedTemplateIsValid,
             type: 'list',
@@ -75,6 +88,15 @@ async function createProjectPrompt(promptOptions, projectTemplates) {
                 })
                 : undefined,
         },
+        {
+            name: 'componentTemplates',
+            message: en_1.lib.prompts.createProjectPrompt.features,
+            when: !promptOptions.features &&
+                createProjectFromComponents &&
+                selectedComponents.length === 0,
+            type: 'checkbox',
+            choices: componentTemplates,
+        },
     ]);
     if (!result.name) {
         result.name = promptOptions.name;
@@ -82,12 +104,15 @@ async function createProjectPrompt(promptOptions, projectTemplates) {
     if (!result.dest) {
         result.dest = promptOptions.dest;
     }
+    if (!result.componentTemplates) {
+        result.componentTemplates = selectedComponents;
+    }
     if (providedTemplateIsValid) {
         result.projectTemplate = findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
     }
     if (projectTemplates && projectTemplates.length > 0) {
         if (!result.projectTemplate) {
-            throw new Error((0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.projectTemplateRequired`));
+            throw new Error(en_1.lib.prompts.createProjectPrompt.errors.projectTemplateRequired);
         }
         return result;
     }

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,7 +1,25 @@
-declare const templateTypeChoices: {
-    name: string;
-    value: string;
-}[];
+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";
+}];
 interface CreateTemplatePromptResponse {
     templateType: (typeof templateTypeChoices)[number]['value'];
 }

package/lib/prompts/installAppPrompt.d.ts

@@ -0,0 +1,2 @@
+export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean): Promise<void>;
+export declare function installAppAutoPrompt(): Promise<boolean>;

package/lib/prompts/installAppPrompt.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installAppBrowserPrompt = installAppBrowserPrompt;
+exports.installAppAutoPrompt = installAppAutoPrompt;
+const open_1 = __importDefault(require("open"));
+const promptUtils_1 = require("./promptUtils");
+const exitCodes_1 = require("../enums/exitCodes");
+const en_1 = require("../../lang/en");
+const logger_1 = require("../ui/logger");
+async function installAppBrowserPrompt(installUrl, isReinstall = false) {
+    logger_1.uiLogger.log('');
+    if (isReinstall) {
+        logger_1.uiLogger.log(en_1.lib.prompts.installAppPrompt.reinstallExplanation);
+    }
+    else {
+        logger_1.uiLogger.log(en_1.lib.prompts.installAppPrompt.explanation);
+    }
+    const { shouldOpenBrowser } = await (0, promptUtils_1.promptUser)({
+        name: 'shouldOpenBrowser',
+        type: 'confirm',
+        message: isReinstall
+            ? en_1.lib.prompts.installAppPrompt.reinstallPrompt
+            : en_1.lib.prompts.installAppPrompt.prompt,
+    });
+    if (!isReinstall && !shouldOpenBrowser) {
+        logger_1.uiLogger.log(en_1.lib.prompts.installAppPrompt.decline);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    else if (!shouldOpenBrowser) {
+        return;
+    }
+    (0, open_1.default)(installUrl);
+}
+async function installAppAutoPrompt() {
+    logger_1.uiLogger.log('');
+    const { shouldInstall } = await (0, promptUtils_1.promptUser)({
+        name: 'shouldInstall',
+        type: 'confirm',
+        message: en_1.lib.prompts.installAppPrompt.autoPrompt,
+    });
+    return shouldInstall;
+}