@hubspot/cli 7.8.12-experimental.0 → 7.9.0-beta.0

package/commands/cms/upload.js

@@ -0,0 +1,212 @@
+import fs from 'fs';
+import path from 'path';
+import { uploadFolder, hasUploadErrors, } from '@hubspot/local-dev-lib/cms/uploadFolder';
+import { getFileMapperQueryValues } from '@hubspot/local-dev-lib/fileMapper';
+import { upload, deleteFile } from '@hubspot/local-dev-lib/api/fileMapper';
+import { getCwd, convertToUnixPath, isAllowedExtension, } from '@hubspot/local-dev-lib/path';
+import { validateSrcAndDestPaths } from '@hubspot/local-dev-lib/cms/modules';
+import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
+import { getThemePreviewUrl, getThemeJSONPath, } from '@hubspot/local-dev-lib/cms/themes';
+import { FieldsJs, isConvertableFieldJs, cleanupTmpDirSync, } from '@hubspot/local-dev-lib/cms/handleFieldsJS';
+import { ApiErrorContext, logError } from '../../lib/errorHandlers/index.js';
+import { getCmsPublishMode } from '../../lib/commonOpts.js';
+import { uploadPrompt } from '../../lib/prompts/uploadPrompt.js';
+import { confirmPrompt } from '../../lib/prompts/promptUtils.js';
+import { validateCmsPublishMode } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { getUploadableFileList } from '../../lib/upload.js';
+import { commands } from '../../lang/en.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'upload [src] [dest]';
+const describe = commands.cms.subcommands.upload.describe;
+function logThemePreview(filePath, accountId) {
+    const previewUrl = getThemePreviewUrl(filePath, accountId);
+    // Only log if we are actually in a theme
+    if (previewUrl) {
+        uiLogger.log(commands.cms.subcommands.upload.previewUrl(previewUrl));
+    }
+}
+async function handler(args) {
+    if (!validateCmsPublishMode(args)) {
+        process.exit(EXIT_CODES.WARNING);
+    }
+    const { derivedAccountId } = args;
+    const cmsPublishMode = getCmsPublishMode(args);
+    const uploadPromptAnswers = await uploadPrompt(args);
+    const src = args.src || uploadPromptAnswers.src;
+    const saveOutput = args.saveOutput;
+    let dest = args.dest || uploadPromptAnswers.dest;
+    let absoluteSrcPath = path.resolve(getCwd(), src);
+    if (!dest) {
+        uiLogger.error(commands.cms.subcommands.upload.errors.destinationRequired);
+        return;
+    }
+    // Check for theme.json file and determine the root path for the project based on it if it exists
+    const themeJsonPath = getThemeJSONPath(absoluteSrcPath);
+    const projectRoot = themeJsonPath
+        ? path.dirname(themeJsonPath)
+        : path.dirname(getCwd());
+    const convertFields = projectRoot &&
+        isConvertableFieldJs(projectRoot, absoluteSrcPath, args.convertFields);
+    let fieldsJs;
+    if (convertFields) {
+        fieldsJs = await new FieldsJs(projectRoot, absoluteSrcPath, undefined, args.fieldOptions).init();
+        if (fieldsJs.rejected)
+            return;
+        // Ensures that the dest path is a .json. The user might pass '.js' accidentally - this ensures it just works.
+        if (fieldsJs.outputPath) {
+            absoluteSrcPath = fieldsJs.outputPath;
+        }
+        dest = path.join(path.dirname(dest), 'fields.json');
+    }
+    let stats;
+    try {
+        stats = fs.statSync(absoluteSrcPath);
+        if (!stats.isFile() && !stats.isDirectory()) {
+            uiLogger.error(commands.cms.subcommands.upload.errors.invalidPath(src));
+            return;
+        }
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.upload.errors.invalidPath(src));
+        return;
+    }
+    const normalizedDest = convertToUnixPath(dest);
+    trackCommandUsage('upload', { mode: cmsPublishMode, type: stats.isFile() ? 'file' : 'folder' }, derivedAccountId);
+    const srcDestIssues = await validateSrcAndDestPaths({ isLocal: true, path: src }, { isHubSpot: true, path: dest });
+    if (srcDestIssues.length) {
+        srcDestIssues.forEach(({ message }) => uiLogger.error(message));
+        process.exit(EXIT_CODES.WARNING);
+    }
+    if (stats.isFile()) {
+        if (!isAllowedExtension(src) && !convertFields) {
+            uiLogger.error(commands.cms.subcommands.upload.errors.invalidPath(src));
+            return;
+        }
+        if (shouldIgnoreFile(absoluteSrcPath)) {
+            uiLogger.error(commands.cms.subcommands.upload.errors.fileIgnored(src));
+            return;
+        }
+        upload(derivedAccountId, absoluteSrcPath, normalizedDest, getFileMapperQueryValues(cmsPublishMode))
+            .then(() => {
+            uiLogger.success(commands.cms.subcommands.upload.success.fileUploaded(src, normalizedDest, derivedAccountId));
+            logThemePreview(src, derivedAccountId);
+        })
+            .catch(error => {
+            uiLogger.error(commands.cms.subcommands.upload.errors.uploadFailed(src, normalizedDest));
+            logError(error, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: normalizedDest,
+                payload: src,
+            }));
+            process.exit(EXIT_CODES.WARNING);
+        })
+            .finally(() => {
+            if (!convertFields)
+                return;
+            if (saveOutput && fieldsJs) {
+                fieldsJs.saveOutput();
+            }
+            if (fieldsJs) {
+                cleanupTmpDirSync(fieldsJs.rootWriteDir);
+            }
+        });
+    }
+    else {
+        uiLogger.log(commands.cms.subcommands.upload.uploading(src, dest, derivedAccountId));
+        // Generate the first-pass file list in here, and pass to uploadFolder.
+        const filePaths = await getUploadableFileList(absoluteSrcPath, args.convertFields ?? false);
+        if (args.clean) {
+            //  If clean is true, will first delete the dest folder and then upload src. Cleans up files that only exist on HS.
+            let cleanUpload = args.force;
+            if (!args.force) {
+                cleanUpload = await confirmPrompt(commands.cms.subcommands.upload.confirmCleanUpload(dest, derivedAccountId), { defaultAnswer: false });
+            }
+            if (cleanUpload) {
+                try {
+                    await deleteFile(derivedAccountId, dest);
+                    uiLogger.log(commands.cms.subcommands.upload.cleaning(dest, derivedAccountId));
+                }
+                catch (error) {
+                    uiLogger.error(commands.cms.subcommands.upload.errors.deleteFailed(dest, derivedAccountId));
+                }
+            }
+        }
+        uploadFolder(derivedAccountId, absoluteSrcPath, dest, {}, {
+            convertFields: args.convertFields,
+            // @ts-expect-error - fieldOptions is a string or string[]
+            fieldOptions: args.fieldOptions ?? undefined,
+            saveOutput: args.saveOutput,
+        }, filePaths)
+            .then(results => {
+            if (!hasUploadErrors(results)) {
+                uiLogger.success(commands.cms.subcommands.upload.success.uploadComplete(dest));
+                logThemePreview(src, derivedAccountId);
+            }
+            else {
+                uiLogger.error(commands.cms.subcommands.upload.errors.someFilesFailed(dest));
+                process.exit(EXIT_CODES.WARNING);
+            }
+        })
+            .catch(error => {
+            uiLogger.error(commands.cms.subcommands.upload.errors.uploadFailed(src, dest));
+            logError(error, {
+                accountId: derivedAccountId,
+            });
+            process.exit(EXIT_CODES.WARNING);
+        });
+    }
+}
+function uploadBuilder(yargs) {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.upload.positionals.src,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.upload.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('fieldOptions', {
+        describe: commands.cms.subcommands.upload.options.options,
+        type: 'array',
+        default: [''],
+        hidden: true,
+    });
+    yargs.option('saveOutput', {
+        describe: commands.cms.subcommands.upload.options.saveOutput,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('convertFields', {
+        describe: commands.cms.subcommands.upload.options.convertFields,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('clean', {
+        describe: commands.cms.subcommands.upload.options.clean,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('force', {
+        describe: commands.cms.subcommands.upload.options.force,
+        type: 'boolean',
+        default: false,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(uploadBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useCmsPublishModeOptions: true,
+});
+const uploadCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default uploadCommand;

package/commands/cms/watch.d.ts

@@ -0,0 +1,14 @@
+import { AccountArgs, CmsPublishModeArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type WatchCommandArgs = ConfigArgs & AccountArgs & EnvironmentArgs & CommonArgs & CmsPublishModeArgs & {
+    src?: string;
+    dest?: string;
+    fieldOptions?: string[];
+    remove?: boolean;
+    initialUpload?: boolean;
+    disableInitial?: boolean;
+    notify?: string;
+    convertFields?: boolean;
+    saveOutput?: boolean;
+};
+declare const watchCommand: YargsCommandModule<unknown, WatchCommandArgs>;
+export default watchCommand;

package/commands/cms/watch.js

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import { watch } from '@hubspot/local-dev-lib/cms/watch';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { getCmsPublishMode } from '../../lib/commonOpts.js';
+import { uploadPrompt } from '../../lib/prompts/uploadPrompt.js';
+import { validateCmsPublishMode } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { getUploadableFileList } from '../../lib/upload.js';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'watch [src] [dest]';
+const describe = commands.cms.subcommands.watch.describe;
+const handler = async (args) => {
+    const { remove, initialUpload, disableInitial, notify, derivedAccountId } = args;
+    if (!validateCmsPublishMode(args)) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const cmsPublishMode = getCmsPublishMode(args);
+    const uploadPromptAnswers = await uploadPrompt(args);
+    const src = args.src || uploadPromptAnswers.src;
+    const dest = args.dest || uploadPromptAnswers.dest;
+    const absoluteSrcPath = path.resolve(getCwd(), src);
+    try {
+        const stats = fs.statSync(absoluteSrcPath);
+        if (!stats.isDirectory()) {
+            uiLogger.log(commands.cms.subcommands.watch.errors.invalidPath(src));
+            return;
+        }
+    }
+    catch (e) {
+        uiLogger.log(commands.cms.subcommands.watch.errors.invalidPath(src));
+        return;
+    }
+    if (!dest) {
+        uiLogger.log(commands.cms.subcommands.watch.errors.destinationRequired);
+        return;
+    }
+    let filesToUpload = [];
+    if (disableInitial) {
+        uiLogger.info(commands.cms.subcommands.watch.warnings.disableInitial);
+    }
+    else if (!initialUpload) {
+        uiLogger.info(commands.cms.subcommands.watch.warnings.notUploaded(src));
+        uiLogger.info(commands.cms.subcommands.watch.warnings.initialUpload);
+    }
+    if (initialUpload) {
+        filesToUpload = await getUploadableFileList(absoluteSrcPath, args.convertFields);
+    }
+    trackCommandUsage('watch', { mode: cmsPublishMode }, derivedAccountId);
+    const onUploadFolderError = (error) => {
+        uiLogger.error(commands.cms.subcommands.watch.errors.folderFailed(src, dest, derivedAccountId));
+        logError(error, {
+            accountId: derivedAccountId,
+        });
+    };
+    const onUploadFileError = (file, destPath, accountId) => (error) => {
+        uiLogger.error(commands.cms.subcommands.watch.errors.fileFailed(file, destPath, accountId));
+        logError(error, new ApiErrorContext({
+            accountId,
+            request: destPath,
+            payload: file,
+        }));
+    };
+    watch(derivedAccountId, absoluteSrcPath, dest, {
+        cmsPublishMode,
+        remove,
+        disableInitial: !initialUpload,
+        notify,
+        commandOptions: args,
+        filePaths: filesToUpload,
+    }, null, onUploadFolderError, undefined, onUploadFileError);
+};
+function watchBuilder(yargs) {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.watch.positionals.src,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.watch.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('fieldOptions', {
+        describe: commands.cms.subcommands.watch.options.options,
+        type: 'array',
+        default: [''],
+        hidden: true,
+    });
+    yargs.option('remove', {
+        alias: 'r',
+        describe: commands.cms.subcommands.watch.options.remove,
+        type: 'boolean',
+    });
+    yargs.option('initial-upload', {
+        alias: 'i',
+        describe: commands.cms.subcommands.watch.options.initialUpload,
+        type: 'boolean',
+    });
+    yargs.option('disable-initial', {
+        describe: commands.cms.subcommands.watch.options.disableInitial,
+        type: 'boolean',
+        hidden: true,
+    });
+    yargs.option('notify', {
+        alias: 'n',
+        describe: commands.cms.subcommands.watch.options.notify,
+        type: 'string',
+        requiresArg: true,
+    });
+    yargs.option('convertFields', {
+        describe: commands.cms.subcommands.watch.options.convertFields,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('saveOutput', {
+        describe: commands.cms.subcommands.watch.options.saveOutput,
+        type: 'boolean',
+        default: false,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(watchBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useGlobalOptions: true,
+    useEnvironmentOptions: true,
+    useCmsPublishModeOptions: { write: true },
+});
+const watchCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default watchCommand;

package/commands/cms/webpack/create.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type WebpackCreateArgs = CommonArgs & ConfigArgs & {
+    dest?: string;
+};
+declare const webpackCreateCommand: YargsCommandModule<unknown, WebpackCreateArgs>;
+export default webpackCreateCommand;

package/commands/cms/webpack/create.js

@@ -0,0 +1,58 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const command = 'create [dest]';
+const describe = commands.cms.subcommands.webpack.subcommands.create.describe;
+async function handler(args) {
+    const { dest, derivedAccountId } = args;
+    const assetType = 'webpack-serverless';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        dest,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.webpack.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function webpackCreateBuilder(yargs) {
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.webpack.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(webpackCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const webpackCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default webpackCreateCommand;

package/commands/cms/webpack.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../../types/Yargs.js';
+declare const webpackCommand: YargsCommandModuleBucket;
+export default webpackCommand;

package/commands/cms/webpack.js

@@ -0,0 +1,17 @@
+import createCommand from './webpack/create.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'webpack';
+const describe = commands.cms.subcommands.webpack.describe;
+function webpackBuilder(yargs) {
+    yargs.command(createCommand).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(webpackBuilder, command, describe);
+const webpackCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default webpackCommand;

package/commands/cms.js

@@ -1,15 +1,41 @@
-import { i18n } from '../lib/lang.js';
+import { commands } from '../lang/en.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 import lighthouseScore from './cms/lighthouseScore.js';
 import convertFields from './cms/convertFields.js';
 import getReactModule from './cms/getReactModule.js';
+import watchCommand from './cms/watch.js';
+import listCommand from './cms/list.js';
+import uploadCommand from './cms/upload.js';
+import fetchCommand from './cms/fetch.js';
+import deleteCommand from './cms/delete.js';
+import mvCommand from './cms/mv.js';
+import functionCommand from './cms/function.js';
+import lintCommand from './cms/lint.js';
+import themeCommand from './cms/theme.js';
+import moduleCommand from './cms/module.js';
+import webpackCommand from './cms/webpack.js';
+import appCommand from './cms/app.js';
+import templateCommand from './cms/template.js';
 const command = 'cms';
-const describe = i18n(`commands.cms.describe`);
+const describe = commands.cms.describe;
 function cmsBuilder(yargs) {
     yargs
         .command(lighthouseScore)
         .command(convertFields)
         .command(getReactModule)
+        .command(watchCommand)
+        .command(listCommand)
+        .command(uploadCommand)
+        .command(fetchCommand)
+        .command(deleteCommand)
+        .command(mvCommand)
+        .command(functionCommand)
+        .command(lintCommand)
+        .command(themeCommand)
+        .command(moduleCommand)
+        .command(webpackCommand)
+        .command(appCommand)
+        .command(templateCommand)
         .demandCommand(1, '');
     return yargs;
 }

package/commands/completion.js

@@ -1,9 +1,9 @@
 import yargsParser from 'yargs-parser';
-import { i18n } from '../lib/lang.js';
+import { commands } from '../lang/en.js';
 import { trackCommandUsage } from '../lib/usageTracking.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 const command = 'completion';
-const describe = i18n('commands.completion.describe');
+const describe = commands.completion.describe;
 async function handler() {
     await trackCommandUsage('completion');
 }
@@ -13,7 +13,7 @@ function completionBuilder(yargs) {
         yargs.completion();
     }
     yargs.example([
-        ['$0 completion >> ~/.zshrc', i18n('commands.completion.examples.default')],
+        ['$0 completion >> ~/.zshrc', commands.completion.examples.default],
     ]);
     return yargs;
 }

package/commands/config/set.d.ts

@@ -1,7 +1,7 @@
 import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
 import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
 type ConfigSetArgs = CommonArgs & ConfigArgs & {
-    defaultCmsPublishMode: CmsPublishMode;
+    defaultCmsPublishMode?: CmsPublishMode;
     allowUsageTracking?: boolean;
     httpTimeout?: string;
     allowAutoUpdates?: boolean;

package/commands/config/set.js

@@ -1,10 +1,11 @@
-import { i18n } from '../../lib/lang.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { setDefaultCmsPublishMode, setHttpTimeout, setAllowUsageTracking, setAllowAutoUpdates, setAutoOpenBrowser, } from '../../lib/configOptions.js';
 import { commands } from '../../lang/en.js';
-import { makeYargsBuilder, getExclusiveConflicts, } from '../../lib/yargsUtils.js';
+import { makeYargsBuilder, strictEnforceBoolean, } from '../../lib/yargsUtils.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { uiLogger } from '../../lib/ui/logger.js';
 const command = 'set';
 const describe = commands.config.subcommands.set.describe;
 async function selectOptions() {
@@ -29,35 +30,41 @@ async function selectOptions() {
 }
 async function handleConfigUpdate(accountId, args) {
     const { allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
-    if (typeof defaultCmsPublishMode !== 'undefined') {
-        await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
-        return true;
-    }
-    else if (typeof httpTimeout !== 'undefined') {
-        await setHttpTimeout({ httpTimeout, accountId });
-        return true;
+    if (allowAutoUpdates !== undefined) {
+        await setAllowAutoUpdates({ allowAutoUpdates, accountId });
     }
-    else if (typeof allowUsageTracking !== 'undefined') {
+    if (allowUsageTracking !== undefined) {
         await setAllowUsageTracking({ allowUsageTracking, accountId });
-        return true;
-    }
-    else if (typeof allowAutoUpdates !== 'undefined') {
-        await setAllowAutoUpdates({ allowAutoUpdates, accountId });
-        return true;
     }
-    else if (typeof autoOpenBrowser !== 'undefined') {
+    if (autoOpenBrowser !== undefined) {
         await setAutoOpenBrowser({ autoOpenBrowser, accountId });
-        return true;
     }
-    return false;
+    if (defaultCmsPublishMode !== undefined) {
+        await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
+    }
+    if (httpTimeout !== undefined) {
+        await setHttpTimeout({ httpTimeout, accountId });
+    }
 }
 async function handler(args) {
-    const { derivedAccountId } = args;
+    const { derivedAccountId, allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
     trackCommandUsage('config-set', {}, derivedAccountId);
-    const configUpdated = await handleConfigUpdate(derivedAccountId, args);
-    if (!configUpdated) {
-        const selectedOptions = await selectOptions();
-        await handleConfigUpdate(derivedAccountId, selectedOptions);
+    try {
+        if (allowAutoUpdates !== undefined ||
+            allowUsageTracking !== undefined ||
+            autoOpenBrowser !== undefined ||
+            defaultCmsPublishMode !== undefined ||
+            httpTimeout !== undefined) {
+            await handleConfigUpdate(derivedAccountId, args);
+        }
+        else {
+            const selectedOptions = await selectOptions();
+            await handleConfigUpdate(derivedAccountId, selectedOptions);
+        }
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
     }
     process.exit(EXIT_CODES.SUCCESS);
 }
@@ -67,15 +74,23 @@ function configSetBuilder(yargs) {
         'default-cms-publish-mode': {
             describe: commands.config.subcommands.set.options.defaultMode.describe,
             type: 'string',
+            choices: ['draft', 'publish'],
+        },
+        'http-timeout': {
+            describe: commands.config.subcommands.set.options.httpTimeout.describe,
+            type: 'number',
+            coerce: (value) => {
+                if (isNaN(value) || value < 3000) {
+                    uiLogger.error(commands.config.subcommands.set.errors.invalidHTTPTimeout);
+                    process.exit(EXIT_CODES.ERROR);
+                }
+                return value;
+            },
         },
         'allow-usage-tracking': {
             describe: commands.config.subcommands.set.options.allowUsageTracking.describe,
             type: 'boolean',
         },
-        'http-timeout': {
-            describe: commands.config.subcommands.set.options.httpTimeout.describe,
-            type: 'string',
-        },
         'allow-auto-updates': {
             describe: commands.config.subcommands.set.options.allowAutoUpdates.describe,
             type: 'boolean',
@@ -86,17 +101,30 @@ function configSetBuilder(yargs) {
             type: 'boolean',
         },
     })
-        .conflicts(getExclusiveConflicts([
-        'default-cms-publish-mode',
-        'allow-usage-tracking',
-        'http-timeout',
-        'allow-auto-updates',
-        'auto-open-browser',
-    ]))
+        .check(() => {
+        // Use process.argv directly because yargs argv has already been parsed/coerced,
+        // but we need to validate the exact format the user provided (e.g., --flag=true vs --flag)
+        return strictEnforceBoolean(process.argv, [
+            'allow-usage-tracking',
+            'allow-auto-updates',
+            'auto-open-browser',
+        ]);
+    })
         .example([
+        ['$0 config set', commands.config.subcommands.set.examples.default],
+        ['$0 config set --allow-usage-tracking=false', 'Disable usage tracking'],
+        ['$0 config set --http-timeout=5000', 'Set HTTP timeout to 5000ms'],
+        [
+            '$0 config set --default-cms-publish-mode=draft',
+            'Set default CMS publish mode to draft',
+        ],
+        [
+            '$0 config set --http-timeout=3000 --allow-usage-tracking=false',
+            'Set HTTP timeout and disable usage tracking',
+        ],
         [
-            '$0 config set',
-            i18n(`commands.config.subcommands.set.examples.default`),
+            '$0 config set --default-cms-publish-mode=draft --http-timeout=4000 --allow-usage-tracking=true',
+            'Configure multiple settings at once',
         ],
     ]);
     return yargs;