@hubspot/cli 6.4.0 → 7.0.0-beta.0

package/lib/usageTracking.js

@@ -1,43 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trackCommandUsage = trackCommandUsage;
+exports.trackHelpUsage = trackHelpUsage;
+exports.trackConvertFieldsUsage = trackConvertFieldsUsage;
+exports.trackAuthAction = trackAuthAction;
 exports.trackCommandMetadataUsage = trackCommandMetadataUsage;
-// @ts-nocheck
-const { trackUsage } = require('@hubspot/local-dev-lib/trackUsage');
-const { isTrackingAllowed, getAccountConfig, } = require('@hubspot/local-dev-lib/config');
-const { API_KEY_AUTH_METHOD, } = require('@hubspot/local-dev-lib/constants/auth');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { version } = require('../package.json');
-const { setLogLevel } = require('./commonOpts');
-/* **
-Available tracking meta properties
-
-  - action: "The specific action taken in the CLI"
-  - os: "The user's OS"
-  - nodeVersion: "The user's version of node.js"
-  - nodeMajorVersion: "The user's major version of node.js"
-  - version: "The user's version of the CLI"
-  - command: "The specific command that the user ran in this interaction"
-  - authType: "The configured auth type the user has for the CLI"
-  - step: "The specific step in the auth process"
-  - assetType: "The CMS asset type"
-  - mode: "The CLI mode (draft or publish"
-  - type: "The upload type (file or folder)"
-  - file: "Whether or not the 'file' flag was used"
-  - successful: "Whether or not the CLI interaction was successful"
-
-*/
+const trackUsage_1 = require("@hubspot/local-dev-lib/trackUsage");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const package_json_1 = require("../package.json");
+const errorHandlers_1 = require("./errorHandlers");
 const EventClass = {
     USAGE: 'USAGE',
     INTERACTION: 'INTERACTION',
     VIEW: 'VIEW',
     ACTIVATION: 'ACTIVATION',
 };
-const getNodeVersionData = () => ({
-    nodeVersion: process.version,
-    nodeMajorVersion: (process.version || '').split('.')[0],
-});
-const getPlatform = () => {
+function getNodeVersionData() {
+    return {
+        nodeVersion: process.version,
+        nodeMajorVersion: (process.version || '').split('.')[0],
+    };
+}
+function getPlatform() {
     switch (process.platform) {
         case 'darwin':
             return 'macos';
@@ -46,144 +32,130 @@ const getPlatform = () => {
         default:
             return process.platform;
     }
-};
-function trackCommandUsage(command, meta = {}, accountId) {
-    if (!isTrackingAllowed()) {
+}
+async function trackCommandUsage(command, meta = {}, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
-    logger.debug('Attempting to track usage of "%s" command', command);
+    logger_1.logger.debug('Attempting to track usage of "%s" command', command);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = (0, config_1.getAccountConfig)(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
-                : API_KEY_AUTH_METHOD.value;
+                : auth_1.API_KEY_AUTH_METHOD.value;
     }
     setImmediate(async () => {
         const usageTrackingEvent = {
             action: 'cli-command',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
             authType,
             ...meta,
         };
         try {
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+            await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
         }
         catch (e) {
-            logger.debug('Usage tracking failed: %s', e.message);
+            (0, errorHandlers_1.debugError)(e);
         }
     });
 }
 async function trackHelpUsage(command) {
-    if (!isTrackingAllowed()) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
     try {
         if (command) {
-            logger.debug('Tracking help usage of "%s" sub-command', command);
+            logger_1.logger.debug('Tracking help usage of "%s" sub-command', command);
         }
         else {
-            logger.debug('Tracking help usage of main command');
+            logger_1.logger.debug('Tracking help usage of main command');
         }
-        await trackUsage('cli-interaction', EventClass.INTERACTION, {
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
             action: 'cli-help',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
         });
     }
     catch (e) {
-        logger.debug('Usage tracking failed: %s', e.message);
+        (0, errorHandlers_1.debugError)(e);
     }
 }
 async function trackConvertFieldsUsage(command) {
-    if (!isTrackingAllowed()) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
     try {
-        logger.debug('Attempting to track usage of "%s" command', command);
-        await trackUsage('cli-interaction', EventClass.INTERACTION, {
+        logger_1.logger.debug('Attempting to track usage of "%s" command', command);
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
             action: 'cli-process-fields',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
         });
     }
     catch (e) {
-        logger.debug('Usage tracking failed: %s', e.message);
+        (0, errorHandlers_1.debugError)(e);
     }
 }
-const addHelpUsageTracking = (program, command) => {
-    program.on('--help', () => {
-        setLogLevel(program);
-        trackHelpUsage(command);
-    });
-};
-const trackAuthAction = async (command, authType, step, accountId) => {
-    if (!isTrackingAllowed()) {
+async function trackAuthAction(command, authType, step, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
     const usageTrackingEvent = {
         action: 'cli-auth',
         os: getPlatform(),
         ...getNodeVersionData(),
-        version,
+        version: package_json_1.version,
         command,
         authType,
         step,
     };
     try {
-        await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+        logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
     }
     catch (e) {
-        logger.debug('Auth action tracking failed: %s', e.message);
+        (0, errorHandlers_1.debugError)(e);
     }
-};
-function trackCommandMetadataUsage(command, meta = {}, accountId) {
-    if (!isTrackingAllowed()) {
+}
+async function trackCommandMetadataUsage(command, meta = {}, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
-    logger.debug('Attempting to track metadata usage of "%s" command', command);
+    logger_1.logger.debug('Attempting to track metadata usage of "%s" command', command);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getAccountConfig(accountId);
+        const accountConfig = (0, config_1.getAccountConfig)(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
-                : API_KEY_AUTH_METHOD.value;
+                : auth_1.API_KEY_AUTH_METHOD.value;
     }
     setImmediate(async () => {
         const usageTrackingEvent = {
             action: 'cli-command-metadata',
             os: getPlatform(),
             ...getNodeVersionData(),
-            version,
+            version: package_json_1.version,
             command,
             authType,
             ...meta,
         };
         try {
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+            await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
         }
         catch (e) {
-            logger.debug('Metadata usage tracking failed: %s', e.message);
+            (0, errorHandlers_1.debugError)(e);
         }
     });
 }
-module.exports = {
-    trackCommandUsage,
-    trackHelpUsage,
-    addHelpUsageTracking,
-    trackConvertFieldsUsage,
-    trackAuthAction,
-    trackCommandMetadataUsage,
-};

package/lib/validation.d.ts

@@ -1 +1,11 @@
-export {};
+import { Arguments } from 'yargs';
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
+export declare function validateAccount(options: Arguments<{
+    account?: string;
+    accountId?: string;
+}>): Promise<boolean>;
+export declare function validateCmsPublishMode(options: Arguments<{
+    cmsPublishMode?: CmsPublishMode;
+}>): boolean;
+export declare function fileExists(_path: string): boolean;
+export declare function checkAndConvertToJson(_path: string): object | null;

package/lib/validation.js

@@ -1,163 +1,177 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const fs = require('fs');
-const path = require('path');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { MODE } = require('@hubspot/local-dev-lib/constants/files');
-const { API_KEY_AUTH_METHOD, OAUTH_AUTH_METHOD, PERSONAL_ACCESS_KEY_AUTH_METHOD, } = require('@hubspot/local-dev-lib/constants/auth');
-const { commaSeparatedValues } = require('@hubspot/local-dev-lib/text');
-const { loadConfig, getConfigPath, validateConfig, getAccountConfig, loadConfigFromEnvironment, } = require('@hubspot/local-dev-lib/config');
-const { getOauthManager } = require('@hubspot/local-dev-lib/oauth');
-const { accessTokenForPersonalAccessKey, } = require('@hubspot/local-dev-lib/personalAccessKey');
-const { getAbsoluteFilePath, getCwd, getExt, } = require('@hubspot/local-dev-lib/path');
-const { getAccountId, getMode, setLogLevel } = require('./commonOpts');
-const { EXIT_CODES } = require('./enums/exitCodes');
-const { checkAndWarnGitInclusion } = require('./ui/git');
-const { logError } = require('./errorHandlers/index');
-async function loadAndValidateOptions(options, shouldValidateAccount = true) {
-    setLogLevel(options);
-    const { config: configPath } = options;
-    loadConfig(configPath, options);
-    checkAndWarnGitInclusion(getConfigPath());
-    let validAccount = true;
-    if (shouldValidateAccount) {
-        validAccount = await validateAccount(options);
-    }
-    if (!(validateConfig() && validAccount)) {
-        process.exit(EXIT_CODES.ERROR);
-    }
-}
-/**
- * Validate that an account was passed to the command and that the account's configuration is valid
- *
- *
- * @param {object} command options
- * @returns {boolean}
- */
+exports.validateAccount = validateAccount;
+exports.validateCmsPublishMode = validateCmsPublishMode;
+exports.fileExists = fileExists;
+exports.checkAndConvertToJson = checkAndConvertToJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const files_1 = require("@hubspot/local-dev-lib/constants/files");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const text_1 = require("@hubspot/local-dev-lib/text");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const oauth_1 = require("@hubspot/local-dev-lib/oauth");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const path_1 = require("@hubspot/local-dev-lib/path");
+const commonOpts_1 = require("./commonOpts");
+const index_1 = require("./errorHandlers/index");
 async function validateAccount(options) {
-    const accountId = getAccountId(options);
-    const { portalId: portalIdOption, portal: portalOption, accountId: _accountIdOption, account: _accountOption, } = options;
-    const accountOption = portalOption || _accountOption;
-    const accountIdOption = portalIdOption || _accountIdOption;
+    const accountId = (0, commonOpts_1.getAccountId)(options);
+    const { accountId: accountIdOption, account: accountOption } = options;
     if (!accountId) {
         if (accountOption) {
-            logger.error(`The account "${accountOption}" could not be found in the config`);
+            logger_1.logger.error(`The account "${accountOption}" could not be found in the config`);
         }
         else if (accountIdOption) {
-            logger.error(`The account "${accountIdOption}" could not be found in the config`);
+            logger_1.logger.error(`The account "${accountIdOption}" could not be found in the config`);
         }
         else {
-            logger.error('An account needs to be supplied either via "--account" or through setting a "defaultPortal"');
+            logger_1.logger.error('An account needs to be supplied either via "--account" or through setting a "defaultPortal"');
         }
         return false;
     }
-    if (accountOption && loadConfigFromEnvironment()) {
+    if (accountOption && (0, config_1.loadConfigFromEnvironment)()) {
         throw new Error('Cannot specify an account when environment variables are supplied. Please unset the environment variables or do not use the "--account" flag.');
     }
-    const accountConfig = getAccountConfig(accountId);
+    const accountConfig = (0, config_1.getAccountConfig)(accountId);
     if (!accountConfig) {
-        logger.error(`The account ${accountId} has not been configured`);
+        logger_1.logger.error(`The account ${accountId} has not been configured`);
         return false;
     }
     const { authType, auth, apiKey, personalAccessKey } = accountConfig;
     if (typeof authType === 'string' && authType !== authType.toLowerCase()) {
-        logger.error(`Invalid "authType" value "${authType}" for account "${accountId}" in config file: ${getConfigPath()}. Valid values are ${commaSeparatedValues([
-            PERSONAL_ACCESS_KEY_AUTH_METHOD,
-            OAUTH_AUTH_METHOD,
-            API_KEY_AUTH_METHOD,
+        logger_1.logger.error(`Invalid "authType" value "${authType}" for account "${accountId}" in config file: ${(0, config_1.getConfigPath)()}. Valid values are ${(0, text_1.commaSeparatedValues)([
+            auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD,
+            auth_1.OAUTH_AUTH_METHOD,
+            auth_1.API_KEY_AUTH_METHOD,
         ].map(method => method.value))}.`);
     }
     if (authType === 'oauth2') {
         if (typeof auth !== 'object') {
-            logger.error(`The OAuth2 auth configuration for account ${accountId} is missing`);
+            logger_1.logger.error(`The OAuth2 auth configuration for account ${accountId} is missing`);
             return false;
         }
         const { clientId, clientSecret, tokenInfo } = auth;
         if (!clientId || !clientSecret || !tokenInfo || !tokenInfo.refreshToken) {
-            logger.error(`The OAuth2 configuration for account ${accountId} is incorrect`);
-            logger.error('Run "hs auth --type=oauth2" to reauthenticate');
+            logger_1.logger.error(`The OAuth2 configuration for account ${accountId} is incorrect`);
+            logger_1.logger.error('Run "hs auth --type=oauth2" to reauthenticate');
             return false;
         }
-        const oauth = getOauthManager(accountId, accountConfig);
+        const oauth = (0, oauth_1.getOauthManager)(accountId, accountConfig);
         try {
-            const accessToken = await oauth.accessToken();
+            let accessToken;
+            if (oauth) {
+                accessToken = await oauth.accessToken();
+            }
             if (!accessToken) {
-                logger.error(`The OAuth2 access token could not be found for accountId ${accountId}`);
+                logger_1.logger.error(`The OAuth2 access token could not be found for accountId ${accountId}`);
                 return false;
             }
         }
         catch (e) {
-            logger.error(e.message);
+            (0, index_1.logError)(e);
             return false;
         }
     }
     else if (authType === 'personalaccesskey') {
         if (!personalAccessKey) {
-            logger.error(`The account "${accountId}" is configured to use a access key for authentication and is missing a "personalAccessKey" in the configuration file`);
+            logger_1.logger.error(`The account "${accountId}" is configured to use a access key for authentication and is missing a "personalAccessKey" in the configuration file`);
             return false;
         }
         try {
-            const accessToken = await accessTokenForPersonalAccessKey(accountId);
+            const accessToken = await (0, personalAccessKey_1.accessTokenForPersonalAccessKey)(accountId);
             if (!accessToken) {
-                logger.error(`An OAuth2 access token for account "${accountId} could not be retrieved using the "personalAccessKey" provided`);
+                logger_1.logger.error(`An OAuth2 access token for account "${accountId} could not be retrieved using the "personalAccessKey" provided`);
                 return false;
             }
         }
         catch (e) {
-            logError(e);
+            (0, index_1.logError)(e);
             return false;
         }
     }
     else if (!apiKey) {
-        logger.error(`The accountId ${accountId} is missing authentication configuration`);
+        logger_1.logger.error(`The accountId ${accountId} is missing authentication configuration`);
         return false;
     }
     return true;
 }
-/**
- * @param {object} command options
- * @returns {boolean}
- */
-function validateMode(options) {
-    const mode = getMode(options);
-    if (MODE[mode]) {
+function validateCmsPublishMode(options) {
+    const cmsPublishMode = (0, commonOpts_1.getCmsPublishMode)(options);
+    if (files_1.CMS_PUBLISH_MODE[cmsPublishMode]) {
         return true;
     }
-    const modesMessage = `Available modes are: ${Object.values(MODE).join(', ')}.`;
-    if (mode != null) {
-        logger.error([`The mode "${mode}" is invalid.`, modesMessage].join(' '));
+    const modesMessage = `Available CMS publish modes are: ${Object.values(files_1.CMS_PUBLISH_MODE).join(', ')}.`;
+    if (cmsPublishMode != null) {
+        logger_1.logger.error([
+            `The CMS publish mode "${cmsPublishMode}" is invalid.`,
+            modesMessage,
+        ].join(' '));
     }
     else {
-        logger.error(['The mode option is missing.', modesMessage].join(' '));
+        logger_1.logger.error(['The CMS publish mode option is missing.', modesMessage].join(' '));
     }
     return false;
 }
-const fileExists = _path => {
+function fileExists(_path) {
     let isFile;
     try {
-        const absoluteSrcPath = path.resolve(getCwd(), _path);
+        const absoluteSrcPath = path.resolve((0, path_1.getCwd)(), _path);
         if (!absoluteSrcPath)
             return false;
         const stats = fs.statSync(absoluteSrcPath);
         isFile = stats.isFile();
         if (!isFile) {
-            logger.error(`The path "${_path}" is not a path to a file`);
+            logger_1.logger.error(`The path "${_path}" is not a path to a file`);
             return false;
         }
     }
     catch (e) {
-        logger.error(`The path "${_path}" is not a path to a file`);
+        logger_1.logger.error(`The path "${_path}" is not a path to a file`);
         return false;
     }
     return true;
-};
-const checkAndConvertToJson = _path => {
-    const filePath = getAbsoluteFilePath(_path);
+}
+function checkAndConvertToJson(_path) {
+    const filePath = (0, path_1.getAbsoluteFilePath)(_path);
     if (!fileExists(filePath))
-        return false;
-    if (getExt(_path) !== 'json') {
-        logger.error(`The file "${_path}" must be a valid JSON file`);
+        return null;
+    if ((0, path_1.getExt)(_path) !== 'json') {
+        logger_1.logger.error(`The file "${_path}" must be a valid JSON file`);
         return null;
     }
     let result;
@@ -165,15 +179,8 @@ const checkAndConvertToJson = _path => {
         result = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
     }
     catch (e) {
-        logger.error(`The file "${_path}" contains invalid JSON`);
+        logger_1.logger.error(`The file "${_path}" contains invalid JSON`);
         result = null;
     }
     return result;
-};
-module.exports = {
-    validateMode,
-    validateAccount,
-    checkAndConvertToJson,
-    fileExists,
-    loadAndValidateOptions,
-};
+}

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@hubspot/cli",
-    "version": "6.4.0",
+    "version": "7.0.0-beta.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "dependencies": {
-        "@hubspot/local-dev-lib": "2.3.0",
+        "@hubspot/local-dev-lib": "3.1.0",
         "@hubspot/serverless-dev-runtime": "7.0.0",
-        "@hubspot/theme-preview-dev-server": "0.0.9",
+        "@hubspot/theme-preview-dev-server": "0.0.10",
         "@hubspot/ui-extensions-dev-server": "0.8.33",
         "archiver": "^7.0.1",
         "chalk": "^4.1.2",
@@ -26,13 +26,18 @@
         "table": "^6.6.0",
         "tmp": "^0.2.1",
         "update-notifier": "^5.1.0",
-        "yargs": "17.7.2"
+        "yargs": "17.7.2",
+        "yargs-parser": "^21.1.1"
     },
     "devDependencies": {
+        "@types/archiver": "^6.0.3",
+        "@types/express": "^5.0.0",
+        "@types/findup-sync": "^4.0.5",
         "@types/fs-extra": "^11.0.4",
         "@types/jest": "^29.5.14",
         "@types/js-yaml": "^4.0.9",
         "@types/semver": "^7.5.8",
+        "@types/tmp": "^0.2.6",
         "@types/yargs": "^17.0.33",
         "@typescript-eslint/eslint-plugin": "^8.11.0",
         "@typescript-eslint/parser": "^8.11.0",
@@ -44,7 +49,7 @@
         "lint-staged": "^10.5.4",
         "madge": "^8.0.0",
         "mock-stdin": "^1.0.0",
-        "prettier": "^1.19.1",
+        "prettier": "^3.4.2",
         "semver": "^7.6.3",
         "ts-jest": "^29.2.5",
         "ts-node": "^10.9.2",
@@ -56,7 +61,8 @@
     "scripts": {
         "build": "ts-node ./scripts/build.ts",
         "lint": "eslint . && prettier --list-different ./**/*.{js,json}",
-        "prettier:write": "prettier --write ./**/*.{js,json}",
+        "list-all-commands": "yarn ts-node ./scripts/get-all-commands.ts",
+        "prettier:write": "prettier --write ./**/*.{ts,js,json}",
         "test": "jest",
         "test-cli": "yarn --cwd 'acceptance-tests' test-ci",
         "test-cli-debug": "yarn --cwd 'acceptance-tests' test-debug",

package/types/Projects.d.ts

@@ -0,0 +1,43 @@
+import { Build, SubbuildStatus } from '@hubspot/local-dev-lib/types/Build';
+import { Deploy, SubdeployStatus } from '@hubspot/local-dev-lib/types/Deploy';
+export type ProjectTemplate = {
+    name: string;
+    label: string;
+    path: string;
+    insertPath: string;
+};
+export type ComponentTemplate = {
+    label: string;
+    path: string;
+    insertPath: string;
+};
+export type ProjectConfig = {
+    name: string;
+    srcDir: string;
+    platformVersion: string;
+};
+export type ProjectTaskStates = {
+    BUILDING?: string;
+    ENQUEUED?: string;
+    DEPLOYING?: string;
+    FAILURE: string;
+    PENDING: string;
+    SUCCESS: string;
+};
+export type ProjectTask = Build | Deploy;
+export type ProjectSubtask = SubbuildStatus | SubdeployStatus;
+export type ProjectPollStatusFunctionText = {
+    STATES: ProjectTaskStates;
+    STATUS_TEXT: string;
+    TYPE_KEY: string;
+    SUBTASK_NAME_KEY: string;
+};
+export type ProjectAddComponentData = {
+    path: string;
+    label: string;
+    insertPath: string;
+};
+export type ProjectTemplateRepoConfig = {
+    projects?: ProjectTemplate[];
+    components?: ComponentTemplate[];
+};

package/types/Projects.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Prompts.d.ts

@@ -0,0 +1,25 @@
+export type GenericPromptResponse = {
+    [key: string]: any;
+};
+type PromptType = 'confirm' | 'list' | 'checkbox' | 'input' | 'password' | 'number' | 'rawlist';
+export type PromptChoices = Array<string | {
+    name: string;
+    value?: any;
+    disabled?: string | boolean;
+}>;
+export type PromptWhen = boolean | (() => boolean);
+type PromptOperand = string | number | boolean | string[] | boolean[] | null;
+export type PromptConfig<T extends GenericPromptResponse> = {
+    name: keyof T;
+    type?: PromptType;
+    message?: string | ((answers: T) => string);
+    choices?: PromptChoices;
+    when?: PromptWhen;
+    pageSize?: number;
+    default?: PromptOperand | ((answers: T) => PromptOperand);
+    transformer?: (input: string) => string | undefined;
+    validate?: (answer?: any) => PromptOperand | Promise<PromptOperand>;
+    mask?: string;
+    filter?: (input: string) => string;
+};
+export {};