@hubspot/cli 7.7.34-experimental.0 → 7.8.0-experimental.0

package/bin/cli.js

@@ -42,6 +42,7 @@ import appCommand from '../commands/app.js';
 import testAccountCommands from '../commands/testAccount.js';
 import getStartedCommand from '../commands/getStarted.js';
 import mcpCommand from '../commands/mcp.js';
+import getStartedV2Command from '../commands/getStartedV2.js';
 function getTerminalWidth() {
     const width = yargs().terminalWidth();
     if (width >= 100)
@@ -92,6 +93,7 @@ const argv = yargs(process.argv.slice(2))
     type: 'boolean',
 })
     .check(performChecks)
+    .command(getStartedV2Command)
     .command(authCommand)
     .command(initCommand)
     .command(logsCommand)

package/commands/app.js

@@ -1,16 +1,11 @@
 import migrateCommand from './app/migrate.js';
 import appSecretCommand from './app/secret.js';
-import installAppCommand from './app/install.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 const command = ['app', 'apps'];
 // Keep the command hidden for now
 const describe = undefined;
 function appBuilder(yargs) {
-    yargs
-        .command(migrateCommand)
-        .command(appSecretCommand)
-        .command(installAppCommand)
-        .demandCommand(1, '');
+    yargs.command(migrateCommand).command(appSecretCommand).demandCommand(1, '');
     return yargs;
 }
 const builder = makeYargsBuilder(appBuilder, command, describe);

package/commands/getStarted.d.ts

@@ -1,7 +1,7 @@
 import { AccountArgs, YargsCommandModule, CommonArgs, ConfigArgs, EnvironmentArgs } from '../types/Yargs.js';
 export declare const command = "get-started";
 export declare const describe: undefined;
-type GetStartedArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+export type GetStartedArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
     name?: string;
     dest?: string;
 };

package/commands/getStarted.js

@@ -4,7 +4,6 @@ import open from 'open';
 import { getCwd } from '@hubspot/local-dev-lib/path';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { commands } from '../lang/en.js';
-import { trackCommandMetadataUsage, trackCommandUsage, } from '../lib/usageTracking.js';
 import { EXIT_CODES } from '../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 import { promptUser } from '../lib/prompts/promptUtils.js';
