@hubspot/cli 7.6.0-beta.11 → 7.6.0-beta.13

package/lib/projects/localDev/LocalDevState.d.ts

@@ -1,4 +1,4 @@
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { IntermediateRepresentationNodeLocalDev, HSProfileVariables } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ProjectConfig } from '../../../types/Projects.js';
 import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev.js';
@@ -12,13 +12,14 @@ declare class LocalDevState {
     private _projectName;
     private _debug;
     private _projectNodes;
+    private _projectProfileData;
     private _projectNodesAtLastUpload;
     private _env;
     private _listeners;
     private _appData;
     private _devServerMessage;
     private _uploadWarnings;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
@@ -34,6 +35,8 @@ declare class LocalDevState {
     set projectNodes(nodes: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     });
+    get projectProfileData(): HSProfileVariables;
+    set projectProfileData(profileData: HSProfileVariables);
     get projectNodesAtLastUpload(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };

package/lib/projects/localDev/LocalDevState.js

@@ -9,13 +9,14 @@ class LocalDevState {
     _projectName;
     _debug;
     _projectNodes;
+    _projectProfileData;
     _projectNodesAtLastUpload;
     _env;
     _listeners;
     _appData;
     _devServerMessage;
     _uploadWarnings;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, profile, env, }) {
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._profile = profile;
@@ -26,6 +27,7 @@ class LocalDevState {
         this._debug = debug || false;
         this._projectNodes = initialProjectNodes;
         this._projectNodesAtLastUpload = initialProjectNodes;
+        this._projectProfileData = initialProjectProfileData;
         this._env = env;
         this._appData = {};
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
@@ -68,6 +70,12 @@ class LocalDevState {
         this._projectNodes = nodes;
         this.runListeners('projectNodes');
     }
+    get projectProfileData() {
+        return structuredClone(this._projectProfileData);
+    }
+    set projectProfileData(profileData) {
+        this._projectProfileData = profileData;
+    }
     get projectNodesAtLastUpload() {
         return structuredClone(this._projectNodesAtLastUpload);
     }

package/lib/projects/localDev/helpers/project.d.ts

@@ -6,7 +6,7 @@ export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig
 export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
 export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
-}): Promise<void>;
+}, profile?: string): Promise<void>;
 export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
-}): Promise<boolean>;
+}, profile?: string): Promise<boolean>;

package/lib/projects/localDev/helpers/project.js

@@ -17,7 +17,7 @@ import { uiAccountDescription } from '../../../ui/index.js';
 import SpinniesManager from '../../../ui/SpinniesManager.js';
 import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { handleProjectUpload } from '../../upload.js';
-import { pollProjectBuildAndDeploy } from '../../buildAndDeploy.js';
+import { pollProjectBuildAndDeploy } from '../../pollProjectBuildAndDeploy.js';
 import { logError } from '../../../errorHandlers/index.js';
 import { ApiErrorContext } from '../../../errorHandlers/index.js';
 // Prompt the user to create a new project if one doesn't exist on their target account
@@ -123,7 +123,7 @@ export async function createInitialBuildForNewProject(projectConfig, projectDir,
     }
     return initialUploadResult.buildResult;
 }
