netlify-cli 17.6.0 → 17.7.0

package/src/commands/env/{env-unset.mjs → env-unset.js}

@@ -1,41 +1,5 @@
-import { chalk, error, log, logJson } from '../../utils/command-helpers.mjs';
-import { AVAILABLE_CONTEXTS, normalizeContext, translateFromEnvelopeToMongo } from '../../utils/env/index.mjs';
-/**
- * The env:unset command
- * @param {string} key Environment variable key
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns {Promise<boolean>}
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'key' implicitly has an 'any' type.
-const envUnset = async (key, options, command) => {
-    const { context } = options;
-    const { api, cachedConfig, site } = command.netlify;
-    const siteId = site.id;
-    if (!siteId) {
-        log('No site id found, please run inside a site folder or `netlify link`');
-        return false;
-    }
-    const { siteInfo } = cachedConfig;
-    let finalEnv;
-    if (siteInfo.use_envelope) {
-        finalEnv = await unsetInEnvelope({ api, context, siteInfo, key });
-    }
-    else if (context) {
-        error(`To specify a context, please run ${chalk.yellow('netlify open:admin')} to open the Netlify UI and opt in to the new environment variables experience from Site settings`);
-        return false;
-    }
-    else {
-        finalEnv = await unsetInMongo({ api, siteInfo, key });
-    }
-    // Return new environment variables of site if using json flag
-    if (options.json) {
-        logJson(finalEnv);
-        return false;
-    }
-    const contextType = AVAILABLE_CONTEXTS.includes(context || 'all') ? 'context' : 'branch';
-    log(`Unset environment variable ${chalk.yellow(key)} in the ${chalk.magenta(context || 'all')} ${contextType}`);
-};
+import { chalk, error, log, logJson } from '../../utils/command-helpers.js';
+import { AVAILABLE_CONTEXTS, translateFromEnvelopeToMongo } from '../../utils/env/index.js';
 /**
  * Deletes a given key from the env of a site record
  * @returns {Promise<object>}
@@ -109,27 +73,31 @@ const unsetInEnvelope = async ({ api, context, key, siteInfo }) => {
     delete env[key];
     return env;
 };
-/**
- * Creates the `netlify env:unset` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
-export const createEnvUnsetCommand = (program) => program
-    .command('env:unset')
-    .aliases(['env:delete', 'env:remove'])
-    .argument('<key>', 'Environment variable key')
-    .option('-c, --context <context...>', 'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev") (default: all contexts)', 
-// spread over an array for variadic options
-// @ts-expect-error TS(7006) FIXME: Parameter 'context' implicitly has an 'any' type.
-(context, previous = []) => [...previous, normalizeContext(context)])
-    .addExamples([
-    'netlify env:unset VAR_NAME # unset in all contexts',
-    'netlify env:unset VAR_NAME --context production',
-    'netlify env:unset VAR_NAME --context production deploy-preview',
-])
-    .description('Unset an environment variable which removes it from the UI')
-    // @ts-expect-error TS(7006) FIXME: Parameter 'key' implicitly has an 'any' type.
-    .action(async (key, options, command) => {
-    await envUnset(key, options, command);
-});
+export const envUnset = async (key, options, command) => {
+    const { context } = options;
+    const { api, cachedConfig, site } = command.netlify;
+    const siteId = site.id;
+    if (!siteId) {
+        log('No site id found, please run inside a site folder or `netlify link`');
+        return false;
+    }
+    const { siteInfo } = cachedConfig;
+    let finalEnv;
+    if (siteInfo.use_envelope) {
+        finalEnv = await unsetInEnvelope({ api, context, siteInfo, key });
+    }
+    else if (context) {
+        error(`To specify a context, please run ${chalk.yellow('netlify open:admin')} to open the Netlify UI and opt in to the new environment variables experience from Site settings`);
+        return false;
+    }
+    else {
+        finalEnv = await unsetInMongo({ api, siteInfo, key });
+    }
+    // Return new environment variables of site if using json flag
+    if (options.json) {
+        logJson(finalEnv);
+        return false;
+    }
+    const contextType = AVAILABLE_CONTEXTS.includes(context || 'all') ? 'context' : 'branch';
+    log(`Unset environment variable ${chalk.yellow(key)} in the ${chalk.magenta(context || 'all')} ${contextType}`);
+};

package/src/commands/env/env.js

@@ -0,0 +1,127 @@
+import { Option } from 'commander';
+import { normalizeContext } from '../../utils/env/index.js';
+const env = (options, command) => {
+    command.help();
+};
+export const createEnvCommand = (program) => {
+    program
+        .command('env:get')
+        .argument('<name>', 'Environment variable name')
+        .option('-c, --context <context>', 'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev")', normalizeContext, 'dev')
+        .addOption(new Option('-s, --scope <scope>', 'Specify a scope')
+        .choices(['builds', 'functions', 'post-processing', 'runtime', 'any'])
+        .default('any'))
+        .addExamples([
+        'netlify env:get MY_VAR # get value for MY_VAR in dev context',
+        'netlify env:get MY_VAR --context production',
+        'netlify env:get MY_VAR --context branch:staging',
+        'netlify env:get MY_VAR --scope functions',
+    ])
+        .description('Get resolved value of specified environment variable (includes netlify.toml)')
+        .action(async (name, options, command) => {
+        const { envGet } = await import('./env-get.js');
+        await envGet(name, options, command);
+    });
+    program
+        .command('env:import')
+        .argument('<fileName>', '.env file to import')
+        .addOption(new Option('-r --replaceExisting', 'Old, prefer --replace-existing. Replace all existing variables instead of merging them with the current ones')
+        .default(false)
+        .hideHelp(true))
+        .option('-r, --replace-existing', 'Replace all existing variables instead of merging them with the current ones', false)
+        .description('Import and set environment variables from .env file')
+        .action(async (fileName, options, command) => {
+        const { envImport } = await import('./env-import.js');
+        await envImport(fileName, options, command);
+    });
+    program
+        .command('env:list')
+        .option('-c, --context <context>', 'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev")', normalizeContext, 'dev')
+        .option('--json', 'Output environment variables as JSON')
+        .addOption(new Option('--plain', 'Output environment variables as plaintext').conflicts('json'))
+        .addOption(new Option('-s, --scope <scope>', 'Specify a scope')
+        .choices(['builds', 'functions', 'post-processing', 'runtime', 'any'])
+        .default('any'))
+        .addExamples([
+        'netlify env:list # list variables with values in the dev context and with any scope',
+        'netlify env:list --context production',
+        'netlify env:list --context branch:staging',
+        'netlify env:list --scope functions',
+        'netlify env:list --plain',
+    ])
+        .description('Lists resolved environment variables for site (includes netlify.toml)')
+        .action(async (options, command) => {
+        const { envList } = await import('./env-list.js');
+        await envList(options, command);
+    });
+    program
+        .command('env:set')
+        .argument('<key>', 'Environment variable key')
+        .argument('[value]', 'Value to set to', '')
+        .option('-c, --context <context...>', 'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev") (default: all contexts)', 
+    // spread over an array for variadic options
+    // @ts-expect-error TS(7006) FIXME: Parameter 'context' implicitly has an 'any' type.
+    (context, previous = []) => [...previous, normalizeContext(context)])
+        .addOption(new Option('-s, --scope <scope...>', 'Specify a scope (default: all scopes)').choices([
+        'builds',
+        'functions',
+        'post-processing',
+        'runtime',
+    ]))
+        .option('--secret', 'Indicate whether the environment variable value can be read again.')
+        .description('Set value of environment variable')
+        .addExamples([
+        'netlify env:set VAR_NAME value # set in all contexts and scopes',
+        'netlify env:set VAR_NAME value --context production',
+        'netlify env:set VAR_NAME value --context production deploy-preview',
+        'netlify env:set VAR_NAME value --context production --secret',
+        'netlify env:set VAR_NAME value --scope builds',
+        'netlify env:set VAR_NAME value --scope builds functions',
+        'netlify env:set VAR_NAME --secret # convert existing variable to secret',
+    ])
+        .action(async (key, value, options, command) => {
+        const { envSet } = await import('./env-set.js');
+        await envSet(key, value, options, command);
+    });
+    program
+        .command('env:unset')
+        .aliases(['env:delete', 'env:remove'])
+        .argument('<key>', 'Environment variable key')
+        .option('-c, --context <context...>', 'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev") (default: all contexts)', 
+    // spread over an array for variadic options
+    // @ts-expect-error TS(7006) FIXME: Parameter 'context' implicitly has an 'any' type.
+    (context, previous = []) => [...previous, normalizeContext(context)])
+        .addExamples([
+        'netlify env:unset VAR_NAME # unset in all contexts',
+        'netlify env:unset VAR_NAME --context production',
+        'netlify env:unset VAR_NAME --context production deploy-preview',
+    ])
+        .description('Unset an environment variable which removes it from the UI')
+        .action(async (key, options, command) => {
+        const { envUnset } = await import('./env-unset.js');
+        await envUnset(key, options, command);
+    });
+    program
+        .command('env:clone')
+        .alias('env:migrate')
+        .option('-f, --from <from>', 'Site ID (From)')
+        .requiredOption('-t, --to <to>', 'Site ID (To)')
+        .description(`Clone environment variables from one site to another`)
+        .addExamples(['netlify env:clone --to <to-site-id>', 'netlify env:clone --to <to-site-id> --from <from-site-id>'])
+        .action(async (options, command) => {
+        const { envClone } = await import('./env-clone.js');
+        await envClone(options, command);
+    });
+    return program
+        .command('env')
+        .description('Control environment variables for the current site')
+        .addExamples([
+        'netlify env:list',
+        'netlify env:get VAR_NAME',
+        'netlify env:set VAR_NAME value',
+        'netlify env:unset VAR_NAME',
+        'netlify env:import fileName',
+        'netlify env:clone --to <to-site-id>',
+    ])
+        .action(env);
+};

package/src/commands/env/index.js

@@ -0,0 +1 @@
+export { createEnvCommand } from './env.js';

package/src/commands/functions/{functions-build.mjs → functions-build.js}

@@ -1,14 +1,8 @@
 import { mkdir } from 'fs/promises';
 import { zipFunctions } from '@netlify/zip-it-and-ship-it';
-import { NETLIFYDEVERR, NETLIFYDEVLOG, exit, log } from '../../utils/command-helpers.mjs';
-import { getFunctionsDir } from '../../utils/functions/index.mjs';
-/**
- * The functions:build command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
-const functionsBuild = async (options, command) => {
+import { NETLIFYDEVERR, NETLIFYDEVLOG, exit, log } from '../../utils/command-helpers.js';
+import { getFunctionsDir } from '../../utils/functions/index.js';
+export const functionsBuild = async (options, command) => {
     const { config } = command.netlify;
     const src = options.src || config.build.functionsSource;
     // @ts-expect-error TS(2554) FIXME: Expected 2 arguments, but got 1.
@@ -30,16 +24,3 @@ const functionsBuild = async (options, command) => {
     zipFunctions(src, dst, { skipGo: true });
     log(`${NETLIFYDEVLOG} Functions built to `, dst);
 };
-/**
- * Creates the `netlify functions:build` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
-export const createFunctionsBuildCommand = (program) => program
-    .command('functions:build')
-    .alias('function:build')
-    .description('Build functions locally')
-    .option('-f, --functions <directory>', 'Specify a functions directory to build to')
-    .option('-s, --src <directory>', 'Specify the source directory for the functions')
-    .action(functionsBuild);

package/src/commands/functions/{functions-create.mjs → functions-create.js}

@@ -14,13 +14,13 @@ import inquirer from 'inquirer';
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'node... Remove this comment to see the full error message
 import fetch from 'node-fetch';
 import ora from 'ora';
-import { fileExistsAsync } from '../../lib/fs.mjs';
-import { getAddons, getCurrentAddon, getSiteData } from '../../utils/addons/prepare.mjs';
-import { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN, chalk, error, log } from '../../utils/command-helpers.mjs';
-import { getDotEnvVariables, injectEnvVariables } from '../../utils/dev.mjs';
+import { fileExistsAsync } from '../../lib/fs.js';
+import { getAddons, getCurrentAddon, getSiteData } from '../../utils/addons/prepare.js';
+import { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN, chalk, error, log } from '../../utils/command-helpers.js';
+import { getDotEnvVariables, injectEnvVariables } from '../../utils/dev.js';
 // @ts-expect-error TS(7034) FIXME: Variable 'execa' implicitly has type 'any' in some... Remove this comment to see the full error message
-import execa from '../../utils/execa.mjs';
-import { readRepoURL, validateRepoURL } from '../../utils/read-repo-url.mjs';
+import execa from '../../utils/execa.js';
+import { readRepoURL, validateRepoURL } from '../../utils/read-repo-url.js';
 const copyTemplateDir = promisify(copyTemplateDirOriginal);
 const require = createRequire(import.meta.url);
 const templatesDir = path.resolve(dirname(fileURLToPath(import.meta.url)), '../../functions-templates');
@@ -97,7 +97,7 @@ const formatRegistryArrayForInquirer = async function (lang, funcType) {
         .filter((folder) => Boolean(folder?.isDirectory()))
         .map(async ({ name }) => {
         try {
-            const templatePath = path.join(templatesDir, lang, name, '.netlify-function-template.mjs');
+            const templatePath = path.join(templatesDir, lang, name, '.netlify-function-template.js');
             // @ts-expect-error TS(7036) FIXME: Dynamic import's specifier must be of type 'string... Remove this comment to see the full error message
             const template = await import(pathToFileURL(templatePath));
             return template.default;
@@ -216,7 +216,7 @@ const selectTypeOfFunc = async () => {
     return functionType;
 };
 /**
- * @param {import('../base-command.mjs').default} command
+ * @param {import('../base-command.js').default} command
  */
 // @ts-expect-error TS(7006) FIXME: Parameter 'command' implicitly has an 'any' type.
 const ensureEdgeFuncDirExists = function (command) {
@@ -236,7 +236,7 @@ const ensureEdgeFuncDirExists = function (command) {
 };
 /**
  * Prompts the user to choose a functions directory
- * @param {import('../base-command.mjs').default} command
+ * @param {import('../base-command.js').default} command
  * @returns {Promise<string>} - functions directory or throws an error
  */
 // @ts-expect-error TS(7006) FIXME: Parameter 'command' implicitly has an 'any' type.
@@ -273,7 +273,7 @@ const promptFunctionsDirectory = async (command) => {
 };
 /**
  * Get functions directory (and make it if necessary)
- * @param {import('../base-command.mjs').default} command
+ * @param {import('../base-command.js').default} command
  * @returns {Promise<string>} - functions directory or throws an error
  */
 // @ts-expect-error TS(7006) FIXME: Parameter 'command' implicitly has an 'any' type.
@@ -290,7 +290,7 @@ const ensureFunctionDirExists = async function (command) {
 };
 /**
  * Download files from a given GitHub URL
- * @param {import('../base-command.mjs').default} command
+ * @param {import('../base-command.js').default} command
  * @param {import('commander').OptionValues} options
  * @param {string} argumentName
  * @param {string} functionsDir
@@ -329,7 +329,7 @@ const downloadFromURL = async function (command, options, argumentName, function
         log(`${NETLIFYDEVLOG} Installing dependencies for ${nameToUse} complete `);
     });
     // read, execute, and delete function template file if exists
-    const fnTemplateFile = path.join(fnFolder, '.netlify-function-template.mjs');
+    const fnTemplateFile = path.join(fnFolder, '.netlify-function-template.js');
     if (await fileExistsAsync(fnTemplateFile)) {
         const { default: { addons = [], onComplete }, } = await import(pathToFileURL(fnTemplateFile).href);
         await installAddons(command, addons, path.resolve(fnFolder));
@@ -394,7 +394,7 @@ const installDeps = async ({ functionPackageJson, functionPath, functionsDir })
 };
 /**
  * no --url flag specified, pick from a provided template
- * @param {import('../base-command.mjs').default} command
+ * @param {import('../base-command.js').default} command
  * @param {import('commander').OptionValues} options
  * @param {string} argumentName
  * @param {string} functionsDir Absolute path of the functions directory
@@ -443,7 +443,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
         let functionPackageJson;
         // These files will not be part of the log message because they'll likely
         // be removed before the command finishes.
-        const omittedFromOutput = new Set(['.netlify-function-template.mjs', 'package.json', 'package-lock.json']);
+        const omittedFromOutput = new Set(['.netlify-function-template.js', 'package.json', 'package-lock.json']);
         const createdFiles = await copyTemplateDir(pathToTemplate, functionPath, vars);
         // @ts-expect-error TS(7006) FIXME: Parameter 'filePath' implicitly has an 'any' type.
         createdFiles.forEach((filePath) => {
@@ -457,7 +457,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
             }
         });
         // delete function template file that was copied over by copydir
-        await unlink(path.join(functionPath, '.netlify-function-template.mjs'));
+        await unlink(path.join(functionPath, '.netlify-function-template.js'));
         // npm install
         if (functionPackageJson !== undefined) {
             const spinner = ora({
@@ -499,8 +499,8 @@ const createFunctionAddon = async function ({ addonName, addons, api, siteData,
 /**
  *
  * @param {object} config
- * @param {import('../base-command.mjs').default} config.command
- * @param {(command: import('../base-command.mjs').default) => any} config.onComplete
+ * @param {import('../base-command.js').default} config.command
+ * @param {(command: import('../base-command.js').default) => any} config.onComplete
  */
 // @ts-expect-error TS(7031) FIXME: Binding element 'command' implicitly has an 'any' ... Remove this comment to see the full error message
 const handleOnComplete = async ({ command, onComplete }) => {
@@ -520,7 +520,7 @@ const handleOnComplete = async ({ command, onComplete }) => {
  * @param {object} config
  * @param {*} config.addonCreated
  * @param {*} config.addonDidInstall
- * @param {import('../base-command.mjs').default} config.command
+ * @param {import('../base-command.js').default} config.command
  * @param {string} config.fnPath
  */
 // @ts-expect-error TS(7031) FIXME: Binding element 'addonCreated' implicitly has an '... Remove this comment to see the full error message
@@ -549,7 +549,7 @@ const handleAddonDidInstall = async ({ addonCreated, addonDidInstall, command, f
 };
 /**
  *
- * @param {import('../base-command.mjs').default} command
+ * @param {import('../base-command.js').default} command
  * @param {*} functionAddons
  * @param {*} fnPath
  * @returns
@@ -638,37 +638,10 @@ const ensureFunctionPathIsOk = function (functionsDir, name) {
     }
     return functionPath;
 };
-/**
- * The functions:create command
- * @param {string} name
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'name' implicitly has an 'any' type.
-const functionsCreate = async (name, options, command) => {
+export const functionsCreate = async (name, options, command) => {
     const functionType = await selectTypeOfFunc();
     const functionsDir = functionType === 'edge' ? await ensureEdgeFuncDirExists(command) : await ensureFunctionDirExists(command);
     /* either download from URL or scaffold from template */
     const mainFunc = options.url ? downloadFromURL : scaffoldFromTemplate;
     await mainFunc(command, options, name, functionsDir, functionType);
 };
-/**
- * Creates the `netlify functions:create` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
-export const createFunctionsCreateCommand = (program) => program
-    .command('functions:create')
-    .alias('function:create')
-    .argument('[name]', 'name of your new function file inside your functions directory')
-    .description('Create a new function locally')
-    .option('-n, --name <name>', 'function name')
-    .option('-u, --url <url>', 'pull template from URL')
-    .option('-l, --language <lang>', 'function language')
-    .addExamples([
-    'netlify functions:create',
-    'netlify functions:create hello-world',
-    'netlify functions:create --name hello-world',
-])
-    .action(functionsCreate);

package/src/commands/functions/{functions-invoke.mjs → functions-invoke.js}

@@ -4,8 +4,8 @@ import path from 'path';
 import inquirer from 'inquirer';
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'node... Remove this comment to see the full error message
 import fetch from 'node-fetch';
-import { NETLIFYDEVWARN, chalk, error, exit } from '../../utils/command-helpers.mjs';
-import { BACKGROUND, CLOCKWORK_USERAGENT, getFunctions } from '../../utils/functions/index.mjs';
+import { NETLIFYDEVWARN, chalk, error, exit } from '../../utils/command-helpers.js';
+import { BACKGROUND, CLOCKWORK_USERAGENT, getFunctions } from '../../utils/functions/index.js';
 const require = createRequire(import.meta.url);
 // https://docs.netlify.com/functions/trigger-on-events/
 const events = [
@@ -122,14 +122,7 @@ const getFunctionToTrigger = function (options, argumentName) {
     }
     return argumentName;
 };
-/**
- * The functions:invoke command
- * @param {string} nameArgument
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'nameArgument' implicitly has an 'any' t... Remove this comment to see the full error message
-const functionsInvoke = async (nameArgument, options, command) => {
+export const functionsInvoke = async (nameArgument, options, command) => {
     const { config, relConfigFilePath } = command.netlify;
     const functionsDir = options.functions || (config.dev && config.dev.functions) || config.functionsDirectory;
     if (typeof functionsDir === 'undefined') {
@@ -216,34 +209,3 @@ const functionsInvoke = async (nameArgument, options, command) => {
         error(`Ran into an error invoking your function: ${error_.message}`);
     }
 };
-/**
- * Creates the `netlify functions:invoke` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
-export const createFunctionsInvokeCommand = (program) => program
-    .command('functions:invoke')
-    .alias('function:trigger')
-    .argument('[name]', 'function name to invoke')
-    .description(`Trigger a function while in netlify dev with simulated data, good for testing function calls including Netlify's Event Triggered Functions`)
-    .option('-n, --name <name>', 'function name to invoke')
-    .option('-f, --functions <dir>', 'Specify a functions folder to parse, overriding netlify.toml')
-    .option('-q, --querystring <query>', 'Querystring to add to your function invocation')
-    .option('-p, --payload <data>', 'Supply POST payload in stringified json, or a path to a json file')
-    // TODO: refactor to not need the `undefined` state by removing the --identity flag (value `identity` will be then always defined to true or false)
-    .option('--identity', 'simulate Netlify Identity authentication JWT. pass --identity to affirm unauthenticated request')
-    .option('--no-identity', 'simulate Netlify Identity authentication JWT. pass --no-identity to affirm unauthenticated request')
-    // @ts-expect-error TS(7006) FIXME: Parameter 'value' implicitly has an 'any' type.
-    .option('--port <port>', 'Port where netlify dev is accessible. e.g. 8888', (value) => Number.parseInt(value))
-    .addExamples([
-    'netlify functions:invoke',
-    'netlify functions:invoke myfunction',
-    'netlify functions:invoke --name myfunction',
-    'netlify functions:invoke --name myfunction --identity',
-    'netlify functions:invoke --name myfunction --no-identity',
-    `netlify functions:invoke myfunction --payload '{"foo": 1}'`,
-    'netlify functions:invoke myfunction --querystring "foo=1',
-    'netlify functions:invoke myfunction --payload "./pathTo.json"',
-])
-    .action(functionsInvoke);

package/src/commands/functions/{functions-list.mjs → functions-list.js}

@@ -1,20 +1,13 @@
 import AsciiTable from 'ascii-table';
-import { exit, log, logJson } from '../../utils/command-helpers.mjs';
-import { getFunctions, getFunctionsDir } from '../../utils/functions/index.mjs';
-import requiresSiteInfo from '../../utils/hooks/requires-site-info.mjs';
+import { exit, log, logJson } from '../../utils/command-helpers.js';
+import { getFunctions, getFunctionsDir } from '../../utils/functions/index.js';
 // @ts-expect-error TS(7006) FIXME: Parameter 'deployedFunctions' implicitly has an 'a... Remove this comment to see the full error message
 const normalizeFunction = function (deployedFunctions, { name, urlPath: url }) {
     // @ts-expect-error TS(7006) FIXME: Parameter 'deployedFunction' implicitly has an 'an... Remove this comment to see the full error message
     const isDeployed = deployedFunctions.some((deployedFunction) => deployedFunction.n === name);
     return { name, url, isDeployed };
 };
-/**
- * The functions:list command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
-const functionsList = async (options, command) => {
+export const functionsList = async (options, command) => {
     const { config, relConfigFilePath, siteInfo } = command.netlify;
     const deploy = siteInfo.published_deploy || {};
     const deployedFunctions = deploy.available_functions || [];
@@ -45,20 +38,3 @@ const functionsList = async (options, command) => {
     });
     log(table.toString());
 };
-/**
- * Creates the `netlify functions:list` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
-export const createFunctionsListCommand = (program) => program
-    .command('functions:list')
-    .alias('function:list')
-    .description(`List functions that exist locally
-Helpful for making sure that you have formatted your functions correctly
-
-NOT the same as listing the functions that have been deployed. For that info you need to go to your Netlify deploy log.`)
-    .option('-f, --functions <dir>', 'Specify a functions directory to list')
-    .option('--json', 'Output function data as JSON')
-    .hook('preAction', requiresSiteInfo)
-    .action(functionsList);

package/src/commands/functions/{functions-serve.mjs → functions-serve.js}

@@ -1,17 +1,11 @@
 import { join } from 'path';
-import { startFunctionsServer } from '../../lib/functions/server.mjs';
-import { printBanner } from '../../utils/banner.mjs';
-import { acquirePort, getDotEnvVariables, getSiteInformation, injectEnvVariables } from '../../utils/dev.mjs';
-import { getFunctionsDir } from '../../utils/functions/index.mjs';
-import { getProxyUrl } from '../../utils/proxy.mjs';
+import { startFunctionsServer } from '../../lib/functions/server.js';
+import { printBanner } from '../../utils/banner.js';
+import { acquirePort, getDotEnvVariables, getSiteInformation, injectEnvVariables } from '../../utils/dev.js';
+import { getFunctionsDir } from '../../utils/functions/index.js';
+import { getProxyUrl } from '../../utils/proxy.js';
 const DEFAULT_PORT = 9999;
-/**
- * The functions:serve command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
-const functionsServe = async (options, command) => {
+export const functionsServe = async (options, command) => {
     const { api, config, site, siteInfo, state } = command.netlify;
     const functionsDir = getFunctionsDir({ options, config }, join('netlify', 'functions'));
     let { env } = command.netlify.cachedConfig;
@@ -51,19 +45,3 @@ const functionsServe = async (options, command) => {
     const url = getProxyUrl({ port: functionsPort });
     printBanner({ url });
 };
-/**
- * Creates the `netlify functions:serve` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'program' implicitly has an 'any' type.
-export const createFunctionsServeCommand = (program) => program
-    .command('functions:serve')
-    .alias('function:serve')
-    .description('Serve functions locally')
-    .option('-f, --functions <dir>', 'Specify a functions directory to serve')
-    // @ts-expect-error TS(7006) FIXME: Parameter 'value' implicitly has an 'any' type.
-    .option('-p, --port <port>', 'Specify a port for the functions server', (value) => Number.parseInt(value))
-    .option('-o, --offline', 'disables any features that require network access')
-    .addHelpText('after', 'Helpful for debugging functions.')
-    .action(functionsServe);