@hubspot/cli 8.6.0-beta.1 → 8.7.0-beta.0

package/lib/projects/npmAuditOnUpload.js

@@ -0,0 +1,73 @@
+import path from 'path';
+import { runNpmAuditJson } from '@hubspot/ui-extensions-dev-server';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export function summarizeNpmAuditJson(source) {
+    try {
+        const data = JSON.parse(source);
+        const errorMessage = data.error?.message ?? data.error?.summary;
+        if (errorMessage) {
+            return errorMessage;
+        }
+        const v = data.metadata?.vulnerabilities;
+        if (!v) {
+            return null;
+        }
+        const total = v.total ?? 0;
+        if (total === 0) {
+            return null;
+        }
+        const severityOrder = [
+            'critical',
+            'high',
+            'moderate',
+            'low',
+            'info',
+        ];
+        const parts = severityOrder
+            .filter(severity => (v[severity] ?? 0) > 0)
+            .map(severity => `${v[severity]} ${severity}`);
+        return `${total} total (${parts.join(', ')})`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runNpmAuditsBeforeProjectUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }) {
+    const auditRoots = new Set();
+    if (isLegacyPlatform) {
+        auditRoots.add(srcDir);
+    }
+    else {
+        for (const { dir } of parsedPackageJsons) {
+            auditRoots.add(dir);
+        }
+        if (auditRoots.size === 0) {
+            auditRoots.add(srcDir);
+        }
+    }
+    const auditRootArray = [...auditRoots];
+    const results = await Promise.all(auditRootArray.map(auditRoot => runNpmAuditJson(auditRoot)));
+    for (let i = 0; i < auditRootArray.length; i++) {
+        const auditRoot = auditRootArray[i];
+        const result = results[i];
+        if (result.skipped) {
+            continue;
+        }
+        const relativeRoot = path.relative(projectDir, auditRoot) || '.';
+        const summary = summarizeNpmAuditJson(result.source);
+        if (result.exitCode === 127) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.npmAuditNpmUnavailable(relativeRoot));
+            continue;
+        }
+        if (summary) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.npmAuditIssues(relativeRoot, summary));
+            continue;
+        }
+        if (result.exitCode !== 0) {
+            uiLogger.warn(lib.projectUpload.handleProjectUpload.npmAuditNonZeroExit(relativeRoot, result.exitCode));
+            continue;
+        }
+        uiLogger.success(lib.projectUpload.handleProjectUpload.npmAuditClean(relativeRoot));
+    }
+}

package/lib/projects/pollProjectBuildAndDeploy.d.ts

@@ -6,5 +6,9 @@ type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskNam
 export declare const pollBuildStatus: PollTaskStatusFunction<Build>;
 export declare const pollDeployStatus: PollTaskStatusFunction<Deploy>;
 export declare function displayWarnLogs(accountId: number, projectName: string, taskId: number, isDeploy?: boolean): Promise<void>;
-export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, silenceLogs?: boolean): Promise<ProjectPollResult>;
+type PollOptions = {
+    silenceLogs?: boolean;
+    skipDeploy?: boolean;
+};
+export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, options?: PollOptions): Promise<ProjectPollResult>;
 export {};

package/lib/projects/pollProjectBuildAndDeploy.js

@@ -291,7 +291,8 @@ export async function displayWarnLogs(accountId, projectName, taskId, isDeploy =
         });
     }
 }
