@hubspot/cli 8.0.11-experimental.0 → 8.0.11-experimental.1

package/lib/usageTracking.d.ts

@@ -1,4 +1,4 @@
-type Meta = {
+export type UsageTrackingMeta = {
     action?: string;
     os?: string;
     nodeVersion?: string;
@@ -24,9 +24,8 @@ export declare function getNodeVersionData(): {
     nodeMajorVersion: string;
 };
 export declare function getPlatform(): string;
-export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export declare function trackCommandUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;
 export declare function trackHelpUsage(command: string): Promise<void>;
 export declare function trackConvertFieldsUsage(command: string): Promise<void>;
 export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): Promise<void>;
-export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
-export {};
+export declare function trackCommandMetadataUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;

package/lib/yargs/makeYargsBuilder.d.ts

@@ -0,0 +1,13 @@
+import { Argv } from 'yargs';
+export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
+    useGlobalOptions?: boolean;
+    useAccountOptions?: boolean;
+    useConfigOptions?: boolean;
+    useEnvironmentOptions?: boolean;
+    useTestingOptions?: boolean;
+    useCmsPublishModeOptions?: boolean | {
+        read?: boolean;
+        write?: boolean;
+    };
+    useJSONOutputOptions?: boolean;
+}): (yargs: Argv) => Promise<Argv<T>>;

package/lib/yargs/makeYargsBuilder.js

@@ -0,0 +1,33 @@
+import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from '../commonOpts.js';
+export function makeYargsBuilder(callback, command, describe, options = {}) {
+    return async function (yargs) {
+        if (options.useGlobalOptions) {
+            addGlobalOptions(yargs);
+        }
+        if (options.useAccountOptions) {
+            addAccountOptions(yargs);
+        }
+        if (options.useConfigOptions) {
+            addConfigOptions(yargs);
+        }
+        if (options.useEnvironmentOptions) {
+            addUseEnvironmentOptions(yargs);
+        }
+        if (options.useTestingOptions) {
+            addTestingOptions(yargs);
+        }
+        if (options.useJSONOutputOptions) {
+            addJSONOutputOptions(yargs);
+        }
+        if (options.useCmsPublishModeOptions) {
+            const opts = typeof options.useCmsPublishModeOptions === 'object'
+                ? options.useCmsPublishModeOptions
+                : { write: true };
+            addCmsPublishModeOptions(yargs, opts);
+        }
+        const result = callback(yargs);
+        // Must go last to pick up available options
+        await addCustomHelpOutput(result, command, describe);
+        return result;
+    };
+}

package/lib/yargs/makeYargsHandlerWithUsageTracking.d.ts

@@ -0,0 +1,3 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { CommonArgs } from '../../types/Yargs.js';
+export declare function makeYargsHandlerWithUsageTracking<T extends CommonArgs>(trackingName: string, handler: (args: ArgumentsCamelCase<T>) => Promise<void>): (args: ArgumentsCamelCase<T>) => Promise<void>;

package/lib/yargs/makeYargsHandlerWithUsageTracking.js

@@ -0,0 +1,95 @@
+import { getConfig } from '@hubspot/local-dev-lib/config';
+import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
+import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { trackCommandUsage as _trackCommandUsage } from '../usageTracking.js';
+import { pkg } from '../jsonLoader.js';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { isPromptExitError } from '../errors/PromptExitError.js';
+import { debugError } from '../errorHandlers/index.js';
+function logUsageTrackingMessage(isJsonOutput) {
+    if (isJsonOutput) {
+        return;
+    }
+    try {
+        const config = getConfig();
+        if (config?.allowUsageTracking !== true) {
+            return;
+        }
+        const lastShownVersion = getStateValue(STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION);
+        if (lastShownVersion === pkg.version) {
+            return;
+        }
+        setStateValue(STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION, pkg.version);
+        uiLogger.info(lib.usageTracking.transparencyMessage);
+    }
+    catch (_e) {
+        return;
+    }
+}
+export function makeYargsHandlerWithUsageTracking(trackingName, handler) {
+    return async (args) => {
+        const meta = {};
+        let trackingFired = false;
+        const trackingArgs = args;
+        const addUsageMetadata = (newMeta) => {
+            Object.assign(meta, newMeta);
+        };
+        trackingArgs.addUsageMetadata = addUsageMetadata;
+        const trackCommandUsage = async (successful) => {
+            if (trackingFired) {
+                return;
+            }
+            trackingFired = true;
+            try {
+                const { accountId: overrideAccountId, ...trackingMeta } = meta;
+                trackingMeta.successful = successful;
+                await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? args.derivedAccountId);
+            }
+            catch (_e) { }
+        };
+        const onForcedExit = () => {
+            process.exit(EXIT_CODES.SUCCESS);
+        };
+        const onSigint = async () => {
+            process.removeListener('SIGINT', onSigint);
+            process.on('SIGINT', onForcedExit);
+            try {
+                await trackCommandUsage(false);
+            }
+            catch (_e) { }
+            process.removeListener('SIGINT', onForcedExit);
+            process.exit(EXIT_CODES.SUCCESS);
+        };
+        process.on('SIGINT', onSigint);
+        const trackCommandUsageAndRemoveListeners = async (successful) => {
+            await trackCommandUsage(successful);
+            process.removeListener('SIGINT', onSigint);
+            process.removeListener('SIGINT', onForcedExit);
+        };
+        trackingArgs.exit = async (code) => {
+            await trackCommandUsageAndRemoveListeners(code !== EXIT_CODES.ERROR);
+            return process.exit(code);
+        };
+        const jsonArgs = args;
+        logUsageTrackingMessage(Boolean(jsonArgs.json || jsonArgs.formatOutputAsJson));
+        try {
+            await handler(trackingArgs);
+        }
+        catch (e) {
+            const isSuccessfulPromptExit = isPromptExitError(e)
+                ? e.exitCode !== EXIT_CODES.ERROR
+                : false;
+            await trackCommandUsageAndRemoveListeners(isSuccessfulPromptExit);
+            if (isPromptExitError(e)) {
+                return process.exit(e.exitCode);
+            }
+            else {
+                debugError(e);
+                return process.exit(EXIT_CODES.ERROR);
+            }
+        }
+        await trackCommandUsageAndRemoveListeners(true);
+    };
+}