-export async function compareLocalProjectToDeployed(projectConfig, accountId, deployedBuildId, localProjectNodes) {
+export async function compareLocalProjectToDeployed(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
     uiLogger.log('');
     if (!deployedBuildId) {
         uiLogger.error(lib.localDevHelpers.project.compareLocalProjectToDeployed.noDeployedBuild(projectConfig.name, uiAccountDescription(accountId)));
@@ -132,12 +132,11 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
     SpinniesManager.add('compareLocalProjectToDeployed', {
         text: lib.localDevHelpers.project.compareLocalProjectToDeployed.checking,
     });
-    const isUpToDate = await isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes);
+    const isUpToDate = await isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile);
     if (isUpToDate) {
         SpinniesManager.succeed('compareLocalProjectToDeployed', {
             text: lib.localDevHelpers.project.compareLocalProjectToDeployed.upToDate,
         });
-        uiLogger.log('');
     }
     else {
         SpinniesManager.fail('compareLocalProjectToDeployed', {
@@ -145,12 +144,11 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
                 .notUpToDate,
         });
         uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed
-            .notUpToDateExplanation);
+        uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed.notUpToDateExplanation(profile));
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
-export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes) {
+export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
     let tempDir = null;
     try {
         tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hubspot-project-compare-'));
@@ -162,7 +160,7 @@ export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountI
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
             accountId: accountId,
-        }, {});
+        }, { profile });
         return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
     }
     finally {

package/lib/projects/platformVersion.d.ts

@@ -0,0 +1 @@
+export declare function useV3Api(platformVersion?: string | null): boolean;

package/lib/projects/platformVersion.js

@@ -0,0 +1,10 @@
+export function useV3Api(platformVersion) {
+    if (!platformVersion || typeof platformVersion !== 'string') {
+        return false;
+    }
+    if (platformVersion.toLowerCase() === 'unstable') {
+        return true;
+    }
+    const [year, minor] = platformVersion.split('.');
+    return Number(year) >= 2025 && Number(minor) >= 2;
+}

package/lib/projects/{buildAndDeploy.d.ts → pollProjectBuildAndDeploy.d.ts}

@@ -2,7 +2,6 @@ import { FileResult } from 'tmp';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
 import { ProjectConfig, ProjectTask, ProjectPollResult } from '../../types/Projects.js';
-export declare function useV3Api(platformVersion?: string | null): boolean;
 type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskName: string, taskId: number, deployedBuildId: number | null, silenceLogs?: boolean) => Promise<T>;
 export declare const pollBuildStatus: PollTaskStatusFunction<Build>;
 export declare const pollDeployStatus: PollTaskStatusFunction<Deploy>;

package/lib/projects/{buildAndDeploy.js → pollProjectBuildAndDeploy.js}

@@ -13,16 +13,6 @@ import { mapToInternalType } from '@hubspot/project-parsing-lib';
 const SPINNER_STATUS = {
     SPINNING: 'spinning',
 };
