@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.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('field-options', {
+        describe: commands.cms.subcommands.upload.options.options,
+        type: 'array',
+        default: [''],
+        hidden: true,
+    });
+    yargs.option('save-output', {
+        describe: commands.cms.subcommands.upload.options.saveOutput,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('convert-fields', {
+        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,13 @@
+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;
+    notify?: string;
+    convertFields?: boolean;
+    saveOutput?: boolean;
+};
+declare const watchCommand: YargsCommandModule<unknown, WatchCommandArgs>;
+export default watchCommand;

package/commands/cms/watch.js

@@ -0,0 +1,132 @@
+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, 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 (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('field-options', {
+        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',
+    });
+    // TODO: remove this before the next major release
+    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('convert-fields', {
+        describe: commands.cms.subcommands.watch.options.convertFields,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('save-output', {
+        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.d.ts

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

package/commands/cms.js

@@ -0,0 +1,49 @@
+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 = 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;
+}
+const builder = makeYargsBuilder(cmsBuilder, command, describe);
+const cmsCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default cmsCommand;

package/commands/completion.d.ts

@@ -0,0 +1,3 @@
+import { CommonArgs, YargsCommandModule } from '../types/Yargs.js';
+declare const completionCommand: YargsCommandModule<unknown, CommonArgs>;
+export default completionCommand;

package/commands/completion.js

@@ -0,0 +1,27 @@
+import yargsParser from 'yargs-parser';
+import { commands } from '../lang/en.js';
+import { trackCommandUsage } from '../lib/usageTracking.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+const command = 'completion';
+const describe = commands.completion.describe;
+async function handler() {
+    await trackCommandUsage('completion');
+}
+function completionBuilder(yargs) {
+    const { help } = yargsParser(process.argv.slice(2));
+    if (!help) {
+        yargs.completion();
+    }
+    yargs.example([
+        ['$0 completion >> ~/.zshrc', commands.completion.examples.default],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(completionBuilder, command, describe);
+const completionCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default completionCommand;

package/commands/config/migrate.d.ts

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

package/commands/config/migrate.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import { localConfigFileExists, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
+import { handleMigration, handleMerge } from '../../lib/configMigrate.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+const describe = commands.config.subcommands.migrate.describe;
+const command = 'migrate';
+async function handler(args) {
+    const { derivedAccountId, config: configPath, force } = args;
+    trackCommandUsage('config-migrate', {}, derivedAccountId);
+    if (configPath && !fs.existsSync(configPath)) {
+        uiLogger.error(commands.config.subcommands.migrate.errors.configNotFound(configPath));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const deprecatedConfigExists = localConfigFileExists();
+    const globalConfigExists = globalConfigFileExists();
+    if (!deprecatedConfigExists) {
+        uiLogger.error(commands.config.subcommands.migrate.errors.noConfigToMigrate);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let success = false;
+    try {
+        if (!globalConfigExists) {
+            success = await handleMigration(true);
+        }
+        else {
+            success = await handleMerge(force, true);
+        }
+    }
+    catch (error) {
+        logError(error);
+    }
+    process.exit(success ? EXIT_CODES.SUCCESS : EXIT_CODES.ERROR);
+}
+function configMigrateBuilder(yargs) {
+    return yargs
+        .option({
+        force: {
+            alias: 'f',
+            type: 'boolean',
+            default: false,
+            description: commands.config.subcommands.migrate.options.force,
+        },
+    })
+        .example([
+        [
+            '$0 config migrate',
+            commands.config.subcommands.migrate.examples.default,
+        ],
+        [
+            '$0 config migrate --config=/path/to/config.yml',
+            commands.config.subcommands.migrate.examples.configFlag,
+        ],
+    ]);
+}
+const builder = makeYargsBuilder(configMigrateBuilder, command, commands.config.subcommands.migrate.verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const configMigrateCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default configMigrateCommand;

package/commands/config/set.d.ts

@@ -0,0 +1,11 @@
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ConfigSetArgs = CommonArgs & ConfigArgs & {
+    defaultCmsPublishMode?: CmsPublishMode;
+    allowUsageTracking?: boolean;
+    httpTimeout?: string;
+    allowAutoUpdates?: boolean;
+    autoOpenBrowser?: boolean;
+};
+declare const configSetCommand: YargsCommandModule<unknown, ConfigSetArgs>;
+export default configSetCommand;