@hubspot/cli 7.8.0-experimental.0 → 7.8.0

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -1,51 +1,75 @@
 import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../ui/logger.js';
 import { addLocalStateFlag } from '@hubspot/local-dev-lib/config';
-import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, } from '../../constants.js';
+import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, } from '../../constants.js';
 import { lib } from '../../../lang/en.js';
 import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
+import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, isAppInstallFailureWebsocketMessage, isAppInstallSuccessWebsocketMessage, isAppInstallInitiatedWebsocketMessage, } from './localDevWebsocketServerUtils.js';
+import pkg from '../../../package.json' with { type: 'json' };
 const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
+const LOCAL_DEV_WEBSOCKET_SERVER_VERSION = 2;
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
+const DOMAINS = ['hubspot.com', 'hubspotqa.com'];
+const SUBDOMAINS = ['local', 'app', 'app-na2', 'app-na3', 'app-ap1', 'app-eu1'];
+const ALLOWED_ORIGIN_REGEX = new RegExp(`^https://(${SUBDOMAINS.join('|')})\\.(${DOMAINS.join('|')})$`);
 class LocalDevWebsocketServer {
     server;
     debug;
     localDevProcess;
-    ALLOWED_ORIGINS = [
-        'https://app.hubspot.com',
-        'https://app.hubspotqa.com',
-        'https://local.hubspot.com',
-        'https://local.hubspotqa.com',
-    ];
     constructor(localDevProcess, debug) {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
     }
     log(message) {
         if (this.debug) {
-            logger.log(LOG_PREFIX, message);
+            uiLogger.log(`${LOG_PREFIX} ${message}`);
         }
     }
     logError(message) {
         if (this.debug) {
-            logger.error(LOG_PREFIX, message);
+            uiLogger.error(`${LOG_PREFIX} ${message}`);
         }
     }
     sendMessage(websocket, message) {
         websocket.send(JSON.stringify(message));
     }
     async handleUpload(websocket) {
-        const uploadSuccess = await this.localDevProcess.uploadProject();
-        if (uploadSuccess) {
-            this.sendMessage(websocket, {
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
-            });
-        }
-        else {
-            this.sendMessage(websocket, {
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
-            });
-        }
+        const { uploadSuccess, buildSuccess, deploySuccess, deployId } = await this.localDevProcess.uploadProject();
+        this.sendMessage(websocket, {
+            type: uploadSuccess
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                buildSuccess,
+                deploySuccess,
+                deployId,
+            },
+        });
+    }
+    async handleDeploy(websocket, force) {
+        const { success, deployId } = await this.localDevProcess.deployLatestBuild(force);
+        this.sendMessage(websocket, {
+            type: success
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                latestDeployId: deployId,
+            },
+        });
+    }
+    async handleAppInstallSuccess() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+    }
+    async handleAppInstallFailure() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_FAILURE);
+    }
+    async handleAppInstallInitiated() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.OAUTH_APP_INSTALL_INITIATED);
     }
     setupMessageHandlers(websocket) {
         websocket.on('message', data => {
@@ -55,15 +79,26 @@ class LocalDevWebsocketServer {
                     this.logError(lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
                     return;
                 }
-                switch (message.type) {
-                    case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
-                        this.handleUpload(websocket);
-                        break;
-                    case LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN:
-                        addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
-                        break;
-                    default:
-                        this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                if (isUploadWebsocketMessage(message)) {
+                    this.handleUpload(websocket);
+                }
+                else if (isDeployWebsocketMessage(message)) {
+                    this.handleDeploy(websocket, message.data.force);
+                }
+                else if (isViewedWelcomeScreenWebsocketMessage(message)) {
+                    addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+                }
+                else if (isAppInstallSuccessWebsocketMessage(message)) {
+                    this.handleAppInstallSuccess();
+                }
+                else if (isAppInstallFailureWebsocketMessage(message)) {
+                    this.handleAppInstallFailure();
+                }
+                else if (isAppInstallInitiatedWebsocketMessage(message)) {
+                    this.handleAppInstallInitiated();
+                }
+                else {
+                    this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
             }
             catch (e) {
@@ -71,12 +106,23 @@ class LocalDevWebsocketServer {
             }
         });
     }
+    sendCliMetadata(websocket) {
+        this.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.CLI_METADATA,
+            data: {
+                cliVersion: pkg.version,
+                localDevWebsocketServerVersion: LOCAL_DEV_WEBSOCKET_SERVER_VERSION,
+            },
+        });
+    }
     sendProjectData(websocket) {
         this.sendMessage(websocket, {
             type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
             data: {
-                projectName: this.localDevProcess.projectName,
-                projectId: this.localDevProcess.projectId,
+                projectName: this.localDevProcess.projectData.name,
+                projectId: this.localDevProcess.projectData.id,
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
                 targetProjectAccountId: this.localDevProcess.targetProjectAccountId,
                 targetTestingAccountId: this.localDevProcess.targetTestingAccountId,
             },
@@ -119,10 +165,24 @@ class LocalDevWebsocketServer {
             this.localDevProcess.removeStateListener('uploadWarnings', listener);
         });
     }
+    setupDevServersStartedListener(websocket) {
+        const listener = (devServersStarted) => {
+            if (devServersStarted) {
+                this.sendMessage(websocket, {
+                    type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEV_SERVERS_STARTED,
+                });
+            }
+        };
+        this.localDevProcess.addStateListener('devServersStarted', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('devServersStarted', listener);
+        });
+    }
     setupStateListeners(websocket) {
         this.setupProjectNodesListener(websocket);
         this.setupAppDataListener(websocket);
         this.setupUploadWarningsListener(websocket);
+        this.setupDevServersStartedListener(websocket);
     }
     async start() {
         const portManagerIsRunning = await isPortManagerServerRunning();
@@ -135,10 +195,11 @@ class LocalDevWebsocketServer {
         this.log(lib.LocalDevWebsocketServer.logs.startup(port));
         this.server.on('connection', (ws, req) => {
             const origin = req.headers.origin;
-            if (!origin || !this.ALLOWED_ORIGINS.includes(origin)) {
+            if (!origin || !ALLOWED_ORIGIN_REGEX.test(origin)) {
                 ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
                 return;
             }
+            this.sendCliMetadata(ws);
             this.sendProjectData(ws);
             this.setupMessageHandlers(ws);
             this.setupStateListeners(ws);

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

@@ -8,7 +8,7 @@ export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount):
 export declare function checkIfAccountFlagIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): void;
 export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[], accountConfig: CLIAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
-export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV3?: boolean): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV2?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;

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

@@ -138,7 +138,7 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
     }
 }
 // Create a developer test account and return its accountId
-export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV3 = false) {
+export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV2 = false) {
     let currentPortalCount = 0;
     let maxTestPortals = 10;
     try {
@@ -168,7 +168,7 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
         trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
-        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV3);
+        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
         return result;
     }
     catch (err) {

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

@@ -6,7 +6,8 @@ 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>;
+export declare function checkAndInstallDependencies(): Promise<void>;

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

@@ -18,8 +18,9 @@ import SpinniesManager from '../../../ui/SpinniesManager.js';
 import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { handleProjectUpload } from '../../upload.js';
 import { pollProjectBuildAndDeploy } from '../../pollProjectBuildAndDeploy.js';
-import { logError } from '../../../errorHandlers/index.js';
+import { debugError, logError } from '../../../errorHandlers/index.js';
 import { ApiErrorContext } from '../../../errorHandlers/index.js';
+import { getProjectPackageJsonLocations, hasMissingPackages, installPackages, } from '../../../dependencyManagement.js';
 // Prompt the user to create a new project if one doesn't exist on their target account
 export async function createNewProjectForLocalDev(projectConfig, targetAccountId, shouldCreateWithoutConfirmation, hasPublicApps) {
     // Create the project without prompting if this is a newly created sandbox
@@ -123,7 +124,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,7 +133,7 @@ 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,
@@ -144,26 +145,28 @@ 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-'));
         const { data: zippedProject } = await downloadProject(accountId, projectConfig.name, deployedBuildId);
-        const extractedProjectPath = path.join(tempDir, sanitizeFileName(projectConfig.name));
-        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { includesRootDir: false, hideLogs: true });
-        const deployedProjectSourceDir = path.join(extractedProjectPath, projectConfig.srcDir);
+        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { hideLogs: true });
+        const deployedProjectSourceDir = path.join(tempDir, projectConfig.srcDir);
         const { intermediateNodesIndexedByUid: deployedProjectNodes } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
             accountId: accountId,
