@hubspot/cli 8.0.0 → 8.0.2-experimental.0

package/lib/__tests__/CLIWebSocketServer.test.js

@@ -0,0 +1,252 @@
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { uiLogger } from '../ui/logger.js';
+import CLIWebSocketServer from '../CLIWebSocketServer.js';
+import { lib } from '../../lang/en.js';
+import { pkg } from '../jsonLoader.js';
+vi.mock('ws');
+vi.mock('@hubspot/local-dev-lib/portManager');
+const INSTANCE_ID = 'test-websocket-server';
+const LOG_PREFIX = '[TestWebSocketServer]';
+const PORT = 1234;
+describe('CLIWebSocketServer', () => {
+    let mockWebSocket;
+    let mockWebSocketServer;
+    let server;
+    beforeEach(() => {
+        mockWebSocket = {
+            on: vi.fn(),
+            send: vi.fn(),
+            close: vi.fn(),
+        };
+        mockWebSocketServer = {
+            on: vi.fn(),
+            close: vi.fn(),
+        };
+        WebSocketServer.mockImplementation(() => mockWebSocketServer);
+        server = new CLIWebSocketServer({
+            instanceId: INSTANCE_ID,
+            logPrefix: LOG_PREFIX,
+            debug: true,
+        });
+    });
+    describe('start()', () => {
+        it('should throw error if port manager is not running', async () => {
+            isPortManagerServerRunning.mockResolvedValue(false);
+            await expect(server.start({})).rejects.toThrow(lib.CLIWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
+        });
+        it('should start websocket server on the assigned port', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+            await server.start({});
+            expect(WebSocketServer).toHaveBeenCalledWith({ port: PORT });
+            expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
+        });
+        it('should log startup message when debug is enabled', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+            await server.start({});
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining(String(PORT)));
+        });
+    });
+    describe('origin validation', () => {
+        const validOrigins = [
+            'https://app.hubspot.com',
+            'https://app.hubspotqa.com',
+            'https://local.hubspot.com',
+            'https://local.hubspotqa.com',
+            'https://app-na2.hubspot.com',
+            'https://app-na2.hubspotqa.com',
+            'https://app-na3.hubspot.com',
+            'https://app-na3.hubspotqa.com',
+            'https://app-ap1.hubspot.com',
+            'https://app-ap1.hubspotqa.com',
+            'https://app-eu1.hubspot.com',
+            'https://app-eu1.hubspotqa.com',
+        ];
+        let connectionCallback;
+        beforeEach(async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+            await server.start({});
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+        });
+        validOrigins.forEach(origin => {
+            it(`should accept connection from ${origin}`, () => {
+                connectionCallback(mockWebSocket, { headers: { origin } });
+                expect(mockWebSocket.close).not.toHaveBeenCalled();
+                expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
+            });
+        });
+        const invalidOrigins = [
+            'https://malicious-site.com',
+            'https://app.malicious-site.com',
+            'https://app.hubspot.com.evil.com',
+        ];
+        invalidOrigins.forEach(origin => {
+            it(`should reject connection from "${origin}"`, () => {
+                connectionCallback(mockWebSocket, { headers: { origin } });
+                expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.CLIWebsocketServer.errors.originNotAllowed(origin));
+                expect(mockWebSocket.on).not.toHaveBeenCalled();
+            });
+        });
+        it('should reject connection with no origin header', () => {
+            connectionCallback(mockWebSocket, { headers: {} });
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.CLIWebsocketServer.errors.originNotAllowed());
+            expect(mockWebSocket.on).not.toHaveBeenCalled();
+        });
+    });
+    describe('sendCliMetadata', () => {
+        let connectionCallback;
+        beforeEach(async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+        });
+        it('should send cliVersion on connection', async () => {
+            await server.start({});
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'server:cliMetadata',
+                data: { cliVersion: pkg.version },
+            }));
+        });
+        it('should merge additional metadata when provided', async () => {
+            await server.start({
+                metadata: { customField: 'customValue', version: 2 },
+            });
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'server:cliMetadata',
+                data: {
+                    cliVersion: pkg.version,
+                    customField: 'customValue',
+                    version: 2,
+                },
+            }));
+        });
+    });
+    describe('callbacks', () => {
+        let connectionCallback;
+        beforeEach(async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+        });
+        it('should call onConnection for valid connections', async () => {
+            const onConnection = vi.fn();
+            await server.start({ onConnection });
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            expect(onConnection).toHaveBeenCalledWith(mockWebSocket);
+        });
+        it('should not call onConnection for rejected connections', async () => {
+            const onConnection = vi.fn();
+            await server.start({ onConnection });
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://malicious.com' },
+            });
+            expect(onConnection).not.toHaveBeenCalled();
+        });
+        it('should call onMessage when a valid message is received', async () => {
+            const onMessage = vi.fn().mockReturnValue(true);
+            await server.start({ onMessage });
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
+            messageCallback(JSON.stringify({ type: 'test:action', data: { key: 'value' } }));
+            expect(onMessage).toHaveBeenCalledWith(mockWebSocket, {
+                type: 'test:action',
+                data: { key: 'value' },
+            });
+        });
+        it('should log error when onMessage returns false', async () => {
+            const onMessage = vi.fn().mockReturnValue(false);
+            await server.start({ onMessage });
+            connectionCallback = mockWebSocketServer.on.mock
+                .calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
+            messageCallback(JSON.stringify({ type: 'UNKNOWN_TYPE' }));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('UNKNOWN_TYPE'));
+        });
+        it('should call onClose when server closes', async () => {
+            const onClose = vi.fn();
+            await server.start({ onClose });
+            const closeCallback = mockWebSocketServer.on.mock.calls.find(call => call[0] === 'close')[1];
+            closeCallback();
+            expect(onClose).toHaveBeenCalled();
+        });
+    });
+    describe('message parsing', () => {
+        let messageCallback;
+        beforeEach(async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+            await server.start({});
+            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+            connectionCallback(mockWebSocket, {
+                headers: { origin: 'https://app.hubspot.com' },
+            });
+            messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
+        });
+        it('should log error for messages missing a type field', () => {
+            messageCallback(JSON.stringify({}));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Missing type field'));
+        });
+        it('should log error for invalid JSON', () => {
+            messageCallback('not valid json');
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Invalid JSON'));
+        });
+    });
+    describe('sendMessage()', () => {
+        it('should serialize and send a message to the websocket', () => {
+            const message = { type: 'test:message', data: { foo: 'bar' } };
+            server.sendMessage(mockWebSocket, message);
+            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify(message));
+        });
+    });
+    describe('shutdown()', () => {
+        it('should close the websocket server', async () => {
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
+                [INSTANCE_ID]: PORT,
+            });
+            await server.start({});
+            server.shutdown();
+            expect(mockWebSocketServer.close).toHaveBeenCalled();
+        });
+        it('should handle shutdown when server was never started', () => {
+            expect(() => server.shutdown()).not.toThrow();
+        });
+    });
+});

