@hubspot/cli 8.11.0-beta.0 → 8.12.0

package/lib/projects/release.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import { fetchProjectBuilds, getBuildStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { BUILD_STATUS } from '@hubspot/local-dev-lib/enums/build';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { meetsMinimumPlatformVersion } from '@hubspot/project-parsing-lib/projects';
+import { PLATFORM_VERSIONS } from '@hubspot/project-parsing-lib/constants';
+import { getLastSuccessfulBuild } from './builds.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { listPrompt } from '../prompts/promptUtils.js';
+import { commands } from '../../lang/en.js';
+import { createRelease } from '../../api/releases.js';
+function buildChoiceName(build) {
+    const base = build.uploadMessage
+        ? `${build.buildId} — ${build.uploadMessage}`
+        : `${build.buildId} — ${commands.project.release.create.noUploadMessage}`;
+    return build.status !== BUILD_STATUS.SUCCESS
+        ? `[${chalk.yellow('DISABLED')}] ${base}`
+        : base;
+}
+export async function resolveBuildId(accountId, projectName, buildOption, force) {
+    if (buildOption) {
+        return buildOption;
+    }
+    if (force) {
+        const lastSuccessful = await getLastSuccessfulBuild(accountId, projectName);
+        return lastSuccessful ? lastSuccessful.buildId : null;
+    }
+    let results;
+    try {
+        ({
+            data: { results },
+        } = await fetchProjectBuilds(accountId, projectName));
+    }
+    catch (e) {
+        if (isSpecifiedError(e, { statusCode: 404 }) ||
+            isSpecifiedError(e, { statusCode: 400 })) {
+            return undefined;
+        }
+        throw e;
+    }
+    if (results.length === 0) {
+        return undefined;
+    }
+    const lastSuccessful = await getLastSuccessfulBuild(accountId, projectName);
+    if (!lastSuccessful) {
+        uiLogger.error(commands.project.release.create.errors.noSuccessfulBuilds(projectName));
+        return null;
+    }
+    return listPrompt(commands.project.release.create.buildIdPrompt, {
+        choices: results.map(b => ({
+            name: buildChoiceName(b),
+            value: b.buildId,
+            disabled: b.status !== BUILD_STATUS.SUCCESS
+                ? `– ${commands.project.release.create.buildStatus[b.status] ?? b.status}`
+                : undefined,
+        })),
+    });
+}
+export async function validateBuildForRelease(accountId, projectName, buildId) {
+    try {
+        const { data: build } = await getBuildStatus(accountId, projectName, buildId);
+        return meetsMinimumPlatformVersion(build.platformVersion, PLATFORM_VERSIONS.v2026_09_BETA);
+    }
+    catch (e) {
+        if (isSpecifiedError(e, { statusCode: 404 })) {
+            uiLogger.error(commands.project.release.create.errors.buildNotFound(buildId, projectName));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId,
+                request: 'project release create',
+            }));
+        }
+        throw e;
+    }
+}
+export async function executeRelease(accountId, projectName, buildId) {
+    try {
+        const { data: release } = await createRelease(accountId, projectName, buildId);
+        return release;
+    }
+    catch (e) {
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'project release create',
+        }));
+        throw e;
+    }
+}

package/lib/yargs/makeWrappedYargsHandler.d.ts

@@ -1,3 +1,7 @@
 import { ArgumentsCamelCase } from 'yargs';
+import { z } from 'zod';
 import { CommonArgs } from '../../types/Yargs.js';
-export declare function makeWrappedYargsHandler<T extends CommonArgs>(trackingName: string, handler: (args: ArgumentsCamelCase<T>) => Promise<void>): (args: ArgumentsCamelCase<T>) => Promise<void>;
+export type WrappedHandlerOptions = {
+    jsonOutputSchema?: z.ZodType;
+};
+export declare function makeWrappedYargsHandler<T extends CommonArgs>(trackingName: string, handler: (args: ArgumentsCamelCase<T>) => Promise<void>, options?: WrappedHandlerOptions): (args: ArgumentsCamelCase<T>) => Promise<void>;

package/lib/yargs/makeWrappedYargsHandler.js

@@ -1,5 +1,6 @@
 import os from 'os';
 import path from 'path';
+import { z } from 'zod';
 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';
@@ -11,7 +12,8 @@ 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');
+import { MAX_LOG_FILES } from '../constants.js';
+const HANDLER_LOG_DIR = path.join(os.homedir(), '.hscli', 'logs', 'cli');
 function logUsageTrackingMessage(isJsonOutput) {
     if (isJsonOutput) {
         return;
@@ -32,90 +34,146 @@ function logUsageTrackingMessage(isJsonOutput) {
         return;
     }
 }
-export function makeWrappedYargsHandler(trackingName, handler) {
-    return async (args) => {
-        const startTime = Date.now();
-        const meta = {};
-        let trackingFired = false;
-        const trackingArgs = args;
-        const addUsageMetadata = (newMeta) => {
-            Object.assign(meta, newMeta);
-        };
-        trackingArgs.addUsageMetadata = addUsageMetadata;
-        const trackCommandUsage = async (successful) => {
-            if (trackingFired) {
-                return;
-            }
-            trackingFired = true;
-            try {
-                const { accountId: overrideAccountId, ...trackingMeta } = meta;
-                trackingMeta.successful = successful;
-                trackingMeta.executionTime = Date.now() - startTime;
-                await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? args.derivedAccountId);
+function createUsageTracker(trackingName, derivedAccountId) {
+    const startTime = Date.now();
+    const meta = {};
+    let fired = false;
+    const addMetadata = (newMeta) => {
+        Object.assign(meta, newMeta);
+    };
+    const track = async (successful) => {
+        if (fired) {
+            return;
+        }
+        fired = true;
+        try {
+            const { accountId: overrideAccountId, ...trackingMeta } = meta;
+            trackingMeta.successful = successful;
+            trackingMeta.executionTime = Date.now() - startTime;
+            await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? derivedAccountId);
+        }
+        catch (_e) { }
+    };
+    const onForcedExit = () => {
+        process.exit(EXIT_CODES.SUCCESS);
+    };
+    const onSigint = async () => {
+        process.removeListener('SIGINT', onSigint);
+        process.on('SIGINT', onForcedExit);
+        try {
+            await track(false);
+        }
+        catch (_e) { }
+        process.removeListener('SIGINT', onForcedExit);
+        process.exit(EXIT_CODES.SUCCESS);
+    };
+    process.on('SIGINT', onSigint);
+    const trackAndCleanup = async (successful) => {
+        await track(successful);
+        process.removeListener('SIGINT', onSigint);
+        process.removeListener('SIGINT', onForcedExit);
+    };
+    return { addMetadata, trackAndCleanup };
+}
+function createJsonOutputManager(isJsonOutput, schema) {
+    const data = {};
+    let emitted = false;
+    const add = (newData) => {
+        Object.assign(data, newData);
+    };
+    const emit = () => {
+        if (!emitted && isJsonOutput && Object.keys(data).length > 0) {
+            emitted = true;
+            if (schema) {
+                const result = schema.safeParse(data);
+                if (!result.success) {
+                    uiLogger.json(data);
+                    uiLogger.warn(lib.jsonSchema.validationFailed);
+                    return false;
+                }
             }
-            catch (_e) { }
-        };
-        const onForcedExit = () => {
-            process.exit(EXIT_CODES.SUCCESS);
-        };
-        const onSigint = async () => {
-            process.removeListener('SIGINT', onSigint);
-            process.on('SIGINT', onForcedExit);
-            try {
-                await trackCommandUsage(false);
+            uiLogger.json(data);
+        }
+        return true;
+    };
+    return { add, emit };
+}
+function createLogFileWriter(trackingName, isJsonOutput) {
+    const writeLogFile = () => {
+        if (isJsonOutput) {
+            return null;
+        }
+        return ldlLogger.writeBufferedLogsToFile({
+            dir: HANDLER_LOG_DIR,
+            filenamePrefix: trackingName,
+            maxFiles: MAX_LOG_FILES,
+        });
+    };
+    const writeFailureLogFile = () => {
+        const savedPath = writeLogFile();
+        if (savedPath) {
+            uiLogger.log('');
+            uiLogger.error(lib.handlerLogFile.saved(savedPath));
+        }
+    };
+    return { writeLogFile, writeFailureLogFile };
+}
+export function makeWrappedYargsHandler(trackingName, handler, options) {
+    return async (args) => {
+        const wrappedHandlerArgs = args;
+        const isJsonOutput = Boolean(wrappedHandlerArgs.json || wrappedHandlerArgs.formatOutputAsJson);
+        const schema = options?.jsonOutputSchema;
+        const tracker = createUsageTracker(trackingName, args.derivedAccountId);
+        if (wrappedHandlerArgs.jsonSchema) {
+            if (schema) {
+                uiLogger.json(z.toJSONSchema(schema));
             }
-            catch (_e) { }
-            process.removeListener('SIGINT', onForcedExit);
-            process.exit(EXIT_CODES.SUCCESS);
-        };
-        process.on('SIGINT', onSigint);
-        const trackCommandUsageAndRemoveListeners = async (successful) => {
-            await trackCommandUsage(successful);
-            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;
+            else {
+                uiLogger.json({ error: lib.jsonSchema.noSchemaForCommand });
             }
-            const savedPath = ldlLogger.writeBufferedLogsToFile({
-                dir: HANDLER_LOG_DIR,
-                filenamePrefix: trackingName,
-            });
-            if (savedPath) {
-                uiLogger.log('');
-                uiLogger.error(lib.handlerLogFile.saved(savedPath));
+            await tracker.trackAndCleanup(true);
+            return process.exit(EXIT_CODES.SUCCESS);
+        }
+        const json = createJsonOutputManager(isJsonOutput, schema);
+        const logs = createLogFileWriter(trackingName, isJsonOutput);
+        wrappedHandlerArgs.addUsageMetadata = tracker.addMetadata;
+        wrappedHandlerArgs.addJsonOutput = json.add;
+        wrappedHandlerArgs.exit = async (code) => {
+            const jsonValid = json.emit();
+            const exitCode = !jsonValid && code === EXIT_CODES.SUCCESS ? EXIT_CODES.WARNING : code;
+            await tracker.trackAndCleanup(exitCode !== EXIT_CODES.ERROR);
+            if (exitCode === EXIT_CODES.ERROR) {
+                logs.writeFailureLogFile();
             }
-        };
-        trackingArgs.exit = async (code) => {
-            await trackCommandUsageAndRemoveListeners(code !== EXIT_CODES.ERROR);
-            if (code === EXIT_CODES.ERROR) {
-                writeFailureLogFile();
+            else {
+                logs.writeLogFile();
             }
-            return process.exit(code);
+            return process.exit(exitCode);
         };
         logUsageTrackingMessage(isJsonOutput);
         try {
-            await handler(trackingArgs);
+            await handler(wrappedHandlerArgs);
         }
         catch (e) {
             const isSuccessfulPromptExit = isPromptExitError(e)
                 ? e.exitCode !== EXIT_CODES.ERROR
                 : false;
-            await trackCommandUsageAndRemoveListeners(isSuccessfulPromptExit);
+            await tracker.trackAndCleanup(isSuccessfulPromptExit);
             if (isPromptExitError(e)) {
+                logs.writeLogFile();
                 return process.exit(e.exitCode);
             }
             else {
                 debugError(e);
-                writeFailureLogFile();
+                logs.writeFailureLogFile();
                 return process.exit(EXIT_CODES.ERROR);
             }
         }
-        await trackCommandUsageAndRemoveListeners(true);
+        const jsonValid = json.emit();
+        await tracker.trackAndCleanup(true);
+        logs.writeLogFile();
+        if (!jsonValid) {
+            return process.exit(EXIT_CODES.WARNING);
+        }
     };
 }

package/mcp-server/Tool.js

@@ -22,6 +22,7 @@ export class Tool {
         return runCommandInDir(directory, command, async (chunk) => {
             try {
                 const message = `${chunk.trimEnd()}`;
+                this.logger.debug(this.toolName, message);
                 const token = extra?._meta?.progressToken;
                 if (token !== undefined && extra?.sendNotification) {
                     progressCount++;
@@ -43,31 +44,36 @@ export class Tool {
     getTrackingMeta(_input) {
         return undefined;
     }
-    async wrappedHandler(input, extra) {
-        const startTime = Date.now();
-        try {
-            // `input` is logged unredacted. Tool input schemas MUST NOT include
-            // credentials or other sensitive values, since MCP clients (Claude
-            // Desktop, Inspector, etc.) will display these logs.
-            this.logger.debug(this.toolName, {
-                message: 'Tool invoked',
-                args: input,
-            });
-            await trackToolUsage(this.toolName, this.getTrackingMeta(input));
-            const result = await this.handler(input, extra);
-            this.logger.debug(this.toolName, {
-                message: 'Tool completed',
-                durationMs: Date.now() - startTime,
-            });
-            return result;
-        }
-        catch (error) {
-            this.logger.error(this.toolName, {
-                message: 'Tool failed',
-                error: error instanceof Error ? error.message : String(error),
-                durationMs: Date.now() - startTime,
-            });
-            return formatTextContents(getErrorMessage(error));
-        }
+    wrappedHandler(input, extra) {
+        return this.logger.runWithBuffer(async () => {
+            const startTime = Date.now();
+            try {
+                // `input` is logged unredacted. Tool input schemas MUST NOT include
+                // credentials or other sensitive values, since MCP clients (Claude
+                // Desktop, Inspector, etc.) will display these logs.
+                this.logger.debug(this.toolName, {
+                    message: 'Tool invoked',
+                    args: input,
+                });
+                await trackToolUsage(this.toolName, this.getTrackingMeta(input));
+                const result = await this.handler(input, extra);
+                this.logger.debug(this.toolName, {
+                    message: 'Tool completed',
+                    durationMs: Date.now() - startTime,
+                });
+                return result;
+            }
+            catch (error) {
+                this.logger.error(this.toolName, {
+                    message: 'Tool failed',
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startTime,
+                });
+                return formatTextContents(getErrorMessage(error));
+            }
+            finally {
+                this.logger.flushLogsToFile(this.toolName);
+            }
+        });
     }
 }

package/mcp-server/utils/logger.d.ts

@@ -1,10 +1,13 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare class McpLogger {
     private mcpServer;
+    private invocationStorage;
     constructor(mcpServer: McpServer);
     private log;
     debug(logger: string, data: unknown): void;
     info(logger: string, data: unknown): void;
     warn(logger: string, data: unknown): void;
     error(logger: string, data: unknown): void;
+    runWithBuffer<T>(fn: () => Promise<T>): Promise<T>;
+    flushLogsToFile(filenamePrefix: string): string | null;
 }

package/mcp-server/utils/logger.js

@@ -1,10 +1,22 @@
+import os from 'os';
+import path from 'path';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { LogBuffer } from '@hubspot/local-dev-lib/LogBuffer';
+import { MAX_LOG_FILES } from '../../lib/constants.js';
+const MCP_LOG_DIR = path.join(os.homedir(), '.hscli', 'logs', 'tools');
 export class McpLogger {
     mcpServer;
+    invocationStorage = new AsyncLocalStorage();
     constructor(mcpServer) {
         this.mcpServer = mcpServer;
     }
     log(level, logger, data) {
         try {
+            const buffer = this.invocationStorage.getStore();
+            if (buffer) {
+                const serialized = typeof data === 'string' ? data : JSON.stringify(data);
+                buffer.record(level, [logger, serialized]);
+            }
             this.mcpServer.sendLoggingMessage({ level, logger, data });
         }
         catch (error) {
@@ -26,4 +38,22 @@ export class McpLogger {
     error(logger, data) {
         this.log('error', logger, data);
     }
+    // Runs fn in a fresh per-invocation log buffer context. All log calls made
+    // within fn (including nested async callbacks like progress chunks) record
+    // into this buffer rather than a shared one, so concurrent tool calls never
+    // intermix their logs.
+    runWithBuffer(fn) {
+        return this.invocationStorage.run(new LogBuffer(), fn);
+    }
+    flushLogsToFile(filenamePrefix) {
+        const buffer = this.invocationStorage.getStore();
+        if (!buffer) {
+            return null;
+        }
+        return buffer.writeToFile({
+            dir: MCP_LOG_DIR,
+            filenamePrefix,
+            maxFiles: MAX_LOG_FILES,
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.11.0-beta.0",
+    "version": "8.12.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.10.0",
-        "@hubspot/project-parsing-lib": "0.19.1",
+        "@hubspot/local-dev-lib": "5.10.1",
+        "@hubspot/project-parsing-lib": "0.21.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
-        "@hubspot/ui-extensions-dev-server": "2.0.10",
+        "@hubspot/ui-extensions-dev-server": "2.0.13",
         "@inquirer/prompts": "7.1.0",
         "@modelcontextprotocol/sdk": "1.29.0",
         "archiver": "7.0.1",
@@ -40,10 +40,11 @@
         "update-notifier": "7.3.1",
         "ws": "8.20.0",
         "yargs": "17.7.2",
-        "yargs-parser": "21.1.1"
+        "yargs-parser": "21.1.1",
+        "zod": "^4.4.3"
     },
     "devDependencies": {
-        "@hubspot/npm-scripts": "0.2.2",
+        "@hubspot/npm-scripts": "0.3.1",
         "@types/archiver": "^6.0.3",
         "@types/cli-progress": "^3.11.6",
         "@types/express": "^5.0.0",
@@ -60,7 +61,7 @@
         "@typescript-eslint/eslint-plugin": "^8.30.1",
         "@typescript-eslint/parser": "^8.11.0",
         "@vitest/coverage-v8": "^2.1.9",
-        "axios": "1.16.0",
+        "axios": "1.18.1",
         "eslint": "^8.56.0",
         "eslint-plugin-import": "^2.31.0",
         "husky": "^4.3.8",
@@ -123,6 +124,7 @@
         "registry": "https://registry.npmjs.org/"
     },
     "resolutions": {
-        "eslint-visitor-keys": "4.2.0"
+        "eslint-visitor-keys": "4.2.0",
+        "@eslint-community/eslint-utils": "4.9.0"
     }
 }

package/types/Yargs.d.ts

@@ -38,9 +38,11 @@ export type OverwriteArgs = Options & {
 export type StringArgType = Options & {
     type: 'string';
 };
-export type JSONOutputArgs = Options & {
+export type JSONOutputArgs<J extends Record<string, unknown> = Record<string, unknown>> = Options & {
     json?: boolean;
+    jsonSchema?: boolean;
     formatOutputAsJson?: boolean;
+    addJsonOutput: (data: Partial<J>) => void;
 };
 export type ProjectDevArgs = CommonArgs & ConfigArgs & EnvironmentArgs & {
     profile?: string;

package/commands/project/dev/deprecatedFlow.d.ts

@@ -1,11 +0,0 @@
-import { ArgumentsCamelCase } from 'yargs';
-import { ProjectConfig } from '../../../types/Projects.js';
-import { ProjectDevArgs } from '../../../types/Yargs.js';
-type DeprecatedProjectDevFlowArgs = {
-    args: ArgumentsCamelCase<ProjectDevArgs>;
-    accountId: number;
-    projectConfig: ProjectConfig;
-    projectDir: string;
-};
-export declare function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }: DeprecatedProjectDevFlowArgs): Promise<void>;
-export {};