package/lib/yargs/strictEnforceBoolean.d.ts

@@ -0,0 +1 @@
+export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;

package/lib/yargs/strictEnforceBoolean.js

@@ -0,0 +1,13 @@
+import { commands } from '../../lang/en.js';
+export function strictEnforceBoolean(rawArgs, booleanOptions) {
+    for (const option of booleanOptions) {
+        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
+        if (argIndex !== -1) {
+            const value = rawArgs[argIndex].split('=')[1];
+            if (value && !['true', 'false'].includes(value.toLowerCase())) {
+                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
+            }
+        }
+    }
+    return true;
+}

package/lib/yargsUtils.d.ts

@@ -1,16 +1,3 @@
-import { Argv } from 'yargs';
-import { hasFlag } from './utils/hasFlag.js';
-export { hasFlag };
-export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
-    useGlobalOptions?: boolean;
-    useAccountOptions?: boolean;
-    useConfigOptions?: boolean;
-    useEnvironmentOptions?: boolean;
-    useTestingOptions?: boolean;
-    useCmsPublishModeOptions?: boolean | {
-        read?: boolean;
-        write?: boolean;
-    };
-    useJSONOutputOptions?: boolean;
-}): (yargs: Argv) => Promise<Argv<T>>;
-export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';

package/lib/yargsUtils.js

@@ -1,49 +1,4 @@
-import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from './commonOpts.js';
-import { hasFlag } from './utils/hasFlag.js';
-import { commands } from '../lang/en.js';
 // Re-export for backwards compatibility
-export { hasFlag };
-export function makeYargsBuilder(callback, command, describe, options = {}) {
-    return async function (yargs) {
-        if (options.useGlobalOptions) {
-            addGlobalOptions(yargs);
-        }
-        if (options.useAccountOptions) {
-            addAccountOptions(yargs);
-        }
-        if (options.useConfigOptions) {
-            addConfigOptions(yargs);
-        }
-        if (options.useEnvironmentOptions) {
-            addUseEnvironmentOptions(yargs);
-        }
-        if (options.useTestingOptions) {
-            addTestingOptions(yargs);
-        }
-        if (options.useJSONOutputOptions) {
-            addJSONOutputOptions(yargs);
-        }
-        if (options.useCmsPublishModeOptions) {
-            const opts = typeof options.useCmsPublishModeOptions === 'object'
-                ? options.useCmsPublishModeOptions
-                : { write: true };
-            addCmsPublishModeOptions(yargs, opts);
-        }
-        const result = callback(yargs);
-        // Must go last to pick up available options
-        await addCustomHelpOutput(result, command, describe);
-        return result;
-    };
-}
-export function strictEnforceBoolean(rawArgs, booleanOptions) {
-    for (const option of booleanOptions) {
-        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
-        if (argIndex !== -1) {
-            const value = rawArgs[argIndex].split('=')[1];
-            if (value && !['true', 'false'].includes(value.toLowerCase())) {
-                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
-            }
-        }
-    }
-    return true;
-}
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';

package/mcp-server/tools/cms/HsCreateTemplateTool.d.ts

@@ -6,7 +6,6 @@ declare const inputSchemaZodObject: z.ZodObject<{
     userSuppliedName: z.ZodOptional<z.ZodString>;
     dest: z.ZodOptional<z.ZodString>;
     templateType: z.ZodOptional<z.ZodEnum<{
-        section: "section";
         "page-template": "page-template";
         "email-template": "email-template";
         partial: "partial";
@@ -14,6 +13,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
         "blog-listing-template": "blog-listing-template";
         "blog-post-template": "blog-post-template";
         "search-template": "search-template";
+        section: "section";
     }>>;
 }, z.core.$strip>;
 export type HsCreateTemplateInputSchema = z.infer<typeof inputSchemaZodObject>;

package/package.json

