@hubspot/cli 7.6.0-beta.0 → 7.6.0-beta.10

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -1,15 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ws_1 = require("ws");
-const portManager_1 = require("@hubspot/local-dev-lib/portManager");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const constants_1 = require("../../constants");
-const en_1 = require("../../../lang/en");
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+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 {
     server;
-    _websocket;
     debug;
     localDevProcess;
     ALLOWED_ORIGINS = [
@@ -22,62 +21,59 @@ class LocalDevWebsocketServer {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
     }
-    websocket() {
-        if (!this._websocket) {
-            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.notInitialized(LOG_PREFIX));
-        }
-        return this._websocket;
-    }
     log(message) {
         if (this.debug) {
-            logger_1.logger.log(LOG_PREFIX, message);
+            logger.log(LOG_PREFIX, message);
         }
     }
     logError(message) {
         if (this.debug) {
-            logger_1.logger.error(LOG_PREFIX, message);
+            logger.error(LOG_PREFIX, message);
         }
     }
-    sendMessage(message) {
-        this.websocket().send(JSON.stringify(message));
+    sendMessage(websocket, message) {
+        websocket.send(JSON.stringify(message));
     }
-    async handleUpload() {
+    async handleUpload(websocket) {
         const uploadSuccess = await this.localDevProcess.uploadProject();
         if (uploadSuccess) {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
             });
         }
         else {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
             });
         }
     }
-    setupMessageHandlers() {
-        this.websocket().on('message', data => {
+    setupMessageHandlers(websocket) {
+        websocket.on('message', data => {
             try {
                 const message = JSON.parse(data.toString());
                 if (!message.type) {
-                    this.logError(en_1.lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
+                    this.logError(lib.LocalDevWebsocketServer.errors.missingTypeField(data.toString()));
                     return;
                 }
                 switch (message.type) {
-                    case constants_1.LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
-                        this.handleUpload();
+                    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(en_1.lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
+                        this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
             }
             catch (e) {
-                this.logError(en_1.lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
+                this.logError(lib.LocalDevWebsocketServer.errors.invalidJSON(data.toString()));
             }
         });
     }
-    sendProjectData() {
-        this.sendMessage({
-            type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+    sendProjectData(websocket) {
+        this.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
             data: {
                 projectName: this.localDevProcess.projectName,
                 projectId: this.localDevProcess.projectId,
@@ -86,46 +82,73 @@ class LocalDevWebsocketServer {
             },
         });
     }
-    setupStateListeners() {
-        this.localDevProcess.addStateListener('projectNodes', nodes => {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+    setupProjectNodesListener(websocket) {
+        const listener = (nodes) => {
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
                 data: nodes,
             });
-        }, true);
-        this.localDevProcess.addStateListener('appData', appData => {
-            this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
+        };
+        this.localDevProcess.addStateListener('projectNodes', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('projectNodes', listener);
+        });
+    }
+    setupAppDataListener(websocket) {
+        const listener = (appData) => {
+            this.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
                 data: appData,
             });
-        }, 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 (0, portManager_1.isPortManagerServerRunning)();
+        const portManagerIsRunning = await isPortManagerServerRunning();
         if (!portManagerIsRunning) {
-            throw new Error(en_1.lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
+            throw new Error(lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
         }
-        const portData = await (0, portManager_1.requestPorts)([{ instanceId: SERVER_INSTANCE_ID }]);
+        const portData = await requestPorts([{ instanceId: SERVER_INSTANCE_ID }]);
         const port = portData[SERVER_INSTANCE_ID];
-        this.server = new ws_1.WebSocketServer({ port });
-        this.log(en_1.lib.LocalDevWebsocketServer.logs.startup(port));
+        this.server = new WebSocketServer({ port });
+        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)) {
-                ws.close(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
+                ws.close(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
                 return;
             }
-            this._websocket = ws;
-            this.sendProjectData();
-            this.setupMessageHandlers();
-            this.setupStateListeners();
-            this.localDevProcess.sendDevServerMessage(constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            this.sendProjectData(ws);
+            this.setupMessageHandlers(ws);
+            this.setupStateListeners(ws);
+            this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
+        this.server.on('close', () => { });
     }
     shutdown() {
         this.server?.close();
         this.server = undefined;
-        this._websocket = undefined;
     }
 }
-exports.default = LocalDevWebsocketServer;
+export default LocalDevWebsocketServer;

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

@@ -1,20 +1,14 @@
 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';
-import { Project } from '@hubspot/local-dev-lib/types/Project';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { ProjectConfig } from '../../../types/Projects';
-import { ProjectDevTargetAccountPromptResponse } from '../../prompts/projectDevTargetAccountPrompt';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.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;
 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): 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/account.js

@@ -0,0 +1,233 @@
+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 { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+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.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.account.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// Confirm the default account is supported for the type of apps being developed
+export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
+    const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
+    if (hasPublicApps &&
+        !(isAppDeveloperAccount(accountConfig) ||
+            isDeveloperTestAccount(accountConfig) ||
+            defaultAccountIsUnified)) {
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
+        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.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// Confirm the default account is a developer account if developing public apps
+export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
+    if (hasPublicApps) {
+        if (!isDeveloperTestAccount(accountConfig)) {
+            uiLogger.error(lib.localDevHelpers.account.validateAccountOption
+                .invalidPublicAppAccount);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        checkIfParentAccountIsAuthed(accountConfig);
+    }
+    else if (isAppDeveloperAccount(accountConfig)) {
+        uiLogger.error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// If the user isn't using the recommended account type, prompt them to use or create one
+export async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
+    uiLogger.log('');
+    uiLine();
+    if (hasPublicApps) {
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
+            .publicAppNonDeveloperTestAccountWarning);
+    }
+    else {
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
+    }
+    uiLine();
+    uiLogger.log('');
+    const targetAccountPrompt = hasPublicApps
+        ? selectDeveloperTestTargetAccountPrompt
+        : selectSandboxTargetAccountPrompt;
+    return targetAccountPrompt(accounts, accountConfig);
+}
+// Create a new sandbox and return its accountId
+export async function createSandboxForLocalDev(accountId, accountConfig, env) {
+    try {
+        await validateSandboxUsageLimits(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            uiLogger.error(lib.sandbox.create.developer.failure.scopes.message);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+            uiLogger.info(lib.sandbox.create.developer.failure.scopes.instructions(accountConfig.name || accountId, url));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        });
+        trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
+        const result = await buildSandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+        const targetAccountId = result.sandbox.sandboxHubId;
+        const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
+        if (!sandboxAccountConfig) {
+            uiLogger.error(lib.sandbox.create.developer.failure.generic);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
+        // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
+        await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks, true);
+        return targetAccountId;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Create a developer test account and return its accountId
+export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV3 = false) {
+    let currentPortalCount = 0;
+    let maxTestPortals = 10;
+    try {
+        const validateResult = await validateDevTestAccountUsageLimits(accountConfig);
+        if (validateResult) {
+            currentPortalCount = validateResult.results
+                ? validateResult.results.length
+                : 0;
+            maxTestPortals = validateResult.maxTestPortals;
+        }
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            uiLogger.error(lib.developerTestAccount.create.failure.scopes.message);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+            uiLogger.info(lib.developerTestAccount.create.failure.scopes.instructions(accountConfig.name || accountId, url));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            currentPortalCount,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        });
+        trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
+        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV3);
+        return result;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Prompt user to confirm usage of an existing developer test account that is not currently in the config
+export async function useExistingDevTestAccount(env, account) {
+    const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
+    if (!useExistingDevTestAcct) {
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
+        uiLogger.log('');
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
+    uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
+}
+export async function hasSandboxes(account) {
+    const accountId = getAccountIdentifier(account);
+    if (!accountId) {
+        return false;
+    }
+    try {
+        const { data: { usage }, } = await getSandboxUsageLimits(accountId);
+        return usage.STANDARD.limit > 0 || usage.DEVELOPER.limit > 0;
+    }
+    catch (e) {
+        debugError(e);
+        return false;
+    }
+}
+// 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.account.selectAccountTypePrompt.message, {
+        choices: [
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .developerTestAccountOption,
+                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            },
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .sandboxAccountOption,
+                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                disabled: !hasAccessToSandboxes
+                    ? lib.localDevHelpers.account.selectAccountTypePrompt
+                        .sandboxAccountOptionDisabled
+                    : false,
+            },
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .productionAccountOption,
+                value: null,
+            },
+        ],
+    });
+    return result;
+}

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,174 @@
+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,
+        });
+        uiLogger.log('');
+    }
+    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);
+        }
+    }
+}

package/lib/projects/structure.d.ts

@@ -1,6 +1,6 @@
-import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
-import { AppIRNode } from '../../types/ProjectComponents';
+import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects.js';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { AppIRNode } from '../../types/ProjectComponents.js';
 export declare const CONFIG_FILES: {
     [k in ComponentTypes]: string;
 };