@hubspot/cli 7.7.27-experimental.1 → 7.7.28-experimental.0

package/README.md

@@ -4,10 +4,6 @@
 
 A CLI for HubSpot developers to enable local development and automation. [Learn more about building on HubSpot](https://developers.hubspot.com).
 
-## Contributing
-
-For more information on developing, see the [Contributing Guide](CONTRIBUTING.md).
-
 ## Getting started
 
 For more information on using these tools, see [Local Development Tooling: Getting Started](https://developers.hubspot.com/docs/cms/guides/getting-started-with-local-development)

package/api/__tests__/migrate.test.js

@@ -1,6 +1,6 @@
 import { http } from '@hubspot/local-dev-lib/http';
 import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
-import { listAppsForMigration, initializeMigration, continueMigration, checkMigrationStatusV2, isMigrationStatus, } from '../migrate.js';
+import { listAppsForMigration, initializeAppMigration, continueAppMigration, checkMigrationStatusV2, isMigrationStatus, } from '../migrate.js';
 vi.mock('@hubspot/local-dev-lib/http');
 const httpMock = http;
 describe('api/migrate', () => {
@@ -49,12 +49,12 @@ describe('api/migrate', () => {
             expect(result).toEqual(mockResponse);
         });
     });
-    describe('initializeMigration', () => {
+    describe('initializeAppMigration', () => {
         it('should call http.post with correct parameters', async () => {
             const mockResponse = { migrationId: mockMigrationId };
             // @ts-expect-error Mock
             httpMock.post.mockResolvedValue(mockResponse);
-            const result = await initializeMigration(mockAccountId, mockAppId, mockPlatformVersion);
+            const result = await initializeAppMigration(mockAccountId, mockAppId, mockPlatformVersion);
             expect(http.post).toHaveBeenCalledWith(mockAccountId, {
                 url: 'dfs/migrations/v2/migrations',
                 data: {
@@ -65,12 +65,12 @@ describe('api/migrate', () => {
             expect(result).toEqual(mockResponse);
         });
     });
-    describe('continueMigration', () => {
+    describe('continueAppMigration', () => {
         it('should call http.post with correct parameters', async () => {
             const mockResponse = { migrationId: mockMigrationId };
             // @ts-expect-error Mock
             httpMock.post.mockResolvedValue(mockResponse);
-            const result = await continueMigration(mockPortalId, mockMigrationId, mockComponentUids, mockProjectName);
+            const result = await continueAppMigration(mockPortalId, mockMigrationId, mockComponentUids, mockProjectName);
             expect(http.post).toHaveBeenCalledWith(mockPortalId, {
                 url: 'dfs/migrations/v2/migrations/continue',
                 data: {

package/api/migrate.d.ts

@@ -24,7 +24,13 @@ export interface ListAppsResponse {
     migratableApps: MigratableApp[];
     unmigratableApps: UnmigratableApp[];
 }
-export interface InitializeMigrationResponse {
+export interface ListThemesResponse {
+    migratableThemes: {
+        THEME: string[];
+        REACT_THEME: string[];
+    };
+}
+export interface InitializeAppMigrationResponse {
     migrationId: number;
 }
 export interface ListAppsMigrationComponent {
@@ -32,7 +38,7 @@ export interface ListAppsMigrationComponent {
     componentType: string;
     isSupported: boolean;
 }
-export type ContinueMigrationResponse = {
+export type ContinueAppMigrationResponse = {
     migrationId: number;
 };
 export interface MigrationBaseStatus {
@@ -65,7 +71,7 @@ export interface MigrationFailed extends MigrationBaseStatus {
 export type MigrationStatus = MigrationInProgress | MigrationInputRequired | MigrationSuccess | MigrationFailed;
 export declare function isMigrationStatus(error: unknown): error is MigrationStatus;
 export declare function listAppsForMigration(accountId: number, platformVersion: string): HubSpotPromise<ListAppsResponse>;
-export declare function initializeMigration(accountId: number, applicationId: number, platformVersion: string): HubSpotPromise<InitializeMigrationResponse>;
-export declare function continueMigration(portalId: number, migrationId: number, componentUids: Record<string, string>, projectName: string): HubSpotPromise<ContinueMigrationResponse>;
+export declare function initializeAppMigration(accountId: number, applicationId: number, platformVersion: string): HubSpotPromise<InitializeAppMigrationResponse>;
+export declare function continueAppMigration(portalId: number, migrationId: number, componentUids: Record<string, string>, projectName: string): HubSpotPromise<ContinueAppMigrationResponse>;
 export declare function checkMigrationStatusV2(accountId: number, id: number): HubSpotPromise<MigrationStatus>;
 export {};

package/api/migrate.js

@@ -24,7 +24,7 @@ function mapPlatformVersionToEnum(platformVersion) {
     }
     return `V${platformVersion.replace('.', '_')}`;
 }
-export async function initializeMigration(accountId, applicationId, platformVersion) {
+export async function initializeAppMigration(accountId, applicationId, platformVersion) {
     return http.post(accountId, {
         url: `${MIGRATIONS_API_PATH_V2}/migrations`,
         data: {
@@ -33,7 +33,7 @@ export async function initializeMigration(accountId, applicationId, platformVers
         },
     });
 }
-export async function continueMigration(portalId, migrationId, componentUids, projectName) {
+export async function continueAppMigration(portalId, migrationId, componentUids, projectName) {
     return http.post(portalId, {
         url: `${MIGRATIONS_API_PATH_V2}/migrations/continue`,
         data: {

package/commands/__tests__/create.test.js

@@ -1,5 +1,6 @@
 import yargs from 'yargs';
 import createCommand from '../create.js';
+import { TEMPLATE_TYPES, HTTP_METHODS } from '../../types/Cms.js';
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
@@ -28,6 +29,25 @@ describe('commands/create', () => {
         it('should support the correct options', () => {
             createCommand.builder(yargs);
             expect(optionSpy).toHaveBeenCalledWith('internal', expect.objectContaining({ type: 'boolean', hidden: true }));
+            // Template creation flags
+            expect(optionSpy).toHaveBeenCalledWith('template-type', expect.objectContaining({
+                type: 'string',
+                choices: [...TEMPLATE_TYPES],
+            }));
+            // Module creation flags
+            expect(optionSpy).toHaveBeenCalledWith('module-label', expect.objectContaining({ type: 'string' }));
+            expect(optionSpy).toHaveBeenCalledWith('react-type', expect.objectContaining({ type: 'boolean' }));
+            expect(optionSpy).toHaveBeenCalledWith('content-types', expect.objectContaining({ type: 'string' }));
+            expect(optionSpy).toHaveBeenCalledWith('global', expect.objectContaining({ type: 'boolean' }));
+            expect(optionSpy).toHaveBeenCalledWith('available-for-new-content', expect.objectContaining({ type: 'boolean' }));
+            // Function creation flags
+            expect(optionSpy).toHaveBeenCalledWith('functions-folder', expect.objectContaining({ type: 'string' }));
+            expect(optionSpy).toHaveBeenCalledWith('filename', expect.objectContaining({ type: 'string' }));
+            expect(optionSpy).toHaveBeenCalledWith('endpoint-method', expect.objectContaining({
+                type: 'string',
+                choices: [...HTTP_METHODS],
+            }));
+            expect(optionSpy).toHaveBeenCalledWith('endpoint-path', expect.objectContaining({ type: 'string' }));
         });
     });
 });

package/commands/__tests__/testAccount.test.js

@@ -2,6 +2,7 @@ import yargs from 'yargs';
 import testAccountCreateCommand from '../testAccount/create.js';
 import testAccountCreateConfigCommand from '../testAccount/createConfig.js';
 import testAccountDeleteCommand from '../testAccount/delete.js';
+import testAccountImportDataCommand from '../testAccount/importData.js';
 import testAccountCommands from '../testAccount.js';
 vi.mock('../testAccount/create');
 vi.mock('../testAccount/createConfig');
@@ -37,6 +38,7 @@ describe('commands/testAccount', () => {
             testAccountCreateCommand,
             testAccountCreateConfigCommand,
             testAccountDeleteCommand,
+            testAccountImportDataCommand,
         ];
         it('should demand the command takes one positional argument', () => {
             testAccountCommands.builder(yargs);

package/commands/app/__tests__/migrate.test.js

@@ -10,6 +10,7 @@ vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('../../../lib/app/migrate');
 vi.mock('../../../lib/app/migrate_legacy');
+vi.mock('../../../lib/projects/config.js');
 const mockYargs = yargs;
 const mockedGetAccountConfig = getAccountConfig;
 const mockedMigrateApp2023_2 = migrateApp2023_2;

package/commands/create/function.js

@@ -5,8 +5,8 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 const functionAssetType = {
     hidden: false,
     dest: ({ name }) => name,
-    execute: async ({ dest }) => {
-        const functionDefinition = await createFunctionPrompt();
+    execute: async ({ dest, commandArgs }) => {
+        const functionDefinition = await createFunctionPrompt(commandArgs);
         try {
             await createFunction(functionDefinition, dest);
         }

package/commands/create/module.js

@@ -14,8 +14,8 @@ const moduleAssetType = {
         }
         return true;
     },
-    execute: async ({ name, dest, getInternalVersion }) => {
-        const moduleDefinition = await createModulePrompt();
+    execute: async ({ name, dest, getInternalVersion, commandArgs }) => {
+        const moduleDefinition = await createModulePrompt(commandArgs);
         try {
             await createModule(moduleDefinition, name, dest, getInternalVersion);
         }

package/commands/create/template.js

@@ -14,8 +14,8 @@ const templateAssetType = {
         }
         return true;
     },
-    execute: async ({ name, dest }) => {
-        const { templateType } = await createTemplatePrompt();
+    execute: async ({ name, dest, commandArgs }) => {
+        const { templateType } = await createTemplatePrompt(commandArgs);
         try {
             await createTemplate(name, dest, templateType);
         }

package/commands/create.js

@@ -8,6 +8,7 @@ import { commands } from '../lang/en.js';
 import { uiLogger } from '../lib/ui/logger.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { TEMPLATE_TYPES, HTTP_METHODS, CONTENT_TYPES } from '../types/Cms.js';
 const SUPPORTED_ASSET_TYPES = Object.keys(assets)
     .filter(t => !assets[t].hidden)
     .join(', ');
@@ -73,6 +74,52 @@ function createBuilder(yargs) {
         type: 'boolean',
         hidden: true,
     });
+    yargs.option('template-type', {
+        describe: commands.create.flags.templateType.describe,
+        type: 'string',
+        choices: [...TEMPLATE_TYPES],
+    });
+    yargs.option('module-label', {
+        describe: commands.create.flags.moduleLabel.describe,
+        type: 'string',
+    });
+    yargs.option('react-type', {
+        describe: commands.create.flags.reactType.describe,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('content-types', {
+        describe: commands.create.flags.contentTypes.describe(CONTENT_TYPES),
+        type: 'string',
+    });
+    yargs.option('global', {
+        describe: commands.create.flags.global.describe,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('available-for-new-content', {
+        describe: commands.create.flags.availableForNewContent.describe,
+        type: 'boolean',
+        default: true,
+    });
+    yargs.option('functions-folder', {
+        describe: commands.create.flags.functionsFolder.describe,
+        type: 'string',
+    });
+    yargs.option('filename', {
+        describe: commands.create.flags.filename.describe,
+        type: 'string',
+    });
+    yargs.option('endpoint-method', {
+        describe: commands.create.flags.endpointMethod.describe,
+        type: 'string',
+        choices: [...HTTP_METHODS],
+        default: 'GET',
+    });
+    yargs.option('endpoint-path', {
+        describe: commands.create.flags.endpointPath.describe,
+        type: 'string',
+    });
     return yargs;
 }
 const builder = makeYargsBuilder(createBuilder, command, describe, {

package/commands/getStarted.js

@@ -4,12 +4,12 @@ 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 { trackCommandUsage } from '../lib/usageTracking.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';
 import { projectNameAndDestPrompt } from '../lib/prompts/projectNameAndDestPrompt.js';
-import { uiFeatureHighlight, uiInfoSection } from '../lib/ui/index.js';
+import { uiAccountDescription, uiFeatureHighlight, uiInfoSection, } from '../lib/ui/index.js';
 import { uiLogger } from '../lib/ui/logger.js';
 import { debugError, logError } from '../lib/errorHandlers/index.js';
 import { handleProjectUpload } from '../lib/projects/upload.js';
@@ -27,9 +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);
     // 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';
-    trackCommandUsage('get-started', {}, derivedAccountId);
     uiInfoSection(commands.getStarted.startTitle, () => {
         uiLogger.log(commands.getStarted.startDescription);
     });
@@ -51,6 +51,8 @@ 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);
@@ -63,6 +65,11 @@ 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');
@@ -88,6 +95,11 @@ async function handler(args) {
         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);
@@ -101,8 +113,16 @@ async function handler(args) {
                 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);
@@ -121,6 +141,11 @@ 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 {
@@ -138,19 +163,30 @@ async function handler(args) {
             uiLogger.log(' ');
         }
         // 6. Ask user if they want to upload the project
+        const accountName = uiAccountDescription(derivedAccountId);
         const { shouldUpload } = await promptUser([
             {
                 type: 'confirm',
                 name: 'shouldUpload',
-                message: commands.getStarted.prompts.uploadProject,
+                message: commands.getStarted.prompts.uploadProject(accountName),
                 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);
@@ -172,11 +208,22 @@ 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);
                     const lastCreatedApp = results.sort((a, b) => b.createdAt - a.createdAt)[0];
@@ -191,6 +238,11 @@ 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,
@@ -206,6 +258,11 @@ 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);
@@ -213,6 +270,11 @@ 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/mcp/setup.d.ts

@@ -1,7 +1,6 @@
 import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
 interface MCPSetupArgs extends CommonArgs {
     client?: string[];
-    addDocsSearch?: boolean;
 }
 declare const mcpSetupCommand: YargsCommandModule<unknown, MCPSetupArgs>;
 export default mcpSetupCommand;

package/commands/mcp/setup.js

@@ -2,7 +2,7 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { addMcpServerToConfig, addMintlifyMcpServer, supportedTools, } from '../../lib/mcp/setup.js';
+import { addMcpServerToConfig, supportedTools } from '../../lib/mcp/setup.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 const command = ['setup', 'update'];
 const describe = undefined; // Leave hidden for now
@@ -16,10 +16,7 @@ async function handler(args) {
     }
     trackCommandUsage('mcp-setup', {}, args.derivedAccountId);
     try {
-        const derivedTargets = await addMcpServerToConfig(args.client);
-        if (args.addDocsSearch) {
-            await addMintlifyMcpServer(derivedTargets);
-        }
+        await addMcpServerToConfig(args.client);
     }
     catch (e) {
         process.exit(EXIT_CODES.ERROR);
@@ -27,15 +24,10 @@ async function handler(args) {
     process.exit(EXIT_CODES.SUCCESS);
 }
 function setupBuilder(yargs) {
-    yargs
-        .option('client', {
+    yargs.option('client', {
         describe: commands.mcp.setup.args.client,
         type: 'array',
         choices: [...supportedTools.map(tool => tool.value)],
-    })
-        .option('add-docs-search', {
-        type: 'boolean',
-        hidden: true,
     });
     return yargs;
 }

package/commands/project/__tests__/create.test.js

@@ -27,14 +27,71 @@ describe('commands/project/create', () => {
         it('should define project creation options', () => {
             const optionsSpy = vi.spyOn(yargsMock, 'options');
             const exampleSpy = vi.spyOn(yargsMock, 'example');
+            const conflictsSpy = vi.spyOn(yargsMock, 'conflicts');
             projectCreateCommand.builder(yargsMock);
             expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
                 name: expect.any(Object),
                 dest: expect.any(Object),
                 template: expect.any(Object),
                 'template-source': expect.any(Object),
+                'platform-version': expect.any(Object),
+                'project-base': expect.any(Object),
+                distribution: expect.any(Object),
+                auth: expect.any(Object),
+                features: expect.any(Object),
             }));
+            expect(conflictsSpy).toHaveBeenCalledWith('template', 'features');
             expect(exampleSpy).toHaveBeenCalled();
         });
+        it('should define platform version option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall['platform-version']).toEqual(expect.objectContaining({
+                hidden: true,
+                type: 'string',
+                choices: ['2023.2', '2025.1', '2025.2'],
+                default: '2023.2',
+            }));
+        });
+        it('should define project base option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall['project-base']).toEqual(expect.objectContaining({
+                hidden: true,
+                type: 'string',
+                choices: ['empty', 'app'],
+            }));
+        });
+        it('should define distribution option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall.distribution).toEqual(expect.objectContaining({
+                hidden: true,
+                type: 'string',
+                choices: ['private', 'marketplace'],
+            }));
+        });
+        it('should define auth option with correct choices', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall.auth).toEqual(expect.objectContaining({
+                hidden: true,
+                type: 'string',
+                choices: ['oauth', 'static'],
+            }));
+        });
+        it('should define features option as array', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            projectCreateCommand.builder(yargsMock);
+            const optionsCall = optionsSpy.mock.calls[0][0];
+            expect(optionsCall.features).toEqual(expect.objectContaining({
+                hidden: true,
+                type: 'array',
+            }));
+        });
     });
 });

package/commands/project/__tests__/devUnifiedFlow.test.js

@@ -5,7 +5,8 @@ import { getConfigAccounts, getAccountConfig, } from '@hubspot/local-dev-lib/con
 import { getValidEnv } from '@hubspot/local-dev-lib/environment';
 import { logError } from '../../../lib/errorHandlers/index.js';
 import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
-import { createInitialBuildForNewProject, createNewProjectForLocalDev, useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, } from '../../../lib/projects/localDev/helpers.js';
+import { createInitialBuildForNewProject, createNewProjectForLocalDev, } from '../../../lib/projects/localDev/helpers/project.js';
+import { useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, } from '../../../lib/projects/localDev/helpers/account.js';
 import { selectDeveloperTestTargetAccountPrompt, selectSandboxTargetAccountPrompt, } from '../../../lib/prompts/projectDevTargetAccountPrompt.js';
 import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
 import LocalDevProcess from '../../../lib/projects/localDev/LocalDevProcess.js';
@@ -34,7 +35,8 @@ vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/environment');
 vi.mock('../../../lib/errorHandlers');
 vi.mock('../../../lib/projects/ensureProjectExists');
-vi.mock('../../../lib/projects/localDev/helpers');
+vi.mock('../../../lib/projects/localDev/helpers/project');
+vi.mock('../../../lib/projects/localDev/helpers/account');
 vi.mock('../../../lib/prompts/projectDevTargetAccountPrompt');
 vi.mock('../../../lib/ui/SpinniesManager');
 vi.mock('../../../lib/projects/localDev/LocalDevProcess');
@@ -322,31 +324,10 @@ describe('unifiedProjectDevFlow', () => {
             });
             expect(createNewProjectForLocalDev).not.toHaveBeenCalled();
             expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
-                deployedBuild: mockProject.deployedBuild,
                 projectId: mockProject.id,
                 projectName: mockProject.name,
             }));
         });
-        it('should detect GitHub linked projects', async () => {
-            const githubLinkedProject = {
-                ...mockProject,
-                sourceIntegration: { source: 'GITHUB' },
-            };
-            ensureProjectExists.mockResolvedValue({
-                projectExists: true,
-                project: githubLinkedProject,
-            });
-            await unifiedProjectDevFlow({
-                args: mockArgs,
-                targetProjectAccountId: mockTargetProjectAccountId,
-                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
-                projectConfig: mockProjectConfig,
-                projectDir: mockProjectDir,
-            });
-            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
-                isGithubLinked: true,
-            }));
-        });
     });
     describe('local dev process setup', () => {
         it('should initialize LocalDevProcess with correct parameters', async () => {
@@ -360,8 +341,6 @@ describe('unifiedProjectDevFlow', () => {
             expect(LocalDevProcess).toHaveBeenCalledWith({
                 initialProjectNodes: mockProjectNodes,
                 debug: mockArgs.debug,
-                deployedBuild: mockProject.deployedBuild,
-                isGithubLinked: false,
                 profile: mockArgs.profile,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 targetTestingAccountId: mockProvidedTargetTestingAccountId,
@@ -401,17 +380,26 @@ describe('unifiedProjectDevFlow', () => {
         beforeEach(() => {
             isTestAccountOrSandbox.mockReturnValue(false);
         });
-        it('should display account type information when prompting', async () => {
-            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.STANDARD);
+        it('should log info message when default account is a sandbox or test account', async () => {
+            isTestAccountOrSandbox.mockReturnValue(true);
+            await unifiedProjectDevFlow({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.defaultSandboxOrDevTestTestingAccountExplanation(mockTargetProjectAccountId));
+        });
+        it('should log info message when testingAccount flag is provided', async () => {
+            const providedTestingAccountId = 999;
             await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: providedTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(uiLine).toHaveBeenCalled();
-            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.accountTypeInformation);
-            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.learnMoreMessage);
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.testingAccountFlagExplanation(providedTestingAccountId));
         });
     });
 });