@@ -1,15 +1,19 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.0.11-experimental.0",
+    "version": "8.0.11-experimental.1",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
+    "files": [
+        "**/*",
+        "!**/__tests__/**"
+    ],
     "dependencies": {
-        "@hubspot/local-dev-lib": "5.2.0",
-        "@hubspot/project-parsing-lib": "0.12.1",
+        "@hubspot/local-dev-lib": "5.3.3",
+        "@hubspot/project-parsing-lib": "0.14.1-beta.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
-        "@hubspot/ui-extensions-dev-server": "2.0.0",
+        "@hubspot/ui-extensions-dev-server": "2.0.4",
         "@inquirer/prompts": "7.1.0",
         "@modelcontextprotocol/sdk": "1.25.0",
         "archiver": "7.0.1",
@@ -55,7 +59,7 @@
         "@typescript-eslint/eslint-plugin": "^8.30.1",
         "@typescript-eslint/parser": "^8.11.0",
         "@vitest/coverage-v8": "^2.1.9",
-        "axios": "^1.12.2",
+        "axios": "1.14.0",
         "eslint": "^8.56.0",
         "eslint-plugin-import": "^2.31.0",
         "husky": "^4.3.8",
@@ -76,6 +80,7 @@
         "debug-mcp": "yarn build && npx @modelcontextprotocol/inspector node dist/mcp-server/server.js",
         "hs": "yarn build && node ./dist/bin/hs",
         "hs-debug": "yarn build && NODE_DEBUG=http* node --inspect-brk ./dist/bin/hs",
+        "hs-proxy": "yarn build && HTTPS_PROXY=http://localhost:8181 NODE_TLS_REJECT_UNAUTHORIZED=0 node ./dist/bin/hs",
         "lint": "echo 'Linting is disabled for Blazar'",
         "lint:local": "eslint . && prettier --list-different './**/*.{ts,tsx,js,json}'",
         "list-all-commands": "yarn tsx ./scripts/get-all-commands.ts",

package/types/LocalDev.d.ts

@@ -6,6 +6,10 @@ import { Project } from '@hubspot/local-dev-lib/types/Project';
 import { ProjectConfig } from './Projects.js';
 import LocalDevState from '../lib/projects/localDev/LocalDevState.js';
 import { APP_INSTALLATION_STATES, LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../lib/constants.js';
+import { ExitFunction } from './Yargs.js';
+export type LocalDevActions = {
+    exit: ExitFunction;
+};
 export type LocalDevStateConstructorOptions = {
     targetProjectAccountId: number;
     targetTestingAccountId: number;
@@ -19,6 +23,7 @@ export type LocalDevStateConstructorOptions = {
     };
     initialProjectProfileData: HSProfileVariables;
     env: Environment;
+    actions: LocalDevActions;
 };
 export type LocalDevDeployWebsocketMessage = {
     type: typeof LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.DEPLOY;

package/types/Projects.d.ts

@@ -117,6 +117,25 @@ export type AppCardComponentConfig = {
     };
 };
 export type GenericComponentConfig = PublicAppComponentConfig | PrivateAppComponentConfig | AppCardComponentConfig;
+export type ProjectInfo = {
+    projectName: string;
+    platformVersion: string;
+    projectId: number;
+    deployedBuildId: number;
+    autoDeployEnabled: boolean;
+    projectUrl?: string;
+    app?: {
+        name: string;
+        id: number;
+        uid: string;
+        authType?: string;
+        distributionType?: string;
+    };
+    components: {
+        uid: string;
+        type: string;
+    }[];
+};
 export declare enum ComponentTypes {
     PrivateApp = "private-app",
     PublicApp = "public-app",

package/types/Yargs.d.ts

@@ -1,11 +1,25 @@
 import { Options, CommandModule, Argv } from 'yargs';
 import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
-export type CommonArgs = {
+import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
+import { UsageTrackingMeta } from '../lib/usageTracking.js';
+export type UsageTrackingMetaWithAccountId = UsageTrackingMeta & {
+    accountId?: number;
+};
+export type AddUsageMetadata = (meta: Omit<UsageTrackingMetaWithAccountId, 'successful'>) => void;
+export type UsageTrackingArgs = {
+    addUsageMetadata: AddUsageMetadata;
+    exit: ExitFunction;
+};
+type AccountMiddlewareArgs = {
     derivedAccountId: number;
     userProvidedAccount?: string;
+};
+type DebugArgs = {
     d: boolean;
     debug: boolean;
 };
+export type CommonArgs = AccountMiddlewareArgs & DebugArgs & UsageTrackingArgs;
 export type ConfigArgs = {
     c?: string;
     config?: string;
@@ -44,3 +58,6 @@ export interface YargsCommandModule<T, U> extends CommandModule<T, U> {
     builder: (yargs: Argv) => Promise<Argv<U>>;
 }
 export type YargsCommandModuleBucket = YargsCommandModule<unknown, object>;
+export type ExitCode = ValueOf<typeof EXIT_CODES>;
+export type ExitFunction = (code: ExitCode) => Promise<never>;
+export {};

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

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

package/api/__tests__/migrate.test.js

@@ -1,199 +0,0 @@
-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/commands/__tests__/account.test.d.ts

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