@hubspot/cli 7.0.1-experimental.0 → 7.0.2-beta.0

package/lib/projects/buildAndDeploy.js

@@ -197,13 +197,13 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
                         resolve(taskStatus);
                     }
                 }
-            }, constants_1.POLLING_DELAY);
+            }, constants_1.DEFAULT_POLLING_DELAY);
         });
     };
 }
 function pollBuildAutodeployStatus(accountId, taskName, buildId) {
     return new Promise((resolve, reject) => {
-        let maxIntervals = (30 * 1000) / constants_1.POLLING_DELAY; // Num of intervals in ~30s
+        let maxIntervals = (30 * 1000) / constants_1.DEFAULT_POLLING_DELAY; // Num of intervals in ~30s
         const pollInterval = setInterval(async () => {
             let build;
             try {
@@ -224,7 +224,7 @@ function pollBuildAutodeployStatus(accountId, taskName, buildId) {
             else {
                 maxIntervals -= 1;
             }
-        }, constants_1.POLLING_DELAY);
+        }, constants_1.DEFAULT_POLLING_DELAY);
     });
 }
 exports.pollBuildStatus = makePollTaskStatusFunc({

package/lib/projects/index.js

@@ -20,7 +20,6 @@ const github_1 = require("@hubspot/local-dev-lib/github");
 const projects_1 = require("@hubspot/local-dev-lib/api/projects");
 const index_1 = require("@hubspot/local-dev-lib/errors/index");
 const path_2 = require("@hubspot/local-dev-lib/path");
-const github_2 = require("@hubspot/local-dev-lib/github");
 const constants_1 = require("../constants");
 const promptUtils_1 = require("../prompts/promptUtils");
 const exitCodes_1 = require("../enums/exitCodes");
@@ -96,7 +95,10 @@ async function createProjectConfig(projectPath, projectName, template, templateS
     const projectConfigPath = path_1.default.join(projectPath, constants_1.PROJECT_CONFIG_FILE);
     logger_1.logger.log(`Creating project config in ${projectPath ? projectPath : 'the current folder'}`);
     const hasCustomTemplateSource = Boolean(templateSource);
-    await (0, github_2.downloadGithubRepoContents)(templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, template.path, projectPath, hasCustomTemplateSource ? undefined : githubRef);
+    await (0, github_1.cloneGithubRepo)(templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectPath, {
+        sourceDir: template.path,
+        tag: hasCustomTemplateSource ? undefined : githubRef,
+    });
     const _config = JSON.parse(fs_extra_1.default.readFileSync(projectConfigPath).toString());
     writeProjectConfig(projectConfigPath, {
         ..._config,
@@ -169,7 +171,7 @@ async function pollFetchProject(accountId, projectName) {
                     reject(err);
                 }
             }
-        }, constants_1.POLLING_DELAY);
+        }, constants_1.DEFAULT_POLLING_DELAY);
     });
 }
 async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
@@ -248,7 +250,10 @@ async function createProjectComponent(component, name, projectComponentsVersion)
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     const componentPath = path_1.default.join(configInfo.projectDir, configInfo.projectConfig.srcDir, component.insertPath, componentName);
-    await (0, github_2.downloadGithubRepoContents)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, component.path, componentPath, projectComponentsVersion);
+    await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
+        sourceDir: component.path,
+        tag: projectComponentsVersion,
+    });
 }
 async function getProjectComponentsByVersion(projectComponentsVersion) {
     const config = await (0, github_1.fetchFileFromRepository)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', projectComponentsVersion);

package/lib/projects/structure.d.ts

@@ -1,78 +1,12 @@
-import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
-export type Component = {
-    type: ComponentTypes;
-    config: object;
-    runnable: boolean;
-    path: string;
-};
-type PrivateAppComponentConfig = {
-    name: string;
-    description: string;
-    uid: string;
-    scopes: Array<string>;
-    public: boolean;
-    extensions?: {
-        crm: {
-            cards: Array<{
-                file: string;
-            }>;
-        };
-    };
-};
-type PublicAppComponentConfig = {
-    name: string;
-    uid: string;
-    description: string;
-    allowedUrls: Array<string>;
-    auth: {
-        redirectUrls: Array<string>;
-        requiredScopes: Array<string>;
-        optionalScopes: Array<string>;
-        conditionallyRequiredScopes: Array<string>;
-    };
-    support: {
-        supportEmail: string;
-        documentationUrl: string;
-        supportUrl: string;
-        supportPhone: string;
-    };
-    extensions?: {
-        crm: {
-            cards: Array<{
-                file: string;
-            }>;
-        };
-    };
-    webhooks?: {
-        file: string;
-    };
-};
-type AppCardComponentConfig = {
-    type: 'crm-card';
-    data: {
-        title: string;
-        uid: string;
-        location: string;
-        module: {
-            file: string;
-        };
-        objectTypes: Array<{
-            name: string;
-        }>;
-    };
-};
-export declare const COMPONENT_TYPES: {
-    readonly privateApp: "private-app";
-    readonly publicApp: "public-app";
-    readonly hublTheme: "hubl-theme";
-};
-type ComponentTypes = ValueOf<typeof COMPONENT_TYPES>;
+import { ComponentTypes, Component, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects';
 export declare const CONFIG_FILES: {
-    [k in ValueOf<typeof COMPONENT_TYPES>]: string;
+    [k in ComponentTypes]: string;
 };
 export declare function getAppCardConfigs(appConfig: PublicAppComponentConfig | PrivateAppComponentConfig, appPath: string): Array<AppCardComponentConfig>;
 export declare function findProjectComponents(projectSourceDir: string): Promise<Array<Component>>;
 export declare function getProjectComponentTypes(components: Array<Component>): {
     [key in ComponentTypes]?: boolean;
 };
-export {};
+export declare function getComponentUid(component?: Component | null): string | null;
+export declare function componentIsApp(component?: Component | null): component is Component<PublicAppComponentConfig | PrivateAppComponentConfig>;
+export declare function componentIsPublicApp(component?: Component | null): component is Component<PublicAppComponentConfig>;

package/lib/projects/structure.js

@@ -33,24 +33,23 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_FILES = exports.COMPONENT_TYPES = void 0;
+exports.CONFIG_FILES = void 0;
 exports.getAppCardConfigs = getAppCardConfigs;
 exports.findProjectComponents = findProjectComponents;
 exports.getProjectComponentTypes = getProjectComponentTypes;
+exports.getComponentUid = getComponentUid;
+exports.componentIsApp = componentIsApp;
+exports.componentIsPublicApp = componentIsPublicApp;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const fs_1 = require("@hubspot/local-dev-lib/fs");
 const logger_1 = require("@hubspot/local-dev-lib/logger");
 const index_1 = require("../errorHandlers/index");
-exports.COMPONENT_TYPES = {
-    privateApp: 'private-app',
-    publicApp: 'public-app',
-    hublTheme: 'hubl-theme',
-};
+const Projects_1 = require("../../types/Projects");
 exports.CONFIG_FILES = {
-    [exports.COMPONENT_TYPES.privateApp]: 'app.json',
-    [exports.COMPONENT_TYPES.publicApp]: 'public-app.json',
-    [exports.COMPONENT_TYPES.hublTheme]: 'theme.json',
+    [Projects_1.ComponentTypes.PrivateApp]: 'app.json',
+    [Projects_1.ComponentTypes.PublicApp]: 'public-app.json',
+    [Projects_1.ComponentTypes.HublTheme]: 'theme.json',
 };
 function getComponentTypeFromConfigFile(configFile) {
     let key;
@@ -129,7 +128,7 @@ async function findProjectComponents(projectSourceDir) {
             const parsedConfig = loadConfigFile(projectFile);
             if (parsedConfig) {
                 const isLegacy = getIsLegacyApp(parsedConfig, dir);
-                const isHublTheme = base === exports.CONFIG_FILES[exports.COMPONENT_TYPES.hublTheme];
+                const isHublTheme = base === exports.CONFIG_FILES[Projects_1.ComponentTypes.HublTheme];
                 const componentType = getComponentTypeFromConfigFile(base);
                 if (componentType) {
                     components.push({
@@ -149,3 +148,21 @@ function getProjectComponentTypes(components) {
     components.forEach(({ type }) => (projectContents[type] = true));
     return projectContents;
 }
+function getComponentUid(component) {
+    if (!component) {
+        return null;
+    }
+    else if ('uid' in component.config) {
+        return component.config.uid;
+    }
+    else {
+        return component.config.data.uid;
+    }
+}
+function componentIsApp(component) {
+    return (component?.type === Projects_1.ComponentTypes.PublicApp ||
+        component?.type === Projects_1.ComponentTypes.PrivateApp);
+}
+function componentIsPublicApp(component) {
+    return component?.type === Projects_1.ComponentTypes.PublicApp;
+}

package/lib/projects/upload.d.ts

@@ -1,8 +1,9 @@
 import { FileResult } from 'tmp';
 import { ProjectConfig } from '../../types/Projects';
-type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId?: number) => Promise<T | undefined>;
-type ProjectUploadDefaultResult = {
+type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId?: number) => Promise<T>;
+type ProjectUploadResult<T> = {
+    result?: T;
     uploadError?: unknown;
 };
-export declare function handleProjectUpload<T = ProjectUploadDefaultResult>(accountId: number, projectConfig: ProjectConfig, projectDir: string, callbackFunc: ProjectUploadCallbackFunction<T>, uploadMessage: string, sendIR?: boolean): Promise<unknown>;
+export declare function handleProjectUpload<T>(accountId: number, projectConfig: ProjectConfig, projectDir: string, callbackFunc: ProjectUploadCallbackFunction<T>, uploadMessage: string): Promise<ProjectUploadResult<T>>;
 export {};

package/lib/projects/upload.js

@@ -15,10 +15,8 @@ const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
 const ui_1 = require("../ui");
 const lang_1 = require("../lang");
 const exitCodes_1 = require("../enums/exitCodes");
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
-const errorHandlers_1 = require("../errorHandlers");
 const i18nKey = 'lib.projectUpload';
-async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
+async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion) {
     SpinniesManager_1.default.init({});
     const accountIdentifier = (0, ui_1.uiAccountDescription)(accountId);
     SpinniesManager_1.default.add('upload', {
@@ -31,7 +29,7 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
     let buildId;
     let error;
     try {
-        const { data: upload } = await (0, projects_1.uploadProject)(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation);
+        const { data: upload } = await (0, projects_1.uploadProject)(accountId, projectName, filePath, uploadMessage, platformVersion);
         buildId = upload.buildId;
         SpinniesManager_1.default.succeed('upload', {
             text: (0, lang_1.i18n)(`${i18nKey}.uploadProjectFiles.succeed`, {
@@ -57,7 +55,7 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
     }
     return { buildId, error };
 }
-async function handleProjectUpload(accountId, projectConfig, projectDir, callbackFunc, uploadMessage, sendIR = false) {
+async function handleProjectUpload(accountId, projectConfig, projectDir, callbackFunc, uploadMessage) {
     const srcDir = path_1.default.resolve(projectDir, projectConfig.srcDir);
     const filenames = fs_extra_1.default.readdirSync(srcDir);
     if (!filenames || filenames.length === 0) {
@@ -73,38 +71,17 @@ async function handleProjectUpload(accountId, projectConfig, projectDir, callbac
     const output = fs_extra_1.default.createWriteStream(tempFile.name);
     const archive = (0, archiver_1.default)('zip');
     const result = new Promise(resolve => output.on('close', async function () {
-        let uploadResult;
         logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.handleProjectUpload.compressed`, {
             byteCount: archive.pointer(),
         }));
-        let intermediateRepresentation;
-        if (sendIR) {
-            try {
-                intermediateRepresentation = await (0, project_parsing_lib_1.translate)({
-                    projectSourceDir: path_1.default.join(projectDir, projectConfig.srcDir),
-                    platformVersion: projectConfig.platformVersion,
-                    accountId,
-                });
-            }
-            catch (e) {
-                if ((0, project_parsing_lib_1.isTranslationError)(e)) {
-                    logger_1.logger.error(e.toString());
-                }
-                else {
-                    (0, errorHandlers_1.logError)(e);
-                }
-                return process.exit(exitCodes_1.EXIT_CODES.ERROR);
-            }
-        }
-        const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
+        const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion);
         if (error) {
-            console.log(error);
-            uploadResult = { uploadError: error };
+            resolve({ uploadError: error });
         }
         else if (callbackFunc) {
-            uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
+            const uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
+            resolve({ result: uploadResult });
         }
-        resolve(uploadResult || {});
     }));
     archive.pipe(output);
     let loggedIgnoredNodeModule = false;

package/lib/projects/watch.d.ts

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

package/lib/projects/watch.js

@@ -1,124 +1,130 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const chokidar = require('chokidar');
-const path = require('path');
-const chalk = require('chalk');
-const { default: PQueue } = require('p-queue');
-const { logError, ApiErrorContext } = require('../errorHandlers/index');
-const { i18n } = require('../lang');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { isAllowedExtension } = require('@hubspot/local-dev-lib/path');
-const { shouldIgnoreFile } = require('@hubspot/local-dev-lib/ignoreRules');
-const { cancelStagedBuild, provisionBuild, uploadFileToBuild, deleteFileFromBuild, queueBuild, } = require('@hubspot/local-dev-lib/api/projects');
-const { isSpecifiedError } = require('@hubspot/local-dev-lib/errors/index');
-const { PROJECT_ERROR_TYPES } = require('../constants');
+exports.createWatcher = createWatcher;
+const chokidar_1 = __importDefault(require("chokidar"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const path_2 = require("@hubspot/local-dev-lib/path");
+const extensions_1 = require("@hubspot/local-dev-lib/constants/extensions");
+const ignoreRules_1 = require("@hubspot/local-dev-lib/ignoreRules");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const errorHandlers_1 = require("../errorHandlers");
+const lang_1 = require("../lang");
+const constants_1 = require("../constants");
 const i18nKey = 'commands.project.subcommands.watch';
-const queue = new PQueue({
+const queue = new p_queue_1.default({
     concurrency: 10,
 });
-const standbyeQueue = [];
-let currentBuildId = null;
-let handleBuildStatus, handleUserInput;
+const standbyQueue = [];
+let currentBuildId;
+let handleBuildStatus;
+let handleUserInput;
 let timer;
-const processStandByQueue = async (accountId, projectName, platformVersion) => {
-    queue.addAll(standbyeQueue.map(({ filePath, remotePath, action }) => {
+async function processStandByQueue(accountId, projectName, platformVersion) {
+    queue.addAll(standbyQueue.map(({ filePath, remotePath, action }) => {
         return async () => {
             queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action);
         };
     }));
-    standbyeQueue.length = 0;
+    standbyQueue.length = 0;
     debounceQueueBuild(accountId, projectName, platformVersion);
-};
-const createNewStagingBuild = async (accountId, projectName, platformVersion) => {
+}
+async function createNewStagingBuild(accountId, projectName, platformVersion) {
     currentBuildId = await createNewBuild(accountId, projectName, platformVersion);
     handleUserInput(accountId, projectName, currentBuildId);
-};
-const debounceQueueBuild = (accountId, projectName, platformVersion) => {
+}
+function debounceQueueBuild(accountId, projectName, platformVersion) {
     if (timer) {
         clearTimeout(timer);
     }
     timer = setTimeout(async () => {
-        logger.debug(i18n(`${i18nKey}.debug.pause`, { projectName }));
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.pause`, { projectName }));
         queue.pause();
         await queue.onIdle();
         try {
-            await queueBuild(accountId, projectName, platformVersion);
-            logger.debug(i18n(`${i18nKey}.debug.buildStarted`, { projectName }));
+            await (0, projects_1.queueBuild)(accountId, projectName, platformVersion);
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.buildStarted`, { projectName }));
         }
         catch (err) {
-            if (isSpecifiedError(err, {
-                subCategory: PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
+            if ((0, index_1.isSpecifiedError)(err, {
+                subCategory: constants_1.PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
             })) {
-                logger.log(i18n(`${i18nKey}.logs.watchCancelledFromUi`));
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logs.watchCancelledFromUi`));
                 process.exit(0);
             }
             else {
-                logError(err, new ApiErrorContext({ accountId }));
+                (0, errorHandlers_1.logError)(err, new errorHandlers_1.ApiErrorContext({ accountId }));
             }
             return;
         }
         await handleBuildStatus(accountId, projectName, currentBuildId);
         await createNewStagingBuild(accountId, projectName, platformVersion);
-        if (standbyeQueue.length > 0) {
+        if (standbyQueue.length > 0) {
             await processStandByQueue(accountId, projectName, platformVersion);
         }
         queue.start();
-        logger.log(i18n(`${i18nKey}.logs.resuming`));
-        logger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logs.resuming`));
+        logger_1.logger.log(`\n> Press ${chalk_1.default.bold('q')} to quit watching\n`);
     }, 2000);
-};
-const queueFileOrFolder = async (accountId, projectName, platformVersion, filePath, remotePath, action) => {
-    if (action === 'upload' && !isAllowedExtension(filePath)) {
-        logger.debug(i18n(`${i18nKey}.debug.extensionNotAllowed`, { filePath }));
+}
+async function queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action) {
+    if (action === 'upload' &&
+        !(0, path_2.isAllowedExtension)(filePath, Array.from(extensions_1.JSR_ALLOWED_EXTENSIONS))) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.extensionNotAllowed`, { filePath }));
         return;
     }
-    if (shouldIgnoreFile(filePath, true)) {
-        logger.debug(i18n(`${i18nKey}.debug.ignored`, { filePath }));
+    if ((0, ignoreRules_1.shouldIgnoreFile)(filePath, true)) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.ignored`, { filePath }));
         return;
     }
     if (!queue.isPaused) {
         debounceQueueBuild(accountId, projectName, platformVersion);
     }
-    logger.debug(i18n(`${i18nKey}.debug.uploading`, { filePath, remotePath }));
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.uploading`, { filePath, remotePath }));
     return queue.add(async () => {
         try {
             if (action === 'upload') {
-                await uploadFileToBuild(accountId, projectName, filePath, remotePath);
+                await (0, projects_1.uploadFileToBuild)(accountId, projectName, filePath, remotePath);
             }
             else if (action === 'deleteFile' || action === 'deleteFolder') {
-                await deleteFileFromBuild(accountId, projectName, remotePath);
+                await (0, projects_1.deleteFileFromBuild)(accountId, projectName, remotePath);
             }
-            logger.log(i18n(`${i18nKey}.logs.${action}Succeeded`, { filePath, remotePath }));
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logs.${action}Succeeded`, { filePath, remotePath }));
         }
         catch (err) {
-            logger.debug(i18n(`${i18nKey}.errors.${action}Failed`, { filePath, remotePath }));
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.${action}Failed`, { filePath, remotePath }));
         }
     });
-};
-const createNewBuild = async (accountId, projectName, platformVersion) => {
+}
+async function createNewBuild(accountId, projectName, platformVersion) {
     try {
-        logger.debug(i18n(`${i18nKey}.debug.attemptNewBuild`));
-        const { data: { buildId }, } = await provisionBuild(accountId, projectName, platformVersion);
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.attemptNewBuild`));
+        const { data: { buildId }, } = await (0, projects_1.provisionBuild)(accountId, projectName, platformVersion);
         return buildId;
     }
     catch (err) {
-        logError(err, new ApiErrorContext({ accountId }));
-        if (isSpecifiedError(err, { subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED })) {
-            await cancelStagedBuild(accountId, projectName);
-            logger.log(i18n(`${i18nKey}.logs.previousStagingBuildCancelled`));
+        (0, errorHandlers_1.logError)(err, new errorHandlers_1.ApiErrorContext({ accountId }));
+        if ((0, index_1.isSpecifiedError)(err, { subCategory: constants_1.PROJECT_ERROR_TYPES.PROJECT_LOCKED })) {
+            await (0, projects_1.cancelStagedBuild)(accountId, projectName);
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logs.previousStagingBuildCancelled`));
         }
         process.exit(1);
     }
-};
-const handleWatchEvent = async (accountId, projectName, platformVersion, projectSourceDir, filePath, action = 'upload') => {
-    const remotePath = path.relative(projectSourceDir, filePath);
+}
+async function handleWatchEvent(accountId, projectName, platformVersion, projectSourceDir, filePath, action = 'upload') {
+    const remotePath = path_1.default.relative(projectSourceDir, filePath);
     if (queue.isPaused) {
-        if (standbyeQueue.find(file => file.filePath === filePath)) {
-            logger.debug(i18n(`${i18nKey}.debug.fileAlreadyQueued`, { filePath }));
+        if (standbyQueue.find(file => file.filePath === filePath)) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.debug.fileAlreadyQueued`, { filePath }));
         }
         else {
-            standbyeQueue.push({
+            standbyQueue.push({
                 filePath,
                 remotePath,
                 action,
@@ -128,19 +134,19 @@ const handleWatchEvent = async (accountId, projectName, platformVersion, project
     else {
         await queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action);
     }
-};
-const createWatcher = async (accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn) => {
-    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
+}
+async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn) {
+    const projectSourceDir = path_1.default.join(projectDir, projectConfig.srcDir);
     handleBuildStatus = handleBuildStatusFn;
     handleUserInput = handleUserInputFn;
     await createNewStagingBuild(accountId, projectConfig.name, projectConfig.platformVersion);
-    const watcher = chokidar.watch(projectSourceDir, {
+    const watcher = chokidar_1.default.watch(projectSourceDir, {
         ignoreInitial: true,
-        ignored: file => shouldIgnoreFile(file),
+        ignored: file => (0, ignoreRules_1.shouldIgnoreFile)(file),
     });
     watcher.on('ready', async () => {
-        logger.log(i18n(`${i18nKey}.logs.watching`, { projectDir }));
-        logger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logs.watching`, { projectDir }));
+        logger_1.logger.log(`\n> Press ${chalk_1.default.bold('q')} to quit watching\n`);
     });
     watcher.on('add', async (path) => {
         handleWatchEvent(accountId, projectConfig.name, projectConfig.platformVersion, projectSourceDir, path);
@@ -154,7 +160,4 @@ const createWatcher = async (accountId, projectConfig, projectDir, handleBuildSt
     watcher.on('unlinkDir', async (path) => {
         handleWatchEvent(accountId, projectConfig.name, projectConfig.platformVersion, projectSourceDir, path, 'deleteFolder');
     });
-};
-module.exports = {
-    createWatcher,
-};
+}

package/lib/prompts/createProjectPrompt.js

@@ -23,7 +23,14 @@ async function createTemplateOptions(templateSource, githubRef) {
     const branch = hasCustomTemplateSource
         ? constants_1.DEFAULT_PROJECT_TEMPLATE_BRANCH
         : githubRef;
-    const config = await (0, github_1.fetchFileFromRepository)(templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', branch);
+    let config;
+    try {
+        config = await (0, github_1.fetchFileFromRepository)(templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', branch);
+    }
+    catch (e) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.missingConfigFileTemplateSource`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
     if (!config || !config[constants_1.PROJECT_COMPONENT_TYPES.PROJECTS]) {
         logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectsInConfig`));
         process.exit(exitCodes_1.EXIT_CODES.ERROR);

package/lib/prompts/installPublicAppPrompt.d.ts

@@ -1 +1 @@
-export declare function installPublicAppPrompt(env: string, targetAccountId: number, clientId: number, scopes: string[], redirectUrls: string[], isReinstall?: boolean): Promise<void>;
+export declare function installPublicAppPrompt(env: string, targetAccountId: number, clientId: string, scopes: string[], redirectUrls: string[], isReinstall?: boolean): Promise<void>;

package/lib/prompts/personalAccessKeyPrompt.d.ts

@@ -21,7 +21,7 @@ type ScopesPromptResponse = {
  */
 export declare function personalAccessKeyPrompt({ env, account, }: {
     env: string;
-    account?: string;
+    account?: number;
 }): Promise<PersonalAccessKeyPromptResponse>;
 export declare const OAUTH_FLOW: (PromptConfig<{
     name: string;

package/lib/prompts/projectDevTargetAccountPrompt.d.ts

@@ -1,6 +1,6 @@
-import { CLIAccount, AccountType } from '@hubspot/local-dev-lib/types/Accounts';
+import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 export declare function selectSandboxTargetAccountPrompt(accounts: CLIAccount[], defaultAccountConfig: CLIAccount): Promise<DeveloperTestAccount | CLIAccount>;
 export declare function selectDeveloperTestTargetAccountPrompt(accounts: CLIAccount[], defaultAccountConfig: CLIAccount): Promise<DeveloperTestAccount | CLIAccount>;
-export declare function confirmDefaultAccountPrompt(accountName: string, accountType: AccountType): Promise<boolean>;
+export declare function confirmDefaultAccountPrompt(accountName: string, accountType: string): Promise<boolean>;
 export declare function confirmUseExistingDeveloperTestAccountPrompt(account: DeveloperTestAccount): Promise<boolean>;

package/lib/sandboxSync.d.ts

@@ -1 +1,4 @@
-export {};
+import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { SandboxSyncTask } from '../types/Sandboxes';
+export declare function syncSandbox(accountConfig: CLIAccount, parentAccountConfig: CLIAccount, env: Environment, syncTasks: Array<SandboxSyncTask>, slimInfoMessage?: boolean): Promise<void>;