@@ -28,8 +27,9 @@ export const describe = undefined;
 async function handler(args) {
     const { derivedAccountId } = args;
     const env = getEnv(derivedAccountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD;
-    await trackCommandUsage('get-started', {}, derivedAccountId);
     const accountName = uiAccountDescription(derivedAccountId);
+    // TODO: Put this in constants.ts once we have a defined place for the template before INBOUND
+    const templateSource = 'robrown-hubspot/hubspot-project-components-ua-app-objects-beta';
     uiInfoSection(commands.getStarted.startTitle, () => {
         uiLogger.log(commands.getStarted.startDescription);
         uiLogger.log(commands.getStarted.guideOverview(accountName));
@@ -52,8 +52,6 @@ async function handler(args) {
             default: GET_STARTED_OPTIONS.APP,
         },
     ]);
-    // Track user's initial choice
-    await trackCommandMetadataUsage('get-started', { step: 'select-option', type: selectedOption }, derivedAccountId);
     if (selectedOption === GET_STARTED_OPTIONS.CMS) {
         uiLogger.log(' ');
         uiLogger.log(commands.getStarted.designManager);
@@ -66,11 +64,6 @@ async function handler(args) {
                     message: commands.getStarted.openDesignManagerPrompt,
                 },
             ]);
-            // Track Design Manager browser action
-            await trackCommandMetadataUsage('get-started', {
-                step: 'open-design-manager',
-                type: shouldOpen ? 'opened' : 'declined',
-            }, derivedAccountId);
             if (shouldOpen) {
                 uiLogger.log('');
                 openLink(derivedAccountId, 'design-manager');
@@ -81,37 +74,36 @@ async function handler(args) {
     else {
         uiLogger.log(' ');
         uiLogger.log(commands.getStarted.logs.appSelected);
+        // 1. Fetch project templates
+        let latestRepoReleaseTag;
         const { dest, name } = await projectNameAndDestPrompt(args);
+        // Specific template for get-started command
+        const projectTemplate = {
+            name: 'private-app-get-started-template',
+            label: 'CRM getting started project with private apps',
+            path: 'projects/private-app-get-started-template',
+        };
+        // 3. Create the project files
         const projectDest = path.resolve(getCwd(), dest);
         const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDest);
         if (existingProjectConfig &&
             existingProjectDir &&
             projectDest.startsWith(existingProjectDir)) {
-            // Track nested project error
-            await trackCommandMetadataUsage('get-started', {
-                successful: false,
-                step: 'project-creation',
-            }, derivedAccountId);
             uiLogger.log(' ');
             uiLogger.error(commands.project.create.errors.cannotNestProjects(existingProjectDir));
             process.exit(EXIT_CODES.ERROR);
         }
+        const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
         // 4. Clone the project template from GitHub
+        // This is temporary until we have the UA template in the main repo
         try {
-            await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDest, {
-                sourceDir: '2025.2/private-app-get-started-template',
+            await cloneGithubRepo(repo, projectDest, {
+                sourceDir: projectTemplate.path,
+                tag: latestRepoReleaseTag,
                 hideLogs: true,
             });
-            await trackCommandMetadataUsage('get-started', {
-                successful: true,
-                step: 'github-clone',
-            }, derivedAccountId);
         }
         catch (err) {
-            await trackCommandMetadataUsage('get-started', {
-                successful: false,
-                step: 'github-clone',
-            }, derivedAccountId);
             debugError(err);
             uiLogger.log(' ');
             uiLogger.error(commands.project.create.errors.failedToDownloadProject);
@@ -130,11 +122,6 @@ async function handler(args) {
         uiLogger.log(' ');
         uiLogger.log(commands.getStarted.prompts.projectCreated.description);
         uiLogger.log(' ');
-        // Track successful project creation
-        await trackCommandMetadataUsage('get-started', {
-            successful: true,
-            step: 'project-creation',
-        }, derivedAccountId);
         // 5. Install dependencies
         const installLocations = await getProjectPackageJsonLocations(projectDest);
         try {
@@ -160,21 +147,11 @@ async function handler(args) {
                 default: true,
             },
         ]);
-        // Track upload decision
-        await trackCommandMetadataUsage('get-started', {
-            step: 'upload-decision',
-            type: shouldUpload ? 'upload' : 'skip',
-        }, derivedAccountId);
         if (shouldUpload) {
             try {
                 // Get the project config for the newly created project
                 const { projectConfig: newProjectConfig, projectDir: newProjectDir } = await getProjectConfig(projectDest);
                 if (!newProjectConfig || !newProjectDir) {
-                    // Track config file not found error
-                    await trackCommandMetadataUsage('get-started', {
-                        successful: false,
-                        step: 'config-file-not-found',
-                    }, derivedAccountId);
                     uiLogger.log(' ');
                     uiLogger.error(commands.getStarted.errors.configFileNotFound);
                     process.exit(EXIT_CODES.ERROR);
@@ -195,21 +172,11 @@ async function handler(args) {
                     skipValidation: false,
                 });
                 if (uploadError) {
-                    // Track upload failure
-                    await trackCommandMetadataUsage('get-started', {
-                        successful: false,
-                        step: 'upload',
-                    }, derivedAccountId);
                     uiLogger.log(' ');
                     uiLogger.error(commands.getStarted.errors.uploadFailed);
                     debugError(uploadError);
                 }
                 else if (result) {
-                    // Track successful upload completion
-                    await trackCommandMetadataUsage('get-started', {
-                        successful: true,
-                        step: 'upload',
-                    }, derivedAccountId);
                     uiLogger.log(' ');
                     uiLogger.success(commands.getStarted.logs.uploadSuccess);
                     const { data: { results }, } = await fetchPublicAppsForPortal(derivedAccountId);
@@ -225,11 +192,6 @@ async function handler(args) {
                                 message: commands.getStarted.openInstallUrl,
                             },
                         ]);
-                        // Track Developer Overview browser action
-                        await trackCommandMetadataUsage('get-started', {
-                            step: 'open-distribution-page',
-                            type: shouldOpenOverview ? 'opened' : 'declined',
-                        }, derivedAccountId);
                         if (shouldOpenOverview) {
                             open(getStaticAuthAppInstallUrl({
                                 targetAccountId: derivedAccountId,
@@ -245,11 +207,6 @@ async function handler(args) {
                 }
             }
             catch (err) {
-                // Track upload exception
-                await trackCommandMetadataUsage('get-started', {
-                    successful: false,
-                    step: 'upload',
-                }, derivedAccountId);
                 uiLogger.log(' ');
                 uiLogger.error(commands.getStarted.errors.uploadFailed);
                 debugError(err);
@@ -257,11 +214,6 @@ async function handler(args) {
             }
         }
     }
-    // Track successful completion of get-started command
-    await trackCommandMetadataUsage('get-started', {
-        successful: true,
-        step: 'command-completed',
-    }, derivedAccountId);
     process.exit(EXIT_CODES.SUCCESS);
 }
 function getStartedBuilder(yargs) {

package/commands/getStartedV2.d.ts

@@ -0,0 +1,9 @@
+import { AccountArgs, YargsCommandModule, CommonArgs, ConfigArgs, EnvironmentArgs } from '../types/Yargs.js';
+export declare const command = "get-started-v2";
+export declare const describe: undefined;
+export type GetStartedArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    dest?: string;
+};
+declare const getStartedV2Command: YargsCommandModule<unknown, GetStartedArgs>;
+export default getStartedV2Command;

package/commands/getStartedV2.js

@@ -0,0 +1,39 @@
+import { commands } from '../lang/en.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+import { getGetStarted } from '../ui/views/GetStarted.js';
+import { render } from 'ink';
+export const command = 'get-started-v2';
+export const describe = undefined;
+async function handler(args) {
+    render(getGetStarted({ args }));
+}
+function getStartedBuilder(yargs) {
+    yargs.options({
+        name: {
+            describe: commands.getStarted.options.name.describe,
+            type: 'string',
+        },
+        dest: {
+            describe: commands.getStarted.options.dest.describe,
+            type: 'string',
+        },
+        'template-source': {
+            describe: commands.getStarted.options.templateSource.describe,
+            type: 'string',
+        },
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(getStartedBuilder, command, commands.getStarted.verboseDescribe, {
+    useGlobalOptions: true,
+    useAccountOptions: true,
+    useConfigOptions: true,
+    useEnvironmentOptions: true,
+});
+const getStartedV2Command = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default getStartedV2Command;

package/commands/project/dev/unifiedFlow.js

@@ -109,7 +109,7 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
     let project = uploadedProject;
     SpinniesManager.init();
     if (projectExists && project) {
-        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes, args.profile);
+        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes);
     }
     else {
         project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, false, false);

package/commands/project/migrate.js

@@ -8,6 +8,8 @@ import { uiCommandReference } from '../../lib/ui/index.js';
 import { commands, lib } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { logInBox } from '../../lib/ui/boxen.js';
+import { renderInline } from '../../ui/index.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 const { v2025_2 } = PLATFORM_VERSIONS;
 const command = 'migrate';
 const describe = undefined; // commands.project.migrate.describe
@@ -19,10 +21,18 @@ async function handler(args) {
         return process.exit(EXIT_CODES.ERROR);
     }
     if (projectConfig?.projectConfig) {
-        await logInBox({
-            contents: lib.migrate.projectMigrationWarning,
-            options: { title: lib.migrate.projectMigrationWarningTitle },
-        });
+        if (!process.env.ENABLE_INK) {
+            await logInBox({
+                contents: lib.migrate.projectMigrationWarning,
+                options: { title: lib.migrate.projectMigrationWarningTitle },
+            });
+        }
+        else {
+            await renderInline(getWarningBox({
+                title: lib.migrate.projectMigrationWarningTitle,
+                message: lib.migrate.projectMigrationWarning,
+            }));
+        }
     }
     const { derivedAccountId } = args;
     try {

package/commands/project/upload.d.ts

@@ -1,5 +1,5 @@
-import { CommonArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectUploadArgs = CommonArgs & JSONOutputArgs & EnvironmentArgs & {
+import { CommonArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
     forceCreate: boolean;
     message: string;
     m: string;

package/commands/project/upload.js

@@ -25,7 +25,7 @@ async function handler(args) {
     validateProjectConfig(projectConfig, projectDir);
     let targetAccountId;
     if (useV3Api(projectConfig.platformVersion)) {
-        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile, args.useEnv);
+        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
     }
     targetAccountId = targetAccountId || derivedAccountId;
     const accountConfig = getAccountConfig(targetAccountId);

package/commands/testAccount/create.js

@@ -75,9 +75,6 @@ async function handler(args) {
         resultJson.personalAccessKey = createResult.personalAccessKey;
     }
     catch (err) {
-        SpinniesManager.fail('createTestAccount', {
-            text: commands.testAccount.create.polling.createFailure,
-        });
         logError(err);
         SpinniesManager.fail('createTestAccount', {
             text: commands.testAccount.create.polling.createFailure,

package/lang/en.d.ts

@@ -1553,28 +1553,6 @@ ${string}`;
     readonly app: {
         readonly describe: "Commands for managing apps.";
         readonly subcommands: {
-            readonly install: {
-                readonly describe: "Install an OAuth app into a test account.";
-                readonly options: {
-                    readonly appUid: "The uid of the app to install";
-                    readonly projectName: "The name of the project that contains the app";
-                };
-                readonly positionals: {
-                    readonly testAccountId: "The id of the test account to install the app into";
-                };
-                readonly errors: {
-                    readonly mustSpecifyProjectName: `You must specify a project name. Use the ${string} flag to specify the project name or run this command from within a project directory.`;
-                    readonly noAppUidFound: `No app uid found. Please specify the app uid with the ${string} flag or run this command from within a project that contains an app.`;
-                    readonly appMustBeOauth: "This command only supports installing oauth apps. Please specify an app with oauth auth type.";
-                };
-                readonly polling: {
-                    readonly start: "Installing app...";
-                    readonly success: "App installed successfully";
-                    readonly failure: "App installation failed";
-                    readonly error: "Error installing app";
-                };
-                readonly example: "Install the app with uid my-app-uid from the project named \"my-project\" into the target account with id 1234567890";
-            };
             readonly secret: {
                 readonly describe: "Commands for managing secrets.";
                 readonly subcommands: {
@@ -2623,7 +2601,7 @@ export declare const lib: {
                 readonly checking: "Checking if your deployed build is up to date...";
                 readonly upToDate: "Deployed build is up to date.";
                 readonly notUpToDate: "Your project contains undeployed local changes.";
-                readonly notUpToDateExplanation: (profile?: string) => string;
+                readonly notUpToDateExplanation: `Run ${string} to upload these changes to HubSpot, then re-run ${string} to continue local development.`;
             };
             readonly createNewProjectForLocalDev: {
                 readonly projectMustExistExplanation: (projectName: string, accountId: number) => string;

package/lang/en.js

@@ -1550,28 +1550,6 @@ export const commands = {
     app: {
         describe: 'Commands for managing apps.',
         subcommands: {
-            install: {
-                describe: 'Install an OAuth app into a test account.',
-                options: {
-                    appUid: 'The uid of the app to install',
-                    projectName: 'The name of the project that contains the app',
-                },
-                positionals: {
-                    testAccountId: 'The id of the test account to install the app into',
-                },
-                errors: {
-                    mustSpecifyProjectName: `You must specify a project name. Use the ${uiCommandReference('--project-name')} flag to specify the project name or run this command from within a project directory.`,
-                    noAppUidFound: `No app uid found. Please specify the app uid with the ${uiCommandReference('--app-uid')} flag or run this command from within a project that contains an app.`,
-                    appMustBeOauth: 'This command only supports installing oauth apps. Please specify an app with oauth auth type.',
-                },
-                polling: {
-                    start: 'Installing app...',
-                    success: 'App installed successfully',
-                    failure: 'App installation failed',
-                    error: 'Error installing app',
-                },
-                example: 'Install the app with uid my-app-uid from the project named "my-project" into the target account with id 1234567890',
-            },
             secret: {
                 describe: 'Commands for managing secrets.',
                 subcommands: {
@@ -2620,7 +2598,7 @@ export const lib = {
                 checking: 'Checking if your deployed build is up to date...',
                 upToDate: 'Deployed build is up to date.',
                 notUpToDate: `Your project contains undeployed local changes.`,
-                notUpToDateExplanation: (profile) => `Run ${uiCommandReference(`hs project upload ${profile ? `--profile ${profile}` : ''}`)} to upload these changes to HubSpot, then re-run ${uiCommandReference(`hs project dev ${profile ? `--profile ${profile}` : ''}`)} to continue local development.`,
+                notUpToDateExplanation: `Run ${uiCommandReference('hs project upload')} to upload these changes to HubSpot, then re-run ${uiCommandReference('hs project dev')} to continue local development.`,
             },
             createNewProjectForLocalDev: {
                 projectMustExistExplanation: (projectName, accountId) => `The project ${projectName} does not exist in the target account ${uiAccountDescription(accountId)}. This command requires the project to exist in the target account.`,

package/lib/__tests__/hasFeature.test.js

@@ -1,173 +1,35 @@
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { http } from '@hubspot/local-dev-lib/http';
-import { hasFeature, hasUnfiedAppsAccess } from '../hasFeature.js';
-import { FEATURES } from '../constants.js';
+import { hasFeature } from '../hasFeature.js';
 vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
-vi.mock('@hubspot/local-dev-lib/http');
 const mockedFetchEnabledFeatures = fetchEnabledFeatures;
-const mockedHttp = http;
 describe('lib/hasFeature', () => {
     describe('hasFeature()', () => {
         const accountId = 123;
-        afterEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should return true if the feature is enabled', async () => {
+        beforeEach(() => {
             mockedFetchEnabledFeatures.mockResolvedValueOnce({
                 data: {
                     enabledFeatures: {
                         'feature-1': true,
+                        'feature-2': false,
+                        'feature-3': true,
                     },
                 },
             });
+        });
+        it('should return true if the feature is enabled', async () => {
             // @ts-expect-error test data
             const result = await hasFeature(accountId, 'feature-1');
             expect(result).toBe(true);
         });
-        it('should return false if the feature is disabled', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-2': false,
-                    },
-                },
-            });
+        it('should return false if the feature is not enabled', async () => {
             // @ts-expect-error test data
             const result = await hasFeature(accountId, 'feature-2');
             expect(result).toBe(false);
         });
         it('should return false if the feature is not present', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {},
-                },
-            });
             // @ts-expect-error test data
             const result = await hasFeature(accountId, 'feature-4');
             expect(result).toBe(false);
         });
-        it('should return true for APPS_HOME feature when not present in enabled features (defaults on)', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {},
-                },
-            });
-            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
-            expect(result).toBe(true);
-        });
-        it('should respect explicit setting for APPS_HOME feature even when it defaults on', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        [FEATURES.APPS_HOME]: false,
-                    },
-                },
-            });
-            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
-            expect(result).toBe(false);
-        });
-        it('should handle truthy values correctly', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-truthy': 'yes',
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const truthyResult = await hasFeature(accountId, 'feature-truthy');
-            expect(truthyResult).toBe(true);
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-number': 1,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const numberResult = await hasFeature(accountId, 'feature-number');
-            expect(numberResult).toBe(true);
-        });
-        it('should handle falsy values correctly', async () => {
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-null': null,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const nullResult = await hasFeature(accountId, 'feature-null');
-            expect(nullResult).toBe(false);
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-zero': 0,
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const zeroResult = await hasFeature(accountId, 'feature-zero');
-            expect(zeroResult).toBe(false);
-            mockedFetchEnabledFeatures.mockResolvedValueOnce({
-                data: {
-                    enabledFeatures: {
-                        'feature-empty': '',
-                    },
-                },
-            });
-            // @ts-expect-error test data
-            const emptyResult = await hasFeature(accountId, 'feature-empty');
-            expect(emptyResult).toBe(false);
-        });
-        it('should propagate errors from fetchEnabledFeatures', async () => {
-            const error = new Error('API error');
-            mockedFetchEnabledFeatures.mockRejectedValueOnce(error);
-            await expect(hasFeature(accountId, FEATURES.UNIFIED_APPS)).rejects.toThrow('API error');
-        });
-    });
-    describe('hasUnfiedAppsAccess()', () => {
-        const accountId = 123;
-        afterEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should return true when API returns true', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: true });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(true);
-            expect(mockedHttp.get).toHaveBeenCalledWith(accountId, {
-                url: 'developer-tooling/external/developer-portal/has-unified-dev-platform-access',
-            });
-        });
-        it('should return false when API returns false', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: false });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(false);
-        });
-        it('should handle truthy values correctly', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: 'yes' });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(true);
-        });
-        it('should handle falsy values correctly', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: null });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(false);
-        });
-        it('should handle undefined response data', async () => {
-            // @ts-expect-error Don't want to mock the full response object
-            mockedHttp.get.mockResolvedValueOnce({ data: undefined });
-            const result = await hasUnfiedAppsAccess(accountId);
-            expect(result).toBe(false);
-        });
-        it('should propagate errors from http.get', async () => {
-            const error = new Error('Network error');
-            mockedHttp.get.mockRejectedValueOnce(error);
-            await expect(hasUnfiedAppsAccess(accountId)).rejects.toThrow('Network error');
-        });
     });
 });

package/lib/constants.d.ts

@@ -81,7 +81,6 @@ export declare const FEATURES: {
     readonly SANDBOXES_V2: "sandboxes:v2:enabled";
     readonly SANDBOXES_V2_CLI: "sandboxes:v2:cliEnabled";
     readonly APP_EVENTS: "Developers:UnifiedApps:AppEventsAccess";
-    readonly APPS_HOME: "UIE:AppHome";
 };
 export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPLOAD_SUCCESS: string;

package/lib/constants.js

@@ -73,7 +73,6 @@ export const FEATURES = {
     SANDBOXES_V2: 'sandboxes:v2:enabled',
     SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
     APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
-    APPS_HOME: 'UIE:AppHome',
 };
 export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPLOAD_SUCCESS: 'server:uploadSuccess',

package/lib/dependencyManagement.d.ts

@@ -2,5 +2,10 @@ export declare function installPackages({ packages, installLocations, }: {
     packages?: string[];
     installLocations?: string[];
 }): Promise<void>;
+export declare function installPackagesV2({ packages, installLocations, }: {
+    packages?: string[];
+    installLocations?: string[];
+}): Promise<void>;
+export declare function installPackagesInDirectoryV2(directory: string, packages?: string[]): Promise<void>;
 export declare function getProjectPackageJsonLocations(dir?: string): Promise<string[]>;
 export declare function hasMissingPackages(directory: string): Promise<boolean>;

package/lib/dependencyManagement.js

@@ -22,6 +22,15 @@ export async function installPackages({ packages, installLocations, }) {
         await installPackagesInDirectory(dir, packages);
     }));
 }
+export async function installPackagesV2({ packages, installLocations, }) {
+    const installDirs = installLocations || (await getProjectPackageJsonLocations());
+    await Promise.all(installDirs.map(async (dir) => {
+        await installPackagesInDirectoryV2(dir, packages);
+    }));
+}
+export async function installPackagesInDirectoryV2(directory, packages) {
+    await executeInstall(packages, null, { cwd: directory });
+}
 async function installPackagesInDirectory(directory, packages) {
     const spinner = `installingDependencies-${directory}`;
     const relativeDir = path.relative(process.cwd(), directory);