@hubspot/cli 8.2.0-beta.0 → 8.2.0-experimental.1

package/lib/projects/projectInfo.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
+import { APP_KEY, USER_FACING_TO_INTERNAL_TYPE, } from '@hubspot/project-parsing-lib/constants';
+import { debugError } from '../errorHandlers/index.js';
+import { getProjectDetailUrl } from './urls.js';
+import { commands } from '../../lang/en.js';
+import { uiLine, uiLink } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+export async function getProjectInfo(project, platformVersion, accountId) {
+    const deployedBuild = project.deployedBuild;
+    const projectInfo = {
+        projectName: project.name,
+        platformVersion,
+        projectId: project.id,
+        deployedBuildId: deployedBuild.buildId,
+        autoDeployEnabled: deployedBuild.isAutoDeployEnabled,
+        components: [],
+    };
+    const projectUrl = getProjectDetailUrl(project.name, accountId);
+    if (projectUrl) {
+        projectInfo.projectUrl = projectUrl;
+    }
+    const appSubbuild = deployedBuild.subbuildStatuses.find(s => s.buildType === USER_FACING_TO_INTERNAL_TYPE[APP_KEY]);
+    if (appSubbuild) {
+        try {
+            const { data: appMetadata } = await fetchAppMetadataBySourceId(project.id, appSubbuild.buildName, accountId);
+            projectInfo.app = {
+                name: appMetadata.name,
+                id: appMetadata.id,
+                uid: appSubbuild.buildName,
+                authType: appMetadata.authType,
+                distributionType: appMetadata.distributionType,
+            };
+        }
+        catch (err) {
+            debugError(err);
+        }
+    }
+    projectInfo.components = deployedBuild.subbuildStatuses
+        .filter(s => s.buildType !== USER_FACING_TO_INTERNAL_TYPE[APP_KEY])
+        .map(s => ({
+        uid: s.buildName,
+        type: s.buildType,
+    }));
+    return projectInfo;
+}
+export function logProjectInfo(projectInfo) {
+    uiLogger.log(chalk.bold(commands.project.info.project.title(projectInfo.projectName)));
+    uiLine();
+    uiLogger.log(commands.project.info.project.platformVersion(projectInfo.platformVersion));
+    uiLogger.log(commands.project.info.project.id(projectInfo.projectId));
+    uiLogger.log(commands.project.info.project.deployedBuild(projectInfo.deployedBuildId));
+    uiLogger.log(commands.project.info.project.autoDeploy(projectInfo.autoDeployEnabled));
+    if (projectInfo.projectUrl) {
+        uiLogger.log('');
+        uiLogger.log(uiLink(commands.project.info.viewProjectLink, projectInfo.projectUrl));
+    }
+    if (projectInfo.app) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.project.info.app.title));
+        uiLine();
+        uiLogger.log(commands.project.info.app.name(projectInfo.app.name));
+        uiLogger.log(commands.project.info.app.id(projectInfo.app.id));
+        uiLogger.log(commands.project.info.app.uid(projectInfo.app.uid));
+        if (projectInfo.app.authType) {
+            uiLogger.log(commands.project.info.app.authType(projectInfo.app.authType));
+        }
+        if (projectInfo.app.distributionType) {
+            uiLogger.log(commands.project.info.app.distributionType(projectInfo.app.distributionType));
+        }
+    }
+    if (projectInfo.components.length > 0) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.project.info.componentsHeader));
+        uiLine();
+        const typeColWidth = Math.max(commands.project.info.labels.type.length, ...projectInfo.components.map(c => c.type.length));
+        uiLogger.log(`${commands.project.info.labels.type.padEnd(typeColWidth)}   ${commands.project.info.labels.uid}`);
+        for (const component of projectInfo.components) {
+            uiLogger.log(`${component.type.padEnd(typeColWidth)}   ${component.uid}`);
+        }
+    }
+}

package/lib/projects/projectProfiles.d.ts

@@ -3,8 +3,7 @@ import { ProjectConfig } from '../../types/Projects.js';
 export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | never;
-export declare function enforceProfileUsage(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string | undefined, silent?: boolean): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string, silent?: boolean): Promise<HsProfileFile | never>;
 type ValidateProjectForProfileOptions = {
     projectConfig: ProjectConfig;
     projectDir: string;

package/lib/projects/projectProfiles.js

@@ -1,7 +1,7 @@
 import path from 'path';
-import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, validateProfileVariables, } from '@hubspot/project-parsing-lib/profiles';
+import { loadHsProfileFile, getHsProfileFilename, validateProfileVariables, } from '@hubspot/project-parsing-lib/profiles';
 import { commands, lib } from '../../lang/en.js';
