@hubspot/cli 6.4.0 → 7.0.0-beta.0

package/lib/projects/index.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeProjectConfig = writeProjectConfig;
+exports.getIsInProject = getIsInProject;
+exports.getProjectConfig = getProjectConfig;
+exports.createProjectConfig = createProjectConfig;
+exports.validateProjectConfig = validateProjectConfig;
+exports.ensureProjectExists = ensureProjectExists;
+exports.logFeedbackMessage = logFeedbackMessage;
+exports.createProjectComponent = createProjectComponent;
+exports.getProjectComponentsByVersion = getProjectComponentsByVersion;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+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");
+const ui_1 = require("../ui");
+const lang_1 = require("../lang");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const index_2 = require("../errorHandlers/index");
+const i18nKey = 'lib.projects';
+function writeProjectConfig(configPath, config) {
+    try {
+        fs_extra_1.default.ensureFileSync(configPath);
+        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        logger_1.logger.debug(`Wrote project config at ${configPath}`);
+    }
+    catch (e) {
+        logger_1.logger.debug(e);
+        return false;
+    }
+    return true;
+}
+function getIsInProject(dir) {
+    const configPath = getProjectConfigPath(dir);
+    return !!configPath;
+}
+function getProjectConfigPath(dir) {
+    const projectDir = dir ? (0, path_2.getAbsoluteFilePath)(dir) : (0, path_2.getCwd)();
+    const configPath = (0, findup_sync_1.default)(constants_1.PROJECT_CONFIG_FILE, {
+        cwd: projectDir,
+        nocase: true,
+    });
+    return configPath;
+}
+async function getProjectConfig(dir) {
+    const configPath = await getProjectConfigPath(dir);
+    if (!configPath) {
+        return { projectConfig: null, projectDir: null };
+    }
+    try {
+        const config = fs_extra_1.default.readFileSync(configPath);
+        const projectConfig = JSON.parse(config.toString());
+        return {
+            projectDir: path_1.default.dirname(configPath),
+            projectConfig,
+        };
+    }
+    catch (e) {
+        logger_1.logger.error('Could not read from project config');
+        return { projectConfig: null, projectDir: null };
+    }
+}
+async function createProjectConfig(projectPath, projectName, template, templateSource, githubRef) {
+    const { projectConfig, projectDir } = await getProjectConfig(projectPath);
+    if (projectConfig) {
+        logger_1.logger.warn(projectPath === projectDir
+            ? 'A project already exists in that location.'
+            : `Found an existing project definition in ${projectDir}.`);
+        const { shouldContinue } = await (0, promptUtils_1.promptUser)([
+            {
+                name: 'shouldContinue',
+                message: () => {
+                    return projectPath === projectDir
+                        ? 'Do you want to overwrite the existing project definition with a new one?'
+                        : `Continue creating a new project in ${projectPath}?`;
+                },
+                type: 'confirm',
+                default: false,
+            },
+        ]);
+        if (!shouldContinue) {
+            return false;
+        }
+    }
+    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);
+    const _config = JSON.parse(fs_extra_1.default.readFileSync(projectConfigPath).toString());
+    writeProjectConfig(projectConfigPath, {
+        ..._config,
+        name: projectName,
+    });
+    if (template.name === 'no-template') {
+        fs_extra_1.default.ensureDirSync(path_1.default.join(projectPath, 'src'));
+    }
+    return true;
+}
+function validateProjectConfig(projectConfig, projectDir) {
+    if (!projectConfig) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.configNotFound`, {
+            createCommand: (0, ui_1.uiCommandReference)('hs project create'),
+        }));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (!projectConfig.name || !projectConfig.srcDir) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.configMissingFields`));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const resolvedPath = path_1.default.resolve(projectDir, projectConfig.srcDir);
+    if (!resolvedPath.startsWith(projectDir)) {
+        const projectConfigFile = path_1.default.relative('.', path_1.default.join(projectDir, constants_1.PROJECT_CONFIG_FILE));
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.srcOutsideProjectDir`, {
+            srcDir: projectConfig.srcDir,
+            projectConfig: projectConfigFile,
+        }));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    if (!fs_extra_1.default.existsSync(resolvedPath)) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateProjectConfig.srcDirNotFound`, {
+            srcDir: projectConfig.srcDir,
+            projectDir: projectDir,
+        }));
+        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+}
+async function pollFetchProject(accountId, projectName) {
+    // Temporary solution for gating slowness. Retry on 403 statusCode
+    return new Promise((resolve, reject) => {
+        let pollCount = 0;
+        SpinniesManager_1.default.init();
+        SpinniesManager_1.default.add('pollFetchProject', {
+            text: (0, lang_1.i18n)(`${i18nKey}.pollFetchProject.checkingProject`, {
+                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+            }),
+        });
+        const pollInterval = setInterval(async () => {
+            try {
+                const response = await (0, projects_1.fetchProject)(accountId, projectName);
+                if (response && response.data) {
+                    SpinniesManager_1.default.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    resolve(response);
+                }
+            }
+            catch (err) {
+                if ((0, index_1.isSpecifiedError)(err, {
+                    statusCode: 403,
+                    category: 'GATED',
+                    subCategory: 'BuildPipelineErrorType.PORTAL_GATED',
+                }) &&
+                    pollCount < 15) {
+                    pollCount += 1;
+                }
+                else {
+                    SpinniesManager_1.default.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    reject(err);
+                }
+            }
+        }, constants_1.POLLING_DELAY);
+    });
+}
+async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
+    const accountIdentifier = (0, ui_1.uiAccountDescription)(accountId);
+    try {
+        const { data: project } = withPolling
+            ? await pollFetchProject(accountId, projectName)
+            : await (0, projects_1.fetchProject)(accountId, projectName);
+        return { projectExists: !!project, project };
+    }
+    catch (err) {
+        if ((0, index_1.isSpecifiedError)(err, { statusCode: 404 })) {
+            let shouldCreateProject = forceCreate;
+            if (allowCreate && !shouldCreateProject) {
+                const promptKey = uploadCommand ? 'createPromptUpload' : 'createPrompt';
+                const promptResult = await (0, promptUtils_1.promptUser)([
+                    {
+                        name: 'shouldCreateProject',
+                        message: (0, lang_1.i18n)(`${i18nKey}.ensureProjectExists.${promptKey}`, {
+                            projectName,
+                            accountIdentifier,
+                        }),
+                        type: 'confirm',
+                    },
+                ]);
+                shouldCreateProject = promptResult.shouldCreateProject;
+            }
+            if (shouldCreateProject) {
+                try {
+                    const { data: project } = await (0, projects_1.createProject)(accountId, projectName);
+                    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.ensureProjectExists.createSuccess`, {
+                        projectName,
+                        accountIdentifier,
+                    }));
+                    return { projectExists: true, project };
+                }
+                catch (err) {
+                    (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
+                    return { projectExists: false };
+                }
+            }
+            else {
+                if (!noLogs) {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.ensureProjectExists.notFound`, {
+                        projectName,
+                        accountIdentifier,
+                    }));
+                }
+                return { projectExists: false };
+            }
+        }
+        if ((0, index_1.isSpecifiedError)(err, {
+            statusCode: 401,
+        })) {
+            logger_1.logger.error(err.message);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        (0, index_2.logError)(err, new index_2.ApiErrorContext({ accountId }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+}
+function logFeedbackMessage(buildId) {
+    if (buildId > 0 && buildId % constants_1.FEEDBACK_INTERVAL === 0) {
+        (0, ui_1.uiLine)();
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logFeedbackMessage.feedbackHeader`));
+        (0, ui_1.uiLine)();
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.logFeedbackMessage.feedbackMessage`));
+    }
+}
+async function createProjectComponent(component, name, projectComponentsVersion) {
+    const i18nKey = 'commands.project.subcommands.add';
+    const componentName = name;
+    const configInfo = await getProjectConfig();
+    if (!configInfo.projectDir || !configInfo.projectConfig) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.error.locationInProject`));
+        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);
+}
+async function getProjectComponentsByVersion(projectComponentsVersion) {
+    const config = await (0, github_1.fetchFileFromRepository)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', projectComponentsVersion);
+    return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
+}

package/lib/projects/structure.d.ts

@@ -0,0 +1,78 @@
+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>;
+export declare const CONFIG_FILES: {
+    [k in ValueOf<typeof COMPONENT_TYPES>]: 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 {};

package/lib/projects/structure.js

@@ -0,0 +1,151 @@
+"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 });
+exports.CONFIG_FILES = exports.COMPONENT_TYPES = void 0;
+exports.getAppCardConfigs = getAppCardConfigs;
+exports.findProjectComponents = findProjectComponents;
+exports.getProjectComponentTypes = getProjectComponentTypes;
+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',
+};
+exports.CONFIG_FILES = {
+    [exports.COMPONENT_TYPES.privateApp]: 'app.json',
+    [exports.COMPONENT_TYPES.publicApp]: 'public-app.json',
+    [exports.COMPONENT_TYPES.hublTheme]: 'theme.json',
+};
+function getComponentTypeFromConfigFile(configFile) {
+    let key;
+    for (key in exports.CONFIG_FILES) {
+        if (exports.CONFIG_FILES[key] === configFile) {
+            return key;
+        }
+    }
+    return null;
+}
+function loadConfigFile(configPath) {
+    if (configPath) {
+        try {
+            const source = fs.readFileSync(configPath);
+            const parsedConfig = JSON.parse(source.toString());
+            return parsedConfig;
+        }
+        catch (e) {
+            logger_1.logger.debug(e);
+        }
+    }
+    return null;
+}
+function getAppCardConfigs(appConfig, appPath) {
+    const cardConfigs = [];
+    let cards;
+    if (appConfig && appConfig.extensions && appConfig.extensions.crm) {
+        cards = appConfig.extensions.crm.cards;
+    }
+    if (cards) {
+        cards.forEach(({ file }) => {
+            if (typeof file === 'string') {
+                const cardConfigPath = path.join(appPath, file);
+                const cardConfig = loadConfigFile(cardConfigPath);
+                if (cardConfig && 'type' in cardConfig) {
+                    cardConfigs.push(cardConfig);
+                }
+            }
+        });
+    }
+    return cardConfigs;
+}
+function getIsLegacyApp(appConfig, appPath) {
+    let hasAnyReactExtensions = false;
+    if (appConfig && 'extensions' in appConfig) {
+        const cardConfigs = getAppCardConfigs(appConfig, appPath);
+        if (!cardConfigs.length) {
+            // Assume any app that does not have any cards is not legacy
+            return false;
+        }
+        cardConfigs.forEach(cardConfig => {
+            if (!hasAnyReactExtensions) {
+                const isReactExtension = cardConfig &&
+                    !!cardConfig.data &&
+                    !!cardConfig.data.module &&
+                    !!cardConfig.data.module.file;
+                hasAnyReactExtensions = isReactExtension;
+            }
+        });
+    }
+    return !hasAnyReactExtensions;
+}
+async function findProjectComponents(projectSourceDir) {
+    const components = [];
+    let projectFiles = [];
+    try {
+        projectFiles = await (0, fs_1.walk)(projectSourceDir);
+    }
+    catch (e) {
+        (0, index_1.logError)(e);
+    }
+    projectFiles.forEach(projectFile => {
+        // Find app components
+        const { base, dir } = path.parse(projectFile);
+        if (Object.values(exports.CONFIG_FILES).includes(base)) {
+            const parsedConfig = loadConfigFile(projectFile);
+            if (parsedConfig) {
+                const isLegacy = getIsLegacyApp(parsedConfig, dir);
+                const isHublTheme = base === exports.CONFIG_FILES[exports.COMPONENT_TYPES.hublTheme];
+                const componentType = getComponentTypeFromConfigFile(base);
+                if (componentType) {
+                    components.push({
+                        type: componentType,
+                        config: parsedConfig,
+                        runnable: !isLegacy && !isHublTheme,
+                        path: dir,
+                    });
+                }
+            }
+        }
+    });
+    return components;
+}
+function getProjectComponentTypes(components) {
+    const projectContents = {};
+    components.forEach(({ type }) => (projectContents[type] = true));
+    return projectContents;
+}

package/lib/projects/upload.d.ts

@@ -0,0 +1,8 @@
+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 = {
+    uploadError?: unknown;
+};
+export declare function handleProjectUpload<T = ProjectUploadDefaultResult>(accountId: number, projectConfig: ProjectConfig, projectDir: string, callbackFunc: ProjectUploadCallbackFunction<T>, uploadMessage: string): Promise<unknown>;
+export {};

package/lib/projects/upload.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProjectUpload = handleProjectUpload;
+const archiver_1 = __importDefault(require("archiver"));
+const tmp_1 = __importDefault(require("tmp"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const ignoreRules_1 = require("@hubspot/local-dev-lib/ignoreRules");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const ui_1 = require("../ui");
+const lang_1 = require("../lang");
+const exitCodes_1 = require("../enums/exitCodes");
+const i18nKey = 'lib.projectUpload';
+async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion) {
+    SpinniesManager_1.default.init({});
+    const accountIdentifier = (0, ui_1.uiAccountDescription)(accountId);
+    SpinniesManager_1.default.add('upload', {
+        text: (0, lang_1.i18n)(`${i18nKey}.uploadProjectFiles.add`, {
+            accountIdentifier,
+            projectName,
+        }),
+        succeedColor: 'white',
+    });
+    let buildId;
+    let error;
+    try {
+        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`, {
+                accountIdentifier,
+                projectName,
+            }),
+        });
+        if (buildId) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadProjectFiles.buildCreated`, {
+                buildId,
+                projectName,
+            }));
+        }
+    }
+    catch (err) {
+        SpinniesManager_1.default.fail('upload', {
+            text: (0, lang_1.i18n)(`${i18nKey}.uploadProjectFiles.fail`, {
+                accountIdentifier,
+                projectName,
+            }),
+        });
+        error = err;
+    }
+    return { buildId, error };
+}
+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) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.handleProjectUpload.emptySource`, {
+            srcDir: projectConfig.srcDir,
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    const tempFile = tmp_1.default.fileSync({ postfix: '.zip' });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.handleProjectUpload.compressing`, {
+        path: tempFile.name,
+    }));
+    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(),
+        }));
+        const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion);
+        if (error) {
+            console.log(error);
+            uploadResult = { uploadError: error };
+        }
+        else if (callbackFunc) {
+            uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
+        }
+        resolve(uploadResult || {});
+    }));
+    archive.pipe(output);
+    let loggedIgnoredNodeModule = false;
+    archive.directory(srcDir, false, file => {
+        const ignored = (0, ignoreRules_1.shouldIgnoreFile)(file.name, true);
+        if (ignored) {
+            const isNodeModule = file.name.includes('node_modules');
+            if (!isNodeModule || !loggedIgnoredNodeModule) {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.handleProjectUpload.fileFiltered`, {
+                    filename: file.name,
+                }));
+            }
+            if (isNodeModule && !loggedIgnoredNodeModule) {
+                loggedIgnoredNodeModule = true;
+            }
+        }
+        return ignored ? false : file;
+    });
+    archive.finalize();
+    return result;
+}