-export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
+export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, options = {}) {
+    const { silenceLogs = false, skipDeploy = false } = options;
     let buildStatus = await pollBuildStatus(accountId, projectConfig.name, buildId, null, silenceLogs);
     if (!silenceLogs) {
         uiLine();
@@ -306,7 +307,7 @@ export async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFi
         result.succeeded = false;
         return result;
     }
-    else if (buildStatus.isAutoDeployEnabled) {
+    else if (buildStatus.isAutoDeployEnabled && !skipDeploy) {
         if (!silenceLogs) {
             uiLogger.log(lib.projectBuildAndDeploy.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying(buildId, uiAccountDescription(accountId)));
             await displayWarnLogs(accountId, projectConfig.name, buildId);

package/lib/projects/preview.d.ts

@@ -0,0 +1,7 @@
+type PreviewResult = {
+    succeeded: boolean;
+    releaseTag?: string;
+    appId?: number;
+};
+export declare function triggerAndPollPreview(accountId: number, projectId: number, buildId: number, targetPortalId: number): Promise<PreviewResult>;
+export {};

package/lib/projects/preview.js

@@ -0,0 +1,48 @@
+import { triggerAutoRelease, getAutoReleaseStatus, } from '../../api/releases.js';
+import { PREVIEW_POLL_TIMEOUT } from '../constants.js';
+import { poll } from '../polling.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+export async function triggerAndPollPreview(accountId, projectId, buildId, targetPortalId) {
+    let triggerResponse;
+    SpinniesManager.add('preview', {
+        text: lib.projectPreview.triggeringPreview(buildId, targetPortalId),
+        succeedColor: 'white',
+    });
+    try {
+        const { data } = await triggerAutoRelease(accountId, projectId, buildId, targetPortalId);
+        triggerResponse = data;
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.triggerFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview trigger',
+        }));
+        return { succeeded: false };
+    }
+    const { releaseTag, appId } = triggerResponse;
+    SpinniesManager.update('preview', {
+        text: lib.projectPreview.pollingStatus(releaseTag, targetPortalId),
+    });
+    try {
+        await poll(() => getAutoReleaseStatus(accountId, projectId, targetPortalId, releaseTag, appId), { successStates: ['COMPLETE'], errorStates: [] }, PREVIEW_POLL_TIMEOUT);
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.pollFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview status',
+        }));
+        return { succeeded: false, releaseTag, appId };
+    }
+    SpinniesManager.succeed('preview', {
+        text: lib.projectPreview.succeeded(releaseTag, targetPortalId),
+    });
+    return { succeeded: true, releaseTag, appId };
+}

package/lib/projects/uieLinting.d.ts

@@ -1,3 +1,4 @@
+import { LoadedProjectConfig } from './config.js';
 export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
     readonly eslint: "9.0.0";
     readonly '@eslint/js': "9.0.0";
@@ -23,6 +24,9 @@ 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, 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;

package/lib/projects/uieLinting.js

@@ -10,7 +10,8 @@ import { uiLogger } from '../ui/logger.js';
 import { clearPackageJsonCache, safeGetPackageJsonCached, } from '../npm/packageJson.js';
 import { debugError } from '../errorHandlers/index.js';
 import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
-import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../constants.js';
+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',
     '@eslint/js': '9.0.0',
@@ -40,6 +41,11 @@ const DEPRECATED_ESLINT_CONFIG_FILES = [
     '.eslintrc.json',
     '.eslintrc',
 ];
+const UIE_COMPONENTS = [
+    Components[CARDS_KEY],
+    Components[SETTINGS_KEY],
+    Components[PAGES_KEY],
+];
 export const LINT_SCRIPTS = {
     lint: 'eslint .',
     'lint:fix': 'eslint . --fix',
@@ -163,6 +169,35 @@ export async function createEslintConfig(directory, platformVersion) {
         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/';
+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)

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

@@ -18,6 +18,8 @@ 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', {
@@ -44,7 +46,7 @@ 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);
@@ -54,11 +56,28 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
     // Versions <= 2025.1 do not support the new npm workspaces bundling behavior.
     let workspaceMappings = [];
     let fileDependencyMappings = [];
+    let parsedPackageJsons = [];
     if (!isLegacyProject(projectConfig.platformVersion)) {
-        const parsedPackageJsons = await findAndParsePackageJsonFiles(srcDir);
+        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 () {
@@ -79,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,
@@ -88,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) {
@@ -123,7 +143,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
         return ignored ? false : file;
     });
     // Archive workspaces and file: dependencies
-    await archiveWorkspacesAndDependencies(archive, srcDir, projectDir, workspaceMappings, fileDependencyMappings);
+    await archiveWorkspacesAndDependencies(archive, srcDir, workspaceMappings, fileDependencyMappings);
     archive.finalize();
     return result;
 }

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

@@ -12,6 +12,16 @@ export type WorkspaceArchiveResult = {
  * 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.
  * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
@@ -39,4 +49,4 @@ export declare function getLockfilePathsToUpdate(srcDir: string, workspaceMappin
  * 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, projectDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;
+export declare function archiveWorkspacesAndDependencies(archive: archiver.Archiver, srcDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;

package/lib/projects/workspaces.js

@@ -12,6 +12,21 @@ import { lib } from '../../lang/en.js';
 export function shortHash(input) {
     return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
 }
+/**
+ * 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 function toPosixPath(p) {
+    if (path.sep === path.posix.sep) {
+        return p;
+    }
+    return p.replaceAll(path.sep, path.posix.sep);
+}
 /**
  * Determines the archive path for an external workspace or file: dependency.
  * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
@@ -20,7 +35,7 @@ export function shortHash(input) {
 export function computeExternalArchivePath(absolutePath) {
     const resolved = path.resolve(absolutePath);
     const name = path.basename(resolved);
-    return path.join('_workspaces', `${name}-${shortHash(resolved)}`);
+    return path.posix.join('_workspaces', `${name}-${shortHash(resolved)}`);
 }
 /**
  * Returns true if dir is inside srcDir (i.e. it will already be included
@@ -71,7 +86,7 @@ async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
         if (isInsideSrcDir(workspaceDir, srcDir)) {
             // Internal: already in archive from srcDir walk.
             // Store the relative path from the package.json directory so npm can resolve it.
-            const relPath = path.relative(path.dirname(sourcePackageJsonPath), path.resolve(workspaceDir));
+            const relPath = toPosixPath(path.relative(path.dirname(sourcePackageJsonPath), path.resolve(workspaceDir)));
             packageWorkspaceEntries.get(sourcePackageJsonPath).push(relPath);
         }
         else {
@@ -89,7 +104,7 @@ async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
                 externalsToArchive.push({ dir: workspaceDir, archivePath });
             }
             const relPkgJsonDir = path.relative(srcDir, path.dirname(sourcePackageJsonPath));
-            const relativeEntry = path.relative(relPkgJsonDir, archivePath);
+            const relativeEntry = toPosixPath(path.relative(relPkgJsonDir, archivePath));
             packageWorkspaceEntries.get(sourcePackageJsonPath).push(relativeEntry);
         }
     }
@@ -130,7 +145,7 @@ async function archiveFileDependencies(archive, srcDir, fileDependencyMappings,
             packageFileDeps.set(sourcePackageJsonPath, new Map());
         }
         const relPkgJsonDir = path.relative(srcDir, path.dirname(sourcePackageJsonPath));
-        const relativeArchivePath = path.relative(relPkgJsonDir, archivePath);
+        const relativeArchivePath = toPosixPath(path.relative(relPkgJsonDir, archivePath));
         packageFileDeps
             .get(sourcePackageJsonPath)
             .set(packageName, relativeArchivePath);
@@ -172,7 +187,7 @@ export async function updatePackageJsonInArchive(archive, srcDir, packageWorkspa
         if (!fs.existsSync(packageJsonPath)) {
             continue;
         }
-        const relativePackageJsonPath = path.relative(srcDir, packageJsonPath);
+        const relativePackageJsonPath = toPosixPath(path.relative(srcDir, packageJsonPath));
         let rawContent;
         try {
             rawContent = fs.readFileSync(packageJsonPath, 'utf8');
@@ -261,11 +276,11 @@ export function rewriteLockfileForExternalDeps(lockfileContent, pathMappings) {
 export function getPackageJsonPathsToUpdate(srcDir, workspaceMappings, fileDependencyMappings) {
     const paths = new Set();
     for (const { sourcePackageJsonPath } of workspaceMappings) {
-        paths.add(path.relative(srcDir, sourcePackageJsonPath));
+        paths.add(toPosixPath(path.relative(srcDir, sourcePackageJsonPath)));
     }
     for (const { localPath, sourcePackageJsonPath } of fileDependencyMappings) {
         if (!isInsideSrcDir(localPath, srcDir)) {
-            paths.add(path.relative(srcDir, sourcePackageJsonPath));
+            paths.add(toPosixPath(path.relative(srcDir, sourcePackageJsonPath)));
         }
     }
     return paths;
@@ -290,7 +305,7 @@ export function getLockfilePathsToUpdate(srcDir, workspaceMappings, fileDependen
     for (const dir of dirsWithExternalDeps) {
         const lockfilePath = path.join(dir, 'package-lock.json');
         if (fs.existsSync(lockfilePath)) {
-            paths.add(path.relative(srcDir, lockfilePath));
+            paths.add(toPosixPath(path.relative(srcDir, lockfilePath)));
         }
     }
     return paths;
@@ -319,12 +334,12 @@ async function rewriteLockfilesInArchive(archive, srcDir, externalArchivePaths,
         const pathMappings = [];
         for (const [absoluteExternalPath, archivePath] of externalArchivePaths) {
             pathMappings.push({
-                oldPath: path.relative(dir, absoluteExternalPath),
-                newPath: path.relative(dir, path.join(srcDir, archivePath)),
+                oldPath: toPosixPath(path.relative(dir, absoluteExternalPath)),
+                newPath: toPosixPath(path.relative(dir, path.join(srcDir, archivePath))),
             });
         }
         const rewritten = rewriteLockfileForExternalDeps(lockfileContent, pathMappings);
-        const relativeLockfilePath = path.relative(srcDir, lockfilePath);
+        const relativeLockfilePath = toPosixPath(path.relative(srcDir, lockfilePath));
         uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingLockfile(relativeLockfilePath));
         archive.append(JSON.stringify(rewritten, null, 2), {
             name: relativeLockfilePath,
@@ -336,7 +351,7 @@ async function rewriteLockfilesInArchive(archive, srcDir, externalArchivePaths,
  * Main orchestration function that handles archiving of workspaces and file dependencies.
  * This is the clean integration point for upload.ts.
  */
-export async function archiveWorkspacesAndDependencies(archive, srcDir, projectDir, workspaceMappings, fileDependencyMappings) {
+export async function archiveWorkspacesAndDependencies(archive, srcDir, workspaceMappings, fileDependencyMappings) {
     // Archive workspace directories (internal ones are skipped, externals are copied)
     const { externalArchivePaths, packageWorkspaceEntries } = await archiveWorkspaceDirectories(archive, srcDir, workspaceMappings);
     // Archive external file: dependencies (internals are skipped)

package/lib/usageTracking.d.ts

@@ -1,29 +1,19 @@
-export type UsageTrackingMeta = {
-    action?: string;
-    os?: string;
-    nodeVersion?: string;
-    nodeMajorVersion?: string;
-    version?: string;
-    command?: string;
-    authType?: string;
-    step?: string;
-    assetType?: string;
-    mode?: string;
-    type?: string | number;
-    file?: boolean;
-    successful?: boolean;
-};
+import { type UsageTrackingMeta, type ConfigType, type ExecutionSource } from './api/usageTracking.js';
+export type { UsageTrackingMeta, ConfigType, ExecutionSource, } from './api/usageTracking.js';
 export declare const EventClass: {
     USAGE: string;
     INTERACTION: string;
     VIEW: string;
     ACTIVATION: string;
 };
-export declare function getNodeVersionData(): {
+export declare function getExecutionEnvironmentMeta(): {
+    os: string;
     nodeVersion: string;
     nodeMajorVersion: string;
+    version: string;
+    configType?: ConfigType;
+    executionSource: ExecutionSource;
 };
-export declare function getPlatform(): string;
 export declare function trackCommandUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;
 export declare function trackHelpUsage(command: string): Promise<void>;
 export declare function trackConvertFieldsUsage(command: string): Promise<void>;