@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/commands/project/release.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../../types/Yargs.js';
+declare const projectReleaseCommand: YargsCommandModuleBucket;
+export default projectReleaseCommand;

package/commands/project/release.js

@@ -0,0 +1,20 @@
+import create from './release/create.js';
+import info from './release/info.js';
+import list from './release/list.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+// import { commands } from '../../lang/en.js';
+const command = 'release';
+// const describe = commands.project.release.describe;
+const describe = undefined;
+function projectReleaseBuilder(yargs) {
+    yargs.command(create).command(info).command(list).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(projectReleaseBuilder, command, describe);
+const projectReleaseCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default projectReleaseCommand;

package/commands/project/updateDeps.js

@@ -1,25 +1,26 @@
 import { updatePackages, getProjectPackageJsonLocations, } from '../../lib/dependencyManagement.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
 import { getProjectConfig } from '../../lib/projects/config.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import path from 'path';
 import { commands } from '../../lang/en.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 const command = 'update-deps [packages..]';
 const describe = commands.project.updateDeps.help.describe;
 async function handler(args) {
-    const { derivedAccountId, packages } = args;
+    const { packages, exit } = args;
     try {
-        trackCommandUsage('project-update-deps', undefined, derivedAccountId);
-        const projectConfig = await getProjectConfig();
-        if (!projectConfig || !projectConfig.projectDir) {
-            uiLogger.error(commands.project.updateDeps.noProjectConfig);
-            return process.exit(EXIT_CODES.ERROR);
+        let projectDir;
+        try {
+            ({ projectDir } = getProjectConfig());
+        }
+        catch (error) {
+            logError(error);
+            return exit(EXIT_CODES.ERROR);
         }
-        const { projectDir } = projectConfig;
         let installLocations = await getProjectPackageJsonLocations();
         if (packages) {
             const { selectedInstallLocations } = await promptUser([
@@ -50,8 +51,11 @@ async function handler(args) {
         });
     }
     catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
         logError(e);
-        return process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
 }
 function projectUpdateDepsBuilder(yargs) {
@@ -74,7 +78,7 @@ const builder = makeYargsBuilder(projectUpdateDepsBuilder, command, describe, {
 const projectUpdateDepsCommand = {
     command,
     describe,
-    handler,
+    handler: makeWrappedYargsHandler('project-update-deps', handler),
     builder,
 };
 export default projectUpdateDepsCommand;

package/commands/project/upload.d.ts

@@ -1,10 +1,16 @@
 import { CommonArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-export type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
+import { UploadJsonOutput } from '../../lib/jsonOutput.js';
+export type ProjectUploadArgs = CommonArgs & JSONOutputArgs<UploadJsonOutput> & {
+    force: boolean;
     forceCreate: boolean;
     message: string;
     m: string;
     skipValidation: boolean;
+    skipNpmAudit: boolean;
+    skipAutoDeploy: boolean;
     profile?: string;
+    preview: boolean;
+    target?: number;
 };
 declare const projectUploadCommand: YargsCommandModule<unknown, ProjectUploadArgs>;
 export default projectUploadCommand;

package/commands/project/upload.js

@@ -2,58 +2,106 @@ import chalk from 'chalk';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { isV2Project } from '../../lib/projects/platformVersion.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
+import { isLegacyProject, meetsMinimumPlatformVersion, } from '@hubspot/project-parsing-lib/projects';
+import { getProjectConfig } from '../../lib/projects/config.js';
 import { logFeedbackMessage } from '../../lib/projects/ui.js';
 import { handleProjectUpload } from '../../lib/projects/upload.js';
 import { loadAndValidateProfile } from '../../lib/projects/projectProfiles.js';
 import { displayWarnLogs, pollProjectBuildAndDeploy, } from '../../lib/projects/pollProjectBuildAndDeploy.js';
-import { commands } from '../../lang/en.js';
+import { triggerAndPollPreview } from '../../lib/projects/preview.js';
+import { commands, lib } from '../../lang/en.js';
 import { PROJECT_ERROR_TYPES } from '../../lib/constants.js';
 import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
+import { mapAccountToTargetAccount, UploadSchema, } from '../../lib/jsonOutput.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { projectProfilePrompt } from '../../lib/prompts/projectProfilePrompt.js';
+import { uiDeprecatedTag } from '../../lib/ui/index.js';
+import { showMcpPromotionNudge } from '../../lib/mcp/promotion.js';
+import { PLATFORM_VERSIONS } from '@hubspot/project-parsing-lib/constants';
 const command = 'upload';
 const describe = commands.project.upload.describe;
+async function handlePreview(accountId, projectId, buildId, targetPortalId) {
+    if (!projectId) {
+        uiLogger.warn(lib.projectPreview.missingProjectId);
+        return;
+    }
+    const previewResult = await triggerAndPollPreview(accountId, projectId, buildId, targetPortalId);
+    if (!previewResult.succeeded) {
+        uiLogger.warn(lib.projectPreview.warning);
+    }
+    return {
+        releaseTag: previewResult.releaseTag,
+        succeeded: previewResult.succeeded,
+    };
+}
 async function handler(args) {
-    const { forceCreate, message, derivedAccountId, skipValidation, formatOutputAsJson, profile, } = args;
-    const jsonOutput = {};
-    const { projectConfig, projectDir } = await getProjectConfig();
+    const { force = false, forceCreate = false, message, derivedAccountId, skipValidation, skipNpmAudit, skipAutoDeploy, formatOutputAsJson, profile: profileOption, useEnv: useEnvOption, preview, target: targetPortalId, exit, addUsageMetadata, addJsonOutput, } = args;
+    if (forceCreate) {
+        uiDeprecatedTag(commands.project.upload.logs.forceCreateDeprecated);
+    }
+    let projectConfig;
+    let projectDir;
     try {
-        validateProjectConfig(projectConfig, projectDir);
+        ({ projectConfig, projectDir } = getProjectConfig());
     }
     catch (error) {
         logError(error);
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
     let targetAccountId;
-    try {
-        if (isV2Project(projectConfig.platformVersion)) {
-            targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+    let profileName = args.profile;
+    let resolvedViaProfile = false;
+    if (!isLegacyProject(projectConfig.platformVersion)) {
+        try {
+            const profileNamePromptResult = await projectProfilePrompt(projectDir, projectConfig, profileOption, !!useEnvOption);
+            if (profileNamePromptResult) {
+                profileName = profileNamePromptResult;
+                const profile = await loadAndValidateProfile(projectConfig, projectDir, profileName);
+                targetAccountId = profile.accountId;
+                resolvedViaProfile = true;
+                uiLogger.log(commands.project.upload.logs.uploadingWithProfile(profileName, targetAccountId));
+                uiLogger.log('');
+            }
+        }
+        catch (error) {
+            logError(error);
+            return exit(EXIT_CODES.ERROR);
         }
-    }
-    catch (err) {
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
     }
     targetAccountId = targetAccountId || derivedAccountId;
     const accountConfig = getConfigAccountById(targetAccountId);
     const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-upload', { type: accountType, assetType: projectConfig.platformVersion }, targetAccountId);
+    addUsageMetadata({
+        type: accountType,
+        assetType: projectConfig.platformVersion,
+    });
+    if (!resolvedViaProfile) {
+        uiLogger.log(commands.project.upload.logs.uploadingToAccount(targetAccountId));
+        uiLogger.log('');
+    }
     try {
-        const { result, uploadError } = await handleProjectUpload({
+        const { result, uploadError, projectId, userDeclined } = await handleProjectUpload({
             accountId: targetAccountId,
             projectConfig,
-            projectDir: projectDir,
-            callbackFunc: pollProjectBuildAndDeploy,
+            projectDir,
+            callbackFunc: preview || skipAutoDeploy
+                ? (...args) => pollProjectBuildAndDeploy(...args, { skipDeploy: true })
+                : pollProjectBuildAndDeploy,
             uploadMessage: message,
-            forceCreate,
+            forceCreate: forceCreate || force,
             isUploadCommand: true,
-            sendIR: isV2Project(projectConfig.platformVersion),
+            sendIR: !isLegacyProject(projectConfig.platformVersion),
             skipValidation,
-            profile: args.profile,
+            skipNpmAudit,
+            skipAutoDeploy,
+            profile: profileName,
+            force,
         });
+        if (userDeclined) {
+            return exit(EXIT_CODES.SUCCESS);
+        }
         if (uploadError) {
             if (isSpecifiedError(uploadError, {
                 subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
@@ -68,39 +116,77 @@ async function handler(args) {
                     request: 'project upload',
                 }));
             }
-            process.exit(EXIT_CODES.ERROR);
+            return exit(EXIT_CODES.ERROR);
         }
-        if (result && result.succeeded && !result.buildResult.isAutoDeployEnabled) {
+        if (result &&
+            result.succeeded &&
+            (!result.buildResult.isAutoDeployEnabled || preview || skipAutoDeploy)) {
             uiLogger.log(chalk.bold(commands.project.upload.logs.buildSucceeded(result.buildId)));
-            uiLogger.log(commands.project.upload.logs.autoDeployDisabled(`hs project deploy --build=${result.buildId}`));
-            logFeedbackMessage(result.buildId);
+            if (!preview) {
+                if (meetsMinimumPlatformVersion(result.buildResult.platformVersion, PLATFORM_VERSIONS.v2027_03_BETA)) {
+                    const releaseCommand = `hs project release create --build=${result.buildId}`;
+                    uiLogger.log(commands.project.upload.logs.releaseManagementRequired(releaseCommand));
+                }
+                else {
+                    const deployCommand = `hs project deploy --build=${result.buildId}`;
+                    uiLogger.log(skipAutoDeploy
+                        ? commands.project.upload.logs.autoDeploySkipped(deployCommand)
+                        : commands.project.upload.logs.autoDeployDisabled(deployCommand));
+                }
+                logFeedbackMessage(result.buildId);
+            }
             await displayWarnLogs(targetAccountId, projectConfig.name, result.buildId);
         }
-        if (result && result.succeeded && formatOutputAsJson) {
-            jsonOutput.buildId = result.buildId;
+        if (result) {
+            addJsonOutput({
+                targetAccount: mapAccountToTargetAccount(targetAccountId, accountConfig),
+                buildId: result.buildId,
+            });
             if (result.deployResult) {
-                jsonOutput.deployId = result.deployResult.deployId;
+                addJsonOutput({ deployId: result.deployResult.deployId });
+            }
+        }
+        if (result && result.succeeded && preview && targetPortalId) {
+            const previewJson = await handlePreview(targetAccountId, projectId, result.buildId, targetPortalId);
+            if (previewJson) {
+                addJsonOutput({ preview: previewJson });
             }
         }
+        if (result && result.succeeded) {
+            uiLogger.log(commands.project.upload.logs.uploadedToAccount(targetAccountId));
+        }
+        if (result && !result.succeeded) {
+            return exit(EXIT_CODES.ERROR);
+        }
+        if (!result && !uploadError) {
+            return exit(EXIT_CODES.ERROR);
+        }
     }
     catch (e) {
         logError(e, new ApiErrorContext({
             accountId: targetAccountId,
             request: 'project upload',
         }));
-        process.exit(EXIT_CODES.ERROR);
+        return exit(EXIT_CODES.ERROR);
     }
-    if (formatOutputAsJson) {
-        uiLogger.json(jsonOutput);
+    if (!formatOutputAsJson) {
+        await showMcpPromotionNudge(args._.join(' '));
     }
-    process.exit(EXIT_CODES.SUCCESS);
+    return exit(EXIT_CODES.SUCCESS);
 }
 function projectUploadBuilder(yargs) {
     yargs.options({
+        force: {
+            alias: 'f',
+            describe: commands.project.upload.options.force.describe,
+            type: 'boolean',
+            default: false,
+        },
         'force-create': {
             describe: commands.project.upload.options.forceCreate.describe,
             type: 'boolean',
             default: false,
+            hidden: true,
         },
         message: {
             alias: 'm',
@@ -113,11 +199,42 @@ function projectUploadBuilder(yargs) {
             hidden: true,
             default: false,
         },
+        'skip-npm-audit': {
+            describe: commands.project.upload.options.skipNpmAudit.describe,
+            type: 'boolean',
+            default: false,
+        },
+        'skip-auto-deploy': {
+            describe: commands.project.upload.options.skipAutoDeploy.describe,
+            type: 'boolean',
+            default: false,
+        },
         profile: {
             type: 'string',
             alias: 'p',
             describe: commands.project.upload.options.profile.describe,
         },
+        preview: {
+            describe: commands.project.upload.options.preview.describe,
+            type: 'boolean',
+            default: false,
+            hidden: true,
+        },
+        target: {
+            describe: commands.project.upload.options.target.describe,
+            type: 'number',
+            requiresArg: true,
+            hidden: true,
+        },
+    });
+    yargs.check(argv => {
+        if (argv.preview && argv.target == null) {
+            throw new Error(commands.project.upload.errors.previewRequiresTarget);
+        }
+        if (argv.target != null && !argv.preview) {
+            throw new Error(commands.project.upload.errors.targetRequiresPreview);
+        }
+        return true;
     });
     yargs.conflicts('profile', 'account');
     yargs.example([
@@ -126,6 +243,11 @@ function projectUploadBuilder(yargs) {
             '$0 project upload --profile=profileName',
             commands.project.upload.examples.withProfile,
         ],
+        // TODO: Unhide when 2026.09 ships
+        // [
+        //   '$0 project upload --preview --target=12345',
+        //   commands.project.upload.examples.withPreview,
+        // ],
     ]);
     return yargs;
 }
@@ -139,7 +261,9 @@ const builder = makeYargsBuilder(projectUploadBuilder, command, describe, {
 const projectUploadCommand = {
     command,
     describe,
-    handler,
+    handler: makeWrappedYargsHandler('project-upload', handler, {
+        jsonOutputSchema: UploadSchema,
+    }),
     builder,
 };
 export default projectUploadCommand;

package/commands/project/validate.d.ts

@@ -1,5 +1,5 @@
 import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectValidateArgs = CommonArgs & {
+export type ProjectValidateArgs = CommonArgs & {
     profile?: string;
 };
 declare const projectValidateCommand: YargsCommandModule<unknown, ProjectValidateArgs>;

package/commands/project/validate.js

@@ -1,116 +1,44 @@
-import path from 'path';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { isV2Project } from '../../lib/projects/platformVersion.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
 import { commands } from '../../lang/en.js';
-import { validateProjectForProfile } from '../../lib/projects/projectProfiles.js';
 import { logError } from '../../lib/errorHandlers/index.js';
-import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
-import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { validateProject } from '../../lib/projects/validate.js';
 const command = 'validate';
 const describe = commands.project.validate.describe;
 async function handler(args) {
-    const { derivedAccountId, profile } = args;
-    const { projectConfig, projectDir } = await getProjectConfig();
+    const { derivedAccountId, profile, exit, addUsageMetadata } = args;
     const accountConfig = getConfigAccountById(derivedAccountId);
     const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-validate', { type: accountType }, derivedAccountId);
-    if (!projectConfig || !projectDir) {
-        uiLogger.error(commands.project.validate.mustBeRanWithinAProject);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!isV2Project(projectConfig?.platformVersion)) {
-        uiLogger.error(commands.project.validate.badVersion);
-        process.exit(EXIT_CODES.ERROR);
-    }
+    addUsageMetadata({ type: accountType });
+    let projectConfig;
+    let projectDir;
     try {
-        validateProjectConfig(projectConfig, projectDir);
+        ({ projectConfig, projectDir } = getProjectConfig());
     }
     catch (error) {
         logError(error);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    let validationSucceeded = true;
-    const srcDir = path.resolve(projectDir, projectConfig.srcDir);
-    const profiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
-    // If a profile is specified, only validate that profile
-    if (profile) {
-        const validationErrors = await validateProjectForProfile({
-            projectConfig,
-            projectDir,
-            profileName: profile,
-            derivedAccountId,
-        });
-        if (validationErrors.length) {
-            logValidationErrors(validationErrors);
-            validationSucceeded = false;
-        }
-    }
-    else if (profiles.length > 0) {
-        // If no profile was specified and the project has profiles, validate all of them
-        SpinniesManager.add('validatingAllProfiles', {
-            text: commands.project.validate.spinners.validatingAllProfiles,
-        });
-        const errors = [];
-        for (const profileName of profiles) {
-            const validationErrors = await validateProjectForProfile({
-                projectConfig,
-                projectDir,
-                profileName,
-                derivedAccountId,
-                indentSpinners: true,
-            });
-            if (validationErrors.length) {
-                errors.push(...validationErrors);
-                validationSucceeded = false;
-            }
-        }
-        if (validationSucceeded) {
-            SpinniesManager.succeed('validatingAllProfiles', {
-                text: commands.project.validate.spinners.allProfilesValidationSucceeded,
-            });
-        }
-        else {
-            SpinniesManager.fail('validatingAllProfiles', {
-                text: commands.project.validate.spinners.allProfilesValidationFailed,
-            });
-        }
-        logValidationErrors(errors);
-    }
-    else if (profiles.length === 0) {
-        // If the project has no profiles, validate the project without a profile
-        try {
-            await handleTranslate({
-                projectDir: projectDir,
-                projectConfig,
-                accountId: derivedAccountId,
-                skipValidation: false,
-            });
-        }
-        catch (e) {
-            uiLogger.error(commands.project.validate.failure(projectConfig.name));
-            logError(e);
-            validationSucceeded = false;
-            uiLogger.log('');
-        }
+        return exit(EXIT_CODES.ERROR);
     }
-    if (!validationSucceeded) {
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        await validateSourceDirectory(srcDir, projectConfig, projectDir);
+    if (isLegacyProject(projectConfig.platformVersion)) {
+        uiLogger.error(commands.project.validate.badVersion);
+        return exit(EXIT_CODES.ERROR);
     }
-    catch (e) {
-        logError(e);
-        process.exit(EXIT_CODES.ERROR);
+    const valid = await validateProject({
+        projectConfig,
+        projectDir,
+        derivedAccountId,
+        profile,
+    });
+    if (!valid) {
+        return exit(EXIT_CODES.ERROR);
     }
     uiLogger.success(commands.project.validate.success(projectConfig.name));
-    process.exit(EXIT_CODES.SUCCESS);
+    return exit(EXIT_CODES.SUCCESS);
 }
 function projectValidateBuilder(yargs) {
     yargs.options({
@@ -130,17 +58,6 @@ function projectValidateBuilder(yargs) {
     ]);
     return yargs;
 }
-function logValidationErrors(validationErrors) {
-    uiLogger.log('');
-    validationErrors.forEach(error => {
-        if (error instanceof Error) {
-            logError(error);
-        }
-        else {
-            uiLogger.log(error);
-        }
-    });
-}
 const builder = makeYargsBuilder(projectValidateBuilder, command, describe, {
     useGlobalOptions: true,
     useConfigOptions: true,
@@ -150,7 +67,7 @@ const builder = makeYargsBuilder(projectValidateBuilder, command, describe, {
 const projectValidateCommand = {
     command,
     describe,
-    handler,
+    handler: makeWrappedYargsHandler('project-validate', handler),
     builder,
 };
 export default projectValidateCommand;