@hubspot/cli 8.11.0-beta.0 → 8.12.0

package/lang/en.js

@@ -1518,26 +1518,19 @@ export const commands = {
             describe: 'Start local dev for the current project.',
             logs: {
                 header: 'HubSpot projects local development',
-                placeholderAccountSelection: 'Using default account as target account (for now)',
-                accountTypeInformation: 'Testing in a developer test account is strongly recommended, but you can use a sandbox account if your plan allows you to create one.',
                 learnMoreMessageV2: `Learn more about ${uiLink('HubSpot projects local dev', 'https://developers.hubspot.com/docs/developer-tooling/local-development/hubspot-cli/project-commands#start-a-local-development-server')} | ${uiLink('HubSpot account types', 'https://developers.hubspot.com/docs/getting-started/account-types')}`,
-                learnMoreMessageLegacy: uiLink('Learn more about the projects local dev server', 'https://developers.hubspot.com/docs/developer-tooling/local-development/hubspot-cli/project-commands#start-a-local-development-server'),
                 profileProjectAccountExplanation: (accountId, profileName) => `Using account ${uiAccountDescription(accountId)} from profile ${chalk.bold(profileName)} for project upload`,
                 defaultProjectAccountExplanation: (accountId) => `Using default account ${uiAccountDescription(accountId)} for project upload`,
                 projectAccountFlagExplanation: (accountId) => `Using account ${uiAccountDescription(accountId)} provided by the --project-account flag for project upload`,
-                accountFlagExplanation: (accountId) => `Using account ${uiAccountDescription(accountId)} provided by the --account flag for project upload`,
                 defaultSandboxOrDevTestTestingAccountExplanation: (accountId) => `Using default account ${uiAccountDescription(accountId)} for testing`,
                 testingAccountFlagExplanation: (accountId) => `Using account ${uiAccountDescription(accountId)} provided by the --testing-account flag for testing`,
             },
             errors: {
                 noProjectConfig: 'No project detected. Please run this command again from a project directory.',
                 noAccount: (accountId) => `An error occurred while reading account ${uiAccountDescription(accountId)} from your config. Run ${uiAuthCommandReference()} to re-auth this account.`,
-                noAccountsInConfig: `No accounts found in your config. Run ${uiAuthCommandReference()} to configure a HubSpot account with the CLI.`,
-                invalidProjectComponents: 'Projects cannot contain both private and public apps. Move your apps to separate projects before attempting local development.',
+                unsupportedPlatformVersion: (platformVersion) => `Local development is not supported for platform version ${chalk.bold(platformVersion)}. Please upgrade to 2025.2 or later.`,
                 noRunnableComponents: `No supported components were found in this project. Run ${uiCommandReference('hs project add')} to see a list of available components and add one to your project.`,
                 accountNotCombined: `\nLocal development of unified apps is currently only compatible with accounts that are opted into the unified apps beta. Make sure that this account is opted in or switch accounts using ${uiCommandReference('hs account use')}.`,
-                unsupportedAccountFlagLegacy: 'The --project-account and --testing-account flags are not supported for projects with platform versions earlier than 2025.2.',
-                unsupportedAccountFlagV2: 'The --account flag is not supported for projects with platform versions 2025.2 and newer. Use --testing-account and --project-account flags to specify accounts to use for local dev',
                 localDevAlreadyRunning: `Another ${uiCommandReference('hs project dev')} process is already running. To proceed with local development of this project, stop the existing process and re-run ${uiCommandReference('hs project dev')}.`,
             },
             examples: {
@@ -1548,9 +1541,8 @@ export const commands = {
             },
             options: {
                 profile: 'The profile to target during local dev',
-                projectAccount: 'The id of the account to upload your project to. Must be used with --testing-account. Supported on platform versions 2025.2 and newer.',
-                testingAccount: 'The id of the account to install apps and test on. Must be used with --project-account. Supported on platform versions 2025.2 and newer.',
-                account: 'The id of the account to upload your project to. Unsupported on platform versions 2025.2 and newer.',
+                projectAccount: 'The id of the account to upload your project to. Must be used with --testing-account.',
+                testingAccount: 'The id of the account to install apps and test on. Must be used with --project-account.',
                 port: `The port for the local dev server. Defaults to ${LOCAL_DEV_DEFAULT_PORT}.`,
             },
         },
@@ -1738,7 +1730,9 @@ export const commands = {
             errors: {
                 deploy: 'Deploy error: an unknown error occurred.',
                 noBuilds: 'Deploy error: no builds for this project were found.',
+                noSuccessfulBuilds: 'Deploy error: no successful builds for this project were found.',
                 noBuildId: 'You must specify a build to deploy',
+                notSupportedForBuildVersion: `This build's platform version does not support deploy. Run ${uiCommandReference('hs project release create')} to create a release instead.`,
                 projectNotFound: (accountId, projectName) => `The project ${chalk.bold(projectName)} does not exist in account ${uiAccountDescription(accountId)}. Run ${uiCommandReference('hs project upload')} to upload your project files to HubSpot.`,
                 buildIdDoesNotExist: (accountId, buildId, projectName) => `Build ${buildId} does not exist for project ${chalk.bold(projectName)}. Run ${uiCommandReference('hs project list-builds')} to view existing builds for this project.`,
                 buildAlreadyDeployed: (accountId, buildId, projectName) => `Build ${buildId} is already deployed. ${uiLink('View project builds in HubSpot', getProjectDetailUrl(projectName, accountId))}`,
@@ -1749,7 +1743,7 @@ export const commands = {
                 deployIssueComponentWarning: (uid, componentTypeName, message) => `- [${mapToUserFriendlyName(componentTypeName)}] ${chalk.bold('(' + uid + ')')} ${message}`,
             },
             examples: {
-                default: 'Deploy the latest build of the current project',
+                default: 'Deploy the last successful build of the current project',
                 withOptions: 'Deploy build 5 of the project my-project',
                 withProfile: 'Deploy using the provided profile',
             },
@@ -1758,29 +1752,38 @@ export const commands = {
                 project: 'Project name',
                 profile: 'The profile to target with this deploy',
                 force: 'Skip warnings and force deploy. Use this carefully as it will bypass warnings for destructive actions.',
-                deployLatestBuild: 'Deploy the latest build of the current project',
+                deployLatestBuild: 'Deploy the last successful build of the current project',
             },
         },
         release: {
             describe: 'Manage project releases.',
             create: {
                 describe: 'Create a release for a project build.',
-                verboseDescribe: `Create a release for a project build\n\nReleases mark a deployed build with an auto-generated semantic version tag (e.g. v1.0.0). The build must have been successfully deployed before it can be released.\n\nBy default, the latest deployed build is used. Use ${uiCommandReference('--build')} to specify a different build ID.`,
+                verboseDescribe: `Create a release for a project build\n\nReleases mark an uploaded build with an auto-generated semantic version tag (e.g. v1.0.0).\n\nBy default, the latest build is used. Use ${uiCommandReference('--build')} to specify a different build ID.`,
                 confirmPrompt: (projectName, buildId) => `Create a release for project ${chalk.bold(projectName)} using build ${chalk.bold(String(buildId))}?`,
                 success: (releaseTag, buildId) => `Release ${chalk.bold(releaseTag)} created for build ${chalk.bold(String(buildId))}.`,
                 cancelled: 'Release creation cancelled.',
+                buildIdPrompt: '[--build] Select a successful build to release:',
+                noUploadMessage: 'No upload message',
+                buildStatus: {
+                    BUILDING: 'Build in progress',
+                    FAILURE: 'Build failed',
+                    PENDING: 'Pending',
+                    PREPARING: 'Preparing',
+                },
+                uploadPrompt: (projectName) => `No successful builds for project ${chalk.bold(projectName)}. Would you like to upload it?`,
                 errors: {
                     projectNotFound: (accountId, projectName) => `The project ${chalk.bold(projectName)} does not exist in account ${uiAccountDescription(accountId)}. Run ${uiCommandReference('hs project upload')} to upload your project files to HubSpot.`,
-                    noDeployedBuild: `No deployed build found for this project. Run ${uiCommandReference('hs project deploy')} first.`,
-                    buildNotFound: (buildId, projectName) => `Build ${chalk.bold(String(buildId))} was not found for project ${chalk.bold(projectName)}. Run ${uiCommandReference('hs project list-builds')} to view existing builds or ${uiCommandReference('hs project deploy')} to deploy a build first.`,
-                    buildNotDeployed: (buildId) => `Build ${chalk.bold(String(buildId))} has not been deployed. Run ${uiCommandReference('hs project deploy')} first.`,
+                    buildNotFound: (buildId, projectName) => `Build ${chalk.bold(String(buildId))} was not found for project ${chalk.bold(projectName)}. Run ${uiCommandReference('hs project list-builds')} to view existing builds or ${uiCommandReference('hs project upload')} to upload a build first.`,
+                    noSuccessfulBuilds: (projectName) => `No successful builds found for project ${chalk.bold(projectName)}. Run ${uiCommandReference('hs project upload')} to create a new build.`,
+                    incompatibleBuildVersion: `This build's platform version does not support releases. Upgrade your project to a newer platform version to use releases.`,
                 },
                 options: {
-                    build: 'Build ID to release. Defaults to the latest deployed build.',
-                    force: 'Skip confirmation prompt.',
+                    build: 'Build ID to release. Defaults to the latest build.',
+                    force: 'Skip all confirmation prompts, including automatic upload when no build exists.',
                 },
                 examples: {
-                    default: 'Create a release for the latest deployed build',
+                    default: 'Create a release for the latest build',
                     withBuild: 'Create a release for a specific build',
                 },
             },
@@ -1906,6 +1909,7 @@ export const commands = {
                 runCommand: (command) => `Run \`${uiCommandReference(command)}\``,
                 autoDeployDisabled: (deployCommand) => `Automatic deploys are disabled for this project. Run ${uiCommandReference(deployCommand)} to deploy this build.`,
                 autoDeploySkipped: (deployCommand) => `Auto-deploy was skipped for this build. Run ${uiCommandReference(deployCommand)} to deploy this build.`,
+                releaseManagementRequired: (releaseCommand) => `Run ${uiCommandReference(releaseCommand)} to create a release for this build.`,
             },
             errors: {
                 noProjectConfig: 'No project detected. Run this command from a project directory.',
@@ -3365,6 +3369,10 @@ export const lib = {
     handlerLogFile: {
         saved: (filePath) => `Debug logs can be viewed at ${filePath}`,
     },
+    jsonSchema: {
+        noSchemaForCommand: 'No schema defined for this command',
+        validationFailed: 'JSON output may be missing or malformed fields. The output schema may be out of date.',
+    },
     DevServerManager: {
         portConflict: (port) => `The port ${port} is already in use.`,
         notInitialized: 'The Dev Server Manager must be initialized before it is started.',
@@ -3522,19 +3530,6 @@ export const lib = {
             },
         },
         account: {
-            checkIfDefaultAccountIsSupported: {
-                publicApp: `This project contains a public app. Local development of public apps is only supported on developer accounts and developer test accounts. Change your default account using ${uiCommandReference('hs account use')}, or link a new account with ${uiAuthCommandReference()}.`,
-                privateApp: `This project contains a private app. Local development of private apps is not supported in developer accounts. Change your default account using ${uiCommandReference('hs account use')}, or link a new account with ${uiAuthCommandReference()}.`,
-            },
-            validateAccountOption: {
-                invalidPublicAppAccount: `This project contains a public app. The "--account" flag must point to a developer test account to develop this project locally. Alternatively, change your default account to an app developer account using ${uiCommandReference('hs account use')} and run ${uiCommandReference('hs project dev')} to set up a new developer test account.`,
-                invalidPrivateAppAccount: `This project contains a private app. The account specified with the "--account" flag points to a developer account, which do not support the local development of private apps. Update the "--account" flag to point to a standard, sandbox, or developer test account, or change your default account by running ${uiCommandReference('hs account use')}.`,
-                nonSandboxWarning: `Testing in a sandbox is strongly recommended. To switch the target account, select an option below or run ${uiCommandReference('hs account use')} before running the command again.`,
-                publicAppNonDeveloperTestAccountWarning: `Local development of public apps is only supported in ${chalk.bold('developer test accounts')}.`,
-            },
-            checkIfParentAccountIsAuthed: {
-                notAuthedError: (parentAccountId, accountIdentifier) => `To develop this project locally, run ${uiAuthCommandReference({ accountId: parentAccountId })} to authenticate the App Developer Account ${parentAccountId} associated with ${accountIdentifier}.`,
-            },
             selectAccountTypePrompt: {
                 message: 'Choose the type of account to test on',
                 developerTestAccountOption: 'Test on a developer test account (recommended)',
@@ -3542,10 +3537,7 @@ export const lib = {
                 sandboxAccountOptionDisabled: 'Disabled - requires access to sandbox accounts',
                 productionAccountOption: (accountId) => `<${chalk.red('!')} Test on your project account: ${uiAccountDescription(accountId, false)} ${chalk.red('!')}>`,
             },
-            confirmDefaultAccountIsTarget: {
-                configError: `An error occurred while reading the default account from your config. Run ${uiAuthCommandReference()} to re-auth this account`,
-                declineDefaultAccountExplanation: `To develop on a different account, run ${uiCommandReference('hs account use')} to change your default account, then re-run ${uiCommandReference('hs project dev')}.`,
-            },
+            declineDefaultAccountExplanation: `To develop on a different account, run ${uiCommandReference('hs account use')} to change your default account, then re-run ${uiCommandReference('hs project dev')}.`,
         },
     },
     middleware: {
@@ -3868,6 +3860,7 @@ export const lib = {
             qa: 'Run command in QA mode',
             useEnv: 'Use environment variable config',
             jsonOutput: 'Format output as JSON',
+            jsonSchema: 'Print the JSON output schema and exit',
             debug: 'Set log level to debug',
         },
     },

package/lib/commonOpts.js

@@ -72,11 +72,16 @@ export function addUseEnvironmentOptions(yargs) {
     return yargs;
 }
 export function addJSONOutputOptions(yargs) {
-    return yargs.option('json', {
+    yargs.option('json', {
         alias: 'format-output-as-json',
         describe: lib.commonOpts.options.jsonOutput,
         type: 'boolean',
     });
+    yargs.option('json-schema', {
+        describe: lib.commonOpts.options.jsonSchema,
+        type: 'boolean',
+    });
+    return yargs;
 }
 // Remove this once we've upgraded to yargs 18.0.0
 function uiBetaTagWithColor(message) {

package/lib/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH: "HubSpot/hubspot-project-components";
+export declare const MAX_LOG_FILES = 10;
 export declare const DEFAULT_PROJECT_TEMPLATE_BRANCH: "main";
 export declare const FEEDBACK_INTERVAL: 10;
 export declare const HUBSPOT_FOLDER: "@hubspot";

package/lib/constants.js

@@ -1,4 +1,5 @@
 export const HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH = 'HubSpot/hubspot-project-components';
+export const MAX_LOG_FILES = 10;
 export const DEFAULT_PROJECT_TEMPLATE_BRANCH = 'main';
 export const FEEDBACK_INTERVAL = 10;
 export const HUBSPOT_FOLDER = '@hubspot';

package/lib/jsonOutput.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import { Release } from '../api/releases.js';
+declare const ReleaseComponentSchema: z.ZodObject<{
+    buildType: z.ZodString;
+    buildName: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ReleaseSchema: z.ZodObject<{
+    releaseTag: z.ZodString;
+    buildId: z.ZodNumber;
+    createdAt: z.ZodString;
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        buildType: z.ZodString;
+        buildName: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ReleaseListSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        releaseTag: z.ZodString;
+        buildId: z.ZodNumber;
+        createdAt: z.ZodString;
+        components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            buildType: z.ZodString;
+            buildName: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+        }, 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;
+    projectId: z.ZodNumber;
+    deployedBuildId: z.ZodNumber;
+    autoDeployEnabled: z.ZodBoolean;
+    projectUrl: z.ZodOptional<z.ZodString>;
+    app: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodNumber;
+        uid: z.ZodString;
+        authType: z.ZodOptional<z.ZodString>;
+        distributionType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    components: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PreviewSchema: z.ZodObject<{
+    releaseTag: z.ZodOptional<z.ZodString>;
+    succeeded: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const UploadSchema: z.ZodObject<{
+    buildId: z.ZodOptional<z.ZodNumber>;
+    deployId: z.ZodOptional<z.ZodNumber>;
+    preview: z.ZodOptional<z.ZodObject<{
+        releaseTag: z.ZodOptional<z.ZodString>;
+        succeeded: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DeploySchema: z.ZodObject<{
+    deployId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const InstallStatusSchema: z.ZodObject<{
+    appId: z.ZodOptional<z.ZodNumber>;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    isInstalled: z.ZodBoolean;
+    isInstalledWithCurrentScopes: z.ZodBoolean;
+    previouslyAuthorizedScopeGroups: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const InstallAppSchema: z.ZodObject<{
+    appId: z.ZodNumber;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    installationState: z.ZodString;
+    installed: z.ZodBoolean;
+    reinstalled: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const CreateTestAccountSchema: z.ZodObject<{
+    accountName: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodNumber>;
+    personalAccessKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ReleaseComponentJsonOutput = z.infer<typeof ReleaseComponentSchema>;
+export type ReleaseJsonOutput = z.infer<typeof ReleaseSchema>;
+export type ReleaseListJsonOutput = z.infer<typeof ReleaseListSchema>;
+export type ProjectInfoJsonOutput = z.infer<typeof ProjectInfoSchema>;
+export type PreviewJsonOutput = z.infer<typeof PreviewSchema>;
+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 mapReleaseToJsonOutput(release: Release): ReleaseJsonOutput;
+export {};

package/lib/jsonOutput.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+const ReleaseComponentSchema = z.object({
+    buildType: z.string(),
+    buildName: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+});
+export const ReleaseSchema = z.object({
+    releaseTag: z.string(),
+    buildId: z.number(),
+    createdAt: z.string(),
+    components: z.array(ReleaseComponentSchema).optional(),
+});
+export const ReleaseListSchema = z.object({
+    results: z.array(ReleaseSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
+export const ProjectInfoSchema = z.object({
+    projectName: z.string(),
+    platformVersion: z.string(),
+    projectId: z.number(),
+    deployedBuildId: z.number(),
+    autoDeployEnabled: z.boolean(),
+    projectUrl: z.string().optional(),
+    app: z
+        .object({
+        name: z.string(),
+        id: z.number(),
+        uid: z.string(),
+        authType: z.string().optional(),
+        distributionType: z.string().optional(),
+    })
+        .optional(),
+    components: z.array(z.object({ uid: z.string(), type: z.string() })),
+});
+const PreviewSchema = z.object({
+    releaseTag: z.string().optional(),
+    succeeded: z.boolean(),
+});
+export const UploadSchema = z.object({
+    buildId: z.number().optional(),
+    deployId: z.number().optional(),
+    preview: PreviewSchema.optional(),
+});
+export const DeploySchema = z.object({
+    deployId: z.number().optional(),
+});
+const ScopeGroupSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+});
+export const InstallStatusSchema = z.object({
+    appId: z.number().optional(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    isInstalled: z.boolean(),
+    isInstalledWithCurrentScopes: z.boolean(),
+    previouslyAuthorizedScopeGroups: z.array(ScopeGroupSchema),
+});
+export const InstallAppSchema = z.object({
+    appId: z.number(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    installationState: z.string(),
+    installed: z.boolean(),
+    reinstalled: z.boolean(),
+});
+export const CreateTestAccountSchema = z.object({
+    accountName: z.string().optional(),
+    accountId: z.number().optional(),
+    personalAccessKey: z.string().optional(),
+});
+export function mapReleaseToJsonOutput(release) {
+    const { releaseTag, buildId, createdAt, components } = release;
+    return {
+        releaseTag,
+        buildId,
+        createdAt,
+        components: components?.map(({ buildType, buildName, rootPath, id }) => ({
+            buildType,
+            buildName,
+            rootPath,
+            id,
+        })),
+    };
+}

package/lib/projects/builds.d.ts

@@ -0,0 +1,2 @@
+import { type Build } from '@hubspot/local-dev-lib/types/Build';
+export declare function getLastSuccessfulBuild(accountId: number, projectName: string, latestBuild?: Build): Promise<Build | undefined>;

package/lib/projects/builds.js

@@ -0,0 +1,22 @@
+import { fetchProjectBuilds } from '@hubspot/local-dev-lib/api/projects';
+import { BUILD_STATUS } from '@hubspot/local-dev-lib/enums/build';
+export async function getLastSuccessfulBuild(accountId, projectName, latestBuild) {
+    if (latestBuild?.status === BUILD_STATUS.SUCCESS) {
+        return latestBuild;
+    }
+    let after;
+    let hasMore = true;
+    while (hasMore) {
+        const { data: { results, paging }, } = await fetchProjectBuilds(accountId, projectName, {
+            limit: 100,
+            ...(after ? { after } : {}),
+        });
+        const successfulBuild = results.find(build => build.status === BUILD_STATUS.SUCCESS);
+        if (successfulBuild) {
+            return successfulBuild;
+        }
+        after = paging?.next?.after;
+        hasMore = !!after;
+    }
+    return undefined;
+}

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

@@ -2,11 +2,11 @@ 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;

package/lib/projects/localDev/DevSessionManager.js

@@ -1,9 +1,7 @@
 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;
@@ -21,13 +19,7 @@ class DevSessionManager {
     }
     validateSessionIdExists() {
         if (!this.devSessionId) {
-            if (this.localDevLogger) {
-                this.localDevLogger.devSessionMissingSessionIdError();
-            }
-            else {
-                // Fallback for deprecated local dev manager
-                uiLogger.error(lib.LocalDevManager.devSession.missingSessionIdError);
-            }
+            this.localDevLogger.devSessionMissingSessionIdError();
             throw new Error(lib.LocalDevManager.devSession.missingSessionIdError);
         }
     }
@@ -39,13 +31,7 @@ class DevSessionManager {
             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;
         }
         try {
@@ -73,13 +59,7 @@ class DevSessionManager {
                     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)));
-                }
+                this.localDevLogger.devSessionHeartbeatError(e);
                 return this.exit(EXIT_CODES.ERROR);
             }
         }, 30000);
@@ -91,13 +71,7 @@ class DevSessionManager {
                 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/helpers/account.d.ts

@@ -1,13 +1,6 @@
 import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
-import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { ExitFunction } from '../../../../types/Yargs.js';
-export declare function confirmDefaultAccountIsTarget(accountConfig: HubSpotConfigAccount, exit: ExitFunction): Promise<void>;
-export declare function checkIfDefaultAccountIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean, exit: ExitFunction): Promise<void>;
-export declare function checkIfParentAccountIsAuthed(accountConfig: HubSpotConfigAccount): void;
-export declare function checkIfAccountFlagIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): void;
-export declare function suggestRecommendedNestedAccount(accounts: HubSpotConfigAccount[], accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment): Promise<number>;
 export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment, useV2?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<boolean>;

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

@@ -1,5 +1,3 @@
-import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
-import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
@@ -7,15 +5,6 @@ import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constant
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { uiLogger } from '../../../ui/logger.js';
 import { lib } from '../../../../lang/en.js';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
-import { confirmDefaultAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { isUnifiedAccount } from '../../../accountTypes.js';
-import { isAppDeveloperAccount } from '../../../accountTypes.js';
-import { isDeveloperTestAccount } from '../../../accountTypes.js';
-import { uiAccountDescription } from '../../../ui/index.js';
-import { uiLine } from '../../../ui/index.js';
-import { selectDeveloperTestTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { selectSandboxTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
 import { validateSandboxUsageLimits } from '../../../sandboxes.js';
 import { logError } from '../../../errorHandlers/index.js';
 import { hubspotAccountNamePrompt } from '../../../prompts/accountNamePrompt.js';
@@ -25,73 +14,6 @@ import { buildDeveloperTestAccount, saveAccountToConfig, buildV2Sandbox, } from
 import { debugError } from '../../../errorHandlers/index.js';
 import { listPrompt } from '../../../prompts/promptUtils.js';
 import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-// If the user passed in the --account flag, confirm they want to use that account as
-// their target account, otherwise exit
-export async function confirmDefaultAccountIsTarget(accountConfig, exit) {
-    if (!accountConfig.name || !accountConfig.accountType) {
-        uiLogger.error(lib.localDevHelpers.account.confirmDefaultAccountIsTarget.configError);
-        return exit(EXIT_CODES.ERROR);
-    }
-    uiLogger.log('');
-    const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
-    if (!useDefaultAccount) {
-        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
-            .declineDefaultAccountExplanation);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-}
-// Confirm the default account is supported for the type of apps being developed
-export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps, exit) {
-    const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
-    if (hasPublicApps &&
-        !(isAppDeveloperAccount(accountConfig) ||
-            isDeveloperTestAccount(accountConfig) ||
-            defaultAccountIsUnified)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-}
-export function checkIfParentAccountIsAuthed(accountConfig) {
-    if (!accountConfig.parentAccountId ||
-        !getConfigAccountIfExists(accountConfig.parentAccountId)?.accountId) {
-        throw new Error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
-    }
-}
-// Confirm the default account is a developer account if developing public apps
-export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
-    if (hasPublicApps) {
-        if (!isDeveloperTestAccount(accountConfig)) {
-            throw new Error(lib.localDevHelpers.account.validateAccountOption
-                .invalidPublicAppAccount);
-        }
-        checkIfParentAccountIsAuthed(accountConfig);
-    }
-    else if (isAppDeveloperAccount(accountConfig)) {
-        throw new Error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
-    }
-}
-// If the user isn't using the recommended account type, prompt them to use or create one
-export async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
-    uiLogger.log('');
-    uiLine();
-    if (hasPublicApps) {
-        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
-            .publicAppNonDeveloperTestAccountWarning);
-    }
-    else {
-        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
-    }
-    uiLine();
-    uiLogger.log('');
-    const targetAccountPrompt = hasPublicApps
-        ? selectDeveloperTestTargetAccountPrompt
-        : selectSandboxTargetAccountPrompt;
-    return targetAccountPrompt(accounts, accountConfig);
-}
 // Create a new sandbox and return its accountId
 export async function createSandboxForLocalDev(accountId, accountConfig, env) {
     try {
@@ -166,8 +88,7 @@ export async function useExistingDevTestAccount(env, account) {
     const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
     if (!useExistingDevTestAcct) {
         uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
-            .declineDefaultAccountExplanation);
+        uiLogger.log(lib.localDevHelpers.account.declineDefaultAccountExplanation);
         uiLogger.log('');
         return false;
     }

package/lib/projects/release.d.ts

@@ -0,0 +1,4 @@
+import { type Release } from '../../api/releases.js';
+export declare function resolveBuildId(accountId: number, projectName: string, buildOption?: number, force?: boolean): Promise<number | null | undefined>;
+export declare function validateBuildForRelease(accountId: number, projectName: string, buildId: number): Promise<boolean>;
+export declare function executeRelease(accountId: number, projectName: string, buildId: number): Promise<Release>;