package/lib/__tests__/commandSuggestion.test.d.ts

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

package/lib/__tests__/commandSuggestion.test.js

@@ -0,0 +1,119 @@
+import yargs from 'yargs';
+import { addCommandSuggestions, commandSuggestionMappings, } from '../commandSuggestion.js';
+import { uiLogger } from '../ui/logger.js';
+import { uiCommandReference } from '../ui/index.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+vi.mock('../ui/logger.js');
+vi.mock('../ui/index.js');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+describe('lib/commandSuggestion', () => {
+    const uiLoggerErrorMock = uiLogger.error;
+    const uiCommandReferenceMock = uiCommandReference;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        commandSpy.mockClear();
+        uiCommandReferenceMock.mockImplementation((command) => `\`${command}\``);
+    });
+    describe('addCommandSuggestions', () => {
+        it('adds all command suggestions to yargs instance', () => {
+            addCommandSuggestions(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(Object.keys(commandSuggestionMappings).length);
+        });
+        it('registers each mapping from commandSuggestionMappings', () => {
+            addCommandSuggestions(yargs);
+            Object.entries(commandSuggestionMappings).forEach(([oldCommand]) => {
+                expect(commandSpy).toHaveBeenCalledWith(expect.objectContaining({
+                    command: oldCommand,
+                }));
+            });
+        });
+        it('returns the yargs instance', () => {
+            const yargsInstance = yargs;
+            const result = addCommandSuggestions(yargsInstance);
+            expect(result).toBe(yargsInstance);
+        });
+        it('creates command modules with handler that logs error and exits', () => {
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
+            });
+            addCommandSuggestions(yargs);
+            // Get the first registered command module
+            const firstCall = commandSpy.mock.calls[0];
+            const commandModule = firstCall[0];
+            const firstMapping = Object.entries(commandSuggestionMappings)[0];
+            const [, newCommand] = firstMapping;
+            // Verify the command module structure
+            expect(commandModule).toHaveProperty('command');
+            expect(commandModule).toHaveProperty('handler');
+            expect(commandModule).toHaveProperty('builder');
+            // Invoke the handler to verify behavior
+            expect(() => {
+                commandModule.handler({});
+            }).toThrow('process.exit called');
+            expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
+            expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            vi.restoreAllMocks();
+        });
+        it('creates command modules with builder that sets strict mode to false', async () => {
+            const yargsInstance = yargs;
+            const commandSpyForTest = vi
+                .spyOn(yargsInstance, 'command')
+                .mockReturnValue(yargsInstance);
+            addCommandSuggestions(yargsInstance);
+            // Get a command module and verify it has a builder
+            const firstCall = commandSpyForTest.mock.calls[0];
+            const commandModule = firstCall[0];
+            expect(commandModule).toHaveProperty('builder');
+            expect(typeof commandModule.builder).toBe('function');
+            // Create a mock yargs builder with strict method
+            const mockYargsBuilder = {
+                strict: vi.fn().mockReturnThis(),
+            };
+            await commandModule.builder(mockYargsBuilder);
+            expect(mockYargsBuilder.strict).toHaveBeenCalledWith(false);
+            commandSpyForTest.mockRestore();
+        });
+        it('handles commands with multiple words', () => {
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
+            });
+            // Find a multi-word command
+            const multiWordCommand = Object.entries(commandSuggestionMappings).find(([oldCommand]) => oldCommand.includes(' '));
+            expect(multiWordCommand).toBeDefined();
+            if (multiWordCommand) {
+                const [oldCommand, newCommand] = multiWordCommand;
+                const yargsInstance = yargs;
+                const commandSpyForTest = vi
+                    .spyOn(yargsInstance, 'command')
+                    .mockReturnValue(yargsInstance);
+                addCommandSuggestions(yargsInstance);
+                // Find the call for this multi-word command
+                const call = commandSpyForTest.mock.calls.find(call => call[0]
+                    .command === oldCommand);
+                expect(call).toBeDefined();
+                const commandModule = call[0];
+                expect(commandModule).toHaveProperty('handler');
+                // Invoke handler to verify it works with multi-word commands
+                expect(() => {
+                    commandModule.handler({});
+                }).toThrow('process.exit called');
+                expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
+                commandSpyForTest.mockRestore();
+            }
+            vi.restoreAllMocks();
+        });
+    });
+    describe('commandSuggestionMappings', () => {
+        it('all mappings point to valid new commands', () => {
+            Object.entries(commandSuggestionMappings).forEach(([, newCommand]) => {
+                expect(newCommand).toMatch(/^hs /);
+                expect(typeof newCommand).toBe('string');
+                expect(newCommand.length).toBeGreaterThan(0);
+            });
+        });
+    });
+});

