@hubspot/cli 8.2.0-beta.0 → 8.2.0-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,21 @@
-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>;

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);
@@ -130,39 +177,30 @@ 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 {
+            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,3 @@
+import { ArgumentsCamelCase } from 'yargs';
+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>;

package/lib/yargs/makeWrappedYargsHandler.js

@@ -0,0 +1,121 @@
+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';
+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;
+    }
+    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;
+    }
+}
+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);
+            }
+            catch (_e) { }
+        };
+        const onForcedExit = () => {
+            process.exit(EXIT_CODES.SUCCESS);
+        };
+        const onSigint = async () => {
+            process.removeListener('SIGINT', onSigint);
+            process.on('SIGINT', onForcedExit);
+            try {
+                await trackCommandUsage(false);
+            }
+            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;
+            }
+            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);
+        };
+        logUsageTrackingMessage(isJsonOutput);
+        try {
+            await handler(trackingArgs);
+        }
+        catch (e) {
+            const isSuccessfulPromptExit = isPromptExitError(e)
+                ? e.exitCode !== EXIT_CODES.ERROR
+                : false;
+            await trackCommandUsageAndRemoveListeners(isSuccessfulPromptExit);
+            if (isPromptExitError(e)) {
+                return process.exit(e.exitCode);
+            }
+            else {
+                debugError(e);
+                writeFailureLogFile();
+                return process.exit(EXIT_CODES.ERROR);
+            }
+        }
+        await trackCommandUsageAndRemoveListeners(true);
+    };
+}

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 {};

package/lib/yargs/parseYargsOrExit.js

@@ -0,0 +1,25 @@
+function getYargsErrorMessage(error) {
+    return error instanceof Error && error.name === 'YError' ? error.message : '';
+}
+function getYargsFailureMessage(message, error) {
+    if (message) {
+        return message;
+    }
+    return getYargsErrorMessage(error) || message;
+}
+export async function parseYargsOrExit(parser, handleFailure) {
+    let failureHandled = false;
+    const parserWithFailureHandler = parser.fail((message, error, yargs) => {
+        failureHandled = true;
+        return handleFailure(getYargsFailureMessage(message, error), error, yargs);
+    });
+    try {
+        return await parserWithFailureHandler.parseAsync();
+    }
+    catch (error) {
+        if (failureHandled) {
+            throw error;
+        }
+        return handleFailure(getYargsErrorMessage(error), error, parserWithFailureHandler);
+    }
+}

package/lib/yargs/strictEnforceBoolean.d.ts

@@ -0,0 +1 @@
+export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;

package/lib/yargs/strictEnforceBoolean.js

@@ -0,0 +1,13 @@
+import { commands } from '../../lang/en.js';
+export function strictEnforceBoolean(rawArgs, booleanOptions) {
+    for (const option of booleanOptions) {
+        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
+        if (argIndex !== -1) {
+            const value = rawArgs[argIndex].split('=')[1];
+            if (value && !['true', 'false'].includes(value.toLowerCase())) {
+                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
+            }
+        }
+    }
+    return true;
+}

package/lib/yargsUtils.d.ts

@@ -1,16 +1,3 @@
-import { Argv } from 'yargs';
-import { hasFlag } from './utils/hasFlag.js';
-export { hasFlag };
-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>>;
-export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';