-export function useV3Api(platformVersion) {
-    if (!platformVersion || typeof platformVersion !== 'string') {
-        return false;
-    }
-    if (platformVersion.toLowerCase() === 'unstable') {
-        return true;
-    }
-    const [year, minor] = platformVersion.split('.');
-    return Number(year) >= 2025 && Number(minor) >= 2;
-}
 function getSubtasks(task) {
     if ('subbuildStatuses' in task) {
         return task.subbuildStatuses;

package/lib/projects/upload.js

@@ -12,7 +12,7 @@ import util from 'node:util';
 import { lib } from '../../lang/en.js';
 import { ensureProjectExists } from './ensureProjectExists.js';
 import { uiLogger } from '../ui/logger.js';
-import { useV3Api } from './buildAndDeploy.js';
+import { useV3Api } from './platformVersion.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import ProjectValidationError from '../errors/ProjectValidationError.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {

package/lib/projects/urls.d.ts

@@ -7,3 +7,4 @@ export declare function getProjectBuildDetailUrl(projectName: string, buildId: n
 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;
+export declare function getAppAllowlistUrl(accountId: number, projectName: string, appUid: string): string;

package/lib/projects/urls.js

@@ -41,3 +41,6 @@ export function getAccountHomeUrl(accountId) {
     const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
     return `${baseUrl}/home?portalId=${accountId}`;
 }
+export function getAppAllowlistUrl(accountId, projectName, appUid) {
+    return `${getProjectHomeUrl(accountId)}/project/${projectName}/component/${appUid}/distribution?panel=static-token-allowlist`;
+}

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

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

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

@@ -0,0 +1,143 @@
+import { Separator } from '@inquirer/prompts';
+import { projectAddPromptV3 } from '../projectAddPrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils');
+const mockedPromptUser = vi.mocked(promptUser);
+describe('lib/prompts/projectAddPrompt', () => {
+    const mockComponentTemplate = {
+        label: 'Test Module',
+        path: 'test-module',
+        type: 'module',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    const mockComponentTemplateWithCliSelector = {
+        label: 'Workflow Action Tool',
+        path: 'workflow-action-tool',
+        type: 'workflow-action',
+        cliSelector: 'workflow-action-tool',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    describe('projectAddPromptV3()', () => {
+        beforeEach(() => {
+            // Mock returns empty result, logic will use selectedComponents when selectedFeatures provided
+            mockedPromptUser.mockResolvedValue({});
+        });
+        it('should select component based on cliSelector when provided', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['workflow-action-tool'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'componentTemplate',
+                    when: false, // selectedFeatures provided, so skip prompt
+                }),
+            ]);
+        });
+        it('should select component based on type when cliSelector not provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['module'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'componentTemplate',
+                    when: false, // selectedFeatures provided and selectedComponents found
+                }),
+            ]);
+        });
+        it('should prefer cliSelector over type when both are available', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['workflow-action-tool']; // matches cliSelector
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should not select component when neither cliSelector nor type matches', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['non-matching-feature'];
+            mockedPromptUser.mockResolvedValue({ componentTemplate: [] });
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([]);
+        });
+        it('should throw error when selected feature component is disabled', async () => {
+            const disabledTemplateChoice = {
+                name: 'Disabled Component',
+                value: mockComponentTemplateWithCliSelector,
+                disabled: 'Component is disabled for testing',
+            };
+            const components = [disabledTemplateChoice];
+            const selectedFeatures = ['workflow-action-tool'];
+            await expect(projectAddPromptV3(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
+        });
+        it('should handle multiple components with mixed cliSelector availability', async () => {
+            const choice1 = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const choice2 = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const components = [choice1, choice2];
+            const selectedFeatures = ['module', 'workflow-action-tool'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([
+                mockComponentTemplate,
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should skip Separator instances when processing components', async () => {
+            const separator = new Separator();
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [separator, templateChoice];
+            const selectedFeatures = ['module'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
+        });
+        it('should prompt user when no selectedFeatures provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = undefined;
+            mockedPromptUser.mockResolvedValue({
+                componentTemplate: [mockComponentTemplate],
+            });
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'componentTemplate',
+                    type: 'checkbox',
+                    choices: components,
+                }),
+            ]);
+            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,160 @@
+import { Separator } from '@inquirer/prompts';
+import { selectProjectTemplatePrompt } from '../selectProjectTemplatePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils');
+const mockedPromptUser = vi.mocked(promptUser);
+describe('lib/prompts/selectProjectTemplatePrompt', () => {
+    const mockComponentTemplate = {
+        label: 'Test Module',
+        path: 'test-module',
+        type: 'module',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    const mockComponentTemplateWithCliSelector = {
+        label: 'Workflow Action Tool',
+        path: 'workflow-action-tool',
+        type: 'workflow-action',
+        cliSelector: 'workflow-action-tool',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    beforeEach(() => {
+        mockedPromptUser.mockResolvedValue({});
+    });
+    describe('selectProjectTemplatePrompt with component templates', () => {
+        it('should select component based on cliSelector when provided', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['workflow-action-tool'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'projectTemplate' }),
+                expect.objectContaining({ name: 'componentTemplates' }),
+            ]);
+        });
+        it('should select component based on type when cliSelector not provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['module'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
+        });
+        it('should prefer cliSelector over type when both are available', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['workflow-action-tool'], // matches cliSelector, not type
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should not select component when neither cliSelector nor type matches', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['non-matching-feature'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([]);
+        });
+        it('should throw error when selected feature component is disabled', async () => {
+            const disabledTemplateChoice = {
+                name: 'Disabled Component',
+                value: mockComponentTemplateWithCliSelector,
+                disabled: 'Component is disabled for testing',
+            };
+            const componentTemplates = [disabledTemplateChoice];
+            const promptOptions = {
+                features: ['workflow-action-tool'],
+            };
+            await expect(selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates)).rejects.toThrow(/Cannot create project with template.*workflow-action/);
+        });
+        it('should handle multiple components with mixed cliSelector availability', async () => {
+            const choice1 = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const choice2 = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const componentTemplates = [choice1, choice2];
+            const promptOptions = {
+                features: ['module', 'workflow-action-tool'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([
+                mockComponentTemplate,
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should skip Separator instances when processing components', async () => {
+            const separator = new Separator();
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [separator, templateChoice];
+            const promptOptions = {
+                features: ['module'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
+        });
+        it('should prompt user when no features provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {};
+            mockedPromptUser.mockResolvedValue({
+                componentTemplates: [mockComponentTemplate],
+            });
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'projectTemplate' }),
+                expect.objectContaining({
+                    name: 'componentTemplates',
+                    type: 'checkbox',
+                    choices: componentTemplates,
+                }),
+            ]);
+            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
+        });
+        it('should handle empty componentTemplates selection', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['non-matching-feature'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([]);
+        });
+    });
+});

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -101,6 +101,7 @@ export async function createDeveloperTestAccountConfigPrompt(args = {}, supportF
             type: 'checkbox',
             pageSize: 13,
             choices: TEST_ACCOUNT_TIERS,
+            loop: false,
             validate: choices => {
                 if (choices?.length < Object.keys(hubs).length) {
                     return lib.prompts.createDeveloperTestAccountConfigPrompt.errors

package/lib/prompts/importDataFilePathPrompt.js

@@ -1,8 +1,8 @@
 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';
+import { isErrorWithMessageOrReason } from '../errorHandlers/index.js';
 export async function importDataFilePathPrompt() {
     uiLogger.log(lib.prompts.importDataFilePathPrompt.promptContext);
     const { filePath } = await promptUser({
@@ -15,7 +15,9 @@ export async function importDataFilePathPrompt() {
                 return true;
             }
             catch (error) {
-                logError(error);
+                if (isErrorWithMessageOrReason(error) && error.message) {
+                    return error.message;
+                }
                 return false;
             }
         },

package/lib/prompts/installAppPrompt.d.ts

@@ -1,2 +1,7 @@
-export declare function installAppBrowserPrompt(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>;

package/lib/prompts/installAppPrompt.js

@@ -3,7 +3,7 @@ import { promptUser } from './promptUtils.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
-export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
+export async function installAppBrowserPrompt(installUrl, isReinstall = false, staticAuthInstallOptions) {
     uiLogger.log('');
     if (isReinstall) {
         uiLogger.log(lib.prompts.installAppPrompt.reinstallExplanation);
@@ -11,6 +11,11 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     else {
         uiLogger.log(lib.prompts.installAppPrompt.explanation);
     }
+    if (staticAuthInstallOptions) {
+        const { testingAccountId, projectAccountId, projectName, appUid } = staticAuthInstallOptions;
+        uiLogger.log(lib.prompts.installAppPrompt.staticAuthExplanation(projectAccountId, testingAccountId, projectName, appUid));
+        uiLogger.log('');
+    }
     const { shouldOpenBrowser } = await promptUser({
         name: 'shouldOpenBrowser',
         type: 'confirm',

package/lib/prompts/projectAddPrompt.js

@@ -51,7 +51,7 @@ export async function projectAddPromptV3(components, selectedFeatures) {
             if (template instanceof Separator || !template.value) {
                 return;
             }
-            if (selectedFeatures?.includes(template.value.type)) {
+            if (selectedFeatures?.includes(template.value.cliSelector || template.value.type)) {
                 if (template.disabled) {
                     throw new Error(lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
                 }

package/lib/prompts/promptUtils.d.ts

@@ -1,6 +1,11 @@
 import { Separator as _Separator } from '@inquirer/prompts';
 import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
 export declare const Separator: _Separator;
+export declare const PROMPT_THEME: {
+    prefix: {
+        idle: string;
+    };
+};
 export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {
     defaultAnswer?: boolean;