package/lib/commandSuggestion.d.ts

@@ -0,0 +1,3 @@
+import { Argv } from 'yargs';
+export declare const commandSuggestionMappings: Record<string, string>;
+export declare function addCommandSuggestions(yargsInstance: Argv): Argv;

package/lib/commandSuggestion.js

@@ -0,0 +1,45 @@
+import { uiLogger } from './ui/logger.js';
+import { uiCommandReference } from './ui/index.js';
+import { EXIT_CODES } from './enums/exitCodes.js';
+export const commandSuggestionMappings = {
+    create: 'hs cms app|theme|module|webpack|function|template create',
+    fetch: 'hs cms fetch',
+    lint: 'hs cms lint',
+    list: 'hs cms list',
+    mv: 'hs cms mv',
+    remove: 'hs cms delete',
+    upload: 'hs cms upload',
+    watch: 'hs cms watch',
+    'function deploy': 'hs cms function deploy',
+    'function list': 'hs cms function list',
+    'function server': 'hs cms function server',
+    logs: 'hs cms function logs',
+    'module marketplace-validate': 'hs cms module marketplace-validate',
+    'theme generate-selectors': 'hs cms theme generate-selectors',
+    'theme marketplace-validate': 'hs cms theme marketplace-validate',
+    'theme preview': 'hs cms theme preview',
+    'custom-object schema create': 'hs custom-object create-schema',
+    'custom-object schema delete': 'hs custom-object delete-schema',
+    'custom-object schema fetch-all': 'hs custom-object fetch-all-schemas',
+    'custom-object schema fetch': 'hs custom-object fetch-schema',
+    'custom-object schema list': 'hs custom-object list-schemas',
+    'custom-object schema update': 'hs custom-object update-schema',
+};
+function createCommandSuggestionHandler(newCommand) {
+    return () => {
+        uiLogger.error(`Did you mean ${uiCommandReference(newCommand)}?`);
+        process.exit(EXIT_CODES.ERROR);
+    };
+}
+function createCommandSuggestion(oldCommand, newCommand) {
+    return {
+        command: oldCommand,
+        builder: async (yargs) => {
+            return yargs.strict(false);
+        },
+        handler: createCommandSuggestionHandler(newCommand),
+    };
+}
+export function addCommandSuggestions(yargsInstance) {
+    return Object.entries(commandSuggestionMappings).reduce((yargs, [oldCommand, newCommand]) => yargs.command(createCommandSuggestion(oldCommand, newCommand)), yargsInstance);
+}

