@hubspot/cli 8.0.2-experimental.0 → 8.0.3-experimental.0

package/lib/marketplaceValidate.d.ts

@@ -2,7 +2,7 @@ import { GetValidationResultsResponse } from '@hubspot/local-dev-lib/types/Marke
 export declare function kickOffValidation(accountId: number, assetType: string, src: string): Promise<number>;
 export declare function pollForValidationFinish(accountId: number, validationId: number): Promise<void>;
 export declare function fetchValidationResults(accountId: number, validationId: number): Promise<GetValidationResultsResponse>;
-export declare function processValidationErrors(invalidPathError: (path: string) => string, validationResults: GetValidationResultsResponse): void;
+export declare function hasProcessValidationErrors(invalidPathError: (path: string) => string, validationResults: GetValidationResultsResponse): boolean;
 type ResultsCopy = {
     noErrors: string;
     required: string;

package/lib/marketplaceValidate.js

@@ -1,54 +1,35 @@
 import chalk from 'chalk';
 import { requestValidation, getValidationStatus, getValidationResults, } from '@hubspot/local-dev-lib/api/marketplaceValidation';
 import { uiLogger } from './ui/logger.js';
-import { EXIT_CODES } from './enums/exitCodes.js';
 const SLEEP_TIME = 2000;
 export async function kickOffValidation(accountId, assetType, src) {
     const requestGroup = 'EXTERNAL_DEVELOPER';
-    try {
-        const { data: requestResult } = await requestValidation(accountId, {
-            path: src,
-            assetType,
-            requestGroup,
-        });
-        return requestResult;
-    }
-    catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
+    const { data: requestResult } = await requestValidation(accountId, {
+        path: src,
+        assetType,
+        requestGroup,
+    });
+    return requestResult;
 }
 export async function pollForValidationFinish(accountId, validationId) {
-    try {
-        const checkValidationStatus = async () => {
-            const { data: validationStatus } = await getValidationStatus(accountId, {
-                validationId,
-            });
-            if (validationStatus === 'REQUESTED') {
-                await new Promise(resolve => setTimeout(resolve, SLEEP_TIME));
-                await checkValidationStatus();
-            }
-        };
-        await checkValidationStatus();
-    }
-    catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
-}
-export async function fetchValidationResults(accountId, validationId) {
-    try {
-        const { data: validationResults } = await getValidationResults(accountId, {
+    async function checkValidationStatus() {
+        const { data: validationStatus } = await getValidationStatus(accountId, {
             validationId,
         });
-        return validationResults;
-    }
-    catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        if (validationStatus === 'REQUESTED') {
+            await new Promise(resolve => setTimeout(resolve, SLEEP_TIME));
+            await checkValidationStatus();
+        }
     }
+    await checkValidationStatus();
+}
+export async function fetchValidationResults(accountId, validationId) {
+    const { data: validationResults } = await getValidationResults(accountId, {
+        validationId,
+    });
+    return validationResults;
 }
-export function processValidationErrors(invalidPathError, validationResults) {
+export function hasProcessValidationErrors(invalidPathError, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
@@ -56,11 +37,12 @@ export function processValidationErrors(invalidPathError, validationResults) {
                 uiLogger.error(invalidPathError(assetPath));
             }
             else {
-                uiLogger.error(`${err.context}`);
+                uiLogger.error(err.context);
             }
         });
-        process.exit(EXIT_CODES.ERROR);
+        return true;
     }
+    return false;
 }
 function displayFileInfo(file, line, resultsCopy) {
     if (file) {

package/lib/projects/ProjectLogsManager.d.ts

@@ -1,10 +1,18 @@
-import { AppFunctionComponentMetadata } from '@hubspot/local-dev-lib/types/ComponentStructure';
+import { ProjectConfig } from '../../types/Projects.js';
+type FunctionInfo = {
+    componentName: string;
+    appId: number;
+    endpoint?: {
+        path: string;
+    };
+};
 declare class _ProjectLogsManager {
     projectName: string | undefined;
+    projectConfig: ProjectConfig | undefined;
     projectId: number | undefined;
     accountId: number | undefined;
-    functions: AppFunctionComponentMetadata[];
-    selectedFunction: AppFunctionComponentMetadata | undefined;
+    functions: FunctionInfo[];
+    selectedFunction: FunctionInfo | undefined;
     functionName: string | undefined;
     appId: number | undefined;
     isPublicFunction: boolean | undefined;
@@ -13,6 +21,7 @@ declare class _ProjectLogsManager {
     constructor();
     init(accountId: number): Promise<void>;
     fetchFunctionDetails(): Promise<void>;
+    fetchFunctionDetailsV2(deployedBuildId: number): Promise<void>;
     getFunctionNames(): string[];
     setFunction(functionName?: string): void;
 }

package/lib/projects/ProjectLogsManager.js

@@ -1,10 +1,15 @@
 import { getProjectConfig } from './config.js';
 import { ensureProjectExists } from './ensureProjectExists.js';
 import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
 import { uiLogger } from '../ui/logger.js';
 import { commands } from '../../lang/en.js';
+import { isV2Project } from './platformVersion.js';
+import { getDeployedProjectNodes } from './localDev/helpers/project.js';
+import { debugError } from '../errorHandlers/index.js';
 class _ProjectLogsManager {
     projectName;
+    projectConfig;
     projectId;
     accountId;
     functions;
@@ -15,6 +20,7 @@ class _ProjectLogsManager {
     endpointName;
     reset() {
         this.projectName = undefined;
+        this.projectConfig = undefined;
         this.projectId = undefined;
         this.accountId = undefined;
         this.functions = [];
@@ -32,8 +38,8 @@ class _ProjectLogsManager {
         if (!projectConfig || !projectConfig.name) {
             throw new Error(commands.project.logs.errors.noProjectConfig);
         }
-        const { name: projectName } = projectConfig;
-        this.projectName = projectName;
+        this.projectConfig = projectConfig;
+        this.projectName = projectConfig.name;
         this.accountId = accountId;
         this.functions = [];
         const { project } = await ensureProjectExists(this.accountId, this.projectName, {
@@ -45,7 +51,16 @@ class _ProjectLogsManager {
             throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
         }
         this.projectId = project.id;
-        await this.fetchFunctionDetails();
+        if (isV2Project(projectConfig.platformVersion)) {
+            const deployedBuildId = project.deployedBuild.buildId;
+            if (!deployedBuildId) {
+                throw new Error(commands.project.logs.errors.noDeployedBuild);
+            }
+            await this.fetchFunctionDetailsV2(deployedBuildId);
+        }
+        else {
+            await this.fetchFunctionDetails();
+        }
     }
     async fetchFunctionDetails() {
         if (!this.projectId) {
@@ -61,14 +76,60 @@ class _ProjectLogsManager {
             return type && type.name === 'PRIVATE_APP';
         });
         apps.forEach(app => {
-            this.functions.push(
-            // If component type is APP_FUNCTION, we can safely cast as AppFunctionComponentMetadata
-            ...app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION'));
+            const appFunctions = app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION');
+            appFunctions.forEach(fn => {
+                if (fn.deployOutput) {
+                    this.functions.push({
+                        componentName: fn.componentName,
+                        appId: fn.deployOutput.appId,
+                        endpoint: fn.deployOutput.endpoint,
+                    });
+                }
+            });
         });
         if (this.functions.length === 0) {
             throw new Error(commands.project.logs.errors.noFunctionsInProject);
         }
     }
+    async fetchFunctionDetailsV2(deployedBuildId) {
+        if (!this.projectId || !this.accountId || !this.projectConfig) {
+            uiLogger.debug(commands.project.logs.errors.projectLogsManagerNotInitialized);
+            throw new Error(commands.project.logs.errors.generic);
+        }
+        let deployedNodes;
+        try {
+            deployedNodes = await getDeployedProjectNodes(this.projectConfig, this.accountId, deployedBuildId);
+        }
+        catch (err) {
+            debugError(err);
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        const appNode = Object.values(deployedNodes).find(node => node.componentType === 'APPLICATION');
+        if (!appNode) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+        let appId;
+        try {
+            const { data: appMetadata } = await fetchAppMetadataBySourceId(this.projectId, appNode.uid, this.accountId);
+            appId = appMetadata.id;
+        }
+        catch (err) {
+            debugError(err);
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        const functionNodes = Object.values(deployedNodes).filter(node => node.componentType === 'APP_FUNCTION');
+        for (const fnNode of functionNodes) {
+            const config = fnNode.config;
+            this.functions.push({
+                componentName: fnNode.uid,
+                appId,
+                endpoint: config.endpoint,
+            });
+        }
+        if (this.functions.length === 0) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+    }
     getFunctionNames() {
         return this.functions.map(serverlessFunction => serverlessFunction.componentName);
     }
@@ -81,12 +142,9 @@ class _ProjectLogsManager {
             throw new Error(commands.project.logs.errors.noFunctionWithName(functionName));
         }
         this.functionName = functionName;
-        if (!this.selectedFunction.deployOutput) {
-            throw new Error(commands.project.logs.errors.functionNotDeployed(functionName));
-        }
-        this.appId = this.selectedFunction.deployOutput.appId;
-        if (this.selectedFunction.deployOutput.endpoint) {
-            this.endpointName = this.selectedFunction.deployOutput.endpoint.path;
+        this.appId = this.selectedFunction.appId;
+        if (this.selectedFunction.endpoint) {
+            this.endpointName = this.selectedFunction.endpoint.path;
             this.isPublicFunction = true;
         }
         else {

package/lib/projects/__tests__/ProjectLogsManager.test.js

@@ -2,6 +2,9 @@ import { ProjectLogsManager } from '../ProjectLogsManager.js';
 import { getProjectConfig } from '../config.js';
 import { ensureProjectExists } from '../ensureProjectExists.js';
 import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
+import { getDeployedProjectNodes } from '../localDev/helpers/project.js';
+import { isV2Project } from '../platformVersion.js';
 const SUBCOMPONENT_TYPES = {
     APP_ID: 'APP_ID',
     PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
@@ -17,11 +20,20 @@ const SUBCOMPONENT_TYPES = {
 vi.mock('../../projects/config');
 vi.mock('../../projects/ensureProjectExists');
 vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/api/appsDev');
+vi.mock('../../projects/localDev/helpers/project');
+vi.mock('../../projects/platformVersion');
 describe('lib/projects/ProjectLogsManager', () => {
     const accountId = 12345678;
     const appId = 999999;
     const projectName = 'super cool test project';
-    const projectConfig = { projectConfig: { name: projectName } };
+    const projectConfig = {
+        projectConfig: {
+            name: projectName,
+            srcDir: 'src',
+            platformVersion: '2024.1',
+        },
+    };
     const projectId = 987654321;
     const projectDetails = {
         project: {
@@ -33,16 +45,26 @@ describe('lib/projects/ProjectLogsManager', () => {
     };
     const function1 = {
         componentName: 'function1',
-        type: {
-            name: SUBCOMPONENT_TYPES.APP_FUNCTION,
-        },
-        deployOutput: {
-            appId,
-            appFunctionName: 'function1',
-        },
+        appId,
     };
     const functions = [
         function1,
+        {
+            componentName: 'function2',
+            appId,
+        },
+    ];
+    const legacyApiFunctions = [
+        {
+            componentName: 'function1',
+            type: {
+                name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+            },
+            deployOutput: {
+                appId,
+                appFunctionName: 'function1',
+            },
+        },
         {
             componentName: 'function2',
             type: {
@@ -56,6 +78,7 @@ describe('lib/projects/ProjectLogsManager', () => {
     ];
     beforeEach(() => {
         ProjectLogsManager.reset();
+        isV2Project.mockReturnValue(false);
         getProjectConfig.mockResolvedValue(projectConfig);
         ensureProjectExists.mockResolvedValue(projectDetails);
         fetchProjectComponentsMetadata.mockResolvedValue({
@@ -69,7 +92,7 @@ describe('lib/projects/ProjectLogsManager', () => {
                             appId,
                         },
                         featureComponents: [
-                            ...functions,
+                            ...legacyApiFunctions,
                             {
                                 type: {
                                     name: 'NOT_AN_APP_FUNCTION',
@@ -128,6 +151,102 @@ describe('lib/projects/ProjectLogsManager', () => {
             expect(ProjectLogsManager.functions).toEqual(functions);
         });
     });
+    describe('v2 project init', () => {
+        const v2ProjectConfig = {
+            projectConfig: {
+                name: projectName,
+                srcDir: 'src',
+                platformVersion: '2025.2',
+            },
+        };
+        const deployedBuildId = 555;
+        const v2ProjectDetails = {
+            project: {
+                id: projectId,
+                deployedBuild: {
+                    buildId: deployedBuildId,
+                    subbuildStatuses: {},
+                },
+            },
+        };
+        const appUid = 'my-app';
+        const fnUid1 = 'my-app/app.functions/function1';
+        const fnUid2 = 'my-app/app.functions/function2';
+        const deployedNodes = {
+            [appUid]: {
+                componentType: 'APPLICATION',
+                componentDeps: {},
+                metaFilePath: 'src/app/app-hsmeta.json',
+                uid: appUid,
+                config: {},
+                files: {},
+            },
+            [fnUid1]: {
+                componentType: 'APP_FUNCTION',
+                componentDeps: { app: appUid },
+                metaFilePath: 'src/app/app.functions/function1.functions/function-hsmeta.json',
+                uid: fnUid1,
+                config: { endpoint: { path: '/my-endpoint' } },
+                files: {},
+            },
+            [fnUid2]: {
+                componentType: 'APP_FUNCTION',
+                componentDeps: { app: appUid },
+                metaFilePath: 'src/app/app.functions/function2.functions/function-hsmeta.json',
+                uid: fnUid2,
+                config: {},
+                files: {},
+            },
+        };
+        beforeEach(() => {
+            getProjectConfig.mockResolvedValue(v2ProjectConfig);
+            ensureProjectExists.mockResolvedValue(v2ProjectDetails);
+            isV2Project.mockReturnValue(true);
+            getDeployedProjectNodes.mockResolvedValue(deployedNodes);
+            fetchAppMetadataBySourceId.mockResolvedValue({
+                data: { id: appId },
+            });
+        });
+        it('should populate functions correctly for v2 projects', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(getDeployedProjectNodes).toHaveBeenCalledWith(v2ProjectConfig.projectConfig, accountId, deployedBuildId);
+            expect(fetchAppMetadataBySourceId).toHaveBeenCalledWith(projectId, appUid, accountId);
+            expect(ProjectLogsManager.functions).toEqual([
+                {
+                    componentName: fnUid1,
+                    appId,
+                    endpoint: { path: '/my-endpoint' },
+                },
+                {
+                    componentName: fnUid2,
+                    appId,
+                    endpoint: undefined,
+                },
+            ]);
+        });
+        it('should throw noDeployedBuild when buildId is missing', async () => {
+            ensureProjectExists.mockResolvedValue({
+                project: {
+                    id: projectId,
+                    deployedBuild: {
+                        buildId: undefined,
+                        subbuildStatuses: {},
+                    },
+                },
+            });
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('This project has not been deployed yet. Deploy the project first, then try again.');
+        });
+        it('should throw noFunctionsInProject when no function nodes exist', async () => {
+            getDeployedProjectNodes.mockResolvedValue({
+                [appUid]: deployedNodes[appUid],
+            });
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There aren't any functions in this project/);
+        });
+        it('should throw a user-friendly error when getDeployedProjectNodes fails', async () => {
+            getDeployedProjectNodes.mockRejectedValue(new Error('download failed'));
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
+        });
+    });
     describe('getFunctionNames', () => {
         it('should return an empty array if functions is empty', async () => {
             ProjectLogsManager.functions = [];
@@ -154,14 +273,8 @@ describe('lib/projects/ProjectLogsManager', () => {
         it('should set the data correctly for public functions', async () => {
             const functionToChoose = {
                 componentName: 'function1',
-                type: {
-                    name: SUBCOMPONENT_TYPES.APP_FUNCTION,
-                },
-                deployOutput: {
-                    appId: 123,
-                    appFunctionName: 'function1',
-                    endpoint: { path: 'yooooooo', methods: ['GET'] },
-                },
+                appId: 123,
+                endpoint: { path: 'yooooooo' },
             };
             ProjectLogsManager.functions = [functionToChoose];
             ProjectLogsManager.setFunction('function1');
@@ -170,7 +283,7 @@ describe('lib/projects/ProjectLogsManager', () => {
             expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
             expect(ProjectLogsManager.isPublicFunction).toEqual(true);
         });
-        it('should set the data correctly for public functions', async () => {
+        it('should set the data correctly for private functions', async () => {
             ProjectLogsManager.functions = functions;
             ProjectLogsManager.setFunction('function1');
             expect(ProjectLogsManager.selectedFunction).toEqual(function1);

package/lib/projects/__tests__/platformVersion.test.js

@@ -1,4 +1,4 @@
-import { isV2Project } from '../platformVersion.js';
+import { isV2Project, isUnsupportedPlatformVersion, } from '../platformVersion.js';
 describe('platformVersion', () => {
     describe('isV2Project', () => {
         it('returns true if platform version is UNSTABLE', () => {
@@ -24,4 +24,40 @@ describe('platformVersion', () => {
             expect(isV2Project('notplaformversion')).toBe(false);
         });
     });
+    describe('isUnsupportedPlatformVersion', () => {
+        it('returns false for platform version 2026.03 (boundary)', () => {
+            expect(isUnsupportedPlatformVersion('2026.03')).toBe(false);
+        });
+        it('returns false for platform versions less than 2026.03', () => {
+            expect(isUnsupportedPlatformVersion('2025.2')).toBe(false);
+            expect(isUnsupportedPlatformVersion('2026.01')).toBe(false);
+            expect(isUnsupportedPlatformVersion('2026.02')).toBe(false);
+        });
+        it('returns true for platform version 2026.04', () => {
+            expect(isUnsupportedPlatformVersion('2026.04')).toBe(true);
+        });
+        it('returns true for platform versions greater than 2026.03', () => {
+            expect(isUnsupportedPlatformVersion('2026.4')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2027.01')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2027.1')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2028.10')).toBe(true);
+        });
+        it('returns false for UNSTABLE', () => {
+            expect(isUnsupportedPlatformVersion('UNSTABLE')).toBe(false);
+            expect(isUnsupportedPlatformVersion('unstable')).toBe(false);
+        });
+        it('returns false for null or undefined', () => {
+            expect(isUnsupportedPlatformVersion(null)).toBe(false);
+            expect(isUnsupportedPlatformVersion(undefined)).toBe(false);
+        });
+        it('returns false for invalid platform versions', () => {
+            expect(isUnsupportedPlatformVersion('notaversion')).toBe(false);
+            expect(isUnsupportedPlatformVersion('abc.def')).toBe(false);
+        });
+        it('handles beta versions correctly', () => {
+            expect(isUnsupportedPlatformVersion('2026.03-beta')).toBe(false);
+            expect(isUnsupportedPlatformVersion('2026.04-beta')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2027.01-beta')).toBe(true);
+        });
+    });
 });

package/lib/projects/__tests__/projects.test.js

@@ -16,12 +16,16 @@ describe('lib/projects', () => {
         });
         it('rejects configuration with missing name', () => {
             // @ts-ignore Testing invalid input
-            expect(() => validateProjectConfig({ srcDir: '.' }, projectDir)).toThrow(/.*missing required fields*/);
+            expect(() => validateProjectConfig({ srcDir: '.' }, projectDir)).toThrow(/missing required field.*name/);
         });
         it('rejects configuration with missing srcDir', () => {
             expect(() => 
             // @ts-ignore Testing invalid input
-            validateProjectConfig({ name: 'hello' }, projectDir)).toThrow(/.*missing required fields.*/);
+            validateProjectConfig({ name: 'hello' }, projectDir)).toThrow(/missing required field.*srcDir/);
+        });
+        it('rejects configuration with both name and srcDir missing', () => {
+            // @ts-ignore Testing invalid input
+            expect(() => validateProjectConfig({}, projectDir)).toThrow(/missing required fields:.*name.*srcDir/);
         });
         describe('rejects configuration with srcDir outside project directory', () => {
             it('for parent directory', () => {

package/lib/projects/components.d.ts

@@ -1,5 +1,11 @@
 import { Collision } from '@hubspot/local-dev-lib/types/Archive';
 import type { ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+export interface ComponentInfo {
+    filename?: string;
+    isNew: boolean;
+}
+export type ComponentsByType = Map<string, ComponentInfo[]>;
+export declare function buildProjectTree(projectName: string, uids: string[], componentsByType: ComponentsByType, showOnlyNew: boolean): string;
 export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;
 export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[], options?: {
     currentProjectMetadata?: ProjectMetadata;

package/lib/projects/components.js

@@ -12,7 +12,7 @@ import { renderInline } from '../../ui/render.js';
 import { getSuccessBox } from '../../ui/components/StatusMessageBoxes.js';
 // Prefix for the metafile extension
 const metafileExtensionPrefix = path.parse(metafileExtension).name;
-function buildProjectTree(projectName, uids, componentsByType, showOnlyNew) {
+export function buildProjectTree(projectName, uids, componentsByType, showOnlyNew) {
     const lines = [];
     lines.push(chalk.bold(projectName));
     const types = Array.from(componentsByType.keys());

package/lib/projects/config.js

@@ -52,8 +52,15 @@ export function validateProjectConfig(projectConfig, projectDir) {
     if (!projectConfig || !projectDir) {
         throw new ProjectValidationError(lib.projects.validateProjectConfig.configNotFound);
     }
-    if (!projectConfig.name || !projectConfig.srcDir) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.configMissingFields);
+    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)) {

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

@@ -1,4 +1,4 @@
-import { type IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import { type IntermediateRepresentationNode, type IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from '../../../../types/Projects.js';
@@ -7,6 +7,9 @@ export declare function createInitialBuildForNewProject(projectConfig: ProjectCo
 export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
 }, profile?: string): Promise<void>;
+export declare function getDeployedProjectNodes(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, profile?: string): Promise<{
+    [key: string]: IntermediateRepresentationNode;
+}>;
 export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
     [key: string]: IntermediateRepresentationNodeLocalDev;
 }, profile?: string): Promise<boolean>;

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

@@ -149,31 +149,36 @@ export async function compareLocalProjectToDeployed(projectConfig, accountId, de
         process.exit(EXIT_CODES.SUCCESS);
     }
 }
-export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+export async function getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, profile) {
     let tempDir = null;
     try {
         tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hubspot-project-compare-'));
         const { data: zippedProject } = await downloadProject(accountId, projectConfig.name, deployedBuildId);
         await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { hideLogs: true });
         const deployedProjectSourceDir = path.join(tempDir, projectConfig.srcDir);
-        const { intermediateNodesIndexedByUid: deployedProjectNodes } = await translate({
+        const { intermediateNodesIndexedByUid } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
             accountId: accountId,
         }, { profile });
-        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
-    }
-    catch (err) {
-        debugError(err);
-        return false;
+        return intermediateNodesIndexedByUid;
     }
     finally {
-        // Clean up temporary directory
         if (tempDir && (await fs.pathExists(tempDir))) {
             await fs.remove(tempDir);
         }
     }
 }
+export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountId, deployedBuildId, localProjectNodes, profile) {
+    try {
+        const deployedProjectNodes = await getDeployedProjectNodes(projectConfig, accountId, deployedBuildId, profile);
+        return isDeepEqual(localProjectNodes, deployedProjectNodes, ['localDev']);
+    }
+    catch (err) {
+        debugError(err);
+        return false;
+    }
+}
 export async function checkAndInstallDependencies() {
     uiLogger.log('');
     SpinniesManager.add('checkingDependencies', {

package/lib/projects/platformVersion.d.ts

@@ -1 +1,9 @@
+/**
+ * Used to surface warnings when users attempt to interact with new platform versions
+ * that were released after this version of the CLI was released.
+ *
+ * We are unable to reliably support versions of projects that are newer than any given CLI release
+ * */
+export declare const LATEST_SUPPORTED_PLATFORM_VERSION = "2026.03";
 export declare function isV2Project(platformVersion?: string | null): boolean;
+export declare function isUnsupportedPlatformVersion(platformVersion?: string | null): boolean;