@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/lib/projects/uieLinting.js

@@ -3,17 +3,28 @@ import path from 'path';
 import util from 'util';
 import semver from 'semver';
 import { exec as execAsync } from 'node:child_process';
+import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
 import { getProjectPackageJsonLocations, isPackageInstalled, } from '../dependencyManagement.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
-import { safeGetPackageJsonCached } from '../npm/packageJson.js';
+import { clearPackageJsonCache, safeGetPackageJsonCached, } from '../npm/packageJson.js';
+import { debugError } from '../errorHandlers/index.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../constants.js';
+import { CARDS_KEY, Components, PAGES_KEY, SETTINGS_KEY, } from '@hubspot/project-parsing-lib/constants';
 export const REQUIRED_PACKAGES_AND_MIN_VERSIONS = {
     eslint: '9.0.0',
-    '@typescript-eslint/eslint-plugin': '8.46.4',
-    '@typescript-eslint/parser': '8.46.4',
+    '@eslint/js': '9.0.0',
     'typescript-eslint': '8.46.4',
+    '@hubspot/eslint-config-ui-extensions': '1.0.0',
+    'eslint-config-prettier': '10.0.0',
+    'eslint-plugin-react': '7.0.0',
+    'eslint-plugin-react-hooks': '7.0.0',
+    'eslint-plugin-unused-imports': '4.0.0',
+    prettier: '3.0.0',
     jiti: '2.6.1',
 };
+const UIE_ESLINT_CONFIG_PATH_IN_REPO = 'components/cards/src/app/cards/eslint.config.js';
 const ESLINT_CONFIG_FILES = [
     'eslint.config.mts',
     'eslint.config.ts',
@@ -30,28 +41,15 @@ const DEPRECATED_ESLINT_CONFIG_FILES = [
     '.eslintrc.json',
     '.eslintrc',
 ];
-const ESLINT_CONFIG_TEMPLATE = `import { defineConfig } from "eslint/config";
-import tsParser from "@typescript-eslint/parser";
-
-export default defineConfig([
-  {
-    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module",
-        ecmaFeatures: {
-          jsx: true
-        }
-      }
-    },
-    rules: {
-      "no-console": ["warn", { allow: ["warn", "error"] }]
-    }
-  },
-]);
-`;
+const UIE_COMPONENTS = [
+    Components[CARDS_KEY],
+    Components[SETTINGS_KEY],
+    Components[PAGES_KEY],
+];
+export const LINT_SCRIPTS = {
+    lint: 'eslint .',
+    'lint:fix': 'eslint . --fix',
+};
 function getPackageVersionFromPackageJson(directory, packageName) {
     const packageJsonPath = path.join(directory, 'package.json');
     const packageJson = safeGetPackageJsonCached(packageJsonPath);
@@ -127,10 +125,43 @@ export function getDeprecatedEslintConfigFiles(directory) {
         return fs.existsSync(configPath);
     });
 }
