@hubspot/cli 8.2.1-experimental.0 → 8.2.1-experimental.1

package/lib/errors/ProjectErrors.js

@@ -4,18 +4,6 @@ export class ProjectNestingError extends Error {
         this.name = 'ProjectNestingError';
     }
 }
-export class ProjectConfigNotFoundError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ProjectConfigNotFoundError';
-    }
-}
-export class ProjectValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ProjectValidationError';
-    }
-}
 export class ProjectUploadError extends Error {
     constructor(message, cause) {
         super(message, { cause });

package/lib/errors/ProjectValidationError.d.ts

@@ -1,4 +1,5 @@
+import { ProjectConfigValidationError } from '@hubspot/project-parsing-lib/projects';
 export default class ProjectValidationError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
-export declare function isProjectValidationError(err: unknown): err is ProjectValidationError;
+export declare function isProjectValidationError(err: unknown): err is ProjectValidationError | ProjectConfigValidationError;

package/lib/errors/ProjectValidationError.js

@@ -1,3 +1,4 @@
+import { ProjectConfigValidationError } from '@hubspot/project-parsing-lib/projects';
 export default class ProjectValidationError extends Error {
     constructor(message, options) {
         super(message, options);
@@ -5,5 +6,6 @@ export default class ProjectValidationError extends Error {
     }
 }
 export function isProjectValidationError(err) {
-    return err instanceof ProjectValidationError;
+    return (err instanceof ProjectValidationError ||
+        err instanceof ProjectConfigValidationError);
 }

package/lib/getStartedV2Actions.js

@@ -11,8 +11,8 @@ import { translate, } from '@hubspot/project-parsing-lib/translate';
 import { commands, lib } from '../lang/en.js';
 import { getStaticAuthAppInstallUrl } from '../lib/app/urls.js';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_CONFIG_FILE, } from '../lib/constants.js';
-import { ProjectNestingError, ProjectConfigNotFoundError, ProjectValidationError, ProjectUploadError, ProjectBuildDeployError, } from './errors/ProjectErrors.js';
-import { getProjectConfig, validateProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
+import { ProjectNestingError, ProjectUploadError, ProjectBuildDeployError, } from './errors/ProjectErrors.js';
+import { getProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
 import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { pollProjectBuildAndDeploy } from '../lib/projects/pollProjectBuildAndDeploy.js';
 import { handleProjectUpload } from '../lib/projects/upload.js';
@@ -29,11 +29,17 @@ export async function createProjectAction({ projectName, projectDest, }) {
             : 'Invalid project directory');
     }
     const projectDestAbsolute = path.resolve(getCwd(), projectDest);
-    const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDestAbsolute);
-    if (existingProjectConfig &&
-        existingProjectDir &&
-        projectDestAbsolute.startsWith(existingProjectDir)) {
-        throw new ProjectNestingError(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+    try {
+        const { projectDir: existingProjectDir } = getProjectConfig(projectDestAbsolute);
+        if (projectDestAbsolute.startsWith(existingProjectDir)) {
+            throw new ProjectNestingError(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+        }
+    }
+    catch (error) {
+        if (error instanceof ProjectNestingError) {
+            throw error;
+        }
+        // Not in a project directory, which is the expected case
     }
     try {
         await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDestAbsolute, {
@@ -88,17 +94,7 @@ async function buildProjectMetadata(projectDir, projectConfig, accountId) {
     };
 }
 export async function uploadAndDeployAction({ accountId, projectDest, }) {
-    const { projectConfig, projectDir } = await getProjectConfig(projectDest);
-    if (!projectConfig || !projectDir) {
-        throw new ProjectConfigNotFoundError(commands.getStarted.errors.configFileNotFound);
-    }
-    try {
-        validateProjectConfig(projectConfig, projectDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new ProjectValidationError(message);
-    }
+    const { projectConfig, projectDir } = getProjectConfig(projectDest);
     const env = getConfigAccountEnvironment(accountId);
     try {
         const { result, uploadError } = await handleProjectUpload({

package/lib/jsonOutput.d.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Release } from '../api/releases.js';
 declare const ReleaseComponentSchema: z.ZodObject<{
     buildType: z.ZodString;
@@ -35,6 +37,74 @@ export declare const ReleaseListSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+declare const BuildSubbuildStatusSchema: z.ZodObject<{
+    buildName: z.ZodString;
+    buildType: z.ZodString;
+    status: z.ZodString;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const BuildSchema: z.ZodObject<{
+    buildId: z.ZodNumber;
+    status: z.ZodString;
+    isDeployed: z.ZodBoolean;
+    isAutoDeployEnabled: z.ZodOptional<z.ZodBoolean>;
+    deployableState: z.ZodOptional<z.ZodString>;
+    platformVersion: z.ZodOptional<z.ZodString>;
+    uploadMessage: z.ZodOptional<z.ZodString>;
+    enqueuedAt: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    subbuildStatuses: z.ZodArray<z.ZodObject<{
+        buildName: z.ZodString;
+        buildType: z.ZodString;
+        status: z.ZodString;
+        errorMessage: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ProjectBuildsListSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    deployedBuildId: z.ZodOptional<z.ZodNumber>;
+    results: z.ZodArray<z.ZodObject<{
+        buildId: z.ZodNumber;
+        status: z.ZodString;
+        isDeployed: z.ZodBoolean;
+        isAutoDeployEnabled: z.ZodOptional<z.ZodBoolean>;
+        deployableState: z.ZodOptional<z.ZodString>;
+        platformVersion: z.ZodOptional<z.ZodString>;
+        uploadMessage: z.ZodOptional<z.ZodString>;
+        enqueuedAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        subbuildStatuses: z.ZodArray<z.ZodObject<{
+            buildName: z.ZodString;
+            buildType: z.ZodString;
+            status: z.ZodString;
+            errorMessage: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            finishedAt: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    paging: z.ZodOptional<z.ZodObject<{
+        next: z.ZodObject<{
+            after: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const ProjectInfoSchema: z.ZodObject<{
     projectName: z.ZodString;
     platformVersion: z.ZodString;
@@ -58,7 +128,17 @@ declare const PreviewSchema: z.ZodObject<{
     releaseTag: z.ZodOptional<z.ZodString>;
     succeeded: z.ZodBoolean;
 }, z.core.$strip>;
+declare const TargetAccountSchema: z.ZodObject<{
+    accountId: z.ZodNumber;
+    accountName: z.ZodOptional<z.ZodString>;
+    accountType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const UploadSchema: z.ZodObject<{
+    targetAccount: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodNumber;
+        accountName: z.ZodOptional<z.ZodString>;
+        accountType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     buildId: z.ZodOptional<z.ZodNumber>;
     deployId: z.ZodOptional<z.ZodNumber>;
     preview: z.ZodOptional<z.ZodObject<{
@@ -98,12 +178,18 @@ export declare const CreateTestAccountSchema: z.ZodObject<{
 export type ReleaseComponentJsonOutput = z.infer<typeof ReleaseComponentSchema>;
 export type ReleaseJsonOutput = z.infer<typeof ReleaseSchema>;
 export type ReleaseListJsonOutput = z.infer<typeof ReleaseListSchema>;
+export type BuildSubbuildStatusJsonOutput = z.infer<typeof BuildSubbuildStatusSchema>;
+export type BuildJsonOutput = z.infer<typeof BuildSchema>;
+export type ProjectBuildsListJsonOutput = z.infer<typeof ProjectBuildsListSchema>;
 export type ProjectInfoJsonOutput = z.infer<typeof ProjectInfoSchema>;
 export type PreviewJsonOutput = z.infer<typeof PreviewSchema>;
+export type TargetAccountJsonOutput = z.infer<typeof TargetAccountSchema>;
 export type UploadJsonOutput = z.infer<typeof UploadSchema>;
 export type DeployJsonOutput = z.infer<typeof DeploySchema>;
 export type InstallStatusJsonOutput = z.infer<typeof InstallStatusSchema>;
 export type InstallAppJsonOutput = z.infer<typeof InstallAppSchema>;
 export type CreateTestAccountJsonOutput = z.infer<typeof CreateTestAccountSchema>;
+export declare function mapAccountToTargetAccount(accountId: number, account?: HubSpotConfigAccount | null): TargetAccountJsonOutput;
+export declare function mapBuildToJsonOutput(build: Build, deployedBuildId?: number): BuildJsonOutput;
 export declare function mapReleaseToJsonOutput(release: Release): ReleaseJsonOutput;
 export {};

package/lib/jsonOutput.js

@@ -21,6 +21,43 @@ export const ReleaseListSchema = z.object({
     })
         .optional(),
 });
+const BuildSubbuildStatusSchema = z.object({
+    buildName: z.string(),
+    buildType: z.string(),
+    status: z.string(),
+    errorMessage: z.string().optional(),
+    startedAt: z.string().optional(),
+    finishedAt: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+    visible: z.boolean().optional(),
+});
+export const BuildSchema = z.object({
+    buildId: z.number(),
+    status: z.string(),
+    isDeployed: z.boolean(),
+    isAutoDeployEnabled: z.boolean().optional(),
+    deployableState: z.string().optional(),
+    platformVersion: z.string().optional(),
+    uploadMessage: z.string().optional(),
+    enqueuedAt: z.string().optional(),
+    startedAt: z.string().optional(),
+    finishedAt: z.string().optional(),
+    createdAt: z.string().optional(),
+    subbuildStatuses: z.array(BuildSubbuildStatusSchema),
+});
+export const ProjectBuildsListSchema = z.object({
+    projectName: z.string(),
+    deployedBuildId: z.number().optional(),
+    results: z.array(BuildSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
 export const ProjectInfoSchema = z.object({
     projectName: z.string(),
     platformVersion: z.string(),
@@ -43,7 +80,13 @@ const PreviewSchema = z.object({
     releaseTag: z.string().optional(),
     succeeded: z.boolean(),
 });
+const TargetAccountSchema = z.object({
+    accountId: z.number(),
+    accountName: z.string().optional(),
+    accountType: z.string().optional(),
+});
 export const UploadSchema = z.object({
+    targetAccount: TargetAccountSchema.optional(),
     buildId: z.number().optional(),
     deployId: z.number().optional(),
     preview: PreviewSchema.optional(),
@@ -78,6 +121,40 @@ export const CreateTestAccountSchema = z.object({
     accountId: z.number().optional(),
     personalAccessKey: z.string().optional(),
 });
+export function mapAccountToTargetAccount(accountId, account) {
+    return {
+        accountId,
+        accountName: account?.name,
+        accountType: account?.accountType,
+    };
+}
+export function mapBuildToJsonOutput(build, deployedBuildId) {
+    const { buildId, status, isAutoDeployEnabled, deployableState, platformVersion, uploadMessage, enqueuedAt, startedAt, finishedAt, createdAt, subbuildStatuses, } = build;
+    return {
+        buildId,
+        status,
+        isDeployed: buildId === deployedBuildId,
+        isAutoDeployEnabled,
+        deployableState,
+        platformVersion,
+        uploadMessage,
+        enqueuedAt,
+        startedAt,
+        finishedAt,
+        createdAt,
+        subbuildStatuses: subbuildStatuses.map(subbuild => ({
+            buildName: subbuild.buildName,
+            buildType: subbuild.buildType,
+            status: subbuild.status,
+            errorMessage: subbuild.errorMessage,
+            startedAt: subbuild.startedAt,
+            finishedAt: subbuild.finishedAt,
+            rootPath: subbuild.rootPath,
+            id: subbuild.id,
+            visible: subbuild.visible,
+        })),
+    };
+}
 export function mapReleaseToJsonOutput(release) {
     const { releaseTag, buildId, createdAt, components } = release;
     return {

package/lib/npm/packageJson.js

@@ -92,7 +92,7 @@ const findAllPackageJsonFilesInDirectoryCached = async (directory) => {
  * @returns Array of absolute paths to package.json files in the project
  */
 export async function findAllPackageJsonFilesInProjectCached() {
-    const projectConfig = await getProjectConfig();
+    const projectConfig = getProjectConfig();
     const { projectDir } = projectConfig;
     if (!projectDir) {
         return [];

package/lib/projects/ProjectLogsManager.js

@@ -34,10 +34,7 @@ class _ProjectLogsManager {
         this.functions = [];
     }
     async init(accountId) {
-        const { projectConfig } = await getProjectConfig();
-        if (!projectConfig || !projectConfig.name) {
-            throw new Error(commands.project.logs.errors.noProjectConfig);
-        }
+        const { projectConfig } = getProjectConfig();
         this.projectConfig = projectConfig;
         this.projectName = projectConfig.name;
         this.accountId = accountId;

package/lib/projects/config.d.ts

@@ -1,9 +1,10 @@
-import { ProjectConfig } from '../../types/Projects.js';
+import type { ProjectConfig } from '@hubspot/project-parsing-lib/projects';
+export { ProjectConfigValidationError } from '@hubspot/project-parsing-lib/projects';
+export type { ProjectConfig } from '@hubspot/project-parsing-lib/projects';
 export declare function writeProjectConfig(configPath: string, config: ProjectConfig): boolean;
 export declare function getIsInProject(dir?: string): boolean;
 export interface LoadedProjectConfig {
-    projectDir: string | null;
-    projectConfig: ProjectConfig | null;
+    projectDir: string;
+    projectConfig: ProjectConfig;
 }
-export declare function getProjectConfig(dir?: string): Promise<LoadedProjectConfig>;
-export declare function validateProjectConfig(projectConfig: ProjectConfig | null, projectDir: string | null): asserts projectConfig is ProjectConfig;
+export declare function getProjectConfig(dir?: string): LoadedProjectConfig;

package/lib/projects/config.js

@@ -2,10 +2,11 @@ import fs from 'fs-extra';
 import path from 'path';
 import findup from 'findup-sync';
 import { getAbsoluteFilePath, getCwd } from '@hubspot/local-dev-lib/path';
+import { parseProjectConfig, ProjectConfigValidationError, } from '@hubspot/project-parsing-lib/projects';
 import { PROJECT_CONFIG_FILE } from '../constants.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
-import ProjectValidationError from '../errors/ProjectValidationError.js';
+export { ProjectConfigValidationError } from '@hubspot/project-parsing-lib/projects';
 export function writeProjectConfig(configPath, config) {
     try {
         fs.ensureFileSync(configPath);
@@ -30,44 +31,12 @@ function getProjectConfigPath(dir) {
     });
     return configPath;
 }
-export async function getProjectConfig(dir) {
+export function getProjectConfig(dir) {
     const configPath = getProjectConfigPath(dir);
     if (!configPath) {
-        return { projectConfig: null, projectDir: null };
-    }
-    try {
-        const config = fs.readFileSync(configPath);
-        const projectConfig = JSON.parse(config.toString());
-        return {
-            projectDir: path.dirname(configPath),
-            projectConfig,
-        };
-    }
-    catch (e) {
-        uiLogger.error(lib.projects.getProjectConfig.error);
-        return { projectConfig: null, projectDir: null };
-    }
-}
-export function validateProjectConfig(projectConfig, projectDir) {
-    if (!projectConfig || !projectDir) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.configNotFound);
-    }
-    const missingFields = [];
-    if (!projectConfig.name) {
-        missingFields.push('name');
-    }
-    if (!projectConfig.srcDir) {
-        missingFields.push('srcDir');
-    }
-    if (missingFields.length > 0) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.configMissingFields(missingFields));
-    }
-    const resolvedPath = path.resolve(projectDir, projectConfig.srcDir);
-    if (!resolvedPath.startsWith(projectDir)) {
-        const projectConfigFile = path.relative('.', path.join(projectDir, PROJECT_CONFIG_FILE));
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
-    }
-    if (!fs.existsSync(resolvedPath)) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
+        throw new ProjectConfigValidationError(lib.projects.validateProjectConfig.configNotFound);
     }
+    const projectDir = path.dirname(configPath);
+    const projectConfig = parseProjectConfig(projectDir);
+    return { projectDir, projectConfig };
 }

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);
@@ -53,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();
@@ -83,17 +108,17 @@ 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;
     }
     async getIntermediateRepresentation(projectNodesAtLastDeploy) {
         const { intermediateRepresentation } = await translateForLocalDev({
@@ -141,10 +166,52 @@ 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();
@@ -165,6 +232,12 @@ class LocalDevProcess {
         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();
         }
@@ -182,6 +255,15 @@ class LocalDevProcess {
         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) {

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

@@ -21,8 +21,10 @@ declare class LocalDevState {
     private _devServerMessage;
     private _uploadWarnings;
     private _devServersStarted;
+    private _autoUploadEnabled;
+    private _uploadInProgress;
     actions: LocalDevActions;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, actions, }: LocalDevStateConstructorOptions);
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, actions, autoUploadEnabled, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
@@ -56,6 +58,10 @@ declare class LocalDevState {
     get uploadWarnings(): Set<string>;
     get devServersStarted(): boolean;
     set devServersStarted(started: boolean);
+    get autoUploadEnabled(): boolean;
+    set autoUploadEnabled(autoUploadEnabled: boolean);
+    get uploadInProgress(): boolean;
+    set uploadInProgress(inProgress: boolean);
     addUploadWarning(warning: string): void;
     clearUploadWarnings(): void;
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;