-import { indent, uiBetaTag, uiLine } from '../ui/index.js';
+import { indent, uiLine } from '../ui/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import SpinniesManager from '../ui/SpinniesManager.js';
@@ -9,7 +9,7 @@ import { handleTranslate } from './upload.js';
 import { getErrorMessage } from '../errorHandlers/index.js';
 export function logProfileHeader(profileName) {
     uiLine();
-    uiBetaTag(lib.projectProfiles.logs.usingProfile(getHsProfileFilename(profileName)));
+    uiLogger.log(lib.projectProfiles.logs.usingProfile(getHsProfileFilename(profileName)));
     uiLogger.log('');
 }
 export function logProfileFooter(profile, includeVariables = false) {
@@ -51,19 +51,7 @@ export function loadProfile(projectConfig, projectDir, profileName) {
     }
     return profile;
 }
-export async function enforceProfileUsage(projectConfig, projectDir) {
-    if (projectConfig && projectDir) {
-        const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
-        if (existingProfiles.length > 0) {
-            throw new Error(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
-        }
-    }
-}
 export async function loadAndValidateProfile(projectConfig, projectDir, profileName, silent = false) {
-    if (!profileName) {
-        await enforceProfileUsage(projectConfig, projectDir);
-        return;
-    }
     if (!silent) {
         logProfileHeader(profileName);
     }
@@ -77,7 +65,7 @@ export async function loadAndValidateProfile(projectConfig, projectDir, profileN
             throw new Error(lib.projectProfiles.loadProfile.errors.profileNotValid(profileName, validationResult.errors));
         }
     }
-    return profile.accountId;
+    return profile;
 }
 function formatProfileValidationError(error, leadingIndentationLevel = 0) {
     // Trim leading whitespace and replace tabs with spaces to reducing indentations
@@ -97,7 +85,7 @@ export async function validateProjectForProfile({ projectConfig, projectDir, pro
         });
     }
     try {
-        const accountId = await loadAndValidateProfile(projectConfig, projectDir, profileName, true);
+        const { accountId } = await loadAndValidateProfile(projectConfig, projectDir, profileName, true);
         targetAccountId = accountId || derivedAccountId;
     }
     catch (error) {

package/lib/projects/uieLinting.d.ts

@@ -1,10 +1,20 @@
+import { LoadedProjectConfig } from './config.js';
 export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
     readonly eslint: "9.0.0";
-    readonly '@typescript-eslint/eslint-plugin': "8.46.4";
-    readonly '@typescript-eslint/parser': "8.46.4";
+    readonly '@eslint/js': "9.0.0";
     readonly 'typescript-eslint': "8.46.4";
+    readonly '@hubspot/eslint-config-ui-extensions': "1.0.0";
+    readonly 'eslint-config-prettier': "10.0.0";
+    readonly 'eslint-plugin-react': "7.0.0";
+    readonly 'eslint-plugin-react-hooks': "7.0.0";
+    readonly 'eslint-plugin-unused-imports': "4.0.0";
+    readonly prettier: "3.0.0";
     readonly jiti: "2.6.1";
 };