-        }, {});
+        }, { profile });
         return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
     }
+    catch (err) {
+        debugError(err);
+        return false;
+    }
     finally {
         // Clean up temporary directory
         if (tempDir && (await fs.pathExists(tempDir))) {
@@ -171,3 +174,39 @@ export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountI
         }
     }
 }
+export async function checkAndInstallDependencies() {
+    SpinniesManager.init();
+    uiLogger.log('');
+    SpinniesManager.add('checkingDependencies', {
+        text: lib.localDevHelpers.project.checkAndInstallDependencies
+            .checkingDependencies,
+    });
+    try {
+        const installLocations = await getProjectPackageJsonLocations();
+        const locationsToInstall = [];
+        for (const location of installLocations) {
+            if (await hasMissingPackages(location)) {
+                locationsToInstall.push(location);
+            }
+        }
+        if (locationsToInstall.length > 0) {
+            SpinniesManager.remove('checkingDependencies');
+            await installPackages({ installLocations: locationsToInstall });
+        }
+        else {
+            SpinniesManager.succeed('checkingDependencies', {
+                text: lib.localDevHelpers.project.checkAndInstallDependencies
+                    .dependenciesUpToDate,
+            });
+        }
+        uiLogger.log('');
+    }
+    catch (e) {
+        logError(e);
+        SpinniesManager.fail('checkingDependencies', {
+            text: lib.localDevHelpers.project.checkAndInstallDependencies
+                .dependenciesFailure,
+        });
+        process.exit(EXIT_CODES.ERROR);
+    }
+}

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

@@ -0,0 +1,7 @@
+import { LocalDevDeployWebsocketMessage, LocalDevWebsocketMessage } from '../../../types/LocalDev.js';
+export declare function isUploadWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isDeployWebsocketMessage(message: LocalDevWebsocketMessage): message is LocalDevDeployWebsocketMessage;
+export declare function isViewedWelcomeScreenWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallSuccessWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallInitiatedWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallFailureWebsocketMessage(message: LocalDevWebsocketMessage): boolean;

package/lib/projects/localDev/localDevWebsocketServerUtils.js

@@ -0,0 +1,19 @@
+import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES } from '../../constants.js';
+export function isUploadWebsocketMessage(message) {
+    return message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD;
+}
+export function isDeployWebsocketMessage(message) {
+    return message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.DEPLOY;
+}
+export function isViewedWelcomeScreenWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN);
+}
+export function isAppInstallSuccessWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_SUCCESS);
+}
+export function isAppInstallInitiatedWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_INITIATED);
+}
+export function isAppInstallFailureWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_FAILURE);
+}

package/lib/projects/platformVersion.d.ts

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

package/lib/projects/platformVersion.js

@@ -1,4 +1,4 @@
-export function useV3Api(platformVersion) {
+export function isV2Project(platformVersion) {
     if (!platformVersion || typeof platformVersion !== 'string') {
         return false;
     }

package/lib/projects/pollProjectBuildAndDeploy.js

@@ -278,10 +278,10 @@ export async function displayWarnLogs(accountId, projectName, taskId, isDeploy =
         }
     }
     if (result && result.logs) {
-        const logLength = result.logs.length;
-        result.logs.forEach((log, i) => {
-            uiLogger.warn(log.message);
-            if (i < logLength - 1) {
+        const dedupedLogs = result.logs.reduce((acc, log) => acc.add(log.message), new Set());
+        Array.from(dedupedLogs).forEach((log, i) => {
+            uiLogger.warn(log);
+            if (i < dedupedLogs.size - 1) {
                 uiLogger.log('');
             }
         });

package/lib/projects/structure.js

@@ -1,14 +1,14 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { walk } from '@hubspot/local-dev-lib/fs';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { logError } from '../errorHandlers/index.js';
 import { ComponentTypes, } from '../../types/Projects.js';
-import { IR_COMPONENT_TYPES } from '../constants.js';
+import { IR_COMPONENT_TYPES, LEGACY_PRIVATE_APP_FILE, LEGACY_PUBLIC_APP_FILE, THEME_FILE, } from '../constants.js';
 export const CONFIG_FILES = {
-    [ComponentTypes.PrivateApp]: 'app.json',
-    [ComponentTypes.PublicApp]: 'public-app.json',
-    [ComponentTypes.HublTheme]: 'theme.json',
+    [ComponentTypes.PrivateApp]: LEGACY_PRIVATE_APP_FILE,
+    [ComponentTypes.PublicApp]: LEGACY_PUBLIC_APP_FILE,
+    [ComponentTypes.HublTheme]: THEME_FILE,
 };
 export function getComponentTypeFromConfigFile(configFile) {
     let key;
@@ -27,7 +27,7 @@ export function loadConfigFile(configPath) {
             return parsedConfig;
         }
         catch (e) {
-            logger.debug(e);
+            uiLogger.debug(e);
         }
     }
     return null;

package/lib/projects/upload.d.ts

@@ -18,7 +18,7 @@ type HandleProjectUploadArg<T> = {
     profile?: string;
 };
 export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
-export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig): void;
+export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig, projectDir: string): Promise<void>;
 export declare function validateNoHSMetaMismatch(srcDir: string, projectConfig: ProjectConfig): Promise<void>;
 export declare function handleTranslate(projectDir: string, projectConfig: ProjectConfig, accountId: number, skipValidation: boolean, profile: string | undefined): Promise<unknown>;
 export {};

package/lib/projects/upload.js

@@ -12,9 +12,11 @@ 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 './platformVersion.js';
+import { isV2Project } from './platformVersion.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import ProjectValidationError from '../errors/ProjectValidationError.js';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import { LEGACY_CONFIG_FILES } from '../constants.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     SpinniesManager.init({});
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
@@ -45,7 +47,7 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
 export async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
     try {
-        validateSourceDirectory(srcDir, projectConfig);
+        await validateSourceDirectory(srcDir, projectConfig, projectDir);
     }
     catch (e) {
         logError(e);
@@ -70,8 +72,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                 intermediateRepresentation = await handleTranslate(projectDir, projectConfig, accountId, skipValidation, profile);
             }
             catch (e) {
-                logError(e);
-                process.exit(EXIT_CODES.ERROR);
+                resolve({ uploadError: e });
             }
         }
         await ensureProjectExists(accountId, projectConfig.name, {
@@ -105,15 +106,23 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
     archive.finalize();
     return result;
 }
-export function validateSourceDirectory(srcDir, projectConfig) {
-    const filenames = fs.readdirSync(srcDir);
-    if (!filenames || filenames.length === 0) {
+export async function validateSourceDirectory(srcDir, projectConfig, projectDir) {
+    const projectFilePaths = await walk(srcDir, ['node_modules']);
+    if (!projectFilePaths || projectFilePaths.length === 0) {
         throw new ProjectValidationError(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
     }
+    if (isV2Project(projectConfig.platformVersion)) {
+        projectFilePaths.forEach(filePath => {
+            const filename = path.basename(filePath);
+            if (LEGACY_CONFIG_FILES.includes(filename)) {
+                uiLogger.warn(lib.projectUpload.handleProjectUpload.legacyFileDetected(path.relative(projectDir, filePath), projectConfig.platformVersion));
+            }
+        });
+    }
 }
 export async function validateNoHSMetaMismatch(srcDir, projectConfig) {
     const hasHsMetaFiles = await projectContainsHsMetaFiles(srcDir);
-    if (!useV3Api(projectConfig.platformVersion) && hasHsMetaFiles) {
+    if (!isV2Project(projectConfig.platformVersion) && hasHsMetaFiles) {
         throw new ProjectValidationError(lib.projectUpload.wrongPlatformVersionMetaFiles);
     }
 }

package/lib/projects/urls.d.ts

@@ -7,4 +7,3 @@ 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,6 +41,3 @@ 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__/downloadProjectPrompt.test.js

@@ -11,6 +11,7 @@ vi.mock('@hubspot/local-dev-lib/api/projects', () => ({
 }));
 vi.mock('@hubspot/local-dev-lib/config', () => ({
     getAccountId: vi.fn().mockImplementation(() => 123456789),
+    configFileExists: vi.fn().mockImplementation(() => true),
 }));
 describe('lib/prompts/downloadProjectPrompt', () => {
     it('should honor the account passed as an option', async () => {

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

@@ -1,5 +1,5 @@
 import { Separator } from '@inquirer/prompts';
-import { projectAddPromptV3 } from '../projectAddPrompt.js';
+import { projectAddPromptV2 } from '../projectAddPrompt.js';
 import { promptUser } from '../promptUtils.js';
 vi.mock('../promptUtils');
 const mockedPromptUser = vi.mocked(promptUser);
@@ -19,7 +19,7 @@ describe('lib/prompts/projectAddPrompt', () => {
         supportedAuthTypes: ['oauth'],
         supportedDistributions: ['private'],
     };
-    describe('projectAddPromptV3()', () => {
+    describe('projectAddPromptV2()', () => {
         beforeEach(() => {
             // Mock returns empty result, logic will use selectedComponents when selectedFeatures provided
             mockedPromptUser.mockResolvedValue({});
@@ -31,7 +31,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [templateChoice];
             const selectedFeatures = ['workflow-action-tool'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([
                 mockComponentTemplateWithCliSelector,
             ]);
@@ -49,7 +49,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [templateChoice];
             const selectedFeatures = ['module'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([mockComponentTemplate]);
             expect(mockedPromptUser).toHaveBeenCalledWith([
                 expect.objectContaining({
@@ -65,7 +65,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [templateChoice];
             const selectedFeatures = ['workflow-action-tool']; // matches cliSelector
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([
                 mockComponentTemplateWithCliSelector,
             ]);
@@ -78,7 +78,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             const components = [templateChoice];
             const selectedFeatures = ['non-matching-feature'];
             mockedPromptUser.mockResolvedValue({ componentTemplate: [] });
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([]);
         });
         it('should throw error when selected feature component is disabled', async () => {
@@ -89,7 +89,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [disabledTemplateChoice];
             const selectedFeatures = ['workflow-action-tool'];
-            await expect(projectAddPromptV3(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
+            await expect(projectAddPromptV2(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
         });
         it('should handle multiple components with mixed cliSelector availability', async () => {
             const choice1 = {
@@ -102,7 +102,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [choice1, choice2];
             const selectedFeatures = ['module', 'workflow-action-tool'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([
                 mockComponentTemplate,
                 mockComponentTemplateWithCliSelector,
@@ -116,7 +116,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [separator, templateChoice];
             const selectedFeatures = ['module'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([mockComponentTemplate]);
         });
         it('should prompt user when no selectedFeatures provided', async () => {
@@ -129,7 +129,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             mockedPromptUser.mockResolvedValue({
                 componentTemplate: [mockComponentTemplate],
             });
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(mockedPromptUser).toHaveBeenCalledWith([
                 expect.objectContaining({
                     name: 'componentTemplate',