package/lib/projects/urls.d.ts

@@ -0,0 +1,4 @@
+export declare function getProjectDetailUrl(projectName: string, accountId: number): string | undefined;
+export declare function getProjectActivityUrl(projectName: string, accountId: number): string;
+export declare function getProjectBuildDetailUrl(projectName: string, buildId: number, accountId: number): string;
+export declare function getProjectDeployDetailUrl(projectName: string, deployId: number, accountId: number): string;

package/lib/projects/urls.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectDetailUrl = getProjectDetailUrl;
+exports.getProjectActivityUrl = getProjectActivityUrl;
+exports.getProjectBuildDetailUrl = getProjectBuildDetailUrl;
+exports.getProjectDeployDetailUrl = getProjectDeployDetailUrl;
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+function getProjectHomeUrl(accountId) {
+    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
+    return `${baseUrl}/developer-projects/${accountId}`;
+}
+function getProjectDetailUrl(projectName, accountId) {
+    if (!projectName)
+        return;
+    return `${getProjectHomeUrl(accountId)}/project/${projectName}`;
+}
+function getProjectActivityUrl(projectName, accountId) {
+    return `${getProjectDetailUrl(projectName, accountId)}/activity`;
+}
+function getProjectBuildDetailUrl(projectName, buildId, accountId) {
+    return `${getProjectActivityUrl(projectName, accountId)}/build/${buildId}`;
+}
+function getProjectDeployDetailUrl(projectName, deployId, accountId) {
+    return `${getProjectActivityUrl(projectName, accountId)}/deploy/${deployId}`;
+}

package/lib/{projectsWatch.js → projects/watch.js}

@@ -5,14 +5,14 @@ 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 { 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');
+const { PROJECT_ERROR_TYPES } = require('../constants');
 const i18nKey = 'commands.project.subcommands.watch';
 const queue = new PQueue({
     concurrency: 10,

package/lib/prompts/accountNamePrompt.d.ts

@@ -1 +1,12 @@
+import { PromptConfig } from '../../types/Prompts';
+import { AccountType } from '@hubspot/local-dev-lib/types/Accounts';
+type AccountNamePromptResponse = {
+    name: string;
+};
+export declare function getCliAccountNamePromptConfig(defaultName?: string): PromptConfig<AccountNamePromptResponse>;
+export declare function cliAccountNamePrompt(defaultName: string): Promise<AccountNamePromptResponse>;
+export declare function hubspotAccountNamePrompt({ accountType, currentPortalCount, }: {
+    accountType: AccountType;
+    currentPortalCount?: number;
+}): Promise<AccountNamePromptResponse>;
 export {};