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

package/commands/function/list.js

@@ -1,59 +1,33 @@
-import moment from 'moment';
-import { getRoutes } from '@hubspot/local-dev-lib/api/functions';
-import { uiLogger } from '../../lib/ui/logger.js';
-import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
-import { getTableContents, getTableHeader } from '../../lib/ui/table.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { commands } from '../../lang/en.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../../lib/ui/index.js';
+import cmsFunctionListCommand from '../cms/function/list.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
 const command = ['list', 'ls'];
-const describe = commands.function.subcommands.list.describe;
+const describe = uiDeprecatedTag(cmsFunctionListCommand.describe, false);
 async function handler(args) {
-    const { derivedAccountId } = args;
-    trackCommandUsage('function-list', undefined, derivedAccountId);
-    uiLogger.debug(commands.function.subcommands.list.debug.gettingFunctions);
-    const { data: routesResp } = await getRoutes(derivedAccountId).catch(async (e) => {
-        logError(e, new ApiErrorContext({ accountId: derivedAccountId }));
-        process.exit(EXIT_CODES.SUCCESS);
-    });
-    if (!routesResp.objects.length) {
-        return uiLogger.info(commands.function.subcommands.list.info.noFunctions);
-    }
-    if (args.json) {
-        return uiLogger.json(routesResp.objects);
-    }
-    const functionsAsArrays = routesResp.objects.map(func => {
-        const { route, method, created, updated, secretNames } = func;
-        return [
-            route,
-            method,
-            secretNames.join(', '),
-            moment(created).format(),
-            moment(updated).format(),
-        ];
-    });
-    functionsAsArrays.unshift(getTableHeader(['Route', 'Method', 'Secrets', 'Created', 'Updated']));
-    return uiLogger.log(getTableContents(functionsAsArrays));
+    uiCommandRelocatedMessage('hs cms function list');
+    await cmsFunctionListCommand.handler(args);
 }
-function functionListBuilder(yargs) {
+function deprecatedFunctionListBuilder(yargs) {
     yargs.options({
         json: {
-            describe: commands.function.subcommands.list.options.json.describe,
+            describe: commands.cms.subcommands.function.subcommands.list.options.json
+                .describe,
             type: 'boolean',
         },
     });
     return yargs;
 }
-const builder = makeYargsBuilder(functionListBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(cmsFunctionListCommand.describe, 'hs cms function list');
+const builder = makeYargsBuilder(deprecatedFunctionListBuilder, command, verboseDescribe, {
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
 });
-const functionListCommand = {
-    command,
+const deprecatedFunctionListCommand = {
+    ...cmsFunctionListCommand,
     describe,
     handler,
     builder,
 };
-export default functionListCommand;
+export default deprecatedFunctionListCommand;

package/commands/function/server.d.ts

@@ -1,10 +1,4 @@
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
-type FunctionServerArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
-    path: string;
-    port?: string;
-    contact?: boolean;
-    watch?: boolean;
-    'log-output'?: boolean;
-};
-declare const functionServerCommand: YargsCommandModule<unknown, FunctionServerArgs>;
-export default functionServerCommand;
+import { YargsCommandModule } from '../../types/Yargs.js';
+import { FunctionServerArgs } from '../cms/function/server.js';
+declare const deprecatedFunctionServerCommand: YargsCommandModule<unknown, FunctionServerArgs>;
+export default deprecatedFunctionServerCommand;

package/commands/function/server.js

@@ -1,64 +1,57 @@
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-// This package is not typed, so we need to use require
-import { start as startTestServer } from '@hubspot/serverless-dev-runtime';
-import { commands } from '../../lang/en.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../../lib/ui/index.js';
+import cmsFunctionServerCommand from '../cms/function/server.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
 const command = 'server <path>';
-const describe = undefined;
+const describe = uiDeprecatedTag(cmsFunctionServerCommand.describe, false);
 async function handler(args) {
-    const { path: functionPath, derivedAccountId } = args;
-    trackCommandUsage('functions-server', undefined, derivedAccountId);
-    uiLogger.debug(commands.function.subcommands.server.debug.startingServer(functionPath));
-    startTestServer({
-        accountId: derivedAccountId,
-        ...args,
-    });
+    uiCommandRelocatedMessage('hs cms function server');
+    await cmsFunctionServerCommand.handler(args);
 }
-function functionServerBuilder(yargs) {
+function deprecatedFunctionServerBuilder(yargs) {
     yargs.positional('path', {
-        describe: commands.function.subcommands.server.positionals.path.describe,
+        describe: commands.cms.subcommands.function.subcommands.server.positionals.path
+            .describe,
         type: 'string',
     });
     yargs.options({
         port: {
-            describe: commands.function.subcommands.server.options.port.describe,
+            describe: commands.cms.subcommands.function.subcommands.server.options.port
+                .describe,
             type: 'string',
             default: 5432,
         },
         contact: {
-            describe: commands.function.subcommands.server.options.contact.describe,
+            describe: commands.cms.subcommands.function.subcommands.server.options.contact
+                .describe,
             type: 'boolean',
             default: true,
         },
         watch: {
-            describe: commands.function.subcommands.server.options.watch.describe,
+            describe: commands.cms.subcommands.function.subcommands.server.options.watch
+                .describe,
             type: 'boolean',
             default: true,
         },
         'log-output': {
-            describe: commands.function.subcommands.server.options.logOutput.describe,
+            describe: commands.cms.subcommands.function.subcommands.server.options.logOutput
+                .describe,
             type: 'boolean',
             default: false,
         },
     });
-    yargs.example([
-        [
-            '$0 functions server ./tmp/myFunctionFolder.functions',
-            commands.function.subcommands.server.examples.default,
-        ],
-    ]);
     return yargs;
 }
-const builder = makeYargsBuilder(functionServerBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(cmsFunctionServerCommand.describe, 'hs cms function server');
+const builder = makeYargsBuilder(deprecatedFunctionServerBuilder, command, verboseDescribe, {
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
 });
-const functionServerCommand = {
-    command,
+const deprecatedFunctionServerCommand = {
+    ...cmsFunctionServerCommand,
     describe,
     handler,
     builder,
 };
-export default functionServerCommand;
+export default deprecatedFunctionServerCommand;

package/commands/function.d.ts

@@ -1,5 +1,3 @@
 import { YargsCommandModuleBucket } from '../types/Yargs.js';
-export declare const command: string[];
-export declare const describe: "Commands for managing CMS serverless functions.";
-declare const functionCommand: YargsCommandModuleBucket;
-export default functionCommand;
+declare const deprecatedFunctionCommand: YargsCommandModuleBucket;
+export default deprecatedFunctionCommand;

package/commands/function.js

@@ -1,21 +1,32 @@
-import list from './function/list.js';
-import deploy from './function/deploy.js';
-import server from './function/server.js';
-import { commands } from '../lang/en.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../lib/ui/index.js';
+import { uiLogger } from '../lib/ui/logger.js';
+import cmsFunctionCommand from './cms/function.js';
+import listCommand from './function/list.js';
+import deployCommand from './function/deploy.js';
+import serverCommand from './function/server.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
-export const command = ['function', 'functions'];
-export const describe = commands.function.describe;
+const command = ['function', 'functions'];
+const describe = uiDeprecatedTag(cmsFunctionCommand.describe, false);
+// We cannot use the builder from cmsFunctionCommand because it includes the create and logs commands
 function functionBuilder(yargs) {
-    yargs.command(list).command(deploy).command(server).demandCommand(1, '');
+    yargs
+        .command(listCommand)
+        .command(deployCommand)
+        .command(serverCommand)
+        .demandCommand(1, '');
     return yargs;
 }
-const builder = makeYargsBuilder(functionBuilder, command, describe, {
-    useGlobalOptions: true,
-});
-const functionCommand = {
-    command,
+const verboseDescribe = uiCommandRenamedDescription(cmsFunctionCommand.describe, 'hs cms function');
+const builder = makeYargsBuilder(functionBuilder, command, verboseDescribe);
+async function handler(args) {
+    uiCommandRelocatedMessage('hs cms function');
+    uiLogger.log('');
+    await cmsFunctionCommand.handler(args);
+}
+const deprecatedFunctionCommand = {
+    ...cmsFunctionCommand,
     describe,
     builder,
-    handler: () => { },
+    handler,
 };
-export default functionCommand;
+export default deprecatedFunctionCommand;

package/commands/lint.d.ts

@@ -1,6 +1,4 @@
-import { AccountArgs, CommonArgs, ConfigArgs, YargsCommandModule } from '../types/Yargs.js';
-type LintArgs = CommonArgs & ConfigArgs & AccountArgs & {
-    path: string;
-};
-declare const lintCommand: YargsCommandModule<unknown, LintArgs>;
-export default lintCommand;
+import { YargsCommandModule } from '../types/Yargs.js';
+import { LintArgs } from './cms/lint.js';
+declare const deprecatedCmsLintCommand: YargsCommandModule<unknown, LintArgs>;
+export default deprecatedCmsLintCommand;

package/commands/lint.js

@@ -1,83 +1,31 @@
-import { lint } from '@hubspot/local-dev-lib/cms/validate';
-import { logError } from '../lib/errorHandlers/index.js';
-import { trackCommandUsage } from '../lib/usageTracking.js';
-import { commands } from '../lang/en.js';
-import { resolveLocalPath } from '../lib/filesystem.js';
-import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../lib/ui/index.js';
+import cmsLintCommand from './cms/lint.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
-import { uiLogger } from '../lib/ui/logger.js';
+import { commands } from '../lang/en.js';
 const command = 'lint <path>';
-// Hiding since this command is still experimental
-const describe = undefined; //'Lint a file or folder for HubL syntax';
-function getErrorsFromHublValidationObject(validation) {
-    return ((validation && validation.meta && validation.meta.template_errors) || []);
-}
-function printHublValidationError(err) {
-    const { severity, message, lineno, startPosition } = err;
-    if (severity === 'FATAL') {
-        uiLogger.error(`[${lineno}, ${startPosition}]: ${message}`);
-    }
-    else {
-        uiLogger.warn(`[${lineno}, ${startPosition}]: ${message}`);
-    }
-}
-function printHublValidationResult({ file, validation }) {
-    let count = 0;
-    if (!validation) {
-        return count;
-    }
-    const errors = getErrorsFromHublValidationObject(validation);
-    if (!errors.length) {
-        return count;
-    }
-    uiLogger.group(file);
-    errors.forEach(err => {
-        if (err.reason !== 'SYNTAX_ERROR') {
-            return;
-        }
-        ++count;
-        printHublValidationError(err);
-    });
-    uiLogger.groupEnd();
-    return count;
-}
+const describe = uiDeprecatedTag(cmsLintCommand.describe, false);
 async function handler(args) {
-    const { path: lintPath, derivedAccountId } = args;
-    const localPath = resolveLocalPath(lintPath);
-    const groupName = commands.lint.groupName(localPath);
-    trackCommandUsage('lint', undefined, derivedAccountId);
-    uiLogger.group(groupName);
-    let count = 0;
-    try {
-        await lint(derivedAccountId, localPath, (result) => {
-            return (count += printHublValidationResult(result));
-        });
-    }
-    catch (err) {
-        uiLogger.groupEnd();
-        logError(err, { accountId: derivedAccountId });
-        process.exit(EXIT_CODES.ERROR);
-    }
-    uiLogger.groupEnd();
-    uiLogger.log(commands.lint.issuesFound(count));
+    uiCommandRelocatedMessage('hs cms lint');
+    await cmsLintCommand.handler(args);
 }
-function lintBuilder(yargs) {
+function deprecatedCmsLintBuilder(yargs) {
     yargs.positional('path', {
-        describe: commands.lint.positionals.path.describe,
+        describe: commands.cms.subcommands.lint.positionals.path.describe,
         required: true,
         type: 'string',
     });
     return yargs;
 }
-const builder = makeYargsBuilder(lintBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(cmsLintCommand.describe, 'hs cms lint');
+const builder = makeYargsBuilder(deprecatedCmsLintBuilder, command, verboseDescribe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
 });
-const lintCommand = {
-    command,
+const deprecatedCmsLintCommand = {
+    ...cmsLintCommand,
     describe,
     handler,
     builder,
 };
-export default lintCommand;
+export default deprecatedCmsLintCommand;

package/commands/list.d.ts

@@ -1,6 +1,4 @@
-import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../types/Yargs.js';
-type ListArgs = CommonArgs & ConfigArgs & EnvironmentArgs & AccountArgs & {
-    path: string;
-};
-declare const cmsListCommand: YargsCommandModule<unknown, ListArgs>;
-export default cmsListCommand;
+import { YargsCommandModule } from '../types/Yargs.js';
+import { ListArgs } from './cms/list.js';
+declare const deprecatedCmsListCommand: YargsCommandModule<unknown, ListArgs>;
+export default deprecatedCmsListCommand;

package/commands/list.js

@@ -1,92 +1,31 @@
-import chalk from 'chalk';
-import { trackCommandUsage } from '../lib/usageTracking.js';
-import { isPathFolder } from '../lib/filesystem.js';
-import { logError } from '../lib/errorHandlers/index.js';
-import { getDirectoryContentsByPath } from '@hubspot/local-dev-lib/api/fileMapper';
-import { HUBSPOT_FOLDER, MARKETPLACE_FOLDER } from '../lib/constants.js';
-import { EXIT_CODES } from '../lib/enums/exitCodes.js';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../lib/ui/index.js';
+import cmsListCommand from './cms/list.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
-import { uiLogger } from '../lib/ui/logger.js';
 import { commands } from '../lang/en.js';
-function addColorToContents(fileOrFolder) {
-    if (!isPathFolder(fileOrFolder)) {
-        return chalk.reset.cyan(fileOrFolder);
-    }
-    if (fileOrFolder === HUBSPOT_FOLDER || fileOrFolder === MARKETPLACE_FOLDER) {
-        return chalk.reset.bold.blue(fileOrFolder);
-    }
-    return chalk.reset.blue(fileOrFolder);
-}
-function sortContents(a, b) {
-    // Pin @hubspot folder to top
-    if (a === HUBSPOT_FOLDER) {
-        return -1;
-    }
-    else if (b === HUBSPOT_FOLDER) {
-        return 1;
-    }
-    // Pin @marketplace folder to top
-    if (a === MARKETPLACE_FOLDER) {
-        return -1;
-    }
-    else if (b === MARKETPLACE_FOLDER) {
-        return 1;
-    }
-    return a.localeCompare(b);
-}
-const command = ['list [path]', 'ls [path]'];
-const describe = commands.list.describe;
+const command = 'list [path]';
+const describe = uiDeprecatedTag(cmsListCommand.describe, false);
 async function handler(args) {
-    const { path, derivedAccountId } = args;
-    const directoryPath = path || '/';
-    let contentsResp;
-    trackCommandUsage('list', undefined, derivedAccountId);
-    uiLogger.debug(commands.list.gettingPathContents(directoryPath));
-    try {
-        const { data } = await getDirectoryContentsByPath(derivedAccountId, directoryPath);
-        contentsResp = data;
-    }
-    catch (e) {
-        logError(e);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!contentsResp.folder) {
-        uiLogger.info(commands.list.noFilesFoundAtPath(directoryPath));
-        return;
-    }
-    // getDirectoryContentsByPath omits @hubspot
-    const contents = directoryPath === '/'
-        ? ['@hubspot', ...contentsResp.children]
-        : contentsResp.children;
-    if (contents.length === 0) {
-        uiLogger.info(commands.list.noFilesFoundAtPath(directoryPath));
-        return;
-    }
-    const folderContentsOutput = contents
-        .map(addColorToContents)
-        .sort(sortContents)
-        .join('\n');
-    uiLogger.log(folderContentsOutput);
-    process.exit(EXIT_CODES.SUCCESS);
+    uiCommandRelocatedMessage('hs cms list');
+    await cmsListCommand.handler(args);
 }
-function cmsListBuilder(yargs) {
+function deprecatedCmsListBuilder(yargs) {
     yargs.positional('path', {
-        describe: commands.list.positionals.path.describe,
+        describe: commands.cms.subcommands.list.positionals.path.describe,
         type: 'string',
     });
-    yargs.example([['$0 list'], ['$0 list /'], ['$0 list my-modules']]);
     return yargs;
 }
-const builder = makeYargsBuilder(cmsListBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(cmsListCommand.describe, 'hs cms list');
+const builder = makeYargsBuilder(deprecatedCmsListBuilder, command, verboseDescribe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
 });
-const cmsListCommand = {
-    command,
+const deprecatedCmsListCommand = {
+    ...cmsListCommand,
     describe,
     handler,
     builder,
 };
-export default cmsListCommand;
+export default deprecatedCmsListCommand;

package/commands/logs.d.ts

@@ -1,10 +1,4 @@
-import { CommonArgs, ConfigArgs, AccountArgs, YargsCommandModule, EnvironmentArgs } from '../types/Yargs.js';
-type LogsArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
-    endpoint?: string;
-    latest?: boolean;
-    compact?: boolean;
-    follow?: boolean;
-    limit?: number;
-};
-declare const logsCommand: YargsCommandModule<unknown, LogsArgs>;
-export default logsCommand;
+import { YargsCommandModule } from '../types/Yargs.js';
+import { LogsArgs } from './cms/function/logs.js';
+declare const deprecatedLogsCommand: YargsCommandModule<unknown, LogsArgs>;
+export default deprecatedLogsCommand;

package/commands/logs.js

@@ -1,121 +1,58 @@
-import { trackCommandUsage } from '../lib/usageTracking.js';
-import { outputLogs } from '../lib/ui/serverlessFunctionLogs.js';
-import { getFunctionLogs, getLatestFunctionLog, } from '@hubspot/local-dev-lib/api/functions';
-import { tailLogs } from '../lib/serverlessLogs.js';
-import { promptUser } from '../lib/prompts/promptUtils.js';
-import { EXIT_CODES } from '../lib/enums/exitCodes.js';
-import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { uiCommandRelocatedMessage, uiCommandRenamedDescription, uiDeprecatedTag, } from '../lib/ui/index.js';
+import functionLogsCommand from './cms/function/logs.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
-import { uiLogger } from '../lib/ui/logger.js';
 import { commands } from '../lang/en.js';
-const handleLogsError = (e, accountId, functionPath) => {
-    if (isHubSpotHttpError(e) && (e.status === 404 || e.status == 400)) {
-        uiLogger.error(commands.logs.errors.noLogsFound(functionPath, accountId));
-    }
-};
-const endpointLog = async (accountId, functionPath, options) => {
-    const { limit, latest, follow, compact } = options;
-    const requestParams = {
-        limit,
-        latest,
-        follow,
-        endpoint: functionPath,
-    };
-    uiLogger.debug(commands.logs.gettingLogs(latest, functionPath));
-    let logsResp;
-    if (follow) {
-        const tailCall = (after) => getFunctionLogs(accountId, functionPath, { after });
-        const fetchLatest = () => {
-            try {
-                return getLatestFunctionLog(accountId, functionPath);
-            }
-            catch (e) {
-                handleLogsError(e, accountId, functionPath);
-                return Promise.reject(e);
-            }
-        };
-        await tailLogs(accountId, functionPath, fetchLatest, tailCall, compact);
-    }
-    else if (latest) {
-        try {
-            const { data } = await getLatestFunctionLog(accountId, functionPath);
-            logsResp = data;
-        }
-        catch (e) {
-            handleLogsError(e, accountId, functionPath);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    else {
-        try {
-            const { data } = await getFunctionLogs(accountId, functionPath, requestParams);
-            logsResp = data;
-        }
-        catch (e) {
-            handleLogsError(e, accountId, functionPath);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    if (logsResp) {
-        return outputLogs(logsResp, { compact });
-    }
-};
 const command = 'logs [endpoint]';
-const describe = commands.logs.describe;
-const handler = async (options) => {
-    const { endpoint: endpointArgValue, latest, derivedAccountId } = options;
-    trackCommandUsage('logs', latest ? { action: 'latest' } : {}, derivedAccountId);
-    const { endpointPromptValue } = await promptUser({
-        name: 'endpointPromptValue',
-        message: commands.logs.endpointPrompt,
-        when: !endpointArgValue,
-    });
-    await endpointLog(derivedAccountId, endpointArgValue || endpointPromptValue, options);
-};
-function logsBuilder(yargs) {
+const describe = uiDeprecatedTag(functionLogsCommand.describe, false);
+async function handler(args) {
+    uiCommandRelocatedMessage('hs cms function logs');
+    await functionLogsCommand.handler(args);
+}
+function deprecatedLogsBuilder(yargs) {
     yargs.positional('endpoint', {
-        describe: commands.logs.positionals.endpoint.describe,
+        describe: commands.cms.subcommands.function.subcommands.logs.positionals.endpoint
+            .describe,
         type: 'string',
     });
     yargs
         .options({
         latest: {
             alias: 'l',
-            describe: commands.logs.options.latest.describe,
+            describe: commands.cms.subcommands.function.subcommands.logs.options.latest
+                .describe,
             type: 'boolean',
         },
         compact: {
-            describe: commands.logs.options.compact.describe,
+            describe: commands.cms.subcommands.function.subcommands.logs.options.compact
+                .describe,
             type: 'boolean',
         },
         follow: {
             alias: ['f'],
-            describe: commands.logs.options.follow.describe,
+            describe: commands.cms.subcommands.function.subcommands.logs.options.follow
+                .describe,
             type: 'boolean',
         },
         limit: {
-            describe: commands.logs.options.limit.describe,
+            describe: commands.cms.subcommands.function.subcommands.logs.options.limit
+                .describe,
             type: 'number',
         },
     })
         .conflicts('follow', 'limit');
-    yargs.example([
-        ['$0 logs my-endpoint', commands.logs.examples.default],
-        ['$0 logs my-endpoint --limit=10', commands.logs.examples.limit],
-        ['$0 logs my-endpoint --follow', commands.logs.examples.follow],
-    ]);
     return yargs;
 }
-const builder = makeYargsBuilder(logsBuilder, command, describe, {
+const verboseDescribe = uiCommandRenamedDescription(functionLogsCommand.describe, 'hs cms function logs');
+const builder = makeYargsBuilder(deprecatedLogsBuilder, command, verboseDescribe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
     useEnvironmentOptions: true,
 });
-const logsCommand = {
-    command,
+const deprecatedLogsCommand = {
+    ...functionLogsCommand,
     describe,
-    builder,
     handler,
+    builder,
 };
-export default logsCommand;
+export default deprecatedLogsCommand;

package/commands/module/marketplace-validate.d.ts

@@ -1,6 +1,4 @@
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
-type MarketplaceValidateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
-    src: string;
-};
-declare const marketplaceValidateCommand: YargsCommandModule<unknown, MarketplaceValidateArgs>;
-export default marketplaceValidateCommand;
+import { YargsCommandModule } from '../../types/Yargs.js';
+import { MarketplaceValidateArgs } from '../cms/module/marketplace-validate.js';
+declare const deprecatedMarketplaceValidateCommand: YargsCommandModule<unknown, MarketplaceValidateArgs>;
+export default deprecatedMarketplaceValidateCommand;