@hubspot/cli 8.2.0 → 8.2.1-experimental.0

package/lib/ui/appLogs.js

@@ -0,0 +1,175 @@
+import moment from 'moment';
+import chalk from 'chalk';
+import { Styles } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './logger.js';
+import { indent, uiLine } from './index.js';
+import { commands } from '../../lang/en.js';
+import { SYSTEM_TYPE_DISPLAY_NAMES, toTypeChoice } from '../app/logs.js';
+import { getAppLogDetailsUrl, getAppLogsUrl } from '../app/urls.js';
+import { renderTable } from '../../ui/render.js';
+const SEPARATOR = ' - ';
+function formatJsonBody(body) {
+    try {
+        return JSON.stringify(JSON.parse(body), null, 2);
+    }
+    catch {
+        return body;
+    }
+}
+const LOG_STATUS_COLORS = {
+    SUCCESS: Styles.success,
+    ERROR: Styles.error,
+};
+function formatLogHeader(log, options) {
+    const color = LOG_STATUS_COLORS[log.status] || ((s) => s);
+    const timestamp = chalk.whiteBright(moment(log.createdAt).toISOString());
+    const status = color(log.status);
+    if (options.compact) {
+        const parts = [timestamp, status];
+        if (log.executionTimeMillis != null) {
+            parts.push(`${log.executionTimeMillis}ms`);
+        }
+        parts.push(log.id);
+        return parts.join(SEPARATOR);
+    }
+    return `${timestamp}${SEPARATOR}${status}`;
+}
+function formatLogDetails(log, options) {
+    if (options.compact) {
+        return '';
+    }
+    const lines = [];
+    lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.id}: ${log.id}`);
+    if (log.executionTimeMillis != null) {
+        lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.duration}: ${log.executionTimeMillis}ms`);
+    }
+    if (log.portalId != null) {
+        lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.portal}: ${log.portalId}`);
+    }
+    if (log.traceId != null && log.traceId !== '') {
+        lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.trace}: ${log.traceId}`);
+    }
+    if (log.status === 'ERROR' && log.errorType) {
+        lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.error}: ${log.errorType}`);
+        if (log.errorMessage) {
+            lines.push(`${indent(2)}${log.errorMessage}`);
+        }
+    }
+    const detailUrl = getAppLogDetailsUrl(options.accountId, options.appId, options.systemType, log.id);
+    lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.viewDetails(log.id, options.appId, toTypeChoice(options.systemType))}`);
+    lines.push(`${indent(1)}${commands.app.subcommands.logs.outputMessages.logDetails.viewInUI(detailUrl)}`);
+    return lines.join(`\n${indent(1)}`);
+}
+function formatLog(log, options) {
+    const header = formatLogHeader(log, options);
+    const details = formatLogDetails(log, options);
+    return details ? `${header}\n${details}` : header;
+}
+export async function outputAppLogs(response, options) {
+    const { results, total } = response;
+    if (results.length === 0) {
+        uiLogger.log(commands.app.subcommands.logs.errors.noLogs);
+        return;
+    }
+    results.forEach(log => {
+        uiLogger.log(formatLog(log, options));
+        if (!options.compact) {
+            uiLogger.log('');
+        }
+    });
+    if (!options.compact && !options.tail) {
+        uiLine();
+        uiLogger.log('');
+        const tableHeaders = [
+            commands.app.subcommands.logs.outputMessages.tableHeaders.appId,
+            commands.app.subcommands.logs.outputMessages.tableHeaders.type,
+            commands.app.subcommands.logs.outputMessages.tableHeaders.logsFound,
+        ];
+        const tableData = [
+            [options.appId.toString(), options.typeName, total.toString()],
+        ];
+        await renderTable(tableHeaders, tableData, true);
+        uiLogger.log('');
+        const listUrl = getAppLogsUrl(options.accountId, options.appId, options.systemType);
+        uiLogger.log(commands.app.subcommands.logs.outputMessages.viewInHubSpot(listUrl));
+    }
+}
+export function outputAppLogDetails(details, options) {
+    const status = details.errorType ? 'ERROR' : 'SUCCESS';
+    const color = LOG_STATUS_COLORS[status] || ((s) => s);
+    uiLogger.log(chalk.bold(commands.app.subcommands.logDetails.outputMessages.logDetailsHeader));
+    uiLogger.log('');
+    uiLogger.log(`${commands.app.subcommands.logDetails.outputMessages.basicInfo.id}: ${details.id}`);
+    uiLogger.log(`${commands.app.subcommands.logDetails.outputMessages.basicInfo.timestamp}: ${chalk.whiteBright(moment(details.requestExecutionTimestamp).toISOString())}`);
+    uiLogger.log(`${commands.app.subcommands.logDetails.outputMessages.basicInfo.status}: ${color(status)}`);
+    if (details.duration != null) {
+        uiLogger.log(`${commands.app.subcommands.logDetails.outputMessages.basicInfo.duration}: ${details.duration}ms`);
+    }
+    if (details.loggingSystemType) {
+        const typeName = SYSTEM_TYPE_DISPLAY_NAMES[details.loggingSystemType] ||
+            details.loggingSystemType;
+        uiLogger.log(`${commands.app.subcommands.logDetails.outputMessages.basicInfo.systemType}: ${typeName}`);
+    }
+    const hasContextInfo = details.portalId ||
+        details.traceId ||
+        details.serverlessFunction ||
+        details.location ||
+        details.cardName;
+    if (hasContextInfo) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.app.subcommands.logDetails.outputMessages.contextInfo.header));
+        if (details.portalId) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.contextInfo.portalId}: ${details.portalId}`);
+        }
+        if (details.traceId) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.contextInfo.traceId}: ${details.traceId}`);
+        }
+        if (details.serverlessFunction) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.contextInfo.function}: ${details.serverlessFunction}`);
+        }
+        if (details.location) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.contextInfo.location}: ${details.location}`);
+        }
+        if (details.cardName) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.contextInfo.card}: ${details.cardName}`);
+        }
+        if (details.userId) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.contextInfo.userId}: ${details.userId}`);
+        }
+    }
+    if (details.requestBody || details.responseBody) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.app.subcommands.logDetails.outputMessages.requestResponse
+            .header));
+        if (details.requestBody) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.requestResponse.requestBody}:`);
+            uiLogger.log(chalk.gray(formatJsonBody(details.requestBody)));
+        }
+        if (details.responseBody) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.requestResponse.responseBody}:`);
+            uiLogger.log(chalk.gray(formatJsonBody(details.responseBody)));
+        }
+    }
+    if (details.errorType || details.errorMessage) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.app.subcommands.logDetails.outputMessages.errorInfo.header));
+        if (details.errorType) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.errorInfo.errorType}: ${Styles.error(details.errorType)}`);
+        }
+        if (details.errorMessage) {
+            uiLogger.log(`${indent(1)}${commands.app.subcommands.logDetails.outputMessages.errorInfo.errorMessage}: ${details.errorMessage}`);
+        }
+    }
+    if (details.extraInfo && Object.keys(details.extraInfo).length > 0) {
+        uiLogger.log('');
+        uiLogger.log(chalk.bold(commands.app.subcommands.logDetails.outputMessages.additionalInfo.header));
+        Object.entries(details.extraInfo).forEach(([key, value]) => {
+            uiLogger.log(`${indent(1)}${key}: ${value}`);
+        });
+    }
+    uiLogger.log('');
+    uiLine();
+    uiLogger.log('');
+    const detailUrl = getAppLogDetailsUrl(options.accountId, options.appId, details.loggingSystemType, details.id);
+    uiLogger.log(commands.app.subcommands.logDetails.outputMessages.viewInHubSpot(detailUrl));
+}

package/lib/ui/spinniesUtils.d.ts

@@ -28,5 +28,4 @@ export declare function breakText(text: string, prefixLength: number): string;
 export declare function getLinesLength(text: string, prefixLength: number): number[];
 export declare function writeStream(stream: NodeJS.WriteStream, output: string, rawLines: number[]): void;
 export declare function cleanStream(stream: NodeJS.WriteStream, rawLines: number[]): void;
-export declare function terminalSupportsUnicode(): boolean;
 export {};

package/lib/ui/spinniesUtils.js

@@ -9,6 +9,8 @@ The above copyright notice and this permission notice shall be included in all c
 **/
 import readline from 'readline';
 import stripAnsi from 'strip-ansi';
+import { isUnicodeSupported } from '@hubspot/local-dev-lib/isUnicodeSupported';
+import { getSymbols } from '@hubspot/local-dev-lib/logger';
 export const VALID_STATUSES = [
     'succeed',
     'fail',
@@ -64,7 +66,7 @@ export function purgeSpinnersOptions({ spinner, disableSpins, ...others }) {
     return { ...colors, ...prefixes, ...disableSpinsOption, spinner };
 }
 function turnToValidSpinner(spinner = {}) {
-    const platformSpinner = terminalSupportsUnicode()
+    const platformSpinner = isUnicodeSupported()
         ? SPINNERS.dots
         : SPINNERS.dashes;
     if (typeof spinner !== 'object') {
@@ -101,14 +103,9 @@ export function colorOptions({ color, succeedColor, failColor, spinnerColor, })
     return colors;
 }
 export function prefixOptions({ succeedPrefix, failPrefix, }) {
-    if (terminalSupportsUnicode()) {
-        succeedPrefix = succeedPrefix || '✓';
-        failPrefix = failPrefix || '✖';
-    }
-    else {
-        succeedPrefix = succeedPrefix || '√';
-        failPrefix = failPrefix || '×';
-    }
+    const symbols = getSymbols();
+    succeedPrefix = succeedPrefix || symbols.success;
+    failPrefix = failPrefix || symbols.error;
     return { succeedPrefix, failPrefix };
 }
 export function breakText(text, prefixLength) {
@@ -142,10 +139,3 @@ export function cleanStream(stream, rawLines) {
     readline.clearScreenDown(stream);
     readline.moveCursor(stream, 0, -rawLines.length);
 }
-export function terminalSupportsUnicode() {
-    // The default command prompt and powershell in Windows do not support Unicode characters.
-    // However, the VSCode integrated terminal and the Windows Terminal both do.
-    return (process.platform !== 'win32' ||
-        process.env.TERM_PROGRAM === 'vscode' ||
-        !!process.env.WT_SESSION);
-}

package/lib/usageTracking.d.ts

@@ -1,32 +1,22 @@
-type Meta = {
-    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?: Meta, accountId?: number): Promise<void>;
+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>;
 export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): Promise<void>;
-export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
-export {};
+export declare function trackCommandMetadataUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;
+export declare function trackMcpPromotionShown(command?: string): Promise<void>;

package/lib/usageTracking.js

@@ -1,10 +1,11 @@
-import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
-import { getConfigAccountById, getConfig } from '@hubspot/local-dev-lib/config';
-import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { getConfig, getConfigAccountById, getConfigFilePath, getGlobalConfigFilePath, } from '@hubspot/local-dev-lib/config';
+import { API_KEY_AUTH_METHOD, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
+import { getAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
 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 +14,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 +30,52 @@ 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(),
+    };
+}
+async function getUsageTrackingUserId(accountId) {
+    if (!accountId) {
+        return undefined;
+    }
+    try {
+        const accountConfig = getConfigAccountById(accountId);
+        if (accountConfig.authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+            return undefined;
+        }
+        const accessToken = await getAccessToken(accountConfig.personalAccessKey, accountConfig.env, accountConfig.accountId);
+        return typeof accessToken.userId === 'number'
+            ? accessToken.userId
+            : undefined;
+    }
+    catch (_e) {
+        return undefined;
+    }
+}
 export async function trackCommandUsage(command, meta = {}, accountId) {
     if (isUsageTrackingDisableFlagSet()) {
         uiLogger.debug(usageTrackingDiabled);
@@ -124,45 +171,45 @@ export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
         meta,
     });
 }
+export async function trackMcpPromotionShown(command) {
+    return trackCliInteraction({
+        action: 'cli-mcp-promotion',
+        command: command ?? 'mcp-promotion',
+        meta: {
+            step: 'shown',
+        },
+    });
+}
 async function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
     try {
         const config = getConfig();
         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 {
+            const userId = await getUsageTrackingUserId(accountId);
+            const request = {
+                eventName: 'cli-interaction',
+                eventClass: EventClass.INTERACTION,
+                meta: usageTrackingEvent,
+                accountId,
+            };
+            if (userId !== undefined) {
+                request.userId = userId;
+            }
             uiLogger.debug('Sent usage tracking command event:', usageTrackingEvent);
-            return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            await sendUsageEvent(request);
         }
         catch (error) {
             debugError(error);

package/lib/yargs/makeWrappedYargsHandler.d.ts

@@ -0,0 +1,7 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { z } from 'zod';
+import { CommonArgs } from '../../types/Yargs.js';
+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

@@ -0,0 +1,179 @@
+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';
+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';
+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';
+import { MAX_LOG_FILES } from '../constants.js';
+const HANDLER_LOG_DIR = path.join(os.homedir(), '.hscli', 'logs', 'cli');
+function logUsageTrackingMessage(isJsonOutput) {
+    if (isJsonOutput) {
+        return;
+    }
+    try {
+        const config = getConfig();
+        if (config?.allowUsageTracking !== true) {
+            return;
+        }
+        const lastShownVersion = getStateValue(STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION);
+        if (lastShownVersion === pkg.version) {
+            return;
+        }
+        setStateValue(STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION, pkg.version);
+        uiLogger.info(lib.usageTracking.transparencyMessage);
+    }
+    catch (_e) {
+        return;
+    }
+}
+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;
+                }
+            }
+            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));
+            }
+            else {
+                uiLogger.json({ error: lib.jsonSchema.noSchemaForCommand });
+            }
+            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();
+            }
+            else {
+                logs.writeLogFile();
+            }
+            return process.exit(exitCode);
+        };
+        logUsageTrackingMessage(isJsonOutput);
+        try {
+            await handler(wrappedHandlerArgs);
+        }
+        catch (e) {
+            const isSuccessfulPromptExit = isPromptExitError(e)
+                ? e.exitCode !== EXIT_CODES.ERROR
+                : false;
+            await tracker.trackAndCleanup(isSuccessfulPromptExit);
+            if (isPromptExitError(e)) {
+                logs.writeLogFile();
+                return process.exit(e.exitCode);
+            }
+            else {
+                debugError(e);
+                logs.writeFailureLogFile();
+                return process.exit(EXIT_CODES.ERROR);
+            }
+        }
+        const jsonValid = json.emit();
+        await tracker.trackAndCleanup(true);
+        logs.writeLogFile();
+        if (!jsonValid) {
+            return process.exit(EXIT_CODES.WARNING);
+        }
+    };
+}

package/lib/yargs/makeYargsBuilder.d.ts

@@ -0,0 +1,13 @@
+import { Argv } from 'yargs';
+export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
+    useGlobalOptions?: boolean;
+    useAccountOptions?: boolean;
+    useConfigOptions?: boolean;
+    useEnvironmentOptions?: boolean;
+    useTestingOptions?: boolean;
+    useCmsPublishModeOptions?: boolean | {
+        read?: boolean;
+        write?: boolean;
+    };
+    useJSONOutputOptions?: boolean;
+}): (yargs: Argv) => Promise<Argv<T>>;

package/lib/yargs/makeYargsBuilder.js

@@ -0,0 +1,33 @@
+import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from '../commonOpts.js';
+export function makeYargsBuilder(callback, command, describe, options = {}) {
+    return async function (yargs) {
+        if (options.useGlobalOptions) {
+            addGlobalOptions(yargs);
+        }
+        if (options.useAccountOptions) {
+            addAccountOptions(yargs);
+        }
+        if (options.useConfigOptions) {
+            addConfigOptions(yargs);
+        }
+        if (options.useEnvironmentOptions) {
+            addUseEnvironmentOptions(yargs);
+        }
+        if (options.useTestingOptions) {
+            addTestingOptions(yargs);
+        }
+        if (options.useJSONOutputOptions) {
+            addJSONOutputOptions(yargs);
+        }
+        if (options.useCmsPublishModeOptions) {
+            const opts = typeof options.useCmsPublishModeOptions === 'object'
+                ? options.useCmsPublishModeOptions
+                : { write: true };
+            addCmsPublishModeOptions(yargs, opts);
+        }
+        const result = callback(yargs);
+        // Must go last to pick up available options
+        await addCustomHelpOutput(result, command, describe);
+        return result;
+    };
+}

package/lib/yargs/parseYargsOrExit.d.ts

@@ -0,0 +1,4 @@
+import { ArgumentsCamelCase, Argv } from 'yargs';
+type YargsFailureHandler<T> = (message: string | null, error: unknown, parser: Argv<T>) => never;
+export declare function parseYargsOrExit<T>(parser: Argv<T>, handleFailure: YargsFailureHandler<T>): Promise<ArgumentsCamelCase<T>>;
+export {};