+export declare const LINT_SCRIPTS: {
+    readonly lint: "eslint .";
+    readonly 'lint:fix': "eslint . --fix";
+};
 export declare function isEslintInstalled(directory: string): boolean;
 export declare function areAllLintPackagesInstalled(directory: string): boolean;
 export declare function getMissingLintPackages(directory: string): {
@@ -13,7 +23,10 @@ export declare function getMissingLintPackages(directory: string): {
 export declare function hasEslintConfig(directory: string): boolean;
 export declare function hasDeprecatedEslintConfig(directory: string): boolean;
 export declare function getDeprecatedEslintConfigFiles(directory: string): string[];
-export declare function createEslintConfig(directory: string): string;
+export declare function createEslintConfig(directory: string, platformVersion?: string | null): Promise<string>;
+export declare function getUieLintablePackageJsonLocations(projectConfig: LoadedProjectConfig): Promise<string[]>;
+export declare const HUBSPOT_UI_EXTENSIONS_RULE_PREFIX = "@hubspot/ui-extensions/";
+export declare function isHubSpotEslintConfigActive(directory: string): Promise<boolean>;
 export declare function lintPackagesInDirectory(directory: string, projectDir?: string): Promise<{
     success: boolean;
     output: string;
@@ -31,3 +44,8 @@ export declare function displayLintResults(results: Array<{
     success: boolean;
     output: string;
 }>): void;
+export declare function getMissingLintScripts(directory: string): string[];
+export declare function addLintScriptsToPackageJson(directory: string): {
+    added: string[];
+    relativePath: string;
+};

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 {
+        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, ESLINT_CONFIG_TEMPLATE, 'utf-8');
+        fs.writeFileSync(configPath, fetchedContent, 'utf-8');
         return path.relative(process.cwd(), configPath);
     }
     catch (error) {
@@ -138,6 +169,38 @@ export function createEslintConfig(directory) {
         throw error;
     }
 }
+export async function getUieLintablePackageJsonLocations(projectConfig) {
+    if (!projectConfig.projectDir || !projectConfig.projectConfig?.srcDir) {
+        return [];
+    }
+    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 +211,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 +282,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

@@ -5,6 +5,7 @@ type ProjectUploadResult<T> = {
     result?: T;
     uploadError?: unknown;
     projectNotFound?: boolean;
+    projectId?: number;
 };
 type HandleProjectUploadArg<T> = {
     accountId: number;
@@ -16,9 +17,10 @@ type HandleProjectUploadArg<T> = {
     isUploadCommand?: boolean;
     sendIR?: boolean;
     skipValidation?: boolean;
+    skipNpmAudit?: boolean;
     profile?: string;
 };
-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, }: 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 = {

package/lib/projects/upload.js

@@ -6,16 +6,20 @@ 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 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';
+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) {
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
     SpinniesManager.add('upload', {
@@ -42,12 +46,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, }) {
     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 () {
@@ -68,7 +98,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                     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 +107,14 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                 uiLogger.log(lib.projectUpload.handleProjectUpload.projectDoesNotExist(accountId));
                 return resolve({ projectNotFound: true });
             }
+            const projectId = project?.id;
             const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
             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 +122,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 +142,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 +152,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,7 +163,7 @@ 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);
     }
 }

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('');
+    }
+}

package/lib/projects/workspaces.d.ts

@@ -0,0 +1,60 @@
+import archiver from 'archiver';
+import { WorkspaceMapping, FileDependencyMapping, FileDependencyKind, LocalDependencyProtocol } from '@hubspot/project-parsing-lib/workspaces';
+export type FileDepArchiveEntry = {
+    archivePath: string;
+    protocol: LocalDependencyProtocol;
+};
+/**
+ * Result of archiving workspaces and file dependencies
+ */
+export type WorkspaceArchiveResult = {
+    packageWorkspaces: Map<string, string[]>;
+    packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>;
+};
+/**
+ * Generates a short hash of the input string for use in workspace paths.
+ * Uses SHA256 truncated to 8 hex characters (4 billion possibilities).
+ */
+export declare function shortHash(input: string): string;
+/**
+ * Converts native path separators to POSIX forward slashes.
+ *
+ * Zip entry names and npm workspace globs are POSIX-only. On Windows,
+ * `path.relative` returns backslash-separated paths; archiver normalizes
+ * its appended entry names to forward slashes but its filter callback
+ * receives forward-slashed names too. Without this normalization, lookups
+ * in our exclusion Sets miss on Windows and a file gets archived twice.
+ */
+export declare function toPosixPath(p: string): string;
+/**
+ * Determines the archive path for an external workspace or file: dependency.
+ *
+ * For directories, produces `_workspaces/<basename>-<hash>`.
+ * For tarballs, produces `_workspaces/<basename-no-ext>-<hash>/<original-basename>`,
+ * so the rewritten package.json reference still ends in the original filename.
+ *
+ * The hash prevents collisions between different paths with the same basename.
+ */
+export declare function computeExternalArchivePath(absolutePath: string, kind?: FileDependencyKind): string;
+/**
+ * Updates package.json files in the archive to reflect new workspace and file: dependency paths.
+ *
+ * Workspace entries in packageWorkspaces are already in final form:
+ * - Internal workspaces: relative paths (e.g. "../packages/utils")
+ * - External workspaces: relative paths (e.g. "../_workspaces/logger-abc")
+ *
+ * Only external file: dependencies appear in packageFileDeps; internal ones
+ * keep their original file: references and are left untouched.
+ */
+export declare function updatePackageJsonInArchive(archive: archiver.Archiver, srcDir: string, packageWorkspaces: Map<string, string[]>, packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>): Promise<void>;
+export declare function rewriteLockfileForExternalDeps(lockfileContent: Record<string, unknown>, pathMappings: Array<{
+    oldPath: string;
+    newPath: string;
+}>): Record<string, unknown>;
+export declare function getPackageJsonPathsToUpdate(srcDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Set<string>;
+export declare function getLockfilePathsToUpdate(srcDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Set<string>;
+/**
+ * Main orchestration function that handles archiving of workspaces and file dependencies.
+ * This is the clean integration point for upload.ts.
+ */
+export declare function archiveWorkspacesAndDependencies(archive: archiver.Archiver, srcDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;