@hubspot/cli 7.11.8-experimental.0 → 8.0.0-beta.1

package/api/__tests__/migrate.test.js

@@ -39,11 +39,29 @@ describe('api/migrate', () => {
             };
             // @ts-expect-error Mock
             httpMock.get.mockResolvedValue(mockResponse);
-            const result = await listAppsForMigration(mockAccountId, mockPlatformVersion);
+            const result = await listAppsForMigration(mockAccountId, mockPlatformVersion, mockAppId);
             expect(http.get).toHaveBeenCalledWith(mockAccountId, {
                 url: 'dfs/migrations/v2/list-apps',
                 params: {
                     platformVersion: convertedPlatformVersion,
+                    appId: 67890,
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should call http.get with undefined appId when not provided', async () => {
+            const mockResponse = {
+                migratableApps: [],
+                unmigratableApps: [],
+            };
+            // @ts-expect-error Mock
+            httpMock.get.mockResolvedValue(mockResponse);
+            const result = await listAppsForMigration(mockAccountId, mockPlatformVersion, undefined);
+            expect(http.get).toHaveBeenCalledWith(mockAccountId, {
+                url: 'dfs/migrations/v2/list-apps',
+                params: {
+                    platformVersion: convertedPlatformVersion,
+                    appId: undefined,
                 },
             });
             expect(result).toEqual(mockResponse);

package/api/migrate.d.ts

@@ -70,7 +70,7 @@ export interface MigrationFailed extends MigrationBaseStatus {
 }
 export type MigrationStatus = MigrationInProgress | MigrationInputRequired | MigrationSuccess | MigrationFailed;
 export declare function isMigrationStatus(error: unknown): error is MigrationStatus;
-export declare function listAppsForMigration(accountId: number, platformVersion: string): HubSpotPromise<ListAppsResponse>;
+export declare function listAppsForMigration(accountId: number, platformVersion: string, appId: number | undefined): HubSpotPromise<ListAppsResponse>;
 export declare function initializeAppMigration(accountId: number, applicationId: number, platformVersion: string): HubSpotPromise<InitializeAppMigrationResponse>;
 export declare function continueAppMigration(portalId: number, migrationId: number, componentUids: Record<string, string>, projectName: string): HubSpotPromise<ContinueAppMigrationResponse>;
 export declare function checkMigrationStatusV2(accountId: number, id: number): HubSpotPromise<MigrationStatus>;

package/api/migrate.js

@@ -10,11 +10,12 @@ export function isMigrationStatus(error) {
         'id' in error &&
         'status' in error);
 }
-export async function listAppsForMigration(accountId, platformVersion) {
+export async function listAppsForMigration(accountId, platformVersion, appId) {
     return http.get(accountId, {
         url: `${MIGRATIONS_API_PATH_V2}/list-apps`,
         params: {
             platformVersion: mapPlatformVersionToEnum(platformVersion),
+            appId,
         },
     });
 }

package/bin/cli.js

@@ -4,32 +4,21 @@ import { logError } from '../lib/errorHandlers/index.js';
 import { setCLILogLevel, getCommandName } from '../lib/commonOpts.js';
 import { trackHelpUsage, trackConvertFieldsUsage, } from '../lib/usageTracking.js';
 import { EXIT_CODES } from '../lib/enums/exitCodes.js';
-import { validateConfigMiddleware, injectAccountIdMiddleware, validateAccountOptions, handleDeprecatedEnvVariables, handleCustomConfigLocationMiddleware, } from '../lib/middleware/configMiddleware.js';
+import { validateConfigMiddleware, injectAccountIdMiddleware, validateAccountOptions, handleCustomConfigLocationMiddleware, } from '../lib/middleware/configMiddleware.js';
 import { autoUpdateCLI } from '../lib/middleware/autoUpdateMiddleware.js';
 import { checkAndWarnGitInclusionMiddleware } from '../lib/middleware/gitMiddleware.js';
 import { performChecks } from '../lib/middleware/yargsChecksMiddleware.js';
 import { setRequestHeaders } from '../lib/middleware/requestMiddleware.js';
 import { checkFireAlarms } from '../lib/middleware/fireAlarmMiddleware.js';
-import removeCommand from '../commands/remove.js';
+import { handleDisableUsageTracking } from '../lib/middleware/usageTrackingMiddleware.js';
 import initCommand from '../commands/init.js';
-import logsCommand from '../commands/logs.js';
-import lintCommand from '../commands/lint.js';
 import hubdbCommand from '../commands/hubdb.js';
-import watchCommand from '../commands/watch.js';
 import authCommand from '../commands/auth.js';
-import uploadCommand from '../commands/upload.js';
-import createCommand from '../commands/create.js';
-import fetchCommand from '../commands/fetch.js';
 import filemanagerCommand from '../commands/filemanager.js';
 import secretCommands from '../commands/secret.js';
 import customObjectCommand from '../commands/customObject.js';
-import functionCommands from '../commands/function.js';
-import listCommand from '../commands/list.js';
 import openCommand from '../commands/open.js';
-import mvCommand from '../commands/mv.js';
 import projectCommands from '../commands/project.js';
-import themeCommand from '../commands/theme.js';
-import moduleCommand from '../commands/module.js';
 import configCommand from '../commands/config.js';
 import accountCommands from '../commands/account.js';
 import sandboxesCommand from '../commands/sandbox.js';
@@ -41,7 +30,9 @@ import appCommand from '../commands/app.js';
 import testAccountCommands from '../commands/testAccount.js';
 import getStartedCommand from '../commands/getStarted.js';
 import mcpCommand from '../commands/mcp.js';
+import upgradeCommand from '../commands/upgrade.js';
 import { uiLogger } from '../lib/ui/logger.js';
+import { initializeSpinniesManager } from '../lib/middleware/spinniesMiddleware.js';
 function getTerminalWidth() {
     const width = yargs().terminalWidth();
     if (width >= 100)
@@ -69,14 +60,15 @@ const argv = yargs(process.argv.slice(2))
     .middleware([
     setCLILogLevel,
     setRequestHeaders,
-    handleDeprecatedEnvVariables,
     handleCustomConfigLocationMiddleware,
+    handleDisableUsageTracking,
     injectAccountIdMiddleware,
     validateConfigMiddleware,
     autoUpdateCLI,
     checkAndWarnGitInclusionMiddleware,
     validateAccountOptions,
     checkFireAlarms,
+    initializeSpinniesManager,
 ])
     .exitProcess(false)
     .fail(handleFailure)
@@ -91,6 +83,11 @@ const argv = yargs(process.argv.slice(2))
     describe: 'prevent color from displaying in the ui',
     hidden: true,
     type: 'boolean',
+})
+    .option('disable-usage-tracking', {
+    default: false,
+    hidden: true,
+    type: 'boolean',
 })
     .check(performChecks)
     // Getting started / important
@@ -108,28 +105,16 @@ const argv = yargs(process.argv.slice(2))
     // Project commands
     .command(projectCommands)
     .command(appCommand)
-    // CMS Design Manager
-    .command(watchCommand)
-    .command(listCommand)
-    .command(uploadCommand)
-    .command(fetchCommand)
-    .command(removeCommand)
-    .command(mvCommand)
     // CMS Commands
     .command(cmsCommand)
-    .command(logsCommand)
-    .command(lintCommand)
     .command(hubdbCommand)
-    .command(createCommand)
     .command(filemanagerCommand)
-    .command(functionCommands)
-    .command(themeCommand)
-    .command(moduleCommand)
     // Misc commands
     .command(customObjectCommand)
     .command(completionCommand)
     .command(doctorCommand)
     .command(mcpCommand)
+    .command(upgradeCommand)
     .help()
     .alias('h', 'help')
     .recommendCommands()

package/commands/__tests__/customObject.test.js

@@ -1,6 +1,5 @@
 import yargs from 'yargs';
 import create from '../customObject/create.js';
-import schema from '../customObject/schema.js';
 import createSchema from '../customObject/createSchema.js';
 import updateSchema from '../customObject/updateSchema.js';
 import listSchemas from '../customObject/listSchemas.js';
@@ -45,7 +44,6 @@ describe('commands/customObject', () => {
         });
         const subcommands = [
             create,
-            schema,
             createSchema,
             updateSchema,
             listSchemas,

package/commands/__tests__/doctor.test.js

@@ -6,9 +6,7 @@ import { Doctor } from '../../lib/doctor/Doctor.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import fs from 'fs';
 import { getCwd as __getCwd } from '@hubspot/local-dev-lib/path';
-vi.mock('../../lib/usageTracking');
 vi.mock('../../lib/doctor/Doctor');
-vi.mock('../../lib/ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/path');
 vi.mock('fs');
 // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables

package/commands/__tests__/getStarted.test.js

@@ -9,11 +9,9 @@ import { getProjectPackageJsonLocations, installPackages, } from '../../lib/depe
 import { GET_STARTED_OPTIONS } from '../../lib/constants.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import open from 'open';
-vi.mock('../../lib/usageTracking');
 vi.mock('../../lib/prompts/promptUtils');
 vi.mock('../../lib/prompts/projectNameAndDestPrompt');
 vi.mock('../../lib/projects/config');
-vi.mock('../../lib/ui/logger');
 vi.mock('../../lib/errorHandlers');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('../../lib/dependencyManagement');
@@ -28,7 +26,6 @@ vi.mock('fs-extra', () => ({
 }));
 describe('commands/get-started', () => {
     beforeEach(() => {
-        vi.clearAllMocks();
         // @TODO Revisit config mocking in tests
         getConfigAccountById.mockReturnValue({
             accountId: 12345,
@@ -76,7 +73,6 @@ describe('commands/get-started', () => {
             $0: 'hs',
         };
         beforeEach(() => {
-            vi.clearAllMocks();
             trackCommandUsage.mockResolvedValue(undefined);
             projectNameAndDestPrompt.mockResolvedValue({
                 dest: 'test-destination',

package/commands/__tests__/project.test.js

@@ -9,9 +9,7 @@ import download from '../project/download.js';
 import open from '../project/open.js';
 import dev from '../project/dev/index.js';
 import add from '../project/add.js';
-import migrateApp from '../project/migrateApp.js';
 import migrate from '../project/migrate.js';
-import cloneApp from '../project/cloneApp.js';
 import installDeps from '../project/installDeps.js';
 import lint from '../project/lint.js';
 import updateDeps from '../project/updateDeps.js';
@@ -71,9 +69,7 @@ describe('commands/project', () => {
             listBuilds,
             download,
             open,
-            migrateApp,
             migrate,
-            cloneApp,
             installDeps,
             lint,
             updateDeps,

package/commands/__tests__/upgrade.test.js

@@ -0,0 +1,309 @@
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import yargs from 'yargs';
+import upgradeCommand from '../upgrade.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { canCliBeAutoUpgraded, getLatestCliVersion, installCliVersion, } from '../../lib/cliUpgradeUtils.js';
+import { confirmPrompt } from '../../lib/prompts/promptUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { pkg } from '../../lib/jsonLoader.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { debugError } from '../../lib/errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+import { isConfigFlagEnabled } from '@hubspot/local-dev-lib/config';
+vi.mock('../../lib/usageTracking');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../lib/cliUpgradeUtils');
+vi.mock('../../lib/prompts/promptUtils');
+vi.mock('../../lib/ui/logger.js');
+vi.mock('../../lib/jsonLoader.js');
+vi.mock('../../lib/ui/SpinniesManager');
+vi.mock('../../lib/errorHandlers/index.js');
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
+const mockedCanCliBeAutoUpgraded = vi.mocked(canCliBeAutoUpgraded);
+const mockedGetLatestCliVersion = vi.mocked(getLatestCliVersion);
+const mockedInstallCliVersion = vi.mocked(installCliVersion);
+const mockedConfirmPrompt = vi.mocked(confirmPrompt);
+const mockedDebugError = vi.mocked(debugError);
+const mockedIsConfigFlagEnabled = vi.mocked(isConfigFlagEnabled);
+const optionSpy = vi
+    .spyOn(yargs, 'option')
+    .mockReturnValue(yargs);
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+describe('commands/upgrade', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let processExitSpy;
+    const accountId = 123456;
+    const currentVersion = '7.11.2';
+    const latestVersion = '7.12.0';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+        vi.mocked(pkg).version = currentVersion;
+        vi.mocked(SpinniesManager.init).mockReturnValue(undefined);
+        vi.mocked(SpinniesManager.add).mockReturnValue(undefined);
+        vi.mocked(SpinniesManager.succeed).mockReturnValue(undefined);
+        vi.mocked(SpinniesManager.fail).mockReturnValue(undefined);
+        // Default mock for isConfigFlagEnabled - can be overridden in individual tests
+        mockedIsConfigFlagEnabled.mockReturnValue(false);
+        // Reset mock implementations to ensure clean state
+        mockedGetLatestCliVersion.mockReset();
+        mockedCanCliBeAutoUpgraded.mockReset();
+        mockedInstallCliVersion.mockReset();
+        mockedConfirmPrompt.mockReset();
+    });
+    describe('command', () => {
+        it('should have the proper command names', () => {
+            expect(upgradeCommand.command).toEqual([
+                'upgrade [version]',
+                'update [version]',
+            ]);
+        });
+    });
+    describe('describe', () => {
+        it('should have a description', () => {
+            expect(upgradeCommand.describe).toBeDefined();
+            expect(upgradeCommand.describe).toContain('Install');
+        });
+    });
+    describe('builder', () => {
+        it('should apply the correct options', async () => {
+            await upgradeCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('[version]', {
+                describe: commands.upgrade.options.version,
+                type: 'string',
+            });
+            expect(optionSpy).toHaveBeenCalledWith('force', {
+                alias: 'f',
+                describe: commands.upgrade.options.force,
+                type: 'boolean',
+                default: false,
+            });
+            expect(optionSpy).toHaveBeenCalledWith('beta', {
+                alias: 'next',
+                describe: commands.upgrade.options.beta,
+                type: 'boolean',
+                default: false,
+            });
+        });
+    });
+    describe('handler', () => {
+        it('should track the command usage', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(false);
+            await upgradeCommand.handler({
+                derivedAccountId: accountId,
+            });
+            expect(mockedTrackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('upgrade', {}, accountId);
+        });
+        it('should exit successfully when already on latest version', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: currentVersion,
+                next: '7.11.2-beta.1',
+            });
+            await upgradeCommand.handler({});
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.alreadyLatest(currentVersion));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should exit successfully when already on requested version', async () => {
+            const requestedVersion = currentVersion;
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            await upgradeCommand.handler({
+                version: requestedVersion,
+            });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.alreadyOnVersion(currentVersion));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should show message when CLI is not globally installed', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(false);
+            await upgradeCommand.handler({});
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.autoUpgradeNotAvailable(latestVersion));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should cancel upgrade when user declines confirmation', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(false);
+            await upgradeCommand.handler({});
+            expect(mockedConfirmPrompt).toHaveBeenCalledWith(commands.upgrade.confirmPrompt(currentVersion, latestVersion), { defaultAnswer: true });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.cancelled);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should upgrade successfully when user confirms', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({});
+            expect(mockedConfirmPrompt).toHaveBeenCalled();
+            expect(SpinniesManager.add).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.installing(latestVersion),
+            });
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(latestVersion);
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.success(latestVersion),
+            });
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should upgrade without confirmation when --force is used', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                force: true,
+            });
+            expect(mockedConfirmPrompt).not.toHaveBeenCalled();
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(latestVersion);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should install specific version when provided', async () => {
+            const specificVersion = '7.10.0';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                version: specificVersion,
+            });
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(specificVersion);
+            expect(SpinniesManager.add).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.installing(specificVersion),
+            });
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle installation errors', async () => {
+            const error = new Error('Installation failed');
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockRejectedValueOnce(error);
+            await upgradeCommand.handler({});
+            expect(mockedDebugError).toHaveBeenCalledWith(error);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.errors.installFailed,
+            });
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.upgrade.errors.generic);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should install beta version when --beta flag is used', async () => {
+            const betaVersion = '7.13.0-beta.1';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            expect(mockedGetLatestCliVersion).toHaveBeenCalled();
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(betaVersion);
+            expect(SpinniesManager.add).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.installing(betaVersion),
+            });
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.success(betaVersion),
+            });
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should error when beta is requested but next version is not available', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: null,
+            });
+            mockedIsConfigFlagEnabled.mockReturnValue(false);
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            expect(mockedGetLatestCliVersion).toHaveBeenCalled();
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.upgrade.errors.unableToDetermineLatestVersion);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+            expect(mockedCanCliBeAutoUpgraded).not.toHaveBeenCalled();
+        });
+        it('should show already on latest beta version message', async () => {
+            const betaVersion = '7.12.0-beta.1';
+            vi.mocked(pkg).version = betaVersion;
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.alreadyLatest(betaVersion, true));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should not show auto-upgrade message when beta flag is used', async () => {
+            const betaVersion = '7.12.0-beta.1';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            mockedIsConfigFlagEnabled.mockReturnValue(false);
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            // Verify the auto-upgrade message was not logged
+            const logCalls = vi.mocked(uiLogger.log).mock.calls;
+            const autoUpgradeMessageCall = logCalls.find(call => call[0]?.includes('automatic updates'));
+            expect(autoUpgradeMessageCall).toBeUndefined();
+            // Should succeed even though auto-updates are disabled when beta is used
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(betaVersion);
+        });
+        it('should upgrade to beta without confirmation when --force and --beta are used', async () => {
+            const betaVersion = '7.12.0-beta.1';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                force: true,
+                beta: true,
+            });
+            expect(mockedConfirmPrompt).not.toHaveBeenCalled();
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(betaVersion);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+    });
+});