package/lib/constants.d.ts

@@ -94,7 +94,6 @@ export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPDATE_APP_DATA: string;
     UPDATE_PROJECT_DATA: string;
     UPDATE_UPLOAD_WARNINGS: string;
-    CLI_METADATA: string;
     DEV_SERVERS_STARTED: string;
 };
 export declare const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES: {

package/lib/constants.js

@@ -86,7 +86,6 @@ export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPDATE_APP_DATA: 'server:updateAppData',
     UPDATE_PROJECT_DATA: 'server:updateProjectData',
     UPDATE_UPLOAD_WARNINGS: 'server:updateUploadWarnings',
-    CLI_METADATA: 'server:cliMetadata',
     DEV_SERVERS_STARTED: 'server:devServersStarted',
 };
 export const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES = {

package/lib/getStarted/getStartedV2.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs } from '../../types/Yargs.js';
+type GetStartedV2Args = CommonArgs & {
+    name?: string;
+    dest?: string;
+};
+export declare function runGetStartedV2({ derivedAccountId, name, dest, }: GetStartedV2Args): Promise<void>;
+export {};

package/lib/getStarted/getStartedV2.js

@@ -0,0 +1,56 @@
+import { LOG_LEVEL, setLogLevel } from '@hubspot/local-dev-lib/logger';
+import { createProjectAction } from '../getStartedV2Actions.js';
+import { trackCommandMetadataUsage } from '../usageTracking.js';
+import { renderInteractive } from '../../ui/render.js';
+import { getGetStartedFlow } from '../../ui/components/GetStartedFlow.js';
+import { getErrorMessage } from '../errorHandlers/index.js';
+export async function runGetStartedV2({ derivedAccountId, name, dest, }) {
+    setLogLevel(LOG_LEVEL.NONE);
+    const onRunCreateProject = async (args) => {
+        try {
+            const result = await createProjectAction(args);
+            await trackCommandMetadataUsage('get-started', {
+                successful: true,
+                step: 'github-clone',
+            }, derivedAccountId);
+            await trackCommandMetadataUsage('get-started', {
+                successful: true,
+                step: 'project-creation',
+            }, derivedAccountId);
+            return {
+                projectName: result.projectName,
+                projectDest: result.projectDest,
+            };
+        }
+        catch (error) {
+            const errorMessage = getErrorMessage(error);
+            // Check if this is a nested project error (happens before cloning)
+            const isNestedProjectError = errorMessage.includes('Projects cannot be nested within other projects');
+            if (isNestedProjectError) {
+                await trackCommandMetadataUsage('get-started', {
+                    successful: false,
+                    step: 'project-creation',
+                }, derivedAccountId);
+            }
+            else {
+                // Clone or other error (failedToDownloadProject message)
+                await trackCommandMetadataUsage('get-started', {
+                    successful: false,
+                    step: 'github-clone',
+                }, derivedAccountId);
+            }
+            throw error;
+        }
+    };
+    try {
+        await renderInteractive(getGetStartedFlow({
+            derivedAccountId,
+            onRunCreateProject,
+            initialName: name,
+            initialDest: dest,
+        }), { fullScreen: true });
+    }
+    finally {
+        setLogLevel(LOG_LEVEL.LOG);
+    }
+}

package/lib/getStartedV2Actions.d.ts

@@ -0,0 +1,8 @@
+export type CreateProjectResult = {
+    projectName: string;
+    projectDest: string;
+};
+export declare function createProjectAction({ projectName, projectDest, }: {
+    projectName: string;
+    projectDest: string;
+}): Promise<CreateProjectResult>;

package/lib/getStartedV2Actions.js

@@ -0,0 +1,51 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { commands, lib } from '../lang/en.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_CONFIG_FILE, } from '../lib/constants.js';
+import { getProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
+import { validateProjectDirectory } from '../lib/prompts/projectNameAndDestPrompt.js';
+import SpinniesManager from '../lib/ui/SpinniesManager.js';
+export async function createProjectAction({ projectName, projectDest, }) {
+    // Validate project name
+    if (!projectName || projectName.trim() === '') {
+        throw new Error(lib.prompts.projectNameAndDestPrompt.errors.nameRequired);
+    }
+    // Validate destination path
+    const validationResult = validateProjectDirectory(projectDest);
+    if (validationResult !== true) {
+        throw new Error(typeof validationResult === 'string'
+            ? validationResult
+            : 'Invalid project directory');
+    }
+    const projectDestAbsolute = path.resolve(getCwd(), projectDest);
+    const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDestAbsolute);
+    if (existingProjectConfig &&
+        existingProjectDir &&
+        projectDestAbsolute.startsWith(existingProjectDir)) {
+        throw new Error(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+    }
+    SpinniesManager.setDisableOutput(true);
+    try {
+        await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDestAbsolute, {
+            sourceDir: '2025.2/private-app-get-started-template',
+            hideLogs: true,
+        });
+        const projectConfigPath = path.join(projectDestAbsolute, PROJECT_CONFIG_FILE);
+        const parsedConfigFile = JSON.parse(fs.readFileSync(projectConfigPath, 'utf8'));
+        writeProjectConfig(projectConfigPath, {
+            ...parsedConfigFile,
+            name: projectName,
+        });
+        return { projectName, projectDest: projectDestAbsolute };
+    }
+    catch (error) {
+        throw new Error(commands.project.create.errors.failedToDownloadProject, {
+            cause: error,
+        });
+    }
+    finally {
+        SpinniesManager.setDisableOutput(false);
+    }
+}