@hubspot/cli 8.1.0-experimental.0 → 8.1.1-experimental.0

package/commands/project/list.d.ts

@@ -1,4 +1,4 @@
-import { AccountArgs, CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectListArgs = CommonArgs & ConfigArgs & AccountArgs;
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectListArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs;
 declare const projectListCommand: YargsCommandModule<unknown, ProjectListArgs>;
 export default projectListCommand;

package/commands/project/list.js

@@ -52,6 +52,7 @@ const builder = makeYargsBuilder(projectListBuilder, command, describe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
+    useEnvironmentOptions: true,
 });
 const projectListCommand = {
     command,

package/commands/project/upload.d.ts

@@ -4,6 +4,7 @@ export type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
     message: string;
     m: string;
     skipValidation: boolean;
+    skipNpmAudit: boolean;
     profile?: string;
 };
 declare const projectUploadCommand: YargsCommandModule<unknown, ProjectUploadArgs>;

package/commands/project/upload.js

@@ -18,7 +18,7 @@ import { projectProfilePrompt } from '../../lib/prompts/projectProfilePrompt.js'
 const command = 'upload';
 const describe = commands.project.upload.describe;
 async function handler(args) {
-    const { forceCreate, message, derivedAccountId, skipValidation, formatOutputAsJson, profile: profileOption, useEnv: useEnvOption, exit, addUsageMetadata, } = args;
+    const { forceCreate, message, derivedAccountId, skipValidation, skipNpmAudit, formatOutputAsJson, profile: profileOption, useEnv: useEnvOption, exit, addUsageMetadata, } = args;
     const jsonOutput = {};
     const { projectConfig, projectDir } = await getProjectConfig();
     try {
@@ -66,6 +66,7 @@ async function handler(args) {
             isUploadCommand: true,
             sendIR: !isLegacyProject(projectConfig.platformVersion),
             skipValidation,
+            skipNpmAudit,
             profile: profileName,
         });
         if (uploadError) {
@@ -127,6 +128,11 @@ function projectUploadBuilder(yargs) {
             hidden: true,
             default: false,
         },
+        'skip-npm-audit': {
+            describe: commands.project.upload.options.skipNpmAudit.describe,
+            type: 'boolean',
+            default: false,
+        },
         profile: {
             type: 'string',
             alias: 'p',

package/lang/en.d.ts

@@ -1826,6 +1826,9 @@ export declare const commands: {
                 profile: {
                     describe: string;
                 };
+                skipNpmAudit: {
+                    describe: string;
+                };
             };
         };
         watch: {
@@ -3089,6 +3092,9 @@ export declare const lib: {
     process: {
         exitDebug: (signal: string) => string;
     };
+    handlerLogFile: {
+        saved: (filePath: string) => string;
+    };
     DevServerManager: {
         portConflict: (port: string) => string;
         notInitialized: string;
@@ -3391,6 +3397,10 @@ export declare const lib: {
             updatingPackageJsonWorkspaces: (packageJsonPath: string) => string;
             updatedWorkspaces: (workspaces: string) => string;
             updatedFileDependency: (packageName: string, relativePath: string) => string;
+            npmAuditClean: (packageRoot: string) => string;
+            npmAuditIssues: (packageRoot: string, details: string) => string;
+            npmAuditNpmUnavailable: (packageRoot: string) => string;
+            npmAuditNonZeroExit: (packageRoot: string, exitCode: number) => string;
         };
     };
     importData: {

package/lang/en.js

@@ -1843,6 +1843,9 @@ export const commands = {
                 profile: {
                     describe: 'Profile to target for this upload',
                 },
+                skipNpmAudit: {
+                    describe: 'Skip the npm audit security check before uploading',
+                },
             },
         },
         watch: {
@@ -3115,6 +3118,9 @@ export const lib = {
     process: {
         exitDebug: (signal) => `Attempting to gracefully exit. Triggered by ${signal}`,
     },
+    handlerLogFile: {
+        saved: (filePath) => `Debug logs can be viewed at ${filePath}`,
+    },
     DevServerManager: {
         portConflict: (port) => `The port ${port} is already in use.`,
         notInitialized: 'The Dev Server Manager must be initialized before it is started.',
@@ -3417,6 +3423,10 @@ export const lib = {
             updatingPackageJsonWorkspaces: (packageJsonPath) => `Updating package.json workspaces in archive: ${packageJsonPath}`,
             updatedWorkspaces: (workspaces) => `  Updated workspaces: ${workspaces}`,
             updatedFileDependency: (packageName, relativePath) => `  Updated dependencies.${packageName}: file:${relativePath}`,
+            npmAuditClean: (packageRoot) => `npm audit: No npm dependency issues found for ${chalk.bold(packageRoot)}`,
+            npmAuditIssues: (packageRoot, details) => `npm audit: security issues found for ${chalk.bold(packageRoot)}: ${details}`,
+            npmAuditNpmUnavailable: (packageRoot) => `npm audit: skipped for ${chalk.bold(packageRoot)} (npm not available in PATH)`,
+            npmAuditNonZeroExit: (packageRoot, exitCode) => `npm audit: ${chalk.bold(packageRoot)} exited with code ${exitCode}`,
         },
     },
     importData: {

package/lib/api/usageTracking.d.ts

@@ -0,0 +1,29 @@
+export type ConfigType = 'local' | 'global';
+export type ExecutionSource = 'ci' | 'mcp' | 'user';
+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;
+    configType?: ConfigType;
+    executionSource?: ExecutionSource;
+    platformVersion?: string;
+    executionTime?: number;
+};
+export type UsageTrackingRequest = {
+    portalId?: number;
+    accountId?: number;
+    eventName: string;
+    eventClass: string;
+    meta: UsageTrackingMeta;
+};
+export declare function sendUsageEvent(request: UsageTrackingRequest): Promise<void>;

package/lib/api/usageTracking.js

@@ -0,0 +1,28 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import { http as unauthedHttp } from '@hubspot/local-dev-lib/http/unauthed';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+const USAGE_PATH = 'local/dev/tools/proxy/v1/usage';
+const USAGE_AUTHENTICATED_PATH = `${USAGE_PATH}/authenticated`;
+export async function sendUsageEvent(request) {
+    const { accountId } = request;
+    if (accountId) {
+        try {
+            const account = getConfigAccountById(accountId);
+            if (account?.authType === 'personalaccesskey') {
+                await http.post(accountId, {
+                    url: USAGE_AUTHENTICATED_PATH,
+                    data: request,
+                });
+                return;
+            }
+        }
+        catch (_e) { }
+    }
+    try {
+        await unauthedHttp.post({
+            url: USAGE_PATH,
+            data: request,
+        });
+    }
+    catch (_e) { }
+}

package/lib/projects/npmAuditOnUpload.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedPackageJson } from '@hubspot/project-parsing-lib/workspaces';
+export declare function summarizeNpmAuditJson(source: string): string | null;
+type RunNpmAuditsBeforeProjectUploadArgs = {
+    srcDir: string;
+    projectDir: string;
+    parsedPackageJsons: ParsedPackageJson[];
+    isLegacyPlatform: boolean;
+};
+export declare function runNpmAuditsBeforeProjectUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }: RunNpmAuditsBeforeProjectUploadArgs): Promise<void>;
+export {};

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/upload.d.ts

@@ -16,9 +16,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,7 @@ 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 { runNpmAuditsBeforeProjectUpload } from './npmAuditOnUpload.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
     SpinniesManager.add('upload', {
@@ -44,7 +45,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 +55,20 @@ 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 && !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 () {
@@ -123,7 +133,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
         return ignored ? false : file;
     });
     // Archive workspaces and file: dependencies
-    await archiveWorkspacesAndDependencies(archive, srcDir, workspaceMappings, fileDependencyMappings);
+    await archiveWorkspacesAndDependencies(archive, srcDir, projectDir, workspaceMappings, fileDependencyMappings);
     archive.finalize();
     return result;
 }

package/lib/projects/workspaces.d.ts

@@ -12,16 +12,6 @@ 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.
@@ -49,4 +39,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, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;
+export declare function archiveWorkspacesAndDependencies(archive: archiver.Archiver, srcDir: string, projectDir: string, workspaceMappings: WorkspaceMapping[], fileDependencyMappings: FileDependencyMapping[]): Promise<WorkspaceArchiveResult>;

package/lib/projects/workspaces.js

@@ -12,21 +12,6 @@ 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.
@@ -35,7 +20,7 @@ export function toPosixPath(p) {
 export function computeExternalArchivePath(absolutePath) {
     const resolved = path.resolve(absolutePath);
     const name = path.basename(resolved);
-    return path.posix.join('_workspaces', `${name}-${shortHash(resolved)}`);
+    return path.join('_workspaces', `${name}-${shortHash(resolved)}`);
 }
 /**
  * Returns true if dir is inside srcDir (i.e. it will already be included
@@ -86,7 +71,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 = toPosixPath(path.relative(path.dirname(sourcePackageJsonPath), path.resolve(workspaceDir)));
+            const relPath = path.relative(path.dirname(sourcePackageJsonPath), path.resolve(workspaceDir));
             packageWorkspaceEntries.get(sourcePackageJsonPath).push(relPath);
         }
         else {
@@ -104,7 +89,7 @@ async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
                 externalsToArchive.push({ dir: workspaceDir, archivePath });
             }
             const relPkgJsonDir = path.relative(srcDir, path.dirname(sourcePackageJsonPath));
-            const relativeEntry = toPosixPath(path.relative(relPkgJsonDir, archivePath));
+            const relativeEntry = path.relative(relPkgJsonDir, archivePath);
             packageWorkspaceEntries.get(sourcePackageJsonPath).push(relativeEntry);
         }
     }
@@ -145,7 +130,7 @@ async function archiveFileDependencies(archive, srcDir, fileDependencyMappings,
             packageFileDeps.set(sourcePackageJsonPath, new Map());
         }
         const relPkgJsonDir = path.relative(srcDir, path.dirname(sourcePackageJsonPath));
-        const relativeArchivePath = toPosixPath(path.relative(relPkgJsonDir, archivePath));
+        const relativeArchivePath = path.relative(relPkgJsonDir, archivePath);
         packageFileDeps
             .get(sourcePackageJsonPath)
             .set(packageName, relativeArchivePath);
@@ -187,7 +172,7 @@ export async function updatePackageJsonInArchive(archive, srcDir, packageWorkspa
         if (!fs.existsSync(packageJsonPath)) {
             continue;
         }
-        const relativePackageJsonPath = toPosixPath(path.relative(srcDir, packageJsonPath));
+        const relativePackageJsonPath = path.relative(srcDir, packageJsonPath);
         let rawContent;
         try {
             rawContent = fs.readFileSync(packageJsonPath, 'utf8');
@@ -276,11 +261,11 @@ export function rewriteLockfileForExternalDeps(lockfileContent, pathMappings) {
 export function getPackageJsonPathsToUpdate(srcDir, workspaceMappings, fileDependencyMappings) {
     const paths = new Set();
     for (const { sourcePackageJsonPath } of workspaceMappings) {
-        paths.add(toPosixPath(path.relative(srcDir, sourcePackageJsonPath)));
+        paths.add(path.relative(srcDir, sourcePackageJsonPath));
     }
     for (const { localPath, sourcePackageJsonPath } of fileDependencyMappings) {
         if (!isInsideSrcDir(localPath, srcDir)) {
-            paths.add(toPosixPath(path.relative(srcDir, sourcePackageJsonPath)));
+            paths.add(path.relative(srcDir, sourcePackageJsonPath));
         }
     }
     return paths;
@@ -305,7 +290,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(toPosixPath(path.relative(srcDir, lockfilePath)));
+            paths.add(path.relative(srcDir, lockfilePath));
         }
     }
     return paths;
@@ -334,12 +319,12 @@ async function rewriteLockfilesInArchive(archive, srcDir, externalArchivePaths,
         const pathMappings = [];
         for (const [absoluteExternalPath, archivePath] of externalArchivePaths) {
             pathMappings.push({
-                oldPath: toPosixPath(path.relative(dir, absoluteExternalPath)),
-                newPath: toPosixPath(path.relative(dir, path.join(srcDir, archivePath))),
+                oldPath: path.relative(dir, absoluteExternalPath),
+                newPath: path.relative(dir, path.join(srcDir, archivePath)),
             });
         }
         const rewritten = rewriteLockfileForExternalDeps(lockfileContent, pathMappings);
-        const relativeLockfilePath = toPosixPath(path.relative(srcDir, lockfilePath));
+        const relativeLockfilePath = path.relative(srcDir, lockfilePath);
         uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingLockfile(relativeLockfilePath));
         archive.append(JSON.stringify(rewritten, null, 2), {
             name: relativeLockfilePath,
@@ -351,7 +336,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, workspaceMappings, fileDependencyMappings) {
+export async function archiveWorkspacesAndDependencies(archive, srcDir, projectDir, 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>;

package/lib/usageTracking.js

@@ -1,10 +1,10 @@
-import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { getConfigAccountById, getConfig } from '@hubspot/local-dev-lib/config';
+import { getConfig, getConfigAccountById, getConfigFilePath, getGlobalConfigFilePath, } from '@hubspot/local-dev-lib/config';
 import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
 import { uiLogger } from './ui/logger.js';
 import { pkg } from './jsonLoader.js';
 import { debugError } from './errorHandlers/index.js';
 import { isUsageTrackingDisableFlagSet } from './middleware/usageTrackingMiddleware.js';
+import { sendUsageEvent, } from './api/usageTracking.js';
 const version = pkg.version;
 const usageTrackingDiabled = 'Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events';
 export const EventClass = {
@@ -13,13 +13,13 @@ export const EventClass = {
     VIEW: 'VIEW',
     ACTIVATION: 'ACTIVATION',
 };
-export function getNodeVersionData() {
+function getNodeVersionData() {
     return {
         nodeVersion: process.version,
         nodeMajorVersion: (process.version || '').split('.')[0],
     };
 }
-export function getPlatform() {
+function getPlatform() {
     switch (process.platform) {
         case 'darwin':
             return 'macos';
@@ -29,6 +29,34 @@ export function getPlatform() {
             return process.platform;
     }
 }
+function getConfigType() {
+    try {
+        return getConfigFilePath() === getGlobalConfigFilePath()
+            ? 'global'
+            : 'local';
+    }
+    catch (_e) {
+        return undefined;
+    }
+}
+function getExecutionSource() {
+    if (process.env.HUBSPOT_MCP_AI_AGENT) {
+        return 'mcp';
+    }
+    if (process.env.CI) {
+        return 'ci';
+    }
+    return 'user';
+}
+export function getExecutionEnvironmentMeta() {
+    return {
+        os: getPlatform(),
+        ...getNodeVersionData(),
+        version,
+        configType: getConfigType(),
+        executionSource: getExecutionSource(),
+    };
+}
 export async function trackCommandUsage(command, meta = {}, accountId) {
     if (isUsageTrackingDisableFlagSet()) {
         uiLogger.debug(usageTrackingDiabled);
@@ -130,39 +158,25 @@ async function trackCliInteraction({ action, accountId, command, authType, meta
         if (config?.allowUsageTracking === false) {
             return;
         }
+        if (isUsageTrackingDisableFlagSet()) {
+            uiLogger.debug(usageTrackingDiabled);
+            return;
+        }
         const usageTrackingEvent = {
             action,
-            os: getPlatform(),
-            ...getNodeVersionData(),
-            version,
             command,
             authType,
+            ...getExecutionEnvironmentMeta(),
             ...meta,
         };
-        if (process.env.HUBSPOT_MCP_AI_AGENT) {
-            try {
-                await trackUsage('cli-interaction', EventClass.INTERACTION, {
-                    ...usageTrackingEvent,
-                    action: 'cli-mcp-server',
-                    type: process.env.HUBSPOT_MCP_AI_AGENT,
-                }, accountId);
-                uiLogger.debug('Sent AI usage tracking command event:', {
-                    ...usageTrackingEvent,
-                    action: 'cli-mcp-server',
-                    type: process.env.HUBSPOT_MCP_AI_AGENT,
-                });
-            }
-            catch (error) {
-                debugError(error);
-            }
-        }
-        if (isUsageTrackingDisableFlagSet()) {
-            uiLogger.debug(usageTrackingDiabled);
-            return;
-        }
         try {
             uiLogger.debug('Sent usage tracking command event:', usageTrackingEvent);
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            await sendUsageEvent({
+                eventName: 'cli-interaction',
+                eventClass: EventClass.INTERACTION,
+                meta: usageTrackingEvent,
+                accountId,
+            });
         }
         catch (error) {
             debugError(error);

package/lib/yargs/makeYargsHandlerWithUsageTracking.js

@@ -1,6 +1,9 @@
+import os from 'os';
+import path from 'path';
 import { getConfig } from '@hubspot/local-dev-lib/config';
 import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
 import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { logger as ldlLogger } from '@hubspot/local-dev-lib/logger';
 import { trackCommandUsage as _trackCommandUsage } from '../usageTracking.js';
 import { pkg } from '../jsonLoader.js';
 import { uiLogger } from '../ui/logger.js';
@@ -8,6 +11,7 @@ import { lib } from '../../lang/en.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isPromptExitError } from '../errors/PromptExitError.js';
 import { debugError } from '../errorHandlers/index.js';
+const HANDLER_LOG_DIR = path.join(os.homedir(), '.hscli', 'logs');
 function logUsageTrackingMessage(isJsonOutput) {
     if (isJsonOutput) {
         return;
@@ -30,6 +34,7 @@ function logUsageTrackingMessage(isJsonOutput) {
 }
 export function makeYargsHandlerWithUsageTracking(trackingName, handler) {
     return async (args) => {
+        const startTime = Date.now();
         const meta = {};
         let trackingFired = false;
         const trackingArgs = args;
@@ -45,6 +50,7 @@ export function makeYargsHandlerWithUsageTracking(trackingName, handler) {
             try {
                 const { accountId: overrideAccountId, ...trackingMeta } = meta;
                 trackingMeta.successful = successful;
+                trackingMeta.executionTime = Date.now() - startTime;
                 await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? args.derivedAccountId);
             }
             catch (_e) { }
@@ -68,12 +74,31 @@ export function makeYargsHandlerWithUsageTracking(trackingName, handler) {
             process.removeListener('SIGINT', onSigint);
             process.removeListener('SIGINT', onForcedExit);
         };
+        const jsonArgs = args;
+        const isJsonOutput = Boolean(jsonArgs.json || jsonArgs.formatOutputAsJson);
+        const writeFailureLogFile = () => {
+            // Skip in JSON output modes so the side effect + stderr message don't
+            // interfere with structured output consumers.
+            if (isJsonOutput) {
+                return;
+            }
+            const savedPath = ldlLogger.writeBufferedLogsToFile({
+                dir: HANDLER_LOG_DIR,
+                filenamePrefix: trackingName,
+            });
+            if (savedPath) {
+                uiLogger.log('');
+                uiLogger.error(lib.handlerLogFile.saved(savedPath));
+            }
+        };
         trackingArgs.exit = async (code) => {
             await trackCommandUsageAndRemoveListeners(code !== EXIT_CODES.ERROR);
+            if (code === EXIT_CODES.ERROR) {
+                writeFailureLogFile();
+            }
             return process.exit(code);
         };
-        const jsonArgs = args;
-        logUsageTrackingMessage(Boolean(jsonArgs.json || jsonArgs.formatOutputAsJson));
+        logUsageTrackingMessage(isJsonOutput);
         try {
             await handler(trackingArgs);
         }
@@ -87,6 +112,7 @@ export function makeYargsHandlerWithUsageTracking(trackingName, handler) {
             }
             else {
                 debugError(e);
+                writeFailureLogFile();
                 return process.exit(EXIT_CODES.ERROR);
             }
         }

package/mcp-server/utils/toolUsageTracking.js

@@ -1,6 +1,6 @@
-import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { EventClass, getNodeVersionData, getPlatform, } from '../../lib/usageTracking.js';
+import { EventClass, getExecutionEnvironmentMeta, } from '../../lib/usageTracking.js';
 import { getConfig, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { sendUsageEvent } from '../../lib/api/usageTracking.js';
 export async function trackToolUsage(toolName, meta) {
     const config = getConfig();
     if (config?.allowUsageTracking === false) {
@@ -8,15 +8,19 @@ export async function trackToolUsage(toolName, meta) {
     }
     const usageTrackingEvent = {
         action: 'cli-mcp-tool-invocation',
-        os: getPlatform(),
-        ...getNodeVersionData(),
         command: toolName,
         type: process.env.HUBSPOT_MCP_AI_AGENT,
+        ...getExecutionEnvironmentMeta(),
         ...meta,
     };
     const accountId = getConfigDefaultAccountIfExists()?.accountId || undefined;
     try {
-        await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+        await sendUsageEvent({
+            eventName: 'cli-interaction',
+            eventClass: EventClass.INTERACTION,
+            meta: usageTrackingEvent,
+            accountId,
+        });
     }
-    catch (error) { }
+    catch (_error) { }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.1.0-experimental.0",
+    "version": "8.1.1-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -10,10 +10,10 @@
         "!**/__tests__/**"
     ],
     "dependencies": {
-        "@hubspot/local-dev-lib": "5.6.0",
+        "@hubspot/local-dev-lib": "5.7.0",
         "@hubspot/project-parsing-lib": "0.16.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
-        "@hubspot/ui-extensions-dev-server": "2.0.5",
+        "@hubspot/ui-extensions-dev-server": "2.0.7",
         "@inquirer/prompts": "7.1.0",
         "@modelcontextprotocol/sdk": "1.29.0",
         "archiver": "7.0.1",