@hubspot/cli 8.1.0-beta.0 → 8.2.0-beta.0

package/lib/mcp/setup.js

@@ -47,23 +47,56 @@ export async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
+        // Prompt for standalone mode
+        const { useStandaloneMode } = await promptUser({
+            name: 'useStandaloneMode',
+            type: 'confirm',
+            message: commands.mcp.setup.prompts.standaloneMode,
+            default: false,
+        });
+        const { cliVersion } = useStandaloneMode
+            ? await promptUser({
+                name: 'cliVersion',
+                type: 'input',
+                message: commands.mcp.setup.prompts.cliVersion,
+                validate: (v) => !v || /^[\d]+\.[\d]+\.[\d]+([-+][\w.]+)?$/.test(v.trim())
+                    ? true
+                    : 'Please enter a valid semver version (e.g. 8.0.1) or leave blank for latest.',
+            })
+            : { cliVersion: '' };
+        const cliPackage = cliVersion
+            ? `@hubspot/cli@${cliVersion}`
+            : '@hubspot/cli';
+        const standaloneEnv = {
+            HUBSPOT_MCP_STANDALONE: 'true',
+        };
+        if (cliVersion) {
+            standaloneEnv.HUBSPOT_CLI_VERSION = cliVersion;
+        }
+        const mcpCommand = useStandaloneMode
+            ? {
+                command: 'npx',
+                args: ['-y', '-p', cliPackage, 'hs', 'mcp', 'start'],
+                env: standaloneEnv,
+            }
+            : defaultMcpCommand;
         if (derivedTargets.includes(claudeCode)) {
-            await runSetupFunction(setupClaudeCode);
+            await runSetupFunction(() => setupClaudeCode(mcpCommand));
         }
         if (derivedTargets.includes(cursor)) {
-            await runSetupFunction(setupCursor);
+            await runSetupFunction(() => setupCursor(mcpCommand));
         }
         if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(setupWindsurf);
+            await runSetupFunction(() => setupWindsurf(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
-            await runSetupFunction(setupVsCode);
+            await runSetupFunction(() => setupVsCode(mcpCommand));
         }
         if (derivedTargets.includes(codex)) {
-            await runSetupFunction(setupCodex);
+            await runSetupFunction(() => setupCodex(mcpCommand));
         }
         if (derivedTargets.includes(gemini)) {
-            await runSetupFunction(setupGemini);
+            await runSetupFunction(() => setupGemini(mcpCommand));
         }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
@@ -121,10 +154,7 @@ function setupMcpConfigFile(config) {
         if (!mcpConfig.mcpServers) {
             mcpConfig.mcpServers = {};
         }
-        // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
-        };
+        mcpConfig.mcpServers[mcpServerName] = config.mcpCommand;
         // Write the updated config
         fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
         SpinniesManager.succeed('spinner', {
@@ -145,10 +175,12 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('vsCode', {
             text: commands.mcp.setup.spinners.configuringVsCode,
         });
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, vscode);
+        const configObject = {
             name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
+            ...commandWithAgent,
+        };
+        const mcpConfig = JSON.stringify(configObject);
         await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
@@ -172,25 +204,27 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
     }
 }
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+    SpinniesManager.add('claudeCode', {
+        text: commands.mcp.setup.spinners.configuringClaudeCode,
+    });
     try {
-        SpinniesManager.add('claudeCode', {
-            text: commands.mcp.setup.spinners.configuringClaudeCode,
+        // Check if claude command is available
+        await execAsync('claude --version');
+    }
+    catch (e) {
+        SpinniesManager.fail('claudeCode', {
+            text: commands.mcp.setup.spinners.claudeCodeNotFound,
         });
-        try {
-            // Check if claude command is available
-            await execAsync('claude --version');
-        }
-        catch (e) {
-            SpinniesManager.fail('claudeCode', {
-                text: commands.mcp.setup.spinners.claudeCodeNotFound,
-            });
-            return false;
-        }
+        return false;
+    }
+    try {
         // Run claude mcp add command
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, claudeCode);
+        const configObject = {
             type: 'stdio',
-            ...buildCommandWithAgentString(mcpCommand, claudeCode),
-        });
+            ...commandWithAgent,
+        };
+        const mcpConfig = JSON.stringify(configObject);
         const { stdout } = await execAsync('claude mcp list');
         if (stdout.includes(mcpServerName)) {
             SpinniesManager.update('claudeCode', {
@@ -248,7 +282,7 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, codex);
-        await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        await execAsync(`codex mcp add "${mcpServerName}"${buildEnvFlagString(mcpCommand)} -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('codexSpinner', {
             text: commands.mcp.setup.spinners.configuredCodex,
         });
@@ -277,7 +311,7 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, gemini);
-        await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        await execAsync(`gemini mcp add -s user${buildEnvFlagString(mcpCommand)} "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('geminiSpinner', {
             text: commands.mcp.setup.spinners.configuredGemini,
         });
@@ -296,3 +330,16 @@ function buildCommandWithAgentString(mcpCommand, agent) {
     mcpCommandCopy.args.push('--ai-agent', agent);
     return mcpCommandCopy;
 }
+function buildEnvFlagString(mcpCommand) {
+    const envFlags = [];
+    if (mcpCommand.env) {
+        const env = Object.entries(mcpCommand.env);
+        env.forEach(([key, value]) => {
+            envFlags.push(`--env ${key}="${value}"`);
+        });
+    }
+    if (envFlags.length === 0) {
+        return '';
+    }
+    return ` ${envFlags.join(' ')}`;
+}

package/lib/projects/create/__tests__/legacy.test.js

@@ -1,6 +1,4 @@
-import { uiLogger } from '../../../ui/logger.js';
 import * as github from '@hubspot/local-dev-lib/api/github';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { getProjectComponentListFromRepo, getProjectTemplateListFromRepo, } from '../legacy.js';
 import { PROJECT_COMPONENT_TYPES, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../../../constants.js';
 vi.mock('@hubspot/local-dev-lib/api/github');
@@ -38,16 +36,6 @@ describe('lib/projects/create/legacy', () => {
         });
     });
     describe('getProjectTemplateListFromRepo()', () => {
-        let exitMock;
-        beforeEach(() => {
-            // @ts-expect-error - Mocking process.exit
-            exitMock = vi
-                .spyOn(process, 'exit')
-                .mockImplementation(() => undefined);
-        });
-        afterEach(() => {
-            exitMock.mockRestore();
-        });
         it('returns a list of project templates', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({
@@ -56,20 +44,16 @@ describe('lib/projects/create/legacy', () => {
             const templates = await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
             expect(templates).toEqual(repoConfig[PROJECT_COMPONENT_TYPES.PROJECTS]);
         });
-        it('Logs an error and exits the process if the request for the template list fails', async () => {
+        it('throws an error if the request for the template list fails', async () => {
             mockedFetchRepoFile.mockRejectedValue(new Error('Not found'));
-            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Failed to fetch the config.json file from the target repository/));
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Failed to fetch the config.json file from the target repository');
         });
-        it('Logs an error and exits the process if there are no projects listed in the repo config', async () => {
+        it('throws an error if there are no projects listed in the repo config', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({});
-            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Unable to find any projects in the target repository's config.json file/));
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Unable to find any projects in the target repository');
         });
-        it('Logs an error and exits the process if any of the projects in the repo config are missing required properties', async () => {
+        it('throws an error if any of the projects in the repo config are missing required properties', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({
                 data: {
@@ -82,9 +66,7 @@ describe('lib/projects/create/legacy', () => {
                     ],
                 },
             });
-            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Found misconfigured projects in the target repository's config.json file/));
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Found misconfigured projects in the target repository');
         });
     });
 });

package/lib/projects/create/index.js

@@ -4,9 +4,7 @@ import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH
 import { isV2Project } from '../platformVersion.js';
 import { v2ComponentFlow } from './v2.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
-import { uiLogger } from '../../ui/logger.js';
 import { commands } from '../../../lang/en.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
 export async function handleProjectCreationFlow(args) {
     const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
@@ -25,8 +23,7 @@ export async function handleProjectCreationFlow(args) {
     }
     const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
     if (!projectTemplates.length) {
-        uiLogger.error(commands.project.create.errors.failedToFetchProjectList);
-        process.exit(EXIT_CODES.ERROR);
+        throw new Error(commands.project.create.errors.failedToFetchProjectList);
     }
     const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, projectTemplates);
     return {

package/lib/projects/create/legacy.js

@@ -1,8 +1,6 @@
 import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { debugError } from '../../errorHandlers/index.js';
-import { uiLogger } from '../../ui/logger.js';
 import { isV2Project } from '../platformVersion.js';
 import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
@@ -36,18 +34,15 @@ export async function getProjectTemplateListFromRepo(templateSource, githubRef)
     }
     catch (e) {
         debugError(e);
-        uiLogger.error(lib.projects.create.errors.missingConfigFileTemplateSource);
-        return process.exit(EXIT_CODES.ERROR);
+        throw new Error(lib.projects.create.errors.missingConfigFileTemplateSource);
     }
     if (!config || !config[PROJECT_COMPONENT_TYPES.PROJECTS]) {
-        uiLogger.error(lib.projects.create.errors.noProjectsInConfig);
-        return process.exit(EXIT_CODES.ERROR);
+        throw new Error(lib.projects.create.errors.noProjectsInConfig);
     }
     const templates = config[PROJECT_COMPONENT_TYPES.PROJECTS];
     const templatesContainAllProperties = templates.every(config => PROJECT_TEMPLATE_PROPERTIES.every(p => Object.prototype.hasOwnProperty.call(config, p)));
     if (!templatesContainAllProperties) {
-        uiLogger.error(lib.projects.create.errors.missingPropertiesInConfig);
-        return process.exit(EXIT_CODES.ERROR);
+        throw new Error(lib.projects.create.errors.missingPropertiesInConfig);
     }
     return templates;
 }

package/lib/projects/create/v2.js

@@ -5,8 +5,6 @@ import { APP_EVENTS_KEY as AppEventsKey, PAGES_KEY as PagesKey, } from '@hubspot
 import { isV2Project } from '../platformVersion.js';
 import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
-import { logError } from '../../errorHandlers/index.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { hasFeature } from '../../hasFeature.js';
 export async function createV2App(providedAuth, providedDistribution) {
     let authType;
@@ -111,13 +109,7 @@ export async function v2ComponentFlow(platformVersion, projectBase, providedAuth
     let repoConfig = undefined;
     let authType;
     let distribution;
-    try {
-        repoConfig = await getConfigForPlatformVersion(platformVersion);
-    }
-    catch (error) {
-        logError(error);
-        return process.exit(EXIT_CODES.SUCCESS);
-    }
+    repoConfig = await getConfigForPlatformVersion(platformVersion);
     const projectContentsChoice = projectBase ||
         (await listPrompt(commands.project.create.prompts.parentComponents, {
             choices: [

package/lib/projects/ensureProjectExists.js

@@ -2,7 +2,6 @@ import { createProject, fetchProject, } from '@hubspot/local-dev-lib/api/project
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
 import { DEFAULT_POLLING_DELAY } from '../constants.js';
 import { promptUser } from '../prompts/promptUtils.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { uiAccountDescription } from '../ui/index.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError, ApiErrorContext } from '../errorHandlers/index.js';
@@ -85,6 +84,6 @@ export async function ensureProjectExists(accountId, projectName, { forceCreate
             }
         }
         logError(err, new ApiErrorContext({ accountId }));
-        process.exit(EXIT_CODES.ERROR);
+        return { projectExists: false };
     }
 }

package/lib/projects/pollProjectBuildAndDeploy.js

@@ -5,7 +5,6 @@ import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError, ApiErrorContext } from '../errorHandlers/index.js';
 import { uiLine, uiLink, uiAccountDescription } from '../ui/index.js';
 import { getProjectBuildDetailUrl, getProjectDeployDetailUrl, getProjectActivityUrl, } from './urls.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 import { APP_FUNCTIONS_PACKAGE_KEY as AppFunctionsPackageKey } from '@hubspot/project-parsing-lib/constants';
@@ -32,8 +31,8 @@ function getSubtaskType(task) {
     return task.deployType;
 }
 function handleTaskStatusError(statusText) {
-    uiLogger.error(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorFetchingTaskStatus(statusText.TYPE_KEY === PROJECT_BUILD_TEXT.TYPE_KEY ? 'build' : 'deploy'));
-    process.exit(EXIT_CODES.ERROR);
+    const taskType = statusText.TYPE_KEY === PROJECT_BUILD_TEXT.TYPE_KEY ? 'build' : 'deploy';
+    throw new Error(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorFetchingTaskStatus(taskType));
 }
 function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrings, linkToHubSpot, }) {
     return async function (accountId, taskName, taskId, deployedBuildId, silenceLogs = false) {
@@ -111,97 +110,103 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                 task.subtasks.forEach((subtask, i) => addTaskSpinner(subtask, 4, i === task.subtasks.length - 1));
             });
         }
-        return new Promise(resolve => {
+        return new Promise((resolve, reject) => {
             const pollInterval = setInterval(async () => {
-                let taskStatus;
                 try {
-                    const { data } = await statusFn(accountId, taskName, taskId);
-                    taskStatus = data;
-                }
-                catch (e) {
-                    uiLogger.debug(e);
-                    logError(e, new ApiErrorContext({
-                        accountId,
-                        projectName: taskName,
-                    }));
-                    handleTaskStatusError(statusText);
-                }
-                const subtasks = getSubtasks(taskStatus);
-                if (!taskStatus || !taskStatus.status || !subtasks) {
-                    handleTaskStatusError(statusText);
-                }
-                const { status } = taskStatus;
-                if (SpinniesManager.hasActiveSpinners()) {
-                    subtasks.forEach(subtask => {
-                        const { id, status } = subtask;
-                        const spinner = SpinniesManager.pick(id);
-                        if (!spinner || spinner.status !== SPINNER_STATUS.SPINNING) {
-                            return;
-                        }
-                        const topLevelTask = structuredTasks.find(t => t.id == id);
-                        if (status === statusText.STATES.SUCCESS ||
-                            status === statusText.STATES.FAILURE) {
-                            const taskStatusText = subtask.status === statusText.STATES.SUCCESS
-                                ? lib.projectBuildAndDeploy.makePollTaskStatusFunc
-                                    .successStatusText
-                                : lib.projectBuildAndDeploy.makePollTaskStatusFunc
-                                    .failedStatusText;
-                            const hasNewline = spinner?.text?.includes('\n') || Boolean(topLevelTask);
-                            const updatedText = `${spinner?.text?.replace('\n', '')} ${taskStatusText}${hasNewline ? '\n' : ''}`;
-                            if (status === statusText.STATES.SUCCESS) {
-                                SpinniesManager.succeed(id, { text: updatedText });
-                            }
-                            else {
-                                SpinniesManager.fail(id, { text: updatedText });
+                    let taskStatus;
+                    try {
+                        const { data } = await statusFn(accountId, taskName, taskId);
+                        taskStatus = data;
+                    }
+                    catch (e) {
+                        uiLogger.debug(e);
+                        logError(e, new ApiErrorContext({
+                            accountId,
+                            projectName: taskName,
+                        }));
+                        handleTaskStatusError(statusText);
+                    }
+                    const subtasks = getSubtasks(taskStatus);
+                    if (!taskStatus || !taskStatus.status || !subtasks) {
+                        handleTaskStatusError(statusText);
+                    }
+                    const { status } = taskStatus;
+                    if (SpinniesManager.hasActiveSpinners()) {
+                        subtasks.forEach(subtask => {
+                            const { id, status } = subtask;
+                            const spinner = SpinniesManager.pick(id);
+                            if (!spinner || spinner.status !== SPINNER_STATUS.SPINNING) {
+                                return;
                             }
-                            if (topLevelTask) {
-                                topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager.remove(currentSubtask.id));
+                            const topLevelTask = structuredTasks.find(t => t.id == id);
+                            if (status === statusText.STATES.SUCCESS ||
+                                status === statusText.STATES.FAILURE) {
+                                const taskStatusText = subtask.status === statusText.STATES.SUCCESS
+                                    ? lib.projectBuildAndDeploy.makePollTaskStatusFunc
+                                        .successStatusText
+                                    : lib.projectBuildAndDeploy.makePollTaskStatusFunc
+                                        .failedStatusText;
+                                const hasNewline = spinner?.text?.includes('\n') || Boolean(topLevelTask);
+                                const updatedText = `${spinner?.text?.replace('\n', '')} ${taskStatusText}${hasNewline ? '\n' : ''}`;
+                                if (status === statusText.STATES.SUCCESS) {
+                                    SpinniesManager.succeed(id, { text: updatedText });
+                                }
+                                else {
+                                    SpinniesManager.fail(id, { text: updatedText });
+                                }
+                                if (topLevelTask) {
+                                    topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager.remove(currentSubtask.id));
+                                }
                             }
-                        }
-                    });
-                    if (status === statusText.STATES.SUCCESS) {
-                        SpinniesManager.succeed(overallTaskSpinniesKey, {
-                            text: statusStrings.SUCCESS(taskName, displayId),
-                        });
-                        clearInterval(pollInterval);
-                        resolve(taskStatus);
-                    }
-                    else if (status === statusText.STATES.FAILURE) {
-                        SpinniesManager.fail(overallTaskSpinniesKey, {
-                            text: statusStrings.FAIL(taskName, displayId),
                         });
-                        if (!silenceLogs) {
-                            const failedSubtasks = subtasks.filter(subtask => subtask.status === 'FAILURE');
-                            uiLine();
-                            uiLogger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
-                                ? getSubtaskName(failedSubtasks[0])
-                                : failedSubtasks.length + ' components', displayId)}\n`);
-                            uiLogger.log(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorSummary);
-                            uiLine();
-                            const displayErrors = failedSubtasks.filter(subtask => subtask?.standardError?.subCategory !==
-                                PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
-                                subtask?.standardError?.subCategory !==
-                                    PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
-                            displayErrors.forEach(subTask => {
-                                uiLogger.log(`\n--- ${chalk.bold(getSubtaskName(subTask))} failed with the following error ---`);
-                                uiLogger.error(subTask.errorMessage);
-                                // Log nested errors
-                                if (subTask.standardError && subTask.standardError.errors) {
-                                    uiLogger.log('');
-                                    subTask.standardError.errors.forEach(error => {
-                                        uiLogger.log(error.message);
-                                    });
-                                }
+                        if (status === statusText.STATES.SUCCESS) {
+                            SpinniesManager.succeed(overallTaskSpinniesKey, {
+                                text: statusStrings.SUCCESS(taskName, displayId),
                             });
+                            clearInterval(pollInterval);
+                            resolve(taskStatus);
+                        }
+                        else if (status === statusText.STATES.FAILURE) {
+                            SpinniesManager.fail(overallTaskSpinniesKey, {
+                                text: statusStrings.FAIL(taskName, displayId),
+                            });
+                            if (!silenceLogs) {
+                                const failedSubtasks = subtasks.filter(subtask => subtask.status === 'FAILURE');
+                                uiLine();
+                                uiLogger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
+                                    ? getSubtaskName(failedSubtasks[0])
+                                    : failedSubtasks.length + ' components', displayId)}\n`);
+                                uiLogger.log(lib.projectBuildAndDeploy.makePollTaskStatusFunc.errorSummary);
+                                uiLine();
+                                const displayErrors = failedSubtasks.filter(subtask => subtask?.standardError?.subCategory !==
+                                    PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
+                                    subtask?.standardError?.subCategory !==
+                                        PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
+                                displayErrors.forEach(subTask => {
+                                    uiLogger.log(`\n--- ${chalk.bold(getSubtaskName(subTask))} failed with the following error ---`);
+                                    uiLogger.error(subTask.errorMessage);
+                                    // Log nested errors
+                                    if (subTask.standardError && subTask.standardError.errors) {
+                                        uiLogger.log('');
+                                        subTask.standardError.errors.forEach(error => {
+                                            uiLogger.log(error.message);
+                                        });
+                                    }
+                                });
+                            }
+                            clearInterval(pollInterval);
+                            resolve(taskStatus);
+                        }
+                        else if (!subtasks.length) {
+                            clearInterval(pollInterval);
+                            resolve(taskStatus);
                         }
-                        clearInterval(pollInterval);
-                        resolve(taskStatus);
-                    }
-                    else if (!subtasks.length) {
-                        clearInterval(pollInterval);
-                        resolve(taskStatus);
                     }
                 }
+                catch (e) {
+                    clearInterval(pollInterval);
+                    reject(e);
+                }
             }, DEFAULT_POLLING_DELAY);
         });
     };

package/lib/projects/upload.d.ts

@@ -4,6 +4,7 @@ type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: Proje
 type ProjectUploadResult<T> = {
     result?: T;
     uploadError?: unknown;
+    projectNotFound?: boolean;
 };
 type HandleProjectUploadArg<T> = {
     accountId: number;

package/lib/projects/upload.js

@@ -8,13 +8,11 @@ import { isTranslationError, translate, } from '@hubspot/project-parsing-lib/tra
 import { projectContainsHsMetaFiles } from '@hubspot/project-parsing-lib/projects';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { uiAccountDescription } from '../ui/index.js';
-import { logError } from '../errorHandlers/index.js';
 import util from 'node:util';
 import { lib } from '../../lang/en.js';
 import { ensureProjectExists } from './ensureProjectExists.js';
 import { uiLogger } from '../ui/logger.js';
 import { isV2Project } from './platformVersion.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import ProjectValidationError from '../errors/ProjectValidationError.js';
 import { walk } from '@hubspot/local-dev-lib/fs';
 import { LEGACY_CONFIG_FILES } from '../constants.js';
@@ -46,57 +44,50 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
 }
 export async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
-    try {
-        await validateSourceDirectory(srcDir, projectConfig, projectDir);
-    }
-    catch (e) {
-        logError(e);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        await validateNoHSMetaMismatch(srcDir, projectConfig);
-    }
-    catch (e) {
-        logError(e);
-        process.exit(EXIT_CODES.ERROR);
-    }
+    await validateSourceDirectory(srcDir, projectConfig, projectDir);
+    await validateNoHSMetaMismatch(srcDir, projectConfig);
     const tempFile = tmp.fileSync({ postfix: '.zip' });
     uiLogger.debug(lib.projectUpload.handleProjectUpload.compressing(tempFile.name));
     const output = fs.createWriteStream(tempFile.name);
     const archive = archiver('zip');
-    const result = new Promise(resolve => output.on('close', async function () {
-        uiLogger.debug(lib.projectUpload.handleProjectUpload.compressed(archive.pointer()));
-        let intermediateRepresentation;
-        if (sendIR) {
-            try {
-                intermediateRepresentation = await handleTranslate({
-                    projectDir,
-                    projectConfig,
-                    accountId,
-                    skipValidation,
-                    profile,
-                });
+    const result = new Promise((resolve, reject) => output.on('close', async function () {
+        try {
+            uiLogger.debug(lib.projectUpload.handleProjectUpload.compressed(archive.pointer()));
+            let intermediateRepresentation;
+            if (sendIR) {
+                try {
+                    intermediateRepresentation = await handleTranslate({
+                        projectDir,
+                        projectConfig,
+                        accountId,
+                        skipValidation,
+                        profile,
+                    });
+                }
+                catch (e) {
+                    return resolve({ uploadError: e });
+                }
             }
-            catch (e) {
-                resolve({ uploadError: e });
+            const { projectExists } = await ensureProjectExists(accountId, projectConfig.name, {
+                forceCreate,
+                uploadCommand: isUploadCommand,
+                noLogs: true,
+            });
+            if (!projectExists) {
+                uiLogger.log(lib.projectUpload.handleProjectUpload.projectDoesNotExist(accountId));
+                return resolve({ projectNotFound: true });
+            }
+            const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
+            if (error) {
+                resolve({ uploadError: error });
+            }
+            else if (callbackFunc) {
+                const uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
+                resolve({ result: uploadResult });
             }
         }
-        const { projectExists } = await ensureProjectExists(accountId, projectConfig.name, {
-            forceCreate,
-            uploadCommand: isUploadCommand,
-            noLogs: true,
-        });
-        if (!projectExists) {
-            uiLogger.log(lib.projectUpload.handleProjectUpload.projectDoesNotExist(accountId));
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
-        if (error) {
-            resolve({ uploadError: error });
-        }
-        else if (callbackFunc) {
-            const uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
-            resolve({ result: uploadResult });
+        catch (e) {
+            reject(e);
         }
     }));
     archive.pipe(output);