@hubspot/cli 8.2.0-experimental.2 → 8.2.1-experimental.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/projects/ui.d.ts

@@ -1 +1,2 @@
 export declare function logFeedbackMessage(buildId: number): void;
+export declare function warnAboutSkippedHsMetaFiles(skippedHsMetaFiles: string[], force: boolean, isUpload?: boolean): Promise<boolean>;

package/lib/projects/ui.js

@@ -2,6 +2,7 @@ import { uiLogger } from '../ui/logger.js';
 import { FEEDBACK_INTERVAL } from '../constants.js';
 import { uiLine } from '../ui/index.js';
 import { lib } from '../../lang/en.js';
+import { confirmPrompt } from '../prompts/promptUtils.js';
 export function logFeedbackMessage(buildId) {
     if (buildId > 0 && buildId % FEEDBACK_INTERVAL === 0) {
         uiLine();
@@ -10,3 +11,16 @@ export function logFeedbackMessage(buildId) {
         uiLogger.log(lib.projects.logFeedbackMessage.feedbackMessage);
     }
 }
+export async function warnAboutSkippedHsMetaFiles(skippedHsMetaFiles, force, isUpload = true) {
+    if (skippedHsMetaFiles.length === 0)
+        return true;
+    const message = isUpload
+        ? lib.projects.skippedHsMetaFiles.uploadWarning(skippedHsMetaFiles)
+        : lib.projects.skippedHsMetaFiles.warning(skippedHsMetaFiles);
+    uiLogger.warn(message);
+    if (force)
+        return true;
+    return confirmPrompt(lib.projects.skippedHsMetaFiles.prompt, {
+        defaultAnswer: false,
+    });
+}

package/lib/projects/upload.d.ts

@@ -1,4 +1,5 @@
 import { FileResult } from 'tmp';
+import { type IntermediateRepresentation } from '@hubspot/project-parsing-lib/translate';
 import { ProjectConfig } from '../../types/Projects.js';
 type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number) => Promise<T>;
 type ProjectUploadResult<T> = {
@@ -6,6 +7,7 @@ type ProjectUploadResult<T> = {
     uploadError?: unknown;
     projectNotFound?: boolean;
     projectId?: number;
+    userDeclined?: boolean;
 };
 type HandleProjectUploadArg<T> = {
     accountId: number;
@@ -18,9 +20,11 @@ type HandleProjectUploadArg<T> = {
     sendIR?: boolean;
     skipValidation?: boolean;
     skipNpmAudit?: boolean;
+    skipAutoDeploy?: boolean;
     profile?: string;
+    force?: boolean;
 };
-export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, skipNpmAudit, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
+export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, skipNpmAudit, skipAutoDeploy, force, }: 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 = {
@@ -31,5 +35,9 @@ type HandleTranslateArg = {
     profile?: string;
     includeTranslationErrorMessage?: boolean;
 };
-export declare function handleTranslate({ projectDir, projectConfig, accountId, skipValidation, profile, includeTranslationErrorMessage, }: HandleTranslateArg): Promise<unknown>;
+export type HandleTranslateResult = {
+    intermediateRepresentation: IntermediateRepresentation;
+    skippedHsMetaFiles: string[];
+};
+export declare function handleTranslate({ projectDir, projectConfig, accountId, skipValidation, profile, includeTranslationErrorMessage, }: HandleTranslateArg): Promise<HandleTranslateResult>;
 export {};

package/lib/projects/upload.js

@@ -9,6 +9,7 @@ import { projectContainsHsMetaFiles } from '@hubspot/project-parsing-lib/project
 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';
@@ -20,7 +21,7 @@ import { archiveWorkspacesAndDependencies, getPackageJsonPathsToUpdate, getLockf
 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) {
+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),
@@ -29,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),
@@ -46,7 +47,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, skipNpmAudit = 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);
@@ -86,13 +87,19 @@ 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 });
@@ -108,7 +115,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                 return resolve({ projectNotFound: true });
             }
             const projectId = project?.id;
-            const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
+            const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation, skipAutoDeploy);
             if (error) {
                 resolve({ uploadError: error, projectId });
             }
@@ -169,13 +176,13 @@ export async function validateNoHSMetaMismatch(srcDir, projectConfig) {
 }
 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/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.d.ts

@@ -1,15 +1,20 @@
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types.js';
 import { McpLogger } from './utils/logger.js';
 import { TextContentResponse } from './types.js';
+import { CommandResults, Command } from './utils/command.js';
+export type ToolExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
 export declare class Tool<InputSchema> {
     protected mcpServer: McpServer;
     protected logger: McpLogger;
     protected toolName: string;
     constructor(mcpServer: McpServer, logger: McpLogger, toolName: string);
     register(): RegisteredTool;
-    handler(input: InputSchema): TextContentResponse | Promise<TextContentResponse>;
-    protected getTrackingMeta(input: InputSchema): {
+    handler(_input: InputSchema): TextContentResponse | Promise<TextContentResponse>;
+    protected runCommand(directory: string, command: Command, extra?: ToolExtra): Promise<CommandResults>;
+    protected getTrackingMeta(_input: InputSchema): {
         [key: string]: string;
     } | undefined;
-    protected wrappedHandler(input: InputSchema): Promise<TextContentResponse>;
+    protected wrappedHandler(input: InputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
 }

package/mcp-server/Tool.js

@@ -1,6 +1,7 @@
 import { formatTextContents } from './utils/content.js';
 import { getErrorMessage } from '../lib/errorHandlers/index.js';
 import { trackToolUsage } from './utils/toolUsageTracking.js';
+import { runCommandInDir } from './utils/command.js';
 export class Tool {
     mcpServer;
     logger;
@@ -13,41 +14,66 @@ export class Tool {
     register() {
         throw new Error('Must implement register');
     }
-    handler(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    input) {
+    handler(_input) {
         throw new Error('Must implement handler');
     }
-    getTrackingMeta(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    input) {
+    runCommand(directory, command, extra) {
+        let progressCount = 0;
+        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++;
+                    await extra.sendNotification({
+                        method: 'notifications/progress',
+                        params: {
+                            progressToken: token,
+                            progress: progressCount,
+                            message,
+                        },
+                    });
+                }
+            }
+            catch {
+                // Swallow notification errors so a failed notification never crashes the tool
+            }
+        });
+    }
+    getTrackingMeta(_input) {
         return undefined;
     }
-    async wrappedHandler(input) {
-        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);
-            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);
+            }
+        });
     }
 }