-export function createEslintConfig(directory) {
-    const configPath = path.join(directory, 'eslint.config.mts');
+function repoFileDataToString(data) {
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (Buffer.isBuffer(data)) {
+        return data.toString('utf-8');
+    }
+    return String(data);
+}
+export async function createEslintConfig(directory, platformVersion) {
+    const versionForRemote = platformVersion && !isLegacyProject(platformVersion)
+        ? platformVersion
+        : null;
+    if (versionForRemote === null) {
+        const message = commands.project.lint.createEslintConfigRequiresV2Platform(platformVersion);
+        uiLogger.error(message);
+        throw new Error(message);
+    }
+    let fetchedContent = null;
     try {
-        fs.writeFileSync(configPath, ESLINT_CONFIG_TEMPLATE, 'utf-8');
+        const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${versionForRemote}/${UIE_ESLINT_CONFIG_PATH_IN_REPO}`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
+        const content = repoFileDataToString(data);
+        if (content.trim().length > 0) {
+            fetchedContent = content;
+        }
+    }
+    catch (error) {
+        debugError(error);
+    }
+    if (fetchedContent === null) {
+        const message = commands.project.lint.failedToFetchRemoteEslintConfig(versionForRemote);
+        uiLogger.error(message);
+        throw new Error(message);
+    }
+    const configPath = path.join(directory, 'eslint.config.js');
+    try {
+        fs.writeFileSync(configPath, fetchedContent, 'utf-8');
         return path.relative(process.cwd(), configPath);
     }
     catch (error) {
@@ -138,6 +169,35 @@ export function createEslintConfig(directory) {
         throw error;
     }
 }
+export async function getUieLintablePackageJsonLocations(projectConfig) {
+    const srcDirAbsolute = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    const uiePackageDirPrefixes = UIE_COMPONENTS.map(component => path.join(srcDirAbsolute, component.parentComponent
+        ? Components[component.parentComponent].dir
+        : '', component.dir));
+    const allLocations = await getProjectPackageJsonLocations(projectConfig.projectDir);
+    return allLocations.filter(location => {
+        const resolvedLocation = path.resolve(location);
+        return uiePackageDirPrefixes.some(prefix => resolvedLocation.startsWith(prefix));
+    });
+}
+export const HUBSPOT_UI_EXTENSIONS_RULE_PREFIX = '@hubspot/ui-extensions/';
+function getEnvironmentWithoutNpmConfig() {
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.toLowerCase().startsWith('npm_config_')));
+}
+export async function isHubSpotEslintConfigActive(directory) {
+    const exec = util.promisify(execAsync);
+    try {
+        const { stdout } = await exec('npx eslint --print-config ./Component.tsx', {
+            cwd: directory,
+        });
+        const config = JSON.parse(stdout);
+        const rules = config.rules ?? {};
+        return Object.keys(rules).some(rule => rule.startsWith(HUBSPOT_UI_EXTENSIONS_RULE_PREFIX));
+    }
+    catch {
+        return false;
+    }
+}
 export async function lintPackagesInDirectory(directory, projectDir) {
     const displayPath = projectDir
         ? path.relative(projectDir, directory)
@@ -148,6 +208,7 @@ export async function lintPackagesInDirectory(directory, projectDir) {
         const { stdout, stderr } = await exec(lintCommand, {
             cwd: directory,
             maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
+            env: getEnvironmentWithoutNpmConfig(),
         });
         let output = `\n${displayPath}:\n`;
         if (stdout && stdout.trim()) {
@@ -218,3 +279,43 @@ export function displayLintResults(results) {
         });
     }
 }
+export function getMissingLintScripts(directory) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    const packageJson = safeGetPackageJsonCached(packageJsonPath);
+    if (!packageJson) {
+        return [];
+    }
+    return Object.keys(LINT_SCRIPTS).filter(scriptName => !packageJson.scripts?.[scriptName]);
+}
+export function addLintScriptsToPackageJson(directory) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    try {
+        const rawContent = fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(rawContent);
+        if (!packageJson.scripts) {
+            packageJson.scripts = {};
+        }
+        const added = [];
+        for (const [scriptName, scriptValue] of Object.entries(LINT_SCRIPTS)) {
+            if (!packageJson.scripts[scriptName]) {
+                packageJson.scripts[scriptName] = scriptValue;
+                added.push(scriptName);
+            }
+        }
+        if (added.length > 0) {
+            fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+            clearPackageJsonCache();
+        }
+        return {
+            added,
+            relativePath: path.relative(process.cwd(), packageJsonPath),
+        };
+    }
+    catch {
+        uiLogger.warn(commands.project.lint.failedToAddLintScripts(packageJsonPath));
+        return {
+            added: [],
+            relativePath: path.relative(process.cwd(), packageJsonPath),
+        };
+    }
+}

package/lib/projects/upload.d.ts

@@ -1,10 +1,13 @@
 import { FileResult } from 'tmp';
+import { type IntermediateRepresentation } from '@hubspot/project-parsing-lib/translate';
 import { ProjectConfig } from '../../types/Projects.js';
 type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number) => Promise<T>;
 type ProjectUploadResult<T> = {
     result?: T;
     uploadError?: unknown;
     projectNotFound?: boolean;
+    projectId?: number;
+    userDeclined?: boolean;
 };
 type HandleProjectUploadArg<T> = {
     accountId: number;
@@ -16,9 +19,12 @@ type HandleProjectUploadArg<T> = {
     isUploadCommand?: boolean;
     sendIR?: boolean;
     skipValidation?: boolean;
+    skipNpmAudit?: boolean;
+    skipAutoDeploy?: boolean;
     profile?: string;
+    force?: boolean;
 };
-export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
+export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, skipNpmAudit, skipAutoDeploy, force, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
 export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig, projectDir: string): Promise<void>;
 export declare function validateNoHSMetaMismatch(srcDir: string, projectConfig: ProjectConfig): Promise<void>;
 type HandleTranslateArg = {
@@ -29,5 +35,9 @@ type HandleTranslateArg = {
     profile?: string;
     includeTranslationErrorMessage?: boolean;
 };
-export declare function handleTranslate({ projectDir, projectConfig, accountId, skipValidation, profile, includeTranslationErrorMessage, }: HandleTranslateArg): Promise<unknown>;
+export type HandleTranslateResult = {
+    intermediateRepresentation: IntermediateRepresentation;
+    skippedHsMetaFiles: string[];
+};
+export declare function handleTranslate({ projectDir, projectConfig, accountId, skipValidation, profile, includeTranslationErrorMessage, }: HandleTranslateArg): Promise<HandleTranslateResult>;
 export {};

package/lib/projects/upload.js

@@ -6,17 +6,22 @@ import { uploadProject } from '@hubspot/local-dev-lib/api/projects';
 import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
 import { isTranslationError, translate, } from '@hubspot/project-parsing-lib/translate';
 import { projectContainsHsMetaFiles } from '@hubspot/project-parsing-lib/projects';
+import { findAndParsePackageJsonFiles, collectWorkspaceDirectories, collectFileDependencies, } from '@hubspot/project-parsing-lib/workspaces';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { uiAccountDescription } from '../ui/index.js';
+import { warnAboutSkippedHsMetaFiles } from './ui.js';
 import util from 'node:util';
 import { lib } from '../../lang/en.js';
 import { ensureProjectExists } from './ensureProjectExists.js';
 import { uiLogger } from '../ui/logger.js';
-import { isV2Project } from './platformVersion.js';
 import ProjectValidationError from '../errors/ProjectValidationError.js';
 import { walk } from '@hubspot/local-dev-lib/fs';
 import { LEGACY_CONFIG_FILES } from '../constants.js';
-async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
+import { archiveWorkspacesAndDependencies, getPackageJsonPathsToUpdate, getLockfilePathsToUpdate, } from './workspaces.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { validateLintConfigOnUpload } from './validateLintConfigOnUpload.js';
+import { runNpmAuditsBeforeProjectUpload } from './npmAuditOnUpload.js';
+async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation, skipAutoDeploy) {
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
     SpinniesManager.add('upload', {
         text: lib.projectUpload.uploadProjectFiles.add(projectName, accountIdentifier),
@@ -25,7 +30,7 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
     let buildId;
     let error;
     try {
-        const { data: upload } = await uploadProject(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation);
+        const { data: upload } = await uploadProject(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation, skipAutoDeploy);
         buildId = upload.buildId;
         SpinniesManager.succeed('upload', {
             text: lib.projectUpload.uploadProjectFiles.succeed(projectName, accountIdentifier),
@@ -42,12 +47,38 @@ async function uploadProjectFiles(accountId, projectName, filePath, uploadMessag
     }
     return { buildId, error };
 }
-export async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, }) {
+export async function handleProjectUpload({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage = '', forceCreate = false, isUploadCommand = false, sendIR = false, skipValidation = false, skipNpmAudit = false, skipAutoDeploy = false, force = false, }) {
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
     await validateSourceDirectory(srcDir, projectConfig, projectDir);
     await validateNoHSMetaMismatch(srcDir, projectConfig);
     const tempFile = tmp.fileSync({ postfix: '.zip' });
     uiLogger.debug(lib.projectUpload.handleProjectUpload.compressing(tempFile.name));
+    // Collect workspace directories and file: dependencies for v2+ projects only.
+    // Versions <= 2025.1 do not support the new npm workspaces bundling behavior.
+    let workspaceMappings = [];
+    let fileDependencyMappings = [];
+    let parsedPackageJsons = [];
+    if (!isLegacyProject(projectConfig.platformVersion)) {
+        parsedPackageJsons = await findAndParsePackageJsonFiles(srcDir);
+        workspaceMappings = await collectWorkspaceDirectories(parsedPackageJsons);
+        fileDependencyMappings = await collectFileDependencies(parsedPackageJsons);
+    }
+    if (isUploadCommand && !skipValidation) {
+        await validateLintConfigOnUpload({
+            srcDir,
+            projectDir,
+            parsedPackageJsons,
+            isLegacyPlatform: isLegacyProject(projectConfig.platformVersion),
+        });
+    }
+    if (isUploadCommand && !skipNpmAudit) {
+        await runNpmAuditsBeforeProjectUpload({
+            srcDir,
+            projectDir,
+            parsedPackageJsons,
+            isLegacyPlatform: isLegacyProject(projectConfig.platformVersion),
+        });
+    }
     const output = fs.createWriteStream(tempFile.name);
     const archive = archiver('zip');
     const result = new Promise((resolve, reject) => output.on('close', async function () {
@@ -56,19 +87,25 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
             let intermediateRepresentation;
             if (sendIR) {
                 try {
-                    intermediateRepresentation = await handleTranslate({
+                    const translateResult = await handleTranslate({
                         projectDir,
                         projectConfig,
                         accountId,
                         skipValidation,
                         profile,
                     });
+                    intermediateRepresentation =
+                        translateResult.intermediateRepresentation;
+                    const shouldContinue = await warnAboutSkippedHsMetaFiles(translateResult.skippedHsMetaFiles, force);
+                    if (!shouldContinue) {
+                        return resolve({ userDeclined: true });
+                    }
                 }
                 catch (e) {
                     return resolve({ uploadError: e });
                 }
             }
-            const { projectExists } = await ensureProjectExists(accountId, projectConfig.name, {
+            const { projectExists, project } = await ensureProjectExists(accountId, projectConfig.name, {
                 forceCreate,
                 uploadCommand: isUploadCommand,
                 noLogs: true,
@@ -77,13 +114,14 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                 uiLogger.log(lib.projectUpload.handleProjectUpload.projectDoesNotExist(accountId));
                 return resolve({ projectNotFound: true });
             }
-            const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
+            const projectId = project?.id;
+            const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation, skipAutoDeploy);
             if (error) {
-                resolve({ uploadError: error });
+                resolve({ uploadError: error, projectId });
             }
             else if (callbackFunc) {
                 const uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
-                resolve({ result: uploadResult });
+                resolve({ result: uploadResult, projectId });
             }
         }
         catch (e) {
@@ -91,8 +129,14 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
         }
     }));
     archive.pipe(output);
+    const modifiedPackageJsonPaths = getPackageJsonPathsToUpdate(srcDir, workspaceMappings, fileDependencyMappings);
+    const lockfilePathsToUpdate = getLockfilePathsToUpdate(srcDir, workspaceMappings, fileDependencyMappings);
     let loggedIgnoredNodeModule = false;
     archive.directory(srcDir, false, file => {
+        if (modifiedPackageJsonPaths.has(file.name) ||
+            lockfilePathsToUpdate.has(file.name)) {
+            return false;
+        }
         const ignored = shouldIgnoreFile(file.name, true);
         if (ignored) {
             const isNodeModule = file.name.includes('node_modules');
@@ -105,6 +149,8 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
         }
         return ignored ? false : file;
     });
+    // Archive workspaces and file: dependencies
+    await archiveWorkspacesAndDependencies(archive, srcDir, workspaceMappings, fileDependencyMappings);
     archive.finalize();
     return result;
 }
@@ -113,7 +159,7 @@ export async function validateSourceDirectory(srcDir, projectConfig, projectDir)
     if (!projectFilePaths || projectFilePaths.length === 0) {
         throw new ProjectValidationError(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
     }
-    if (isV2Project(projectConfig.platformVersion)) {
+    if (!isLegacyProject(projectConfig.platformVersion)) {
         projectFilePaths.forEach(filePath => {
             const filename = path.basename(filePath);
             if (LEGACY_CONFIG_FILES.includes(filename)) {
@@ -124,19 +170,19 @@ export async function validateSourceDirectory(srcDir, projectConfig, projectDir)
 }
 export async function validateNoHSMetaMismatch(srcDir, projectConfig) {
     const hasHsMetaFiles = await projectContainsHsMetaFiles(srcDir);
-    if (!isV2Project(projectConfig.platformVersion) && hasHsMetaFiles) {
+    if (isLegacyProject(projectConfig.platformVersion) && hasHsMetaFiles) {
         throw new ProjectValidationError(lib.projectUpload.wrongPlatformVersionMetaFiles);
     }
 }
 export async function handleTranslate({ projectDir, projectConfig, accountId, skipValidation, profile, includeTranslationErrorMessage = true, }) {
     try {
-        const intermediateRepresentation = await translate({
+        const { intermediateRepresentation, skippedHsMetaFiles } = await translate({
             projectSourceDir: path.join(projectDir, projectConfig.srcDir),
             platformVersion: projectConfig.platformVersion,
             accountId,
         }, { skipValidation, profile });
         uiLogger.debug(util.inspect(intermediateRepresentation, false, null, true));
-        return intermediateRepresentation;
+        return { intermediateRepresentation, skippedHsMetaFiles };
     }
     catch (e) {
         if (isTranslationError(e)) {

package/lib/projects/urls.d.ts

@@ -1,4 +1,3 @@
-export declare function getBaseHubSpotUrlForAccount(accountId: number): string;
 export declare function getProjectComponentDistributionUrl(projectName: string, componentName: string, accountId: number): string;
 export declare function getDeveloperOverviewUrl(accountId: number): string;
 export declare function getProjectDetailUrl(projectName: string, accountId: number): string | undefined;

package/lib/projects/urls.js

@@ -1,18 +1,12 @@
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
-export function getBaseHubSpotUrlForAccount(accountId) {
-    return getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-}
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 function getProjectHomeUrl(accountId) {
-    return `${getBaseHubSpotUrlForAccount(accountId)}/developer-projects/${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-projects/${accountId}`;
 }
 export function getProjectComponentDistributionUrl(projectName, componentName, accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/developer-projects/${accountId}/project/${projectName}/component/${componentName}/distribution`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-projects/${accountId}/project/${projectName}/component/${componentName}/distribution`;
 }
 export function getDeveloperOverviewUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/developer-overview/${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-overview/${accountId}`;
 }
 export function getProjectDetailUrl(projectName, accountId) {
     if (!projectName)
@@ -34,9 +28,8 @@ export function getProjectDeployDetailUrl(projectName, deployId, accountId) {
     return `${getProjectActivityUrl(projectName, accountId)}/deploy/${deployId}`;
 }
 export function getLocalDevUiUrl(accountId, showWelcomeScreen) {
-    return `${getBaseHubSpotUrlForAccount(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-projects-local-dev/${accountId}${showWelcomeScreen ? '?welcome' : ''}`;
 }
 export function getAccountHomeUrl(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(accountId));
-    return `${baseUrl}/home?portalId=${accountId}`;
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/home?portalId=${accountId}`;
 }

package/lib/projects/validate.d.ts

@@ -0,0 +1,9 @@
+import { ProjectConfig } from '../../types/Projects.js';
+type ValidateProjectArgs = {
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    derivedAccountId: number;
+    profile?: string;
+};
+export declare function validateProject({ projectConfig, projectDir, derivedAccountId, profile, }: ValidateProjectArgs): Promise<boolean>;
+export {};

package/lib/projects/validate.js

@@ -0,0 +1,96 @@
+import path from 'path';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
+import { uiLogger } from '../ui/logger.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError } from '../errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+import { validateProjectForProfile } from './projectProfiles.js';
+import { handleTranslate, validateSourceDirectory } from './upload.js';
+function logValidationErrors(validationErrors) {
+    uiLogger.log('');
+    validationErrors.forEach(error => {
+        if (error instanceof Error) {
+            logError(error);
+        }
+        else {
+            uiLogger.log(error);
+        }
+    });
+}
+export async function validateProject({ projectConfig, projectDir, derivedAccountId, profile, }) {
+    let valid = true;
+    const srcDir = path.resolve(projectDir, projectConfig.srcDir);
+    const profiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
+    // If a profile is specified, only validate that profile
+    if (profile) {
+        const validationErrors = await validateProjectForProfile({
+            projectConfig,
+            projectDir,
+            profileName: profile,
+            derivedAccountId,
+        });
+        if (validationErrors.length) {
+            logValidationErrors(validationErrors);
+            valid = false;
+        }
+    }
+    else if (profiles.length > 0) {
+        // If no profile was specified and the project has profiles, validate all of them
+        SpinniesManager.add('validatingAllProfiles', {
+            text: commands.project.validate.spinners.validatingAllProfiles,
+        });
+        const errors = [];
+        for (const profileName of profiles) {
+            const validationErrors = await validateProjectForProfile({
+                projectConfig,
+                projectDir,
+                profileName,
+                derivedAccountId,
+                indentSpinners: true,
+            });
+            if (validationErrors.length) {
+                errors.push(...validationErrors);
+                valid = false;
+            }
+        }
+        if (valid) {
+            SpinniesManager.succeed('validatingAllProfiles', {
+                text: commands.project.validate.spinners.allProfilesValidationSucceeded,
+            });
+        }
+        else {
+            SpinniesManager.fail('validatingAllProfiles', {
+                text: commands.project.validate.spinners.allProfilesValidationFailed,
+            });
+        }
+        logValidationErrors(errors);
+    }
+    else {
+        // If the project has no profiles, validate the project without a profile
+        try {
+            await handleTranslate({
+                projectDir,
+                projectConfig,
+                accountId: derivedAccountId,
+                skipValidation: false,
+            });
+        }
+        catch (e) {
+            uiLogger.error(commands.project.validate.failure(projectConfig.name));
+            logError(e);
+            valid = false;
+            uiLogger.log('');
+        }
+    }
+    if (!valid) {
+        return false;
+    }
+    try {
+        await validateSourceDirectory(srcDir, projectConfig, projectDir);
+    }
+    catch (e) {
+        logError(e);
+        return false;
+    }
+    return true;
+}

package/lib/projects/validateLintConfigOnUpload.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedPackageJson } from '@hubspot/project-parsing-lib/workspaces';
+type ValidateLintConfigOnUploadArgs = {
+    srcDir: string;
+    projectDir: string;
+    parsedPackageJsons: ParsedPackageJson[];
+    isLegacyPlatform: boolean;
+};
+export declare function validateLintConfigOnUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }: ValidateLintConfigOnUploadArgs): Promise<void>;
+export {};

package/lib/projects/validateLintConfigOnUpload.js

@@ -0,0 +1,45 @@
+import path from 'path';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+import { areAllLintPackagesInstalled, hasEslintConfig, isHubSpotEslintConfigActive, } from './uieLinting.js';
+export async function validateLintConfigOnUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }) {
+    const lintRoots = new Set();
+    if (isLegacyPlatform) {
+        lintRoots.add(srcDir);
+    }
+    else {
+        for (const { dir } of parsedPackageJsons) {
+            lintRoots.add(dir);
+        }
+        if (lintRoots.size === 0) {
+            lintRoots.add(srcDir);
+        }
+    }
+    let hasAnyOutput = false;
+    for (const lintRoot of lintRoots) {
+        const relativeRoot = path.relative(projectDir, lintRoot) || '.';
+        let warnMessage;
+        if (!areAllLintPackagesInstalled(lintRoot)) {
+            warnMessage =
+                lib.projectUpload.handleProjectUpload.lintPackagesNotConfigured(relativeRoot);
+        }
+        else if (!hasEslintConfig(lintRoot)) {
+            warnMessage =
+                lib.projectUpload.handleProjectUpload.lintConfigNotFound(relativeRoot);
+        }
+        else if (!(await isHubSpotEslintConfigActive(lintRoot))) {
+            warnMessage =
+                lib.projectUpload.handleProjectUpload.lintHubSpotRulesNotActive(relativeRoot);
+        }
+        if (warnMessage) {
+            if (!hasAnyOutput) {
+                uiLogger.log('');
+                hasAnyOutput = true;
+            }
+            uiLogger.warn(warnMessage);
+        }
+    }
+    if (hasAnyOutput) {
+        uiLogger.log('');
+    }
+}