@hubspot/cli 8.2.0 → 8.2.1-experimental.0

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/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>;