@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/api/__tests__/migrate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/__tests__/migrate.test.js

@@ -0,0 +1,199 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
+import { listAppsForMigration, initializeAppMigration, continueAppMigration, checkMigrationStatusV2, isMigrationStatus, } from '../migrate.js';
+vi.mock('@hubspot/local-dev-lib/http');
+const httpMock = http;
+describe('api/migrate', () => {
+    const mockAccountId = 12345;
+    const mockPortalId = 12345;
+    const mockAppId = 67890;
+    const mockMigrationId = 54321;
+    const mockPlatformVersion = '2025.2';
+    const convertedPlatformVersion = 'V2025_2';
+    const mockProjectName = 'Test Project';
+    const mockComponentUids = { 'component-1': 'uid-1', 'component-2': 'uid-2' };
+    describe('listAppsForMigration', () => {
+        it('should call http.get with correct parameters', async () => {
+            const mockResponse = {
+                migratableApps: [
+                    {
+                        appId: 1,
+                        appName: 'App 1',
+                        isMigratable: true,
+                        migrationComponents: [
+                            { id: 'comp1', componentType: 'type1', isSupported: true },
+                        ],
+                    },
+                ],
+                unmigratableApps: [
+                    {
+                        appId: 2,
+                        appName: 'App 2',
+                        isMigratable: false,
+                        unmigratableReason: 'UP_TO_DATE',
+                        migrationComponents: [
+                            { id: 'comp2', componentType: 'type2', isSupported: false },
+                        ],
+                    },
+                ],
+            };
+            // @ts-expect-error Mock
+            httpMock.get.mockResolvedValue(mockResponse);
+            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);
+        });
+    });
+    describe('initializeAppMigration', () => {
+        it('should call http.post with correct parameters', async () => {
+            const mockResponse = { migrationId: mockMigrationId };
+            // @ts-expect-error Mock
+            httpMock.post.mockResolvedValue(mockResponse);
+            const result = await initializeAppMigration(mockAccountId, mockAppId, mockPlatformVersion);
+            expect(http.post).toHaveBeenCalledWith(mockAccountId, {
+                url: 'dfs/migrations/v2/migrations',
+                data: {
+                    applicationId: mockAppId,
+                    platformVersion: convertedPlatformVersion,
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('continueAppMigration', () => {
+        it('should call http.post with correct parameters', async () => {
+            const mockResponse = { migrationId: mockMigrationId };
+            // @ts-expect-error Mock
+            httpMock.post.mockResolvedValue(mockResponse);
+            const result = await continueAppMigration(mockPortalId, mockMigrationId, mockComponentUids, mockProjectName);
+            expect(http.post).toHaveBeenCalledWith(mockPortalId, {
+                url: 'dfs/migrations/v2/migrations/continue',
+                data: {
+                    migrationId: mockMigrationId,
+                    projectName: mockProjectName,
+                    componentUids: mockComponentUids,
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('checkMigrationStatusV2', () => {
+        it('should call http.get with correct parameters for in-progress status', async () => {
+            const mockResponse = {
+                id: mockMigrationId,
+                status: MIGRATION_STATUS.IN_PROGRESS,
+            };
+            // @ts-expect-error Mock
+            httpMock.get.mockResolvedValue(mockResponse);
+            const result = await checkMigrationStatusV2(mockAccountId, mockMigrationId);
+            expect(http.get).toHaveBeenCalledWith(mockAccountId, {
+                url: `dfs/migrations/v2/migrations/${mockMigrationId}/status`,
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should handle input required status', async () => {
+            const mockResponse = {
+                id: mockMigrationId,
+                status: MIGRATION_STATUS.INPUT_REQUIRED,
+                componentsRequiringUids: {
+                    'component-1': {
+                        componentType: 'type1',
+                        componentHint: 'hint1',
+                    },
+                },
+            };
+            // @ts-expect-error Mock
+            httpMock.get.mockResolvedValue(mockResponse);
+            const result = await checkMigrationStatusV2(mockAccountId, mockMigrationId);
+            expect(result).toEqual(mockResponse);
+        });
+        it('should handle success status', async () => {
+            const mockResponse = {
+                id: mockMigrationId,
+                status: MIGRATION_STATUS.SUCCESS,
+                buildId: 98765,
+            };
+            // @ts-expect-error Mock
+            httpMock.get.mockResolvedValue(mockResponse);
+            const result = await checkMigrationStatusV2(mockAccountId, mockMigrationId);
+            expect(result).toEqual(mockResponse);
+        });
+        it('should handle failure status', async () => {
+            const mockResponse = {
+                id: mockMigrationId,
+                status: MIGRATION_STATUS.FAILURE,
+                projectErrorDetail: 'Error details',
+                componentErrors: [],
+            };
+            // @ts-expect-error Mock
+            httpMock.get.mockResolvedValue(mockResponse);
+            const result = await checkMigrationStatusV2(mockAccountId, mockMigrationId);
+            expect(result).toEqual(mockResponse);
+        });
+    });
+});
+describe('isMigrationStatus', () => {
+    it.each([
+        {
+            id: 123,
+            status: MIGRATION_STATUS.IN_PROGRESS,
+        },
+        {
+            id: 456,
+            status: MIGRATION_STATUS.INPUT_REQUIRED,
+            componentsRequiringUids: {
+                'component-1': {
+                    componentType: 'type1',
+                    componentHint: 'hint1',
+                },
+            },
+        },
+        {
+            id: 789,
+            status: MIGRATION_STATUS.SUCCESS,
+            buildId: 98765,
+        },
+        {
+            id: 101,
+            status: MIGRATION_STATUS.FAILURE,
+            projectErrorDetail: 'Error details',
+            componentErrors: [],
+        },
+    ])('should return true for valid MigrationStatus object %j', status => {
+        expect(isMigrationStatus(status)).toBe(true);
+    });
+    it.each([null, undefined, 123, 'string', true, false, []])('should return false for non-object value %j', value => {
+        expect(isMigrationStatus(value)).toBe(false);
+    });
+    it.each([
+        {},
+        { id: 123 },
+        { status: MIGRATION_STATUS.IN_PROGRESS },
+        { foo: 'bar' },
+    ])('should return false for invalid object %j', obj => {
+        expect(isMigrationStatus(obj)).toBe(false);
+    });
+});

package/api/migrate.d.ts

@@ -0,0 +1,77 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
+import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
+interface BaseMigrationApp {
+    appId: number;
+    appName: string;
+    isMigratable: boolean;
+    migrationComponents: ListAppsMigrationComponent[];
+    projectName?: string;
+}
+export interface MigratableApp extends BaseMigrationApp {
+    isMigratable: true;
+    unmigratableReason?: undefined;
+}
+export declare const CLI_UNMIGRATABLE_REASONS: {
+    readonly PART_OF_PROJECT_ALREADY: "PART_OF_PROJECT_ALREADY";
+};
+export interface UnmigratableApp extends BaseMigrationApp {
+    isMigratable: false;
+    unmigratableReason: keyof typeof UNMIGRATABLE_REASONS | keyof typeof CLI_UNMIGRATABLE_REASONS;
+}
+export type MigrationApp = MigratableApp | UnmigratableApp;
+export interface ListAppsResponse {
+    migratableApps: MigratableApp[];
+    unmigratableApps: UnmigratableApp[];
+}
+export interface ListThemesResponse {
+    migratableThemes: {
+        THEME: string[];
+        REACT_THEME: string[];
+    };
+}
+export interface InitializeAppMigrationResponse {
+    migrationId: number;
+}
+export interface ListAppsMigrationComponent {
+    id: string;
+    componentType: string;
+    isSupported: boolean;
+}
+export type ContinueAppMigrationResponse = {
+    migrationId: number;
+};
+export interface MigrationBaseStatus {
+    id: number;
+}
+export interface MigrationInProgress extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.IN_PROGRESS;
+}
+export interface MigrationInputRequired extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.INPUT_REQUIRED;
+    componentsRequiringUids: Record<string, {
+        componentType: string;
+        componentHint: string;
+    }>;
+}
+export interface MigrationSuccess extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.SUCCESS;
+    buildId: number;
+}
+interface ComponentError {
+    componentType: string;
+    developerSymbol?: string;
+    errorMessage: string;
+}
+export interface MigrationFailed extends MigrationBaseStatus {
+    status: typeof MIGRATION_STATUS.FAILURE;
+    projectErrorDetail: string;
+    componentErrors: ComponentError[];
+}
+export type MigrationStatus = MigrationInProgress | MigrationInputRequired | MigrationSuccess | MigrationFailed;
+export declare function isMigrationStatus(error: unknown): error is MigrationStatus;
+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>;
+export {};

package/api/migrate.js

@@ -0,0 +1,55 @@
+import { PLATFORM_VERSIONS, } from '@hubspot/local-dev-lib/constants/projects';
+import { http } from '@hubspot/local-dev-lib/http';
+const MIGRATIONS_API_PATH_V2 = 'dfs/migrations/v2';
+export const CLI_UNMIGRATABLE_REASONS = {
+    PART_OF_PROJECT_ALREADY: 'PART_OF_PROJECT_ALREADY',
+};
+export function isMigrationStatus(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'id' in error &&
+        'status' in error);
+}
+export async function listAppsForMigration(accountId, platformVersion, appId) {
+    return http.get(accountId, {
+        url: `${MIGRATIONS_API_PATH_V2}/list-apps`,
+        params: {
+            platformVersion: mapPlatformVersionToEnum(platformVersion),
+            appId,
+        },
+    });
+}
+function mapPlatformVersionToEnum(platformVersion) {
+    if (platformVersion === PLATFORM_VERSIONS.unstable) {
+        return PLATFORM_VERSIONS.unstable.toUpperCase();
+    }
+    const reformattedPlatformVersion = platformVersion
+        .replaceAll('.', '_')
+        .replaceAll('-', '_')
+        .toUpperCase();
+    return `V${reformattedPlatformVersion}`;
+}
+export async function initializeAppMigration(accountId, applicationId, platformVersion) {
+    return http.post(accountId, {
+        url: `${MIGRATIONS_API_PATH_V2}/migrations`,
+        data: {
+            applicationId,
+            platformVersion: mapPlatformVersionToEnum(platformVersion),
+        },
+    });
+}
+export async function continueAppMigration(portalId, migrationId, componentUids, projectName) {
+    return http.post(portalId, {
+        url: `${MIGRATIONS_API_PATH_V2}/migrations/continue`,
+        data: {
+            migrationId,
+            projectName,
+            componentUids,
+        },
+    });
+}
+export async function checkMigrationStatusV2(accountId, id) {
+    return http.get(accountId, {
+        url: `${MIGRATIONS_API_PATH_V2}/migrations/${id}/status`,
+    });
+}

package/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/cli.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+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, 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 { handleDisableUsageTracking } from '../lib/middleware/usageTrackingMiddleware.js';
+import initCommand from '../commands/init.js';
+import hubdbCommand from '../commands/hubdb.js';
+import authCommand from '../commands/auth.js';
+import filemanagerCommand from '../commands/filemanager.js';
+import secretCommands from '../commands/secret.js';
+import customObjectCommand from '../commands/customObject.js';
+import openCommand from '../commands/open.js';
+import projectCommands from '../commands/project.js';
+import configCommand from '../commands/config.js';
+import accountCommands from '../commands/account.js';
+import sandboxesCommand from '../commands/sandbox.js';
+import cmsCommand from '../commands/cms.js';
+import feedbackCommand from '../commands/feedback.js';
+import doctorCommand from '../commands/doctor.js';
+import completionCommand from '../commands/completion.js';
+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';
+import { addCommandSuggestions } from '../lib/commandSuggestion.js';
+function getTerminalWidth() {
+    const width = yargs().terminalWidth();
+    if (width >= 100)
+        return width * 0.9;
+    return width;
+}
+function handleFailure(msg, err, yargs) {
+    if (msg) {
+        uiLogger.error(msg);
+    }
+    else if (err) {
+        logError(err);
+    }
+    if (msg === null && !err) {
+        // Required so running `hs` without a command shows the help
+        yargs.showHelp('log');
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else {
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+const argv = yargs(process.argv.slice(2))
+    .usage('The command line interface to interact with HubSpot.')
+    .middleware([
+    setCLILogLevel,
+    setRequestHeaders,
+    handleCustomConfigLocationMiddleware,
+    handleDisableUsageTracking,
+    injectAccountIdMiddleware,
+    validateConfigMiddleware,
+    autoUpdateCLI,
+    checkAndWarnGitInclusionMiddleware,
+    validateAccountOptions,
+    checkFireAlarms,
+    initializeSpinniesManager,
+])
+    .exitProcess(false)
+    .fail(handleFailure)
+    .option('noHyperlinks', {
+    default: false,
+    describe: 'prevent hyperlinks from displaying in the ui',
+    hidden: true,
+    type: 'boolean',
+})
+    .option('noColor', {
+    default: false,
+    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
+    .command(getStartedCommand)
+    .command(feedbackCommand)
+    // Config/Account management
+    .command(authCommand)
+    .command(initCommand)
+    .command(configCommand)
+    .command(accountCommands)
+    .command(testAccountCommands)
+    .command(sandboxesCommand)
+    .command(secretCommands)
+    .command(openCommand)
+    // Project commands
+    .command(projectCommands)
+    .command(appCommand)
+    // CMS Commands
+    .command(cmsCommand)
+    .command(hubdbCommand)
+    .command(filemanagerCommand)
+    // Misc commands
+    .command(customObjectCommand)
+    .command(completionCommand)
+    .command(doctorCommand)
+    .command(mcpCommand)
+    .command(upgradeCommand);
+const argvWithSuggestions = addCommandSuggestions(argv)
+    .help()
+    .alias('h', 'help')
+    .recommendCommands()
+    .demandCommand(1, '')
+    .wrap(getTerminalWidth())
+    .strict().argv;
+if ('help' in argvWithSuggestions && argvWithSuggestions.help !== undefined) {
+    (async () => {
+        await trackHelpUsage(getCommandName(argvWithSuggestions));
+    })();
+}
+if ('convertFields' in argvWithSuggestions &&
+    argvWithSuggestions.convertFields !== undefined) {
+    (async () => {
+        await trackConvertFieldsUsage(getCommandName(argvWithSuggestions));
+    })();
+}

package/bin/hs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/hscms.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/silenceErrors.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/silenceErrors.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const SILENCED_ERRORS = ['DeprecationWarning:'];
+const originalConsoleError = console.error;
+console.error = msg => {
+    const isSilencedError = SILENCED_ERRORS.some(error => typeof msg === 'string' && msg.includes(error));
+    if (isSilencedError) {
+        return;
+    }
+    originalConsoleError(msg);
+};
+export {};

package/commands/__tests__/account.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/account.test.js

@@ -0,0 +1,69 @@
+import yargs from 'yargs';
+import auth from '../account/auth.js';
+import list from '../account/list.js';
+import rename from '../account/rename.js';
+import use from '../account/use.js';
+import info from '../account/info.js';
+import remove from '../account/remove.js';
+import clean from '../account/clean.js';
+import createOverride from '../account/createOverride.js';
+import removeOverride from '../account/removeOverride.js';
+import accountCommands from '../account.js';
+vi.mock('../account/auth');
+vi.mock('../account/list');
+vi.mock('../account/rename');
+vi.mock('../account/use');
+vi.mock('../account/info');
+vi.mock('../account/remove');
+vi.mock('../account/clean');
+vi.mock('../account/createOverride');
+vi.mock('../account/removeOverride');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/account', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountCommands.command).toEqual(['account', 'accounts']);
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountCommands.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [
+            auth,
+            list,
+            rename,
+            use,
+            info,
+            remove,
+            clean,
+            createOverride,
+            removeOverride,
+        ];
+        it('should demand the command takes one positional argument', () => {
+            accountCommands.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            accountCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            accountCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/auth.test.js

@@ -0,0 +1,43 @@
+import yargs from 'yargs';
+import { addConfigOptions, addTestingOptions } from '../../lib/commonOpts.js';
+import authCommand from '../auth.js';
+vi.mock('../../lib/commonOpts');
+const optionsSpy = vi
+    .spyOn(mockYargs, 'options')
+    .mockReturnValue(yargs);
+describe('commands/auth', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(authCommand.command).toEqual('auth');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(authCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            authCommand.builder(yargs);
+            expect(optionsSpy).toHaveBeenCalledTimes(1);
+            expect(optionsSpy).toHaveBeenCalledWith({
+                'auth-type': expect.objectContaining({
+                    type: 'string',
+                    choices: ['personalaccesskey', 'oauth2'],
+                    default: 'personalaccesskey',
+                }),
+                account: expect.objectContaining({ type: 'string' }),
+                'personal-access-key': expect.objectContaining({ type: 'string' }),
+                'disable-tracking': expect.objectContaining({
+                    type: 'boolean',
+                    hidden: true,
+                    default: false,
+                }),
+            });
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addTestingOptions).toHaveBeenCalledTimes(1);
+            expect(addTestingOptions).toHaveBeenCalledWith(yargs);
+        });
+    });
+});

package/commands/__tests__/cms.test.d.ts

@@ -0,0 +1 @@
+export {};