@hubspot/cli 8.0.10-experimental.0 → 8.0.10-experimental.2

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);

package/lib/projects/watch.d.ts

@@ -1,4 +1,5 @@
 import { ProjectConfig } from '../../types/Projects.js';
 type ProjectWatchHandlerFunction = (accountId: number, projectName: string, currentBuildId: number) => Promise<void> | void;
-export declare function createWatcher(accountId: number, projectConfig: ProjectConfig, projectDir: string, handleBuildStatusFn: ProjectWatchHandlerFunction, handleUserInputFn: ProjectWatchHandlerFunction): Promise<void>;
+type WatchTerminationHandler = (error?: unknown) => void;
+export declare function createWatcher(accountId: number, projectConfig: ProjectConfig, projectDir: string, handleBuildStatusFn: ProjectWatchHandlerFunction, handleUserInputFn: ProjectWatchHandlerFunction, handleWatchTerminationFn: WatchTerminationHandler): Promise<void>;
 export {};

package/lib/projects/watch.js

@@ -18,6 +18,7 @@ const standbyQueue = [];
 let currentBuildId;
 let handleBuildStatus;
 let handleUserInput;
+let handleWatchTermination = () => { };
 let timer;
 async function processStandByQueue(accountId, projectName, platformVersion) {
     queue.addAll(standbyQueue.map(({ filePath, remotePath, action }) => {
@@ -37,33 +38,39 @@ function debounceQueueBuild(accountId, projectName, platformVersion) {
         clearTimeout(timer);
     }
     timer = setTimeout(async () => {
-        uiLogger.debug(commands.project.watch.debug.pause);
-        queue.pause();
-        await queue.onIdle();
         try {
-            await queueBuild(accountId, projectName, platformVersion);
-            uiLogger.debug(commands.project.watch.debug.buildStarted);
-        }
-        catch (err) {
-            if (isSpecifiedError(err, {
-                subCategory: PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
-            })) {
-                uiLogger.log(commands.project.watch.logs.watchCancelledFromUi);
-                process.exit(0);
+            uiLogger.debug(commands.project.watch.debug.pause);
+            queue.pause();
+            await queue.onIdle();
+            try {
+                await queueBuild(accountId, projectName, platformVersion);
+                uiLogger.debug(commands.project.watch.debug.buildStarted);
+            }
+            catch (err) {
+                if (isSpecifiedError(err, {
+                    subCategory: PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
+                })) {
+                    uiLogger.log(commands.project.watch.logs.watchCancelledFromUi);
+                    handleWatchTermination();
+                    return;
+                }
+                else {
+                    logError(err, new ApiErrorContext({ accountId }));
+                }
+                return;
             }
-            else {
-                logError(err, new ApiErrorContext({ accountId }));
+            await handleBuildStatus(accountId, projectName, currentBuildId);
+            await createNewStagingBuild(accountId, projectName, platformVersion);
+            if (standbyQueue.length > 0) {
+                await processStandByQueue(accountId, projectName, platformVersion);
             }
-            return;
+            queue.start();
+            uiLogger.log(commands.project.watch.logs.resuming);
+            uiLogger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
         }
-        await handleBuildStatus(accountId, projectName, currentBuildId);
-        await createNewStagingBuild(accountId, projectName, platformVersion);
-        if (standbyQueue.length > 0) {
-            await processStandByQueue(accountId, projectName, platformVersion);
+        catch (err) {
+            handleWatchTermination(err);
         }
-        queue.start();
-        uiLogger.log(commands.project.watch.logs.resuming);
-        uiLogger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
     }, 2000);
 }
 async function queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action) {
@@ -111,7 +118,7 @@ async function createNewBuild(accountId, projectName, platformVersion) {
             await cancelStagedBuild(accountId, projectName);
             uiLogger.log(commands.project.watch.logs.previousStagingBuildCancelled);
         }
-        process.exit(1);
+        throw err;
     }
 }
 async function handleWatchEvent(accountId, projectName, platformVersion, projectSourceDir, filePath, action = 'upload') {
@@ -132,10 +139,11 @@ async function handleWatchEvent(accountId, projectName, platformVersion, project
         await queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action);
     }
 }
-export async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn) {
+export async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn, handleWatchTerminationFn) {
     const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
     handleBuildStatus = handleBuildStatusFn;
     handleUserInput = handleUserInputFn;
+    handleWatchTermination = handleWatchTerminationFn;
     await createNewStagingBuild(accountId, projectConfig.name, projectConfig.platformVersion);
     const watcher = chokidar.watch(projectSourceDir, {
         ignoreInitial: true,

package/lib/serverlessLogs.js

@@ -9,7 +9,6 @@ import { outputLogs } from './ui/serverlessFunctionLogs.js';
 import { logError, ApiErrorContext } from './errorHandlers/index.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { handleExit, handleKeypress } from './process.js';
-import { EXIT_CODES } from './enums/exitCodes.js';
 import { lib } from '../lang/en.js';
 const TAIL_DELAY = 5000;
 function base64EncodeString(valueToEncode) {
@@ -19,19 +18,6 @@ function base64EncodeString(valueToEncode) {
     const stringBuffer = Buffer.from(valueToEncode);
     return encodeURIComponent(stringBuffer.toString('base64'));
 }
-function handleUserInput() {
-    const onTerminate = async () => {
-        SpinniesManager.remove('tailLogs');
-        SpinniesManager.remove('stopMessage');
-        process.exit(EXIT_CODES.SUCCESS);
-    };
-    handleExit(onTerminate);
-    handleKeypress(key => {
-        if ((key.ctrl && key.name == 'c') || key.name === 'q') {
-            onTerminate();
-        }
-    });
-}
 async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
     const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
@@ -80,40 +66,60 @@ export async function tailLogs(accountId, name, fetchLatest, tailCall, compact =
             }
         }
     }
-    async function tail(after) {
-        let latestLog;
-        let nextAfter;
-        try {
-            const { data } = await tailCall(after);
-            latestLog = data;
-            nextAfter = latestLog.paging.next.after;
+    return new Promise(resolve => {
+        function cleanup() {
+            SpinniesManager.remove('tailLogs');
+            SpinniesManager.remove('stopMessage');
         }
-        catch (e) {
-            if (isHubSpotHttpError(e) && e.status !== 404) {
-                logError(e, new ApiErrorContext({
-                    accountId,
-                }));
+        let resolved = false;
+        const onTerminate = async () => {
+            if (resolved)
+                return;
+            resolved = true;
+            cleanup();
+            resolve();
+        };
+        handleExit(onTerminate);
+        handleKeypress(key => {
+            if ((key.ctrl && key.name == 'c') || key.name === 'q') {
+                onTerminate();
             }
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        if (latestLog && latestLog.results.length) {
-            outputLogs(latestLog, {
-                compact,
-            });
+        });
+        async function tail(after) {
+            let latestLog;
+            let nextAfter;
+            try {
+                const { data } = await tailCall(after);
+                latestLog = data;
+                nextAfter = latestLog.paging.next.after;
+            }
+            catch (e) {
+                if (isHubSpotHttpError(e) && e.status !== 404) {
+                    logError(e, new ApiErrorContext({
+                        accountId,
+                    }));
+                }
+                await onTerminate();
+                return;
+            }
+            if (latestLog && latestLog.results.length) {
+                outputLogs(latestLog, {
+                    compact,
+                });
+            }
+            setTimeout(async () => {
+                await tail(nextAfter);
+            }, TAIL_DELAY);
         }
-        setTimeout(async () => {
-            await tail(nextAfter);
-        }, TAIL_DELAY);
-    }
-    SpinniesManager.add('tailLogs', {
-        text: `Following logs for ${name}`,
-    });
-    SpinniesManager.add('stopMessage', {
-        text: `> Press ${chalk.bold('q')} to stop following`,
-        status: 'non-spinnable',
+        SpinniesManager.add('tailLogs', {
+            text: `Following logs for ${name}`,
+        });
+        SpinniesManager.add('stopMessage', {
+            text: `> Press ${chalk.bold('q')} to stop following`,
+            status: 'non-spinnable',
+        });
+        tail(initialAfter);
     });
-    handleUserInput();
-    await tail(initialAfter);
 }
 export async function outputBuildLog(buildLogUrl) {
     if (!buildLogUrl) {

package/mcp-server/tools/cms/HsCreateFunctionTool.js

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';

package/mcp-server/tools/cms/HsCreateModuleTool.js

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';

package/mcp-server/tools/cms/HsCreateTemplateTool.js

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';