@hubspot/cli 7.7.27-experimental.2 → 7.7.29-experimental.0

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

@@ -1,4 +1,3 @@
-import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ProjectConfig } from '../../../types/Projects.js';
@@ -12,15 +11,14 @@ declare class LocalDevState {
     private _projectId;
     private _projectName;
     private _debug;
-    private _deployedBuild?;
-    private _isGithubLinked;
     private _projectNodes;
     private _projectNodesAtLastUpload;
     private _env;
     private _listeners;
     private _appData;
     private _devServerMessage;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
+    private _uploadWarnings;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
@@ -30,8 +28,6 @@ declare class LocalDevState {
     get projectId(): number;
     get projectName(): string;
     get debug(): boolean;
-    get deployedBuild(): Build | undefined;
-    get isGithubLinked(): boolean;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
@@ -50,7 +46,10 @@ declare class LocalDevState {
     setAppDataForUid(uid: string, appData: AppLocalDevData): void;
     get devServerMessage(): string;
     set devServerMessage(message: LocalDevServerMessage);
-    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    get uploadWarnings(): Set<string>;
+    addUploadWarning(warning: string): void;
+    clearUploadWarnings(): void;
+    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
     removeListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -8,15 +8,14 @@ class LocalDevState {
     _projectId;
     _projectName;
     _debug;
-    _deployedBuild;
-    _isGithubLinked;
     _projectNodes;
     _projectNodesAtLastUpload;
     _env;
     _listeners;
     _appData;
     _devServerMessage;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, profile, env, }) {
+    _uploadWarnings;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, initialProjectNodes, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._profile = profile;
@@ -25,13 +24,12 @@ class LocalDevState {
         this._projectId = projectId;
         this._projectName = projectName;
         this._debug = debug || false;
-        this._deployedBuild = deployedBuild;
-        this._isGithubLinked = isGithubLinked;
         this._projectNodes = initialProjectNodes;
         this._projectNodesAtLastUpload = initialProjectNodes;
         this._env = env;
         this._appData = {};
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
+        this._uploadWarnings = new Set();
         this._listeners = {};
     }
     runListeners(key) {
@@ -63,12 +61,6 @@ class LocalDevState {
     get debug() {
         return this._debug;
     }
-    get deployedBuild() {
-        return this._deployedBuild && structuredClone(this._deployedBuild);
-    }
-    get isGithubLinked() {
-        return this._isGithubLinked;
-    }
     get projectNodes() {
         return structuredClone(this._projectNodes);
     }
@@ -102,14 +94,23 @@ class LocalDevState {
         this._devServerMessage = message;
         this.runListeners('devServerMessage');
     }
-    addListener(key, listener, callOnInit = false) {
+    get uploadWarnings() {
+        return this._uploadWarnings;
+    }
+    addUploadWarning(warning) {
+        this.uploadWarnings.add(warning);
+        this.runListeners('uploadWarnings');
+    }
+    clearUploadWarnings() {
+        this.uploadWarnings.clear();
+        this.runListeners('uploadWarnings');
+    }
+    addListener(key, listener) {
         if (!this._listeners[key]) {
             this._listeners[key] = [];
         }
         this._listeners[key].push(listener);
-        if (callOnInit) {
-            listener(this[key]);
-        }
+        listener(this[key]);
     }
     removeListener(key, listener) {
         if (this._listeners[key]) {

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

@@ -13,6 +13,7 @@ declare class LocalDevWebsocketServer {
     private sendProjectData;
     private setupProjectNodesListener;
     private setupAppDataListener;
+    private setupUploadWarningsListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -4,6 +4,7 @@ import { logger } from '@hubspot/local-dev-lib/logger';
 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 { lib } from '../../../lang/en.js';
+import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
 const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
 class LocalDevWebsocketServer {
@@ -88,7 +89,7 @@ class LocalDevWebsocketServer {
                 data: nodes,
             });
         };
-        this.localDevProcess.addStateListener('projectNodes', listener, true);
+        this.localDevProcess.addStateListener('projectNodes', listener);
         websocket.on('close', () => {
             this.localDevProcess.removeStateListener('projectNodes', listener);
         });
@@ -100,14 +101,28 @@ class LocalDevWebsocketServer {
                 data: appData,
             });
         };
-        this.localDevProcess.addStateListener('appData', listener, true);
+        this.localDevProcess.addStateListener('appData', listener);
         websocket.on('close', () => {
             this.localDevProcess.removeStateListener('appData', listener);
         });
     }
+    setupUploadWarningsListener(websocket) {
+        const listener = (uploadWarnings) => {
+            const formattedUploadWarnings = Array.from(uploadWarnings).map(removeAnsiCodes);
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_UPLOAD_WARNINGS,
+                data: { uploadWarnings: formattedUploadWarnings },
+            });
+        };
+        this.localDevProcess.addStateListener('uploadWarnings', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('uploadWarnings', listener);
+        });
+    }
     setupStateListeners(websocket) {
         this.setupProjectNodesListener(websocket);
         this.setupAppDataListener(websocket);
+        this.setupUploadWarningsListener(websocket);
     }
     async start() {
         const portManagerIsRunning = await isPortManagerServerRunning();

package/lib/projects/localDev/{helpers.d.ts → helpers/account.d.ts}

@@ -1,10 +1,7 @@
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
-import { Project } from '@hubspot/local-dev-lib/types/Project';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { ProjectConfig } from '../../../types/Projects.js';
-import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt.js';
+import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
 export declare function confirmDefaultAccountIsTarget(accountConfig: CLIAccount): Promise<void>;
 export declare function checkIfDefaultAccountIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): Promise<void>;
 export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount): void;
@@ -13,8 +10,5 @@ export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[],
 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 useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
-export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
-export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
-export declare function getAccountHomeUrl(accountId: number): string;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;

package/lib/projects/localDev/{helpers.js → helpers/account.js}

@@ -1,41 +1,44 @@
-import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
-import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getAccountConfig, getEnv } from '@hubspot/local-dev-lib/config';
-import { createProject } from '@hubspot/local-dev-lib/api/projects';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
 import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { confirmDefaultAccountPrompt, selectSandboxTargetAccountPrompt, selectDeveloperTestTargetAccountPrompt, confirmUseExistingDeveloperTestAccountPrompt, } from '../../prompts/projectDevTargetAccountPrompt.js';
-import { confirmPrompt, listPrompt } from '../../prompts/promptUtils.js';
-import { validateSandboxUsageLimits, getAvailableSyncTypes, } from '../../sandboxes.js';
-import { syncSandbox } from '../../sandboxSync.js';
-import { validateDevTestAccountUsageLimits } from '../../developerTestAccounts.js';
-import { uiLine, uiAccountDescription } from '../../ui/index.js';
-import SpinniesManager from '../../ui/SpinniesManager.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { trackCommandMetadataUsage } from '../../usageTracking.js';
-import { isAppDeveloperAccount, isDeveloperTestAccount, isUnifiedAccount, } from '../../accountTypes.js';
-import { handleProjectUpload } from '../../projects/upload.js';
-import { pollProjectBuildAndDeploy } from '../../projects/buildAndDeploy.js';
-import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } from '../../constants.js';
-import { logError, ApiErrorContext, debugError, } from '../../errorHandlers/index.js';
-import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../buildAccount.js';
-import { hubspotAccountNamePrompt } from '../../prompts/accountNamePrompt.js';
-import { lib } from '../../../lang/en.js';
-import { uiLogger } from '../../ui/logger.js';
+import { uiLogger } from '../../../ui/logger.js';
+import { lib } from '../../../../lang/en.js';
+import { EXIT_CODES } from '../../../enums/exitCodes.js';
+import { confirmDefaultAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+import { isUnifiedAccount } from '../../../accountTypes.js';
+import { isAppDeveloperAccount } from '../../../accountTypes.js';
+import { isDeveloperTestAccount } from '../../../accountTypes.js';
+import { uiAccountDescription } from '../../../ui/index.js';
+import { uiLine } from '../../../ui/index.js';
+import { selectDeveloperTestTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+import { selectSandboxTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+import { validateSandboxUsageLimits } from '../../../sandboxes.js';
+import { logError } from '../../../errorHandlers/index.js';
+import { syncSandbox } from '../../../sandboxSync.js';
+import { getAvailableSyncTypes } from '../../../sandboxes.js';
+import { hubspotAccountNamePrompt } from '../../../prompts/accountNamePrompt.js';
+import { trackCommandMetadataUsage } from '../../../usageTracking.js';
+import { validateDevTestAccountUsageLimits } from '../../../developerTestAccounts.js';
+import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../../buildAccount.js';
+import { debugError } from '../../../errorHandlers/index.js';
+import { listPrompt } from '../../../prompts/promptUtils.js';
+import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
 // If the user passed in the --account flag, confirm they want to use that account as
 // their target account, otherwise exit
 export async function confirmDefaultAccountIsTarget(accountConfig) {
     if (!accountConfig.name || !accountConfig.accountType) {
-        uiLogger.error(lib.localDevHelpers.confirmDefaultAccountIsTarget.configError);
+        uiLogger.error(lib.localDevHelpers.account.confirmDefaultAccountIsTarget.configError);
         process.exit(EXIT_CODES.ERROR);
     }
     uiLogger.log('');
     const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
     if (!useDefaultAccount) {
-        uiLogger.log(lib.localDevHelpers.confirmDefaultAccountIsTarget
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
         process.exit(EXIT_CODES.SUCCESS);
     }
@@ -47,18 +50,18 @@ export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicA
         !(isAppDeveloperAccount(accountConfig) ||
             isDeveloperTestAccount(accountConfig) ||
             defaultAccountIsUnified)) {
-        uiLogger.error(lib.localDevHelpers.checkIfDefaultAccountIsSupported.publicApp);
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
         process.exit(EXIT_CODES.SUCCESS);
     }
     else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.checkIfDefaultAccountIsSupported.privateApp);
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
 export function checkIfParentAccountIsAuthed(accountConfig) {
     if (!accountConfig.parentAccountId ||
         !getAccountConfig(accountConfig.parentAccountId)) {
-        uiLogger.error(lib.localDevHelpers.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
+        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
@@ -66,13 +69,14 @@ export function checkIfParentAccountIsAuthed(accountConfig) {
 export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps) {
         if (!isDeveloperTestAccount(accountConfig)) {
-            uiLogger.error(lib.localDevHelpers.validateAccountOption.invalidPublicAppAccount);
+            uiLogger.error(lib.localDevHelpers.account.validateAccountOption
+                .invalidPublicAppAccount);
             process.exit(EXIT_CODES.SUCCESS);
         }
         checkIfParentAccountIsAuthed(accountConfig);
     }
     else if (isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.validateAccountOption.invalidPrivateAppAccount);
+        uiLogger.error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
@@ -81,11 +85,11 @@ export async function suggestRecommendedNestedAccount(accounts, accountConfig, h
     uiLogger.log('');
     uiLine();
     if (hasPublicApps) {
-        uiLogger.log(lib.localDevHelpers.validateAccountOption
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
             .publicAppNonDeveloperTestAccountWarning);
     }
     else {
-        uiLogger.log(lib.localDevHelpers.validateAccountOption.nonSandboxWarning);
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
     }
     uiLine();
     uiLogger.log('');
@@ -177,7 +181,7 @@ export async function useExistingDevTestAccount(env, account) {
     const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
     if (!useExistingDevTestAcct) {
         uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.confirmDefaultAccountIsTarget
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
         uiLogger.log('');
         process.exit(EXIT_CODES.SUCCESS);
@@ -185,110 +189,6 @@ export async function useExistingDevTestAccount(env, account) {
     const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
     uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
 }
-// 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
-    let shouldCreateProject = shouldCreateWithoutConfirmation;
-    if (!shouldCreateProject) {
-        const explanationLangFunction = hasPublicApps
-            ? lib.localDevHelpers.createNewProjectForLocalDev
-                .publicAppProjectMustExistExplanation
-            : lib.localDevHelpers.createNewProjectForLocalDev
-                .projectMustExistExplanation;
-        const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
-        uiLogger.log('');
-        uiLine();
-        uiLogger.log(explanationString);
-        uiLine();
-        shouldCreateProject = await confirmPrompt(lib.localDevHelpers.createNewProjectForLocalDev.createProject(projectConfig.name, uiAccountDescription(targetAccountId)));
-    }
-    if (shouldCreateProject) {
-        SpinniesManager.add('createProject', {
-            text: lib.localDevHelpers.createNewProjectForLocalDev.creatingProject(projectConfig.name, uiAccountDescription(targetAccountId)),
-        });
-        try {
-            const { data: project } = await createProject(targetAccountId, projectConfig.name);
-            SpinniesManager.succeed('createProject', {
-                text: lib.localDevHelpers.createNewProjectForLocalDev.createdProject(projectConfig.name, uiAccountDescription(targetAccountId)),
-                succeedColor: 'white',
-            });
-            return project;
-        }
-        catch (err) {
-            SpinniesManager.fail('createProject');
-            uiLogger.log(lib.localDevHelpers.createNewProjectForLocalDev.failedToCreateProject);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    else {
-        // We cannot continue if the project does not exist in the target account
-        uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.createNewProjectForLocalDev.choseNotToCreateProject);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-}
-function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
-    if (!buildId) {
-        uiLogger.error(lib.localDevHelpers.createInitialBuildForNewProject.genericError);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    return pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, true);
-}
-// Create an initial build if the project was newly created in the account
-// Return the newly deployed build
-export async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
-    const { result: initialUploadResult, uploadError } = await handleProjectUpload({
-        accountId: targetAccountId,
-        projectConfig,
-        projectDir,
-        callbackFunc: projectUploadCallback,
-        uploadMessage: lib.localDevHelpers.createInitialBuildForNewProject
-            .initialUploadMessage,
-        forceCreate: true,
-        skipValidation: true,
-        sendIR,
-        profile,
-    });
-    if (uploadError) {
-        if (isSpecifiedError(uploadError, {
-            subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
-        })) {
-            uiLogger.log('');
-            uiLogger.error(lib.localDevHelpers.createInitialBuildForNewProject.projectLockedError);
-            uiLogger.log('');
-        }
-        else {
-            logError(uploadError, new ApiErrorContext({
-                accountId: targetAccountId,
-                projectName: projectConfig.name,
-            }));
-        }
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!initialUploadResult?.succeeded) {
-        let subTasks = [];
-        if (initialUploadResult?.buildResult.status === 'FAILURE') {
-            subTasks =
-                initialUploadResult.buildResult[PROJECT_BUILD_TEXT.SUBTASK_KEY];
-        }
-        else if (initialUploadResult?.deployResult?.status === 'FAILURE') {
-            subTasks =
-                initialUploadResult.deployResult[PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
-        }
-        const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
-        uiLogger.log('');
-        failedSubTasks.forEach(failedSubTask => {
-            uiLogger.error(failedSubTask.errorMessage);
-        });
-        uiLogger.log('');
-        process.exit(EXIT_CODES.ERROR);
-    }
-    return initialUploadResult.buildResult;
-}
-export function getAccountHomeUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
-    return `${baseUrl}/home?portalId=${accountId}`;
-}
 export async function hasSandboxes(account) {
     const accountId = getAccountIdentifier(account);
     if (!accountId) {
@@ -306,25 +206,25 @@ export async function hasSandboxes(account) {
 // Top level prompt to choose the type of account to test on
 export async function selectAccountTypePrompt(accountConfig) {
     const hasAccessToSandboxes = await hasSandboxes(accountConfig);
-    const result = await listPrompt(lib.localDevHelpers.selectAccountTypePrompt.message, {
+    const accountId = getAccountIdentifier(accountConfig);
+    const result = await listPrompt(lib.localDevHelpers.account.selectAccountTypePrompt.message, {
         choices: [
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
                     .developerTestAccountOption,
                 value: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
             },
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
                     .sandboxAccountOption,
                 value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 disabled: !hasAccessToSandboxes
-                    ? lib.localDevHelpers.selectAccountTypePrompt
+                    ? lib.localDevHelpers.account.selectAccountTypePrompt
                         .sandboxAccountOptionDisabled
                     : false,
             },
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
-                    .productionAccountOption,
+                name: lib.localDevHelpers.account.selectAccountTypePrompt.productionAccountOption(accountId),
                 value: null,
             },
         ],

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

@@ -0,0 +1,12 @@
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { ProjectConfig } from '../../../../types/Projects.js';
+export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
+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>;
+export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): Promise<boolean>;

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

@@ -0,0 +1,173 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { createProject } from '@hubspot/local-dev-lib/api/projects';
+import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
+import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import { sanitizeFileName } from '@hubspot/local-dev-lib/path';
+import { isDeepEqual } from '@hubspot/local-dev-lib/isDeepEqual';
+import { translate } from '@hubspot/project-parsing-lib';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } from '../../../constants.js';
+import { lib } from '../../../../lang/en.js';
+import { uiLogger } from '../../../ui/logger.js';
+import { uiLine } from '../../../ui/index.js';
+import { confirmPrompt } from '../../../prompts/promptUtils.js';
+import { uiAccountDescription } from '../../../ui/index.js';
+import SpinniesManager from '../../../ui/SpinniesManager.js';
+import { EXIT_CODES } from '../../../enums/exitCodes.js';
+import { handleProjectUpload } from '../../upload.js';
+import { pollProjectBuildAndDeploy } from '../../buildAndDeploy.js';
+import { logError } from '../../../errorHandlers/index.js';
+import { ApiErrorContext } from '../../../errorHandlers/index.js';
+// Prompt the user to create a new project if one doesn't exist on their target account
+export async function createNewProjectForLocalDev(projectConfig, targetAccountId, shouldCreateWithoutConfirmation, hasPublicApps) {
+    // Create the project without prompting if this is a newly created sandbox
+    let shouldCreateProject = shouldCreateWithoutConfirmation;
+    if (!shouldCreateProject) {
+        const explanationLangFunction = hasPublicApps
+            ? lib.localDevHelpers.project.createNewProjectForLocalDev
+                .publicAppProjectMustExistExplanation
+            : lib.localDevHelpers.project.createNewProjectForLocalDev
+                .projectMustExistExplanation;
+        const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
+        uiLogger.log('');
+        uiLine();
+        uiLogger.log(explanationString);
+        uiLine();
+        shouldCreateProject = await confirmPrompt(lib.localDevHelpers.project.createNewProjectForLocalDev.createProject(projectConfig.name, uiAccountDescription(targetAccountId)));
+    }
+    if (shouldCreateProject) {
+        SpinniesManager.add('createProject', {
+            text: lib.localDevHelpers.project.createNewProjectForLocalDev.creatingProject(projectConfig.name, uiAccountDescription(targetAccountId)),
+        });
+        try {
+            const { data: project } = await createProject(targetAccountId, projectConfig.name);
+            SpinniesManager.succeed('createProject', {
+                text: lib.localDevHelpers.project.createNewProjectForLocalDev.createdProject(projectConfig.name, uiAccountDescription(targetAccountId)),
+                succeedColor: 'white',
+            });
+            return project;
+        }
+        catch (err) {
+            SpinniesManager.fail('createProject');
+            uiLogger.log(lib.localDevHelpers.project.createNewProjectForLocalDev
+                .failedToCreateProject);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        // We cannot continue if the project does not exist in the target account
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.project.createNewProjectForLocalDev
+            .choseNotToCreateProject);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
+    if (!buildId) {
+        uiLogger.error(lib.localDevHelpers.project.createInitialBuildForNewProject.genericError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    return pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, true);
+}
+// Create an initial build if the project was newly created in the account
+// Return the newly deployed build
+export async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
+    const { result: initialUploadResult, uploadError } = await handleProjectUpload({
+        accountId: targetAccountId,
+        projectConfig,
+        projectDir,
+        callbackFunc: projectUploadCallback,
+        uploadMessage: lib.localDevHelpers.project.createInitialBuildForNewProject
+            .initialUploadMessage,
+        forceCreate: true,
+        skipValidation: true,
+        sendIR,
+        profile,
+    });
+    if (uploadError) {
+        if (isSpecifiedError(uploadError, {
+            subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
+        })) {
+            uiLogger.log('');
+            uiLogger.error(lib.localDevHelpers.project.createInitialBuildForNewProject
+                .projectLockedError);
+            uiLogger.log('');
+        }
+        else {
+            logError(uploadError, new ApiErrorContext({
+                accountId: targetAccountId,
+                projectName: projectConfig.name,
+            }));
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (!initialUploadResult?.succeeded) {
+        let subTasks = [];
+        if (initialUploadResult?.buildResult.status === 'FAILURE') {
+            subTasks =
+                initialUploadResult.buildResult[PROJECT_BUILD_TEXT.SUBTASK_KEY];
+        }
+        else if (initialUploadResult?.deployResult?.status === 'FAILURE') {
+            subTasks =
+                initialUploadResult.deployResult[PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
+        }
+        const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
+        uiLogger.log('');
+        failedSubTasks.forEach(failedSubTask => {
+            uiLogger.error(failedSubTask.errorMessage);
+        });
+        uiLogger.log('');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    return initialUploadResult.buildResult;
+}
+export async function compareLocalProjectToDeployed(projectConfig, accountId, deployedBuildId, localProjectNodes) {
+    uiLogger.log('');
+    if (!deployedBuildId) {
+        uiLogger.error(lib.localDevHelpers.project.compareLocalProjectToDeployed.noDeployedBuild(projectConfig.name, uiAccountDescription(accountId)));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    SpinniesManager.add('compareLocalProjectToDeployed', {
+        text: lib.localDevHelpers.project.compareLocalProjectToDeployed.checking,
+    });
+    const isUpToDate = await isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes);
+    if (isUpToDate) {
+        SpinniesManager.succeed('compareLocalProjectToDeployed', {
+            text: lib.localDevHelpers.project.compareLocalProjectToDeployed.upToDate,
+        });
+    }
+    else {
+        SpinniesManager.fail('compareLocalProjectToDeployed', {
+            text: lib.localDevHelpers.project.compareLocalProjectToDeployed
+                .notUpToDate,
+        });
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.project.compareLocalProjectToDeployed
+            .notUpToDateExplanation);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes) {
+    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);
+        const { intermediateNodesIndexedByUid: deployedProjectNodes } = await translate({
+            projectSourceDir: deployedProjectSourceDir,
+            platformVersion: projectConfig.platformVersion,
+            accountId: accountId,
+        }, {});
+        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
+    }
+    finally {
+        // Clean up temporary directory
+        if (tempDir && (await fs.pathExists(tempDir))) {
+            await fs.remove(tempDir);
+        }
+    }
+}