@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/lib/projects/localDev/AppDevModeInterface.js

@@ -3,17 +3,17 @@ import { fetchAppMetadataBySourceId, fetchPublicAppProductionInstallCounts, inst
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { isAppIRNode } from '../../projects/structure.js';
 import { uiLine } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
+import { isPromptExitError } from '../../errors/PromptExitError.js';
 import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { lib } from '../../../lang/en.js';
 import { uiLogger } from '../../ui/logger.js';
 import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
-import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 import { isServerRunningAtUrl } from '../../http.js';
+import { canUseStaticAuthTestAccountInstall, getAppInstallationState, getAppNodeFromProjectNodes, isMarketplaceApp, isOAuthApp, } from '../../app/install.js';
 class AppDevModeInterface {
     localDevState;
     localDevLogger;
@@ -27,16 +27,13 @@ class AppDevModeInterface {
             !this.localDevState.projectConfig ||
             !this.localDevState.projectDir) {
             uiLogger.error(lib.LocalDevManager.failedToInitialize);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.LocalDevManager.failedToInitialize);
         }
     }
-    getAppNodeFromProjectNodes(projectNodes) {
-        return Object.values(projectNodes).find(isAppIRNode) || null;
-    }
     // Assumes only one app per project
     get appNode() {
         if (this._appNode === undefined) {
-            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
+            this._appNode = getAppNodeFromProjectNodes(this.localDevState.projectNodes);
         }
         return this._appNode;
     }
@@ -45,12 +42,12 @@ class AppDevModeInterface {
         // App data will never be accessed before being set
         if (!this.appNode) {
             uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.AppDevModeInterface.appDataNotFound);
         }
         const data = this.localDevState.getAppDataByUid(this.appNode.uid);
         if (!data) {
             uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
-            process.exit(EXIT_CODES.ERROR);
+            throw new Error(lib.AppDevModeInterface.appDataNotFound);
         }
         return data;
     }
@@ -60,25 +57,16 @@ class AppDevModeInterface {
         }
         this.localDevState.setAppDataForUid(this.appNode.uid, appData);
     }
-    isStaticAuthApp() {
-        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC);
-    }
-    isOAuthApp() {
-        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH);
-    }
     isAutomaticallyInstallable() {
         const targetTestingAccount = getConfigAccountById(this.localDevState.targetTestingAccountId);
-        if (!targetTestingAccount) {
-            return false;
-        }
-        const isTestAccount = isDeveloperTestAccount(targetTestingAccount) ||
-            isSandbox(targetTestingAccount);
-        const hasCorrectParent = targetTestingAccount.parentAccountId ===
-            this.localDevState.targetProjectAccountId;
-        return isTestAccount && hasCorrectParent && this.isStaticAuthApp();
+        return canUseStaticAuthTestAccountInstall({
+            accountConfig: targetTestingAccount,
+            appNode: this.appNode,
+            parentAccountId: this.localDevState.targetProjectAccountId,
+        });
     }
     async getAppInstallUrl() {
-        if (this.appNode && this.isOAuthApp()) {
+        if (this.appNode && isOAuthApp(this.appNode)) {
             return getOauthAppInstallUrl({
                 targetAccountId: this.localDevState.targetTestingAccountId,
                 env: this.localDevState.env,
@@ -107,7 +95,7 @@ class AppDevModeInterface {
                 text: lib.AppDevModeInterface.fetchAppData.error,
             });
             logError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return this.localDevState.actions.exit(EXIT_CODES.ERROR);
         }
         if (!appData) {
             return;
@@ -135,7 +123,7 @@ class AppDevModeInterface {
         uiLine();
         const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
         if (!proceed) {
-            process.exit(EXIT_CODES.SUCCESS);
+            return this.localDevState.actions.exit(EXIT_CODES.SUCCESS);
         }
         this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
     }
@@ -155,7 +143,7 @@ class AppDevModeInterface {
         const shouldInstall = await installAppAutoPrompt();
         if (!shouldInstall) {
             uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
-            process.exit(EXIT_CODES.SUCCESS);
+            return this.localDevState.actions.exit(EXIT_CODES.SUCCESS);
         }
         uiLogger.log('');
         SpinniesManager.add('autoInstallStaticAuthApp', {
@@ -194,26 +182,17 @@ class AppDevModeInterface {
             return {};
         }
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await fetchAppInstallationData(this.localDevState.targetTestingAccountId, this.localDevState.projectId, this.appNode.uid, this.appNode.config.auth.requiredScopes, this.appNode.config.auth.optionalScopes);
-        const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
-        if (isInstalledWithScopeGroups) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED,
-            };
-        }
-        else if (isReinstall) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
-            };
-        }
-        else {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
-            };
-        }
-        return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
+        const installationState = getAppInstallationState(isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups);
+        const isReinstall = installationState ===
+            APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES;
+        this.appData = {
+            ...this.appData,
+            installationState,
+        };
+        return {
+            needsInstall: installationState !== APP_INSTALLATION_STATES.INSTALLED,
+            isReinstall,
+        };
     }
     async validateOauthAppRedirectUrl() {
         const redirectUrl = this.appNode?.config.auth.redirectUrls[0];
@@ -224,7 +203,7 @@ class AppDevModeInterface {
         if (!serverIsRunningAtRedirectUrl) {
             uiLogger.log('');
             uiLogger.error(lib.AppDevModeInterface.oauthAppRedirectUrlError(redirectUrl));
-            process.exit(EXIT_CODES.ERROR);
+            return this.localDevState.actions.exit(EXIT_CODES.ERROR);
         }
     }
     resolveAppInstallPromise() {
@@ -245,7 +224,7 @@ class AppDevModeInterface {
     }
     handleAppInstallFailureDevServerMessage() {
         uiLogger.error(lib.AppDevModeInterface.installationFailed);
-        process.exit(EXIT_CODES.ERROR);
+        this.localDevState.actions.exit(EXIT_CODES.ERROR);
     }
     onDevServerMessage = async (message) => {
         if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
@@ -262,7 +241,7 @@ class AppDevModeInterface {
         }
     };
     onChangeProjectNodes = (nodes) => {
-        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
+        const newAppNode = getAppNodeFromProjectNodes(nodes);
         const oldDistribution = this.appNode?.config.distribution;
         const newDistribution = newAppNode?.config.distribution;
         const oldAuthType = this.appNode?.config.auth.type;
@@ -286,7 +265,7 @@ class AppDevModeInterface {
         }
         try {
             await this.fetchAppData();
-            if (this.appNode.config.distribution === APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+            if (isMarketplaceApp(this.appNode)) {
                 await this.checkMarketplaceAppInstalls();
             }
             const { needsInstall, isReinstall } = await this.checkTestAccountAppInstallation();
@@ -297,7 +276,7 @@ class AppDevModeInterface {
                         failColor: 'white',
                     });
                 }
-                if (this.isOAuthApp()) {
+                if (isOAuthApp(this.appNode)) {
                     await this.validateOauthAppRedirectUrl();
                 }
                 this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
@@ -313,6 +292,9 @@ class AppDevModeInterface {
             }
         }
         catch (e) {
+            if (isPromptExitError(e)) {
+                throw e;
+            }
             if (SpinniesManager.pick('fetchAppData')) {
                 SpinniesManager.fail('fetchAppData', {
                     text: lib.AppDevModeInterface.fetchAppData.error,
@@ -320,7 +302,7 @@ class AppDevModeInterface {
                 });
             }
             logError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return this.localDevState.actions.exit(EXIT_CODES.ERROR);
         }
     }
     async start() {

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

@@ -1,14 +1,17 @@
 import LocalDevLogger from './LocalDevLogger.js';
+import { ExitFunction } from '../../../types/Yargs.js';
 type DevSessionManagerConstructorOptions = {
     targetTestingAccountId: number;
-    localDevLogger?: LocalDevLogger;
+    localDevLogger: LocalDevLogger;
+    exit: ExitFunction;
 };
 declare class DevSessionManager {
-    localDevLogger?: LocalDevLogger;
+    localDevLogger: LocalDevLogger;
     targetTestingAccountId: number;
-    protected _devSessionId: number | undefined;
-    private _heartbeatInterval;
-    private _heartbeatRetries;
+    protected devSessionId: number | undefined;
+    private heartbeatInterval;
+    private heartbeatRetries;
+    private exit;
     constructor(options: DevSessionManagerConstructorOptions);
     private validateSessionIdExists;
     registerSession(): Promise<boolean>;

package/lib/projects/localDev/DevSessionManager.js

@@ -1,32 +1,26 @@
 import { getActiveServers } from '@hubspot/local-dev-lib/portManager';
 import { devSessionHeartbeat, registerDevSession, deleteDevSession, } from './helpers/devSessionsApi.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { uiLogger } from '../../ui/logger.js';
 import { lib } from '../../../lang/en.js';
-import { getErrorMessage } from '../../errorHandlers/index.js';
 class DevSessionManager {
     localDevLogger;
     targetTestingAccountId;
-    _devSessionId;
-    _heartbeatInterval;
-    _heartbeatRetries;
+    devSessionId;
+    heartbeatInterval;
+    heartbeatRetries;
+    exit;
     constructor(options) {
         this.targetTestingAccountId = options.targetTestingAccountId;
         this.localDevLogger = options.localDevLogger;
-        this._devSessionId = undefined;
-        this._heartbeatInterval = undefined;
-        this._heartbeatRetries = 0;
+        this.exit = options.exit;
+        this.devSessionId = undefined;
+        this.heartbeatInterval = undefined;
+        this.heartbeatRetries = 0;
     }
     validateSessionIdExists() {
-        if (!this._devSessionId) {
-            if (this.localDevLogger) {
-                this.localDevLogger.devSessionMissingSessionIdError();
-            }
-            else {
-                // Fallback for deprecated local dev manager
-                uiLogger.error(lib.LocalDevManager.devSession.missingSessionIdError);
-            }
-            process.exit(EXIT_CODES.ERROR);
+        if (!this.devSessionId) {
+            this.localDevLogger.devSessionMissingSessionIdError();
+            throw new Error(lib.LocalDevManager.devSession.missingSessionIdError);
         }
     }
     async registerSession() {
@@ -34,58 +28,50 @@ class DevSessionManager {
             const activeServers = await getActiveServers();
             const portData = Object.entries(activeServers).map(([serverId, port]) => ({ serverId, port }));
             const registerDevSessionResponse = await registerDevSession(this.targetTestingAccountId, portData);
-            this._devSessionId = registerDevSessionResponse.data.sessionId;
+            this.devSessionId = registerDevSessionResponse.data.sessionId;
         }
         catch (e) {
-            if (this.localDevLogger) {
-                this.localDevLogger.devSessionRegistrationError(e);
-            }
-            else {
-                // Fallback for deprecated local dev manager
-                uiLogger.error(lib.LocalDevManager.devSession.registrationError(getErrorMessage(e)));
-            }
+            this.localDevLogger.devSessionRegistrationError(e);
             return false;
         }
-        this.validateSessionIdExists();
+        try {
+            this.validateSessionIdExists();
+        }
+        catch {
+            return this.exit(EXIT_CODES.ERROR);
+        }
         this.initializeHeartbeat();
         return true;
     }
     initializeHeartbeat() {
-        this._heartbeatInterval = setInterval(async () => {
-            this.validateSessionIdExists();
+        this.heartbeatInterval = setInterval(async () => {
+            try {
+                this.validateSessionIdExists();
+            }
+            catch {
+                return this.exit(EXIT_CODES.ERROR);
+            }
             try {
-                await devSessionHeartbeat(this.targetTestingAccountId, this._devSessionId);
+                await devSessionHeartbeat(this.targetTestingAccountId, this.devSessionId);
             }
             catch (e) {
-                if (this._heartbeatRetries < 3) {
-                    this._heartbeatRetries++;
+                if (this.heartbeatRetries < 3) {
+                    this.heartbeatRetries++;
                     return;
                 }
-                if (this.localDevLogger) {
-                    this.localDevLogger.devSessionHeartbeatError(e);
-                }
-                else {
-                    // Fallback for deprecated local dev manager
-                    uiLogger.error(lib.LocalDevManager.devSession.heartbeatError(getErrorMessage(e)));
-                }
-                process.exit(EXIT_CODES.ERROR);
+                this.localDevLogger.devSessionHeartbeatError(e);
+                return this.exit(EXIT_CODES.ERROR);
             }
         }, 30000);
     }
     async deleteDevSession() {
-        if (this._devSessionId) {
-            clearInterval(this._heartbeatInterval);
+        if (this.devSessionId) {
+            clearInterval(this.heartbeatInterval);
             try {
-                await deleteDevSession(this.targetTestingAccountId, this._devSessionId);
+                await deleteDevSession(this.targetTestingAccountId, this.devSessionId);
             }
             catch (e) {
-                if (this.localDevLogger) {
-                    this.localDevLogger.devSessionDeletionError(e);
-                }
-                else {
-                    // Fallback for deprecated local dev manager
-                    uiLogger.error(lib.LocalDevManager.devSession.deletionError(getErrorMessage(e)));
-                }
+                this.localDevLogger.devSessionDeletionError(e);
                 return false;
             }
         }

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

@@ -22,6 +22,10 @@ declare class LocalDevLogger {
     cleanupError(): void;
     cleanupSuccess(): void;
     uploadInitiated(): void;
+    autoUploadScheduled(filePath: string): void;
+    autoUploadTriggered(): void;
+    autoUploadInProgress(): void;
+    autoUploadToggled(enabled: boolean): void;
     deployInitiated(): void;
     projectConfigMismatch(): void;
     uploadError(error: unknown): void;

package/lib/projects/localDev/LocalDevLogger.js

@@ -99,6 +99,10 @@ class LocalDevLogger {
             uiLogger.log('');
             uiLogger.log(lib.LocalDevManager.localDevUIAutoMessage(this.state.targetTestingAccountId, showWelcomeScreen));
         }
+        if (this.state.autoUploadEnabled) {
+            uiLogger.log('');
+            uiLogger.log(lib.LocalDevManager.autoUploadEnabled);
+        }
         uiLogger.log('');
         uiLogger.log(lib.LocalDevManager.quitHelper);
         uiLine();
@@ -122,6 +126,20 @@ class LocalDevLogger {
     uploadInitiated() {
         uiLogger.log(lib.LocalDevProcess.uploadInitiated);
     }
+    autoUploadScheduled(filePath) {
+        uiLogger.debug(lib.LocalDevProcess.autoUploadScheduled(filePath));
+    }
+    autoUploadTriggered() {
+        uiLogger.debug(lib.LocalDevProcess.autoUploadTriggered);
+    }
+    autoUploadInProgress() {
+        uiLogger.debug(lib.LocalDevProcess.autoUploadInProgress);
+    }
+    autoUploadToggled(enabled) {
+        uiLogger.log('');
+        uiLogger.log(lib.LocalDevProcess.autoUploadToggled(enabled));
+        uiLogger.log('');
+    }
     deployInitiated() {
         uiLogger.log(lib.LocalDevProcess.deployInitiated);
     }

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

@@ -8,6 +8,9 @@ declare class LocalDevProcess {
     private _logger;
     private devServerManager;
     private devSessionManager;
+    private autoUploadTimeout;
+    private pendingAutoUpload;
+    private autoUploadStopped;
     constructor(options: LocalDevStateConstructorOptions);
     get projectDir(): string;
     get projectData(): Project;
@@ -17,6 +20,10 @@ declare class LocalDevProcess {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
     get logger(): LocalDevLogger;
+    get autoUploadEnabled(): boolean;
+    setAutoUploadEnabled(enabled: boolean): void;
+    get autoUploadAvailable(): boolean;
+    private isAutoDeployEnabled;
     private setupDevServers;
     private startDevServers;
     private cleanupDevServers;
@@ -27,10 +34,13 @@ declare class LocalDevProcess {
     private openLocalDevUi;
     private updateProjectData;
     handleFileChange(filePath: string, event: string): Promise<void>;
-    handleConfigFileChange(): Promise<void>;
+    handleConfigFileChange(configFilePath: string): Promise<void>;
+    private scheduleAutoUpload;
+    private runAutoUpload;
     start(): Promise<void>;
     stop(showProgress?: boolean): Promise<void>;
     uploadProject(): Promise<LocalDevProjectUploadResult>;
+    private performUpload;
     deployLatestBuild(force?: boolean): Promise<LocalDevProjectDeployResult>;
     addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
     sendDevServerMessage(message: LocalDevServerMessage): void;

package/lib/projects/localDev/LocalDevProcess.js

@@ -17,11 +17,15 @@ import { getLocalDevUiUrl } from '../urls.js';
 import { CONFIG_LOCAL_STATE_FLAGS, PROJECT_DEPLOY_STATES, } from '../../constants.js';
 import { lib } from '../../../lang/en.js';
 import { debugError } from '../../errorHandlers/index.js';
+const AUTO_UPLOAD_DEBOUNCE_MS = 2000;
 class LocalDevProcess {
     state;
     _logger;
     devServerManager;
     devSessionManager;
+    autoUploadTimeout = null;
+    pendingAutoUpload = false;
+    autoUploadStopped = false;
     constructor(options) {
         this.state = new LocalDevState(options);
         this._logger = new LocalDevLogger(this.state);
@@ -32,6 +36,7 @@ class LocalDevProcess {
         this.devSessionManager = new DevSessionManager({
             targetTestingAccountId: this.state.targetTestingAccountId,
             localDevLogger: this._logger,
+            exit: this.state.actions.exit,
         });
     }
     get projectDir() {
@@ -52,6 +57,27 @@ class LocalDevProcess {
     get logger() {
         return this._logger;
     }
+    get autoUploadEnabled() {
+        return this.state.autoUploadEnabled;
+    }
+    setAutoUploadEnabled(enabled) {
+        this.state.autoUploadEnabled = enabled;
+        this.logger.autoUploadToggled(enabled);
+        if (!enabled) {
+            if (this.autoUploadTimeout) {
+                clearTimeout(this.autoUploadTimeout);
+                this.autoUploadTimeout = null;
+            }
+            this.pendingAutoUpload = false;
+        }
+    }
+    get autoUploadAvailable() {
+        return this.isAutoDeployEnabled();
+    }
+    isAutoDeployEnabled() {
+        const { deployedBuild, latestBuild } = this.state.projectData;
+        return (deployedBuild ?? latestBuild)?.isAutoDeployEnabled ?? true;
+    }
     async setupDevServers() {
         try {
             await this.devServerManager.setup();
@@ -68,7 +94,7 @@ class LocalDevProcess {
         }
         catch (e) {
             this.logger.devServerStartError(e);
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
     }
     async cleanupDevServers() {
@@ -82,20 +108,20 @@ class LocalDevProcess {
         }
     }
     async projectConfigValidForUpload() {
-        const { projectConfig } = await getProjectConfig();
-        if (!projectConfig) {
+        let projectConfig;
+        try {
+            ({ projectConfig } = getProjectConfig());
+        }
+        catch {
             return false;
         }
-        Object.keys(projectConfig).forEach(key => {
+        return Object.keys(projectConfig).every(key => {
             const field = key;
-            if (projectConfig[field] !== this.state.projectConfig[field]) {
-                return false;
-            }
+            return projectConfig[field] === this.state.projectConfig[field];
         });
-        return true;
     }
-    getIntermediateRepresentation(projectNodesAtLastDeploy) {
-        return translateForLocalDev({
+    async getIntermediateRepresentation(projectNodesAtLastDeploy) {
+        const { intermediateRepresentation } = await translateForLocalDev({
             projectSourceDir: path.join(this.state.projectDir, this.state.projectConfig.srcDir),
             platformVersion: this.state.projectConfig.platformVersion,
             accountId: this.state.targetProjectAccountId,
@@ -103,6 +129,7 @@ class LocalDevProcess {
             projectNodesAtLastUpload: projectNodesAtLastDeploy,
             profile: this.state.profile,
         });
+        return intermediateRepresentation;
     }
     async updateProjectNodes() {
         const intermediateRepresentation = await this.getIntermediateRepresentation(this.state.projectNodesAtLastDeploy);
@@ -139,30 +166,78 @@ class LocalDevProcess {
         catch (e) {
             this.logger.fileChangeError(e);
         }
+        this.scheduleAutoUpload(filePath);
     }
-    async handleConfigFileChange() {
+    async handleConfigFileChange(configFilePath) {
         await this.updateProjectNodes();
-        this.logger.uploadWarning();
+        if (this.state.autoUploadEnabled) {
+            this.scheduleAutoUpload(configFilePath);
+        }
+        else {
+            this.logger.uploadWarning();
+        }
+    }
+    scheduleAutoUpload(changedPath) {
+        if (!this.state.autoUploadEnabled || this.autoUploadStopped) {
+            return;
+        }
+        this.logger.autoUploadScheduled(changedPath ?? 'project files');
+        if (this.autoUploadTimeout) {
+            clearTimeout(this.autoUploadTimeout);
+        }
+        this.autoUploadTimeout = setTimeout(() => {
+            this.autoUploadTimeout = null;
+            void this.runAutoUpload();
+        }, AUTO_UPLOAD_DEBOUNCE_MS);
+    }
+    async runAutoUpload() {
+        if (this.autoUploadStopped) {
+            return;
+        }
+        if (this.state.uploadInProgress) {
+            this.logger.autoUploadInProgress();
+            this.pendingAutoUpload = true;
+            return;
+        }
+        this.logger.autoUploadTriggered();
+        try {
+            await this.uploadProject();
+        }
+        catch (e) {
+            this.logger.uploadError(e);
+        }
+        finally {
+            if (this.pendingAutoUpload) {
+                this.pendingAutoUpload = false;
+                this.scheduleAutoUpload();
+            }
+        }
     }
     async start() {
         this.logger.resetSpinnies();
         const setupSucceeded = await this.setupDevServers();
         if (!setupSucceeded) {
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
         this.logger.startupMessage();
-        if (isConfigFlagEnabled(CONFIG_FLAGS.AUTO_OPEN_BROWSER, true)) {
-            this.openLocalDevUi();
-        }
         await this.startDevServers();
         const devSessionRegistered = await this.devSessionManager.registerSession();
         if (!devSessionRegistered) {
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
+        }
+        if (isConfigFlagEnabled(CONFIG_FLAGS.AUTO_OPEN_BROWSER, true)) {
+            this.openLocalDevUi();
         }
         this.state.devServersStarted = true;
         this.logger.monitorConsoleOutput();
     }
     async stop(showProgress = true) {
+        this.autoUploadStopped = true;
+        this.pendingAutoUpload = false;
+        if (this.autoUploadTimeout) {
+            clearTimeout(this.autoUploadTimeout);
+            this.autoUploadTimeout = null;
+        }
         if (showProgress) {
             this.logger.cleanupStart();
         }
@@ -172,14 +247,23 @@ class LocalDevProcess {
             if (showProgress) {
                 this.logger.cleanupError();
             }
-            process.exit(EXIT_CODES.ERROR);
+            return this.state.actions.exit(EXIT_CODES.ERROR);
         }
         if (showProgress) {
             this.logger.cleanupSuccess();
         }
-        process.exit(EXIT_CODES.SUCCESS);
+        return this.state.actions.exit(EXIT_CODES.SUCCESS);
     }
     async uploadProject() {
+        this.state.uploadInProgress = true;
+        try {
+            return await this.performUpload();
+        }
+        finally {
+            this.state.uploadInProgress = false;
+        }
+    }
+    async performUpload() {
         this.logger.uploadInitiated();
         const isUploadable = await this.projectConfigValidForUpload();
         if (!isUploadable) {
@@ -196,6 +280,7 @@ class LocalDevProcess {
             projectDir: this.state.projectDir,
             callbackFunc: pollProjectBuildAndDeploy,
             sendIR: true,
+            force: true,
         });
         const deploy = result?.deployResult;
         if (uploadError) {