@hubspot/cli 7.0.0-experimental.1 → 7.0.1-experimental.0

package/lib/generateSelectors.d.ts

@@ -1 +1,20 @@
+export declare function getMaxFieldsDepth(): number;
+export declare function findFieldsJsonPath(basePath: string): string | null;
+export declare function combineThemeCss(basePath: string, cssString?: string): string | null;
+type Field = {
+    name: string;
+    children: Field[];
+    selectors?: string[];
+    inherited_value?: {
+        property_value_paths?: {
+            [key: string]: string;
+        };
+    };
+};
+export declare function setPreviewSelectors(fields: Field[], fieldPath: string[], selectors: string[], depth?: number): Field[];
+export declare function generateInheritedSelectors(fields: Field[]): Field[];
+type SelectorsMap = {
+    [key: string]: string[] | undefined;
+};
+export declare function generateSelectorsMap(fields: Field[], fieldKey?: string[]): SelectorsMap;
 export {};

package/lib/generateSelectors.js

@@ -1,10 +1,18 @@
 "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 fs = require('fs');
-const { EXIT_CODES } = require('./enums/exitCodes');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { i18n } = require('./lang');
+exports.getMaxFieldsDepth = getMaxFieldsDepth;
+exports.findFieldsJsonPath = findFieldsJsonPath;
+exports.combineThemeCss = combineThemeCss;
+exports.setPreviewSelectors = setPreviewSelectors;
+exports.generateInheritedSelectors = generateInheritedSelectors;
+exports.generateSelectorsMap = generateSelectorsMap;
+const fs_1 = __importDefault(require("fs"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const exitCodes_1 = require("./enums/exitCodes");
+const lang_1 = require("./lang");
 const CSS_COMMENTS_REGEX = new RegExp(/\/\*.*\*\//, 'g');
 const CSS_PSEUDO_CLASS_REGEX = new RegExp(/:active|:checked|:disabled|:empty|:enabled|:first-of-type|:focus|:hover|:in-range|:invalid|:link|:optional|:out-of-range|:read-only|:read-write|:required|:target|:valid|:visited/, 'g');
 const i18nKey = 'commands.theme.subcommands.generateSelectors';
@@ -14,19 +22,19 @@ function getMaxFieldsDepth() {
 }
 function findFieldsJsonPath(basePath) {
     const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
-    if (!fs.existsSync(_path)) {
-        logger.error(i18n(`${i18nKey}.errors.invalidPath`, {
+    if (!fs_1.default.existsSync(_path)) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidPath`, {
             themePath: basePath,
         }));
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    const files = fs.readdirSync(_path);
+    const files = fs_1.default.readdirSync(_path);
     if (files.includes('fields.json')) {
         return `${_path}/fields.json`;
     }
     for (let i = 0; i < files.length; i++) {
         const fileName = files[i];
-        const isDirectory = fs.lstatSync(`${_path}/${fileName}`).isDirectory();
+        const isDirectory = fs_1.default.lstatSync(`${_path}/${fileName}`).isDirectory();
         if (isDirectory && !fileName.includes('.module')) {
             const fieldsJsonPath = findFieldsJsonPath(`${_path}/${fileName}`);
             if (fieldsJsonPath)
@@ -37,16 +45,16 @@ function findFieldsJsonPath(basePath) {
 }
 function combineThemeCss(basePath, cssString = '') {
     const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
-    const isDirectory = fs.lstatSync(_path).isDirectory();
+    const isDirectory = fs_1.default.lstatSync(_path).isDirectory();
     if (isDirectory) {
-        const filesList = fs.readdirSync(_path);
+        const filesList = fs_1.default.readdirSync(_path);
         return filesList.reduce((css, fileName) => {
             const newCss = combineThemeCss(`${_path}/${fileName}`);
             return newCss ? `${css}\n${newCss}` : css;
         }, cssString);
     }
     else if (_path.includes('.css') && !_path.includes('.module')) {
-        return `${cssString}\n${fs.readFileSync(_path, 'utf8')}`;
+        return `${cssString}\n${fs_1.default.readFileSync(_path, 'utf8')}`;
     }
     return null;
 }
@@ -78,7 +86,7 @@ function setPreviewSelectors(fields, fieldPath, selectors, depth = 0) {
 }
 function generateInheritedSelectors(fields) {
     let finalFieldsJson = [...fields];
-    const _generateInheritedSelectors = fieldsToCheck => {
+    function _generateInheritedSelectors(fieldsToCheck) {
         fieldsToCheck.forEach(field => {
             if (field.children) {
                 _generateInheritedSelectors(field.children);
@@ -94,7 +102,7 @@ function generateInheritedSelectors(fields) {
                 });
             }
         });
-    };
+    }
     _generateInheritedSelectors(fields);
     return finalFieldsJson;
 }
@@ -115,11 +123,3 @@ function generateSelectorsMap(fields, fieldKey = []) {
     });
     return selectorsMap;
 }
-module.exports = {
-    findFieldsJsonPath,
-    combineThemeCss,
-    setPreviewSelectors,
-    generateInheritedSelectors,
-    generateSelectorsMap,
-    getMaxFieldsDepth,
-};

package/lib/localDev.js

@@ -19,7 +19,8 @@ const { i18n } = require('./lang');
 const { EXIT_CODES } = require('./enums/exitCodes');
 const { trackCommandMetadataUsage } = require('./usageTracking');
 const { isAppDeveloperAccount, isDeveloperTestAccount, } = require('./accountTypes');
-const { handleProjectUpload, pollProjectBuildAndDeploy, } = require('./projects');
+const { handleProjectUpload } = require('./projects/upload');
+const { pollProjectBuildAndDeploy } = require('./projects/buildAndDeploy');
 const { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } = require('./constants');
 const { logError, ApiErrorContext } = require('./errorHandlers/index');
 const { PERSONAL_ACCESS_KEY_AUTH_METHOD, } = require('@hubspot/local-dev-lib/constants/auth');

package/lib/marketplaceValidate.d.ts

@@ -1 +1,6 @@
-export {};
+import { GetValidationResultsResponse } from '@hubspot/local-dev-lib/types/MarketplaceValidation';
+export declare function kickOffValidation(accountId: number, assetType: string, src: string): Promise<number>;
+export declare function pollForValidationFinish(accountId: number, validationId: string): Promise<void>;
+export declare function fetchValidationResults(accountId: number, validationId: string): Promise<GetValidationResultsResponse>;
+export declare function processValidationErrors(i18nKey: string, validationResults: GetValidationResultsResponse): void;
+export declare function displayValidationResults(i18nKey: string, validationResults: GetValidationResultsResponse): void;

package/lib/marketplaceValidate.js

@@ -1,16 +1,23 @@
 "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 chalk = require('chalk');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { requestValidation, getValidationStatus, getValidationResults, } = require('@hubspot/local-dev-lib/api/marketplaceValidation');
-const { i18n } = require('./lang');
-const { EXIT_CODES } = require('./enums/exitCodes');
+exports.kickOffValidation = kickOffValidation;
+exports.pollForValidationFinish = pollForValidationFinish;
+exports.fetchValidationResults = fetchValidationResults;
+exports.processValidationErrors = processValidationErrors;
+exports.displayValidationResults = displayValidationResults;
+const chalk_1 = __importDefault(require("chalk"));
+const marketplaceValidation_1 = require("@hubspot/local-dev-lib/api/marketplaceValidation");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const lang_1 = require("./lang");
+const exitCodes_1 = require("./enums/exitCodes");
 const SLEEP_TIME = 2000;
-const kickOffValidation = async (accountId, assetType, src) => {
+async function kickOffValidation(accountId, assetType, src) {
     const requestGroup = 'EXTERNAL_DEVELOPER';
     try {
-        const { data: requestResult } = await requestValidation(accountId, {
+        const { data: requestResult } = await (0, marketplaceValidation_1.requestValidation)(accountId, {
             path: src,
             assetType,
             requestGroup,
@@ -18,14 +25,14 @@ const kickOffValidation = async (accountId, assetType, src) => {
         return requestResult;
     }
     catch (err) {
-        logger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.logger.debug(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-};
-const pollForValidationFinish = async (accountId, validationId) => {
+}
+async function pollForValidationFinish(accountId, validationId) {
     try {
         const checkValidationStatus = async () => {
-            const { data: validationStatus } = await getValidationStatus(accountId, {
+            const { data: validationStatus } = await (0, marketplaceValidation_1.getValidationStatus)(accountId, {
                 validationId,
             });
             if (validationStatus === 'REQUESTED') {
@@ -36,89 +43,81 @@ const pollForValidationFinish = async (accountId, validationId) => {
         await checkValidationStatus();
     }
     catch (err) {
-        logger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.logger.debug(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-};
-const fetchValidationResults = async (accountId, validationId) => {
+}
+async function fetchValidationResults(accountId, validationId) {
     try {
-        const { data: validationResults } = await getValidationResults(accountId, {
+        const { data: validationResults } = await (0, marketplaceValidation_1.getValidationResults)(accountId, {
             validationId,
         });
         return validationResults;
     }
     catch (err) {
-        logger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.logger.debug(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-};
-const processValidationErrors = (i18nKey, validationResults) => {
+}
+function processValidationErrors(i18nKey, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
             if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
-                logger.error(i18n(`${i18nKey}.errors.invalidPath`, {
+                logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidPath`, {
                     path: assetPath,
                 }));
             }
             else {
-                logger.error(`${err.context}`);
+                logger_1.logger.error(`${err.context}`);
             }
         });
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-};
-const displayValidationResults = (i18nKey, validationResults) => {
-    const displayResults = checks => {
-        const displayFileInfo = (file, line) => {
-            if (file) {
-                logger.log(i18n(`${i18nKey}.results.warnings.file`, {
-                    file,
-                }));
-            }
-            if (line) {
-                logger.log(i18n(`${i18nKey}.results.warnings.lineNumber`, {
-                    line,
-                }));
-            }
-            return null;
-        };
-        if (checks) {
-            const { status, results } = checks;
-            if (status === 'FAIL') {
-                const failedValidations = results.filter(test => test.status === 'FAIL');
-                const warningValidations = results.filter(test => test.status === 'WARN');
-                failedValidations.forEach(val => {
-                    logger.error(`${val.message}`);
-                    displayFileInfo(val.file, val.line);
-                });
-                warningValidations.forEach(val => {
-                    logger.warn(`${val.message}`);
-                    displayFileInfo(val.file, val.line);
-                });
-            }
-            if (status === 'PASS') {
-                logger.success(i18n(`${i18nKey}.results.noErrors`));
-                results.forEach(test => {
-                    if (test.status === 'WARN') {
-                        logger.warn(`${test.message}`);
-                        displayFileInfo(test.file, test.line);
-                    }
-                });
-            }
+}
+function displayFileInfo(file, line, i18nKey) {
+    if (file) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.file`, {
+            file,
+        }));
+    }
+    if (line) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.lineNumber`, {
+            line,
+        }));
+    }
+}
+function displayResults(checks, i18nKey) {
+    if (checks) {
+        const { status, results } = checks;
+        if (status === 'FAIL') {
+            const failedValidations = results.filter(test => test.status === 'FAIL');
+            const warningValidations = results.filter(test => test.status === 'WARN');
+            failedValidations.forEach(val => {
+                logger_1.logger.error(`${val.message}`);
+                displayFileInfo(val.file, val.line, i18nKey);
+            });
+            warningValidations.forEach(val => {
+                logger_1.logger.warn(`${val.message}`);
+                displayFileInfo(val.file, val.line, i18nKey);
+            });
         }
-        return null;
-    };
+        if (status === 'PASS') {
+            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.results.noErrors`));
+            results.forEach(test => {
+                if (test.status === 'WARN') {
+                    logger_1.logger.warn(`${test.message}`);
+                    displayFileInfo(test.file, test.line, i18nKey);
+                }
+            });
+        }
+    }
+    return;
+}
+function displayValidationResults(i18nKey, validationResults) {
     Object.keys(validationResults.results).forEach(type => {
-        logger.log(chalk.bold(i18n(`${i18nKey}.results.${type.toLowerCase()}`)));
-        displayResults(validationResults.results[type]);
-        logger.log();
+        logger_1.logger.log(chalk_1.default.bold((0, lang_1.i18n)(`${i18nKey}.results.${type.toLowerCase()}`)));
+        displayResults(validationResults.results[type], i18nKey);
+        logger_1.logger.log();
     });
-};
-module.exports = {
-    kickOffValidation,
-    pollForValidationFinish,
-    fetchValidationResults,
-    processValidationErrors,
-    displayValidationResults,
-};
+}

package/lib/oauth.d.ts

@@ -1 +1,2 @@
-export {};
+import { OAuth2ManagerAccountConfig } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function authenticateWithOauth(accountConfig: OAuth2ManagerAccountConfig): Promise<void>;

package/lib/oauth.js

@@ -1,38 +1,53 @@
 "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 express = require('express');
-const open = require('open');
-const { OAuth2Manager, } = require('@hubspot/local-dev-lib/models/OAuth2Manager');
-const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
-const { addOauthToAccountConfig } = require('@hubspot/local-dev-lib/oauth');
-const { handleExit } = require('./process');
-const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { ENVIRONMENTS, } = require('@hubspot/local-dev-lib/constants/environments');
+exports.authenticateWithOauth = authenticateWithOauth;
+const express_1 = __importDefault(require("express"));
+const open_1 = __importDefault(require("open"));
+const OAuth2Manager_1 = require("@hubspot/local-dev-lib/models/OAuth2Manager");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
+const oauth_1 = require("@hubspot/local-dev-lib/oauth");
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const process_1 = require("./process");
+const lang_1 = require("./lang");
+const exitCodes_1 = require("./enums/exitCodes");
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
-const buildAuthUrl = oauthManager => {
-    return (`${getHubSpotWebsiteOrigin(oauthManager.account.env)}/oauth/${oauthManager.account.accountId}/authorize` +
-        `?client_id=${encodeURIComponent(oauthManager.account.clientId)}` + // app's client ID
-        `&scope=${encodeURIComponent(oauthManager.account.scopes.join(' '))}` + // scopes being requested by the app
+const i18nKey = 'lib.oauth';
+function buildAuthUrl(oauthManager) {
+    const { env: accountEnv, clientId, scopes: accountScopes, } = oauthManager.account;
+    const env = accountEnv || environments_1.ENVIRONMENTS.PROD;
+    const scopes = accountScopes || auth_1.DEFAULT_OAUTH_SCOPES;
+    if (!clientId) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.missingClientId`));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    return (`${(0, urls_1.getHubSpotWebsiteOrigin)(env)}/oauth/${oauthManager.account.accountId}/authorize` +
+        `?client_id=${encodeURIComponent(clientId)}` + // app's client ID
+        `&scope=${encodeURIComponent(scopes.join(' '))}` + // scopes being requested by the app
         `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
     );
-};
-const handleServerOnProcessEnd = server => {
+}
+function handleServerOnProcessEnd(server) {
     const shutdownServerIfRunning = () => {
         server?.close();
     };
-    handleExit(shutdownServerIfRunning);
-};
-const authorize = async (oauthManager) => {
+    (0, process_1.handleExit)(shutdownServerIfRunning);
+}
+async function authorize(oauthManager) {
     if (process.env.BROWSER !== 'none') {
-        open(buildAuthUrl(oauthManager), { url: true });
+        (0, open_1.default)(buildAuthUrl(oauthManager), { url: true });
     }
     // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
         let server;
-        const app = express();
+        const app = (0, express_1.default)();
         app.get('/oauth-callback', async (req, res) => {
             if (req.query.code) {
                 const authCodeProof = {
@@ -69,24 +84,21 @@ const authorize = async (oauthManager) => {
                 reject();
             }
         });
-        server = app.listen(PORT, () => logger.log(`Waiting for authorization...`));
+        server = app.listen(PORT, () => logger_1.logger.log(`Waiting for authorization...`));
         handleServerOnProcessEnd(server);
     });
-};
-const setupOauth = accountConfig => {
-    const accountId = parseInt(accountConfig.portalId, 10);
-    const config = getAccountConfig(accountId) || {};
-    return new OAuth2Manager({
+}
+function setupOauth(accountConfig) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
+    const config = (0, config_1.getAccountConfig)(accountId);
+    return new OAuth2Manager_1.OAuth2Manager({
         ...accountConfig,
-        environment: accountConfig.env || config.env || ENVIRONMENTS.PROD,
+        env: accountConfig.env || config?.env || environments_1.ENVIRONMENTS.PROD,
     });
-};
-const authenticateWithOauth = async (configData) => {
-    const oauthManager = setupOauth(configData);
-    logger.log('Authorizing');
+}
+async function authenticateWithOauth(accountConfig) {
+    const oauthManager = setupOauth(accountConfig);
+    logger_1.logger.log('Authorizing');
     await authorize(oauthManager);
-    addOauthToAccountConfig(oauthManager);
-};
-module.exports = {
-    authenticateWithOauth,
-};
+    (0, oauth_1.addOauthToAccountConfig)(oauthManager);
+}

package/lib/polling.d.ts

@@ -1 +1,9 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
+import { POLLING_STATUS } from './constants';
+type GenericPollingResponse = {
+    status: ValueOf<typeof POLLING_STATUS>;
+};
+type PollingCallback<T extends GenericPollingResponse> = (accountId: number, taskId: number | string) => HubSpotPromise<T>;
+export declare function poll<T extends GenericPollingResponse>(callback: PollingCallback<T>, accountId: number, taskId: number | string): Promise<T>;
 export {};

package/lib/polling.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const { POLLING_DELAY, POLLING_STATUS } = require('./constants');
-const poll = (callback, accountId, taskId) => {
+exports.poll = poll;
+const constants_1 = require("./constants");
+function poll(callback, accountId, taskId) {
     return new Promise((resolve, reject) => {
         const pollInterval = setInterval(async () => {
             try {
                 const { data: pollResp } = await callback(accountId, taskId);
                 const { status } = pollResp;
-                if (status === POLLING_STATUS.SUCCESS) {
+                if (status === constants_1.POLLING_STATUS.SUCCESS) {
                     clearInterval(pollInterval);
                     resolve(pollResp);
                 }
-                else if (status === POLLING_STATUS.ERROR ||
-                    status === POLLING_STATUS.REVERTED ||
-                    status === POLLING_STATUS.FAILURE) {
+                else if (status === constants_1.POLLING_STATUS.ERROR ||
+                    status === constants_1.POLLING_STATUS.REVERTED ||
+                    status === constants_1.POLLING_STATUS.FAILURE) {
                     clearInterval(pollInterval);
                     reject(pollResp);
                 }
@@ -23,9 +23,6 @@ const poll = (callback, accountId, taskId) => {
                 clearInterval(pollInterval);
                 reject(error);
             }
-        }, POLLING_DELAY);
+        }, constants_1.POLLING_DELAY);
     });
-};
-module.exports = {
-    poll,
-};
+}

package/lib/projects/ProjectLogsManager.d.ts

@@ -0,0 +1,20 @@
+import { AppFunctionComponentMetadata } from '@hubspot/local-dev-lib/types/ComponentStructure';
+declare class _ProjectLogsManager {
+    projectName: string | undefined;
+    projectId: number | undefined;
+    accountId: number | undefined;
+    functions: AppFunctionComponentMetadata[];
+    selectedFunction: AppFunctionComponentMetadata | undefined;
+    functionName: string | undefined;
+    appId: number | undefined;
+    isPublicFunction: boolean | undefined;
+    endpointName: string | undefined;
+    reset(): void;
+    constructor();
+    init(accountId: number): Promise<void>;
+    fetchFunctionDetails(): Promise<void>;
+    getFunctionNames(): string[];
+    setFunction(functionName: string): void;
+}
+export declare const ProjectLogsManager: _ProjectLogsManager;
+export {};

package/lib/projects/ProjectLogsManager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLogsManager = void 0;
+const index_1 = require("./index");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const lang_1 = require("../lang");
+const ui_1 = require("../ui");
+const i18nKey = 'commands.project.subcommands.logs';
+class _ProjectLogsManager {
+    projectName;
+    projectId;
+    accountId;
+    functions;
+    selectedFunction;
+    functionName;
+    appId;
+    isPublicFunction;
+    endpointName;
+    reset() {
+        this.projectName = undefined;
+        this.projectId = undefined;
+        this.accountId = undefined;
+        this.functions = [];
+        this.selectedFunction = undefined;
+        this.functionName = undefined;
+        this.appId = undefined;
+        this.isPublicFunction = undefined;
+        this.endpointName = undefined;
+    }
+    constructor() {
+        this.functions = [];
+    }
+    async init(accountId) {
+        const { projectConfig } = await (0, index_1.getProjectConfig)();
+        if (!projectConfig || !projectConfig.name) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`));
+        }
+        const { name: projectName } = projectConfig;
+        this.projectName = projectName;
+        this.accountId = accountId;
+        this.functions = [];
+        const { project } = await (0, index_1.ensureProjectExists)(this.accountId, this.projectName, {
+            allowCreate: false,
+        });
+        if (!project ||
+            !project.deployedBuild ||
+            !project.deployedBuild.subbuildStatuses) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchProjectDetails`));
+        }
+        this.projectId = project.id;
+        await this.fetchFunctionDetails();
+    }
+    async fetchFunctionDetails() {
+        if (!this.projectId) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`));
+        }
+        if (!this.accountId) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.projectLogsManagerNotInitialized`));
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.generic`));
+        }
+        const { data: { topLevelComponentMetadata }, } = await (0, projects_1.fetchProjectComponentsMetadata)(this.accountId, this.projectId);
+        const apps = topLevelComponentMetadata.filter(componentMetadata => {
+            const { type } = componentMetadata;
+            return type && type.name === 'PRIVATE_APP';
+        });
+        apps.forEach(app => {
+            this.functions.push(
+            // If component type is APP_FUNCTION, we can safely cast as AppFunctionComponentMetadata
+            ...app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION'));
+        });
+        if (this.functions.length === 0) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsInProject`, {
+                link: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsLinkText`), 'https://developers.hubspot.com/docs/platform/serverless-functions'),
+            }));
+        }
+    }
+    getFunctionNames() {
+        return this.functions.map(serverlessFunction => serverlessFunction.componentName);
+    }
+    setFunction(functionName) {
+        if (!(this.functions.length > 0)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsInProject`, {
+                link: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsLinkText`), 'https://developers.hubspot.com/docs/platform/serverless-functions'),
+            }));
+        }
+        this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
+        if (!this.selectedFunction) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionWithName`, { name: functionName }));
+        }
+        this.functionName = functionName;
+        if (!this.selectedFunction.deployOutput) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.functionNotDeployed`, { name: functionName }));
+        }
+        this.appId = this.selectedFunction.deployOutput.appId;
+        if (this.selectedFunction.deployOutput.endpoint) {
+            this.endpointName = this.selectedFunction.deployOutput.endpoint.path;
+            this.isPublicFunction = true;
+        }
+        else {
+            this.isPublicFunction = false;
+        }
+    }
+}
+exports.ProjectLogsManager = new _ProjectLogsManager();

package/lib/projects/buildAndDeploy.d.ts

@@ -0,0 +1,16 @@
+import { FileResult } from 'tmp';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
+import { ProjectConfig, ProjectTask } from '../../types/Projects';
+type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskName: string, taskId: number, deployedBuildId: number | null, silenceLogs: boolean) => Promise<T>;
+export declare const pollBuildStatus: PollTaskStatusFunction<Build>;
+export declare const pollDeployStatus: PollTaskStatusFunction<Deploy>;
+type ProjectPollResult = {
+    succeeded: boolean;
+    buildId: number;
+    buildResult: Build;
+    deployResult: Deploy | null;
+};
+export declare function displayWarnLogs(accountId: number, projectName: string, taskId: number, isDeploy?: boolean): Promise<void>;
+export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, silenceLogs?: boolean): Promise<ProjectPollResult>;
+export {};