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

package/commands/{__tests__ → cms/__tests__}/function.test.js

@@ -2,18 +2,22 @@ import yargs from 'yargs';
 import list from '../function/list.js';
 import deploy from '../function/deploy.js';
 import server from '../function/server.js';
+import logs from '../function/logs.js';
+import create from '../function/create.js';
 import functionCommands from '../function.js';
 vi.mock('../function/list');
 vi.mock('../function/deploy');
 vi.mock('../function/server');
-vi.mock('../../lib/commonOpts');
+vi.mock('../function/logs');
+vi.mock('../function/create');
+vi.mock('../../../lib/commonOpts');
 const commandSpy = vi
     .spyOn(yargs, 'command')
     .mockReturnValue(yargs);
 const demandCommandSpy = vi
     .spyOn(yargs, 'demandCommand')
     .mockReturnValue(yargs);
-describe('commands/function', () => {
+describe('commands/cms/function', () => {
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(functionCommands.command).toEqual(['function', 'functions']);
@@ -25,7 +29,7 @@ describe('commands/function', () => {
         });
     });
     describe('builder', () => {
-        const subcommands = [list, deploy, server];
+        const subcommands = [list, deploy, server, logs, create];
         it('should demand the command takes one positional argument', () => {
             functionCommands.builder(yargs);
             expect(demandCommandSpy).toHaveBeenCalledTimes(1);

package/commands/{__tests__ → cms/__tests__}/lint.test.js

@@ -1,11 +1,11 @@
 import yargs from 'yargs';
-import { addConfigOptions, addAccountOptions } from '../../lib/commonOpts.js';
+import { addConfigOptions, addAccountOptions, } from '../../../lib/commonOpts.js';
 import lintCommand from '../lint.js';
-vi.mock('../../lib/commonOpts');
+vi.mock('../../../lib/commonOpts');
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
-describe('commands/lint', () => {
+describe('commands/cms/lint', () => {
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(lintCommand.command).toEqual('lint <path>');

package/commands/{__tests__ → cms/__tests__}/list.test.js

@@ -1,14 +1,14 @@
 import yargs from 'yargs';
-import { addConfigOptions, addAccountOptions, addUseEnvironmentOptions, } from '../../lib/commonOpts.js';
+import { addConfigOptions, addAccountOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
 import listCommand from '../list.js';
-vi.mock('../../lib/commonOpts');
+vi.mock('../../../lib/commonOpts');
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
 const exampleSpy = vi
     .spyOn(yargs, 'example')
     .mockReturnValue(yargs);
-describe('commands/list', () => {
+describe('commands/cms/list', () => {
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(listCommand.command).toEqual(['list [path]', 'ls [path]']);

package/commands/{__tests__ → cms/__tests__}/mv.test.js

@@ -1,11 +1,11 @@
 import yargs from 'yargs';
-import * as commonOpts from '../../lib/commonOpts.js';
+import * as commonOpts from '../../../lib/commonOpts.js';
 import mvCommand from '../mv.js';
-vi.mock('../../lib/commonOpts');
+vi.mock('../../../lib/commonOpts');
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
-describe('commands/mv', () => {
+describe('commands/cms/mv', () => {
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(mvCommand.command).toBe('mv <srcPath> <destPath>');

package/commands/{__tests__ → cms/__tests__}/theme.test.js

@@ -2,10 +2,12 @@ import yargs from 'yargs';
 import preview from '../theme/preview.js';
 import generateSelectors from '../theme/generate-selectors.js';
 import marketplaceValidate from '../theme/marketplace-validate.js';
+import create from '../theme/create.js';
 import themeCommands from '../theme.js';
 vi.mock('../theme/preview');
 vi.mock('../theme/generate-selectors');
 vi.mock('../theme/marketplace-validate');
+vi.mock('../theme/create');
 vi.mock('../../lib/commonOpts');
 const commandSpy = vi
     .spyOn(yargs, 'command')
@@ -13,7 +15,7 @@ const commandSpy = vi
 const demandCommandSpy = vi
     .spyOn(yargs, 'demandCommand')
     .mockReturnValue(yargs);
-describe('commands/theme', () => {
+describe('commands/cms/theme', () => {
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(themeCommands.command).toEqual(['theme', 'themes']);
@@ -29,7 +31,12 @@ describe('commands/theme', () => {
             commandSpy.mockClear();
             demandCommandSpy.mockClear();
         });
-        const subcommands = [preview, generateSelectors, marketplaceValidate];
+        const subcommands = [
+            preview,
+            generateSelectors,
+            marketplaceValidate,
+            create,
+        ];
         it('should demand the command takes one positional argument', () => {
             themeCommands.builder(yargs);
             expect(demandCommandSpy).toHaveBeenCalledTimes(1);

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

@@ -0,0 +1,9 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type AppCreateArgs = CommonArgs & ConfigArgs & {
+    type: string;
+    name?: string;
+    dest?: string;
+    internal?: boolean;
+};
+declare const appCreateCommand: YargsCommandModule<unknown, AppCreateArgs>;
+export default appCreateCommand;

package/commands/cms/app/create.js

@@ -0,0 +1,82 @@
+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 APP_ASSET_TYPES = ['api-sample', 'app', 'react-app', 'vue-app'];
+const SUPPORTED_APP_TYPES = APP_ASSET_TYPES.filter(t => !assets[t].hidden).join(', ');
+const command = 'create <type> [name] [dest]';
+const describe = commands.cms.subcommands.app.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, name, internal: getInternalVersion, type, dest, } = args;
+    const assetType = type.toLowerCase();
+    if (!assetType || !APP_ASSET_TYPES.includes(assetType)) {
+        uiLogger.error(commands.cms.subcommands.app.subcommands.create.errors.unsupportedAssetType(assetType, SUPPORTED_APP_TYPES));
+        return;
+    }
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        name,
+        dest,
+        getInternalVersion: getInternalVersion || false,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.app.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    if (asset.validate && !asset.validate(argsToPass))
+        return;
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function appCreateBuilder(yargs) {
+    yargs.positional('type', {
+        describe: commands.cms.subcommands.app.subcommands.create.positionals.type,
+        type: 'string',
+        choices: APP_ASSET_TYPES.filter(t => !assets[t].hidden),
+    });
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.app.subcommands.create.positionals.name,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.app.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('internal', {
+        describe: 'Internal HubSpot version of creation command',
+        type: 'boolean',
+        hidden: true,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(appCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const appCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default appCreateCommand;

package/commands/cms/app.d.ts

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

package/commands/cms/app.js

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

package/commands/cms/convertFields.js

@@ -2,21 +2,19 @@ import path from 'path';
 import fs from 'fs';
 import { createIgnoreFilter } from '@hubspot/local-dev-lib/ignoreRules';
 import { isAllowedExtension, getCwd } from '@hubspot/local-dev-lib/path';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { walk } from '@hubspot/local-dev-lib/fs';
 import { getThemeJSONPath } from '@hubspot/local-dev-lib/cms/themes';
-import { i18n } from '../../lib/lang.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
 import { FieldsJs, isConvertableFieldJs, } from '@hubspot/local-dev-lib/cms/handleFieldsJS';
 import { trackConvertFieldsUsage } from '../../lib/usageTracking.js';
 import { logError } from '../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 const command = 'convert-fields';
-const describe = i18n(`commands.convertFields.describe`);
+const describe = commands.convertFields.describe;
 function invalidPath(src) {
-    logger.error(i18n(`commands.convertFields.errors.invalidPath`, {
-        path: src,
-    }));
+    uiLogger.error(commands.convertFields.errors.invalidPath(src));
     process.exit(EXIT_CODES.ERROR);
 }
 async function handler(args) {
@@ -77,13 +75,13 @@ async function handler(args) {
 }
 function convertFieldsBuilder(yargs) {
     yargs.option('src', {
-        describe: i18n(`commands.convertFields.positionals.src.describe`),
+        describe: commands.convertFields.positionals.src.describe,
         type: 'string',
         required: true,
-        demandOption: i18n(`commands.convertFields.errors.missingSrc`),
+        demandOption: commands.convertFields.errors.missingSrc,
     });
     yargs.option('fieldOptions', {
-        describe: i18n(`commands.convertFields.options.options.describe`),
+        describe: commands.convertFields.options.options.describe,
         type: 'array',
         default: [''],
     });

package/commands/cms/delete.d.ts

@@ -0,0 +1,6 @@
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type DeleteArgs = CommonArgs & ConfigArgs & EnvironmentArgs & AccountArgs & {
+    path: string;
+};
+declare const cmsDeleteCommand: YargsCommandModule<unknown, DeleteArgs>;
+export default cmsDeleteCommand;

package/commands/cms/delete.js

@@ -0,0 +1,43 @@
+import { deleteFile } from '@hubspot/local-dev-lib/api/fileMapper';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'delete <path>';
+const describe = commands.cms.subcommands.delete.describe;
+async function handler(args) {
+    const { path: hsPath, derivedAccountId } = args;
+    trackCommandUsage('delete', undefined, derivedAccountId);
+    try {
+        await deleteFile(derivedAccountId, hsPath);
+        uiLogger.log(commands.cms.subcommands.delete.deleted(hsPath, derivedAccountId));
+    }
+    catch (error) {
+        uiLogger.error(commands.cms.subcommands.delete.errors.deleteFailed(hsPath, derivedAccountId));
+        logError(error, new ApiErrorContext({
+            accountId: derivedAccountId,
+            request: hsPath,
+        }));
+    }
+}
+function cmsDeleteBuilder(yargs) {
+    yargs.positional('path', {
+        describe: commands.cms.subcommands.delete.positionals.path,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(cmsDeleteBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const cmsDeleteCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default cmsDeleteCommand;

package/commands/cms/fetch.d.ts

@@ -0,0 +1,12 @@
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type FetchCommandArgs = {
+    src: string;
+    dest?: string;
+    cmsPublishMode?: CmsPublishMode;
+    staging?: boolean;
+    assetVersion?: number;
+    overwrite?: boolean;
+} & ConfigArgs & AccountArgs & EnvironmentArgs & CommonArgs;
+declare const fetchCommand: YargsCommandModule<unknown, FetchCommandArgs>;
+export default fetchCommand;

package/commands/cms/fetch.js

@@ -0,0 +1,79 @@
+import { downloadFileOrFolder } from '@hubspot/local-dev-lib/fileMapper';
+import { addCmsPublishModeOptions, addOverwriteOptions, getCmsPublishMode, } from '../../lib/commonOpts.js';
+import { resolveLocalPath } from '../../lib/filesystem.js';
+import { validateCmsPublishMode } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'fetch <src> [dest]';
+const describe = commands.cms.subcommands.fetch.describe;
+async function handler(options) {
+    const { src, dest } = options;
+    if (!validateCmsPublishMode(options)) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (typeof src !== 'string') {
+        uiLogger.error(commands.cms.subcommands.fetch.errors.sourceRequired);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const { derivedAccountId } = options;
+    const cmsPublishMode = getCmsPublishMode(options);
+    trackCommandUsage('fetch', { mode: cmsPublishMode }, derivedAccountId);
+    const { assetVersion, staging, overwrite } = options;
+    try {
+        // Fetch and write file/folder.
+        await downloadFileOrFolder(derivedAccountId, src, resolveLocalPath(dest), cmsPublishMode, {
+            assetVersion: assetVersion !== undefined ? `${assetVersion}` : assetVersion,
+            staging,
+            overwrite,
+        });
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+const fetchBuilder = (yargs) => {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.fetch.positionals.src.describe,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.fetch.positionals.dest.describe,
+        type: 'string',
+    });
+    yargs.options({
+        staging: {
+            describe: commands.cms.subcommands.fetch.options.staging.describe,
+            type: 'boolean',
+            default: false,
+            hidden: true,
+        },
+    });
+    yargs.options({
+        assetVersion: {
+            type: 'number',
+            describe: commands.cms.subcommands.fetch.options.assetVersion.describe,
+        },
+    });
+    addCmsPublishModeOptions(yargs, { read: true });
+    addOverwriteOptions(yargs);
+    return yargs;
+};
+const builder = makeYargsBuilder(fetchBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useGlobalOptions: true,
+    useEnvironmentOptions: true,
+    useTestingOptions: false,
+});
+const fetchCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default fetchCommand;

package/commands/{__tests__ → cms/function/__tests__}/logs.test.js

@@ -1,6 +1,7 @@
 import yargs from 'yargs';
-import { addConfigOptions, addAccountOptions, addUseEnvironmentOptions, } from '../../lib/commonOpts.js';
-vi.mock('../../lib/commonOpts');
+import { addConfigOptions, addAccountOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
+import logsCommand from '../logs.js';
+vi.mock('../../../../lib/commonOpts');
 const optionsSpy = vi
     .spyOn(yargs, 'options')
     .mockReturnValue(yargs);
@@ -13,9 +14,7 @@ const exampleSpy = vi
 const positionalSpy = vi
     .spyOn(yargs, 'positional')
     .mockReturnValue(yargs);
-// Import this last so mocks apply
-import logsCommand from '../logs.js';
-describe('commands/logs', () => {
+describe('commands/cms/function/logs', () => {
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(logsCommand.command).toEqual('logs [endpoint]');

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

@@ -0,0 +1,12 @@
+import { HttpMethod } from '../../../types/Cms.js';
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type FunctionCreateArgs = CommonArgs & ConfigArgs & {
+    name?: string;
+    dest?: string;
+    functionsFolder?: string;
+    filename?: string;
+    endpointMethod?: HttpMethod;
+    endpointPath?: string;
+};
+declare const functionCreateCommand: YargsCommandModule<unknown, FunctionCreateArgs>;
+export default functionCreateCommand;

package/commands/cms/function/create.js

@@ -0,0 +1,84 @@
+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 { HTTP_METHODS } from '../../../types/Cms.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 [name] [dest]';
+const describe = commands.cms.subcommands.function.subcommands.create.describe;
+async function handler(args) {
+    const { derivedAccountId, name, dest } = args;
+    const assetType = 'function';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        name,
+        dest,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.function.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function functionCreateBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.cms.subcommands.function.subcommands.create.positionals.name,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.function.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('functions-folder', {
+        describe: commands.cms.subcommands.function.subcommands.create.options
+            .functionsFolder,
+        type: 'string',
+    });
+    yargs.option('filename', {
+        describe: commands.cms.subcommands.function.subcommands.create.options.filename,
+        type: 'string',
+    });
+    yargs.option('endpoint-method', {
+        describe: commands.cms.subcommands.function.subcommands.create.options
+            .endpointMethod,
+        type: 'string',
+        choices: [...HTTP_METHODS],
+        default: 'GET',
+    });
+    yargs.option('endpoint-path', {
+        describe: commands.cms.subcommands.function.subcommands.create.options.endpointPath,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(functionCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const functionCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default functionCreateCommand;

package/commands/cms/function/deploy.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type FunctionDeployArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    path: string;
+};
+declare const functionDeployCommand: YargsCommandModule<unknown, FunctionDeployArgs>;
+export default functionDeployCommand;

package/commands/cms/function/deploy.js

@@ -0,0 +1,89 @@
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { buildPackage, getBuildStatus, } from '@hubspot/local-dev-lib/api/functions';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { logError, ApiErrorContext } from '../../../lib/errorHandlers/index.js';
+import { uiAccountDescription } from '../../../lib/ui/index.js';
+import { poll } from '../../../lib/polling.js';
+import { outputBuildLog } from '../../../lib/serverlessLogs.js';
+import { commands } from '../../../lang/en.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+function isFunctionBuildError(e) {
+    return (typeof e === 'object' && e !== null && 'status' in e && e.status === 'ERROR');
+}
+const command = 'deploy <path>';
+const describe = undefined; // Hidden command
+async function handler(args) {
+    const { path: functionPath, derivedAccountId } = args;
+    const splitFunctionPath = functionPath.split('.');
+    trackCommandUsage('function-deploy', undefined, derivedAccountId);
+    if (!splitFunctionPath.length ||
+        splitFunctionPath[splitFunctionPath.length - 1] !== 'functions') {
+        uiLogger.error(commands.cms.subcommands.function.subcommands.deploy.errors.notFunctionsFolder(functionPath));
+        return;
+    }
+    uiLogger.debug(commands.cms.subcommands.function.subcommands.deploy.debug.startingBuildAndDeploy(functionPath));
+    SpinniesManager.init();
+    SpinniesManager.add('loading', {
+        text: commands.cms.subcommands.function.subcommands.deploy.loading(functionPath, uiAccountDescription(derivedAccountId)),
+    });
+    try {
+        const { data: buildId } = await buildPackage(derivedAccountId, functionPath);
+        const successResp = await poll(() => getBuildStatus(derivedAccountId, Number(buildId)));
+        if (successResp) {
+            const buildTimeSeconds = successResp.buildTime
+                ? (successResp.buildTime / 1000).toFixed(2)
+                : 0;
+            SpinniesManager.succeed('loading');
+            if (successResp.cdnUrl) {
+                await outputBuildLog(successResp.cdnUrl);
+            }
+            uiLogger.success(commands.cms.subcommands.function.subcommands.deploy.success.deployed(functionPath, derivedAccountId, buildTimeSeconds));
+        }
+    }
+    catch (e) {
+        SpinniesManager.fail('loading', {
+            text: commands.cms.subcommands.function.subcommands.deploy.loadingFailed(functionPath, uiAccountDescription(derivedAccountId)),
+        });
+        if (isHubSpotHttpError(e) && e.status === 404) {
+            uiLogger.error(commands.cms.subcommands.function.subcommands.deploy.errors.noPackageJson(functionPath));
+        }
+        else if (isFunctionBuildError(e)) {
+            await outputBuildLog(e.cdnUrl);
+            uiLogger.error(commands.cms.subcommands.function.subcommands.deploy.errors.buildError(String(e.errorReason)));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: functionPath,
+            }));
+        }
+    }
+}
+function functionDeployBuilder(yargs) {
+    yargs.positional('path', {
+        describe: commands.cms.subcommands.function.subcommands.deploy.positionals.path
+            .describe,
+        type: 'string',
+    });
+    yargs.example([
+        [
+            '$0 functions deploy myFunctionFolder.functions',
+            commands.cms.subcommands.function.subcommands.deploy.examples.default,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(functionDeployBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const functionDeployCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default functionDeployCommand;

package/commands/cms/function/list.d.ts

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