firebase-tools 9.17.0 → 9.21.0

package/lib/commands/ext-update.js

@@ -12,10 +12,12 @@ const billingMigrationHelper_1 = require("../extensions/billingMigrationHelper")
 const checkProjectBilling_1 = require("../extensions/checkProjectBilling");
 const cloudbilling_1 = require("../gcp/cloudbilling");
 const extensionsApi = require("../extensions/extensionsApi");
+const secretsUtils = require("../extensions/secretsUtils");
 const provisioningHelper = require("../extensions/provisioningHelper");
 const extensionsHelper_1 = require("../extensions/extensionsHelper");
 const paramHelper = require("../extensions/paramHelper");
 const updateHelper_1 = require("../extensions/updateHelper");
+const refs = require("../extensions/refs");
 const projectUtils_1 = require("../projectUtils");
 const requirePermissions_1 = require("../requirePermissions");
 const utils = require("../utils");
@@ -42,6 +44,8 @@ exports.default = new command_1.Command("ext:update <extensionInstanceId> [updat
 ])
     .before(extensionsHelper_1.ensureExtensionsApiEnabled)
     .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extMinVersion")
+    .withForce()
+    .option("--params <paramsFile>", "name of params variables file with .env format.")
     .action(async (instanceId, updateSource, options) => {
     const spinner = ora.default(`Updating ${clc.bold(instanceId)}. This usually takes 3 to 5 minutes...`);
     try {
@@ -56,12 +60,12 @@ exports.default = new command_1.Command("ext:update <extensionInstanceId> [updat
             }
             throw err;
         }
-        const existingSpec = _.get(existingInstance, "config.source.spec");
+        const existingSpec = existingInstance.config.source.spec;
         if (existingInstance.config.source.state === "DELETED") {
             throw new error_1.FirebaseError(`Instance '${clc.bold(instanceId)}' cannot be updated anymore because the underlying extension was unpublished from Firebase's registry of extensions. Going forward, you will only be able to re-configure or uninstall this instance.`);
         }
-        const existingParams = _.get(existingInstance, "config.params");
-        const existingSource = _.get(existingInstance, "config.source.name");
+        const existingParams = existingInstance.config.params;
+        const existingSource = existingInstance.config.source.name;
         if (existingInstance.config.extensionRef) {
             updateSource = updateHelper_1.inferUpdateSource(updateSource, existingInstance.config.extensionRef);
         }
@@ -75,60 +79,99 @@ exports.default = new command_1.Command("ext:update <extensionInstanceId> [updat
         switch (newSourceOrigin) {
             case extensionsHelper_1.SourceOrigin.LOCAL:
                 if (previews_1.previews.extdev) {
-                    newSourceName = await updateHelper_1.updateFromLocalSource(projectId, instanceId, updateSource, existingSpec, existingSource);
+                    newSourceName = await updateHelper_1.updateFromLocalSource(projectId, instanceId, updateSource, existingSpec);
                     break;
                 }
             case extensionsHelper_1.SourceOrigin.URL:
                 if (previews_1.previews.extdev) {
-                    newSourceName = await updateHelper_1.updateFromUrlSource(projectId, instanceId, updateSource, existingSpec, existingSource);
+                    newSourceName = await updateHelper_1.updateFromUrlSource(projectId, instanceId, updateSource, existingSpec);
                     break;
                 }
             case extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION_VERSION:
-                newSourceName = await updateHelper_1.updateToVersionFromPublisherSource(projectId, instanceId, updateSource, existingSpec, existingSource);
+                newSourceName = await updateHelper_1.updateToVersionFromPublisherSource(projectId, instanceId, updateSource, existingSpec);
                 break;
             case extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION:
-                newSourceName = await updateHelper_1.updateFromPublisherSource(projectId, instanceId, updateSource, existingSpec, existingSource);
+                newSourceName = await updateHelper_1.updateFromPublisherSource(projectId, instanceId, updateSource, existingSpec);
                 break;
             default:
                 throw new error_1.FirebaseError(`Unknown source '${clc.bold(updateSource)}.'`);
         }
+        if (!(await extensionsHelper_1.confirm({
+            nonInteractive: options.nonInteractive,
+            force: options.force,
+            default: true,
+        }))) {
+            throw new error_1.FirebaseError(`Update cancelled.`);
+        }
         const newSource = await extensionsApi.getSource(newSourceName);
         const newSpec = newSource.spec;
         if (![extensionsHelper_1.SourceOrigin.LOCAL, extensionsHelper_1.SourceOrigin.URL].includes(newSourceOrigin) &&
             existingSpec.version === newSpec.version) {
             utils.logLabeledBullet(extensionsHelper_1.logPrefix, `${clc.bold(instanceId)} is already up to date. Its version is ${clc.bold(existingSpec.version)}.`);
-            const retry = await updateHelper_1.retryUpdate();
+            const retry = await extensionsHelper_1.confirm({
+                nonInteractive: options.nonInteractive,
+                force: options.force,
+                default: false,
+            });
             if (!retry) {
                 utils.logLabeledBullet(extensionsHelper_1.logPrefix, "Update aborted.");
                 return;
             }
         }
-        await updateHelper_1.displayChanges(existingSpec, newSpec);
+        await updateHelper_1.displayChanges({
+            spec: existingSpec,
+            newSpec: newSpec,
+            nonInteractive: options.nonInteractive,
+            force: options.force,
+        });
         await provisioningHelper.checkProductsProvisioned(projectId, newSpec);
-        if (newSpec.billingRequired) {
+        const usesSecrets = secretsUtils.usesSecrets(newSpec);
+        if (newSpec.billingRequired || usesSecrets) {
             const enabled = await cloudbilling_1.checkBillingEnabled(projectId);
+            billingMigrationHelper_1.displayNode10UpdateBillingNotice(existingSpec, newSpec);
+            if (!(await extensionsHelper_1.confirm({
+                nonInteractive: options.nonInteractive,
+                force: options.force,
+                default: true,
+            }))) {
+                throw new error_1.FirebaseError("Update cancelled.");
+            }
             if (!enabled) {
-                await billingMigrationHelper_1.displayNode10UpdateBillingNotice(existingSpec, newSpec, false);
-                await checkProjectBilling_1.enableBilling(projectId, instanceId);
+                if (!options.nonInteractive) {
+                    await checkProjectBilling_1.enableBilling(projectId, instanceId);
+                }
+                else {
+                    throw new error_1.FirebaseError("The extension requires your project to be upgraded to the Blaze plan. " +
+                        "To run this command in non-interactive mode, first upgrade your project: " +
+                        marked(`https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`));
+                }
             }
-            else {
-                await billingMigrationHelper_1.displayNode10UpdateBillingNotice(existingSpec, newSpec, true);
+            if (usesSecrets) {
+                await secretsUtils.ensureSecretManagerApiEnabled(options);
             }
         }
-        const newParams = await paramHelper.promptForNewParams(existingSpec, newSpec, existingParams, projectId);
+        const oldParamValues = Object.assign({}, existingParams);
+        const newParams = await paramHelper.getParamsForUpdate({
+            spec: existingSpec,
+            newSpec,
+            currentParams: existingParams,
+            projectId,
+            paramsEnvPath: options.params,
+            nonInteractive: options.nonInteractive,
+            instanceId,
+        });
         spinner.start();
         const updateOptions = {
             projectId,
             instanceId,
         };
         if (newSourceName.includes("publisher")) {
-            const { publisherId, extensionId, version } = extensionsApi.parseExtensionVersionName(newSourceName);
-            updateOptions.extRef = `${publisherId}/${extensionId}@${version}`;
+            updateOptions.extRef = refs.toExtensionVersionRef(refs.parse(newSourceName));
         }
         else {
             updateOptions.source = newSource;
         }
-        if (!_.isEqual(newParams, existingParams)) {
+        if (!_.isEqual(newParams, oldParamValues)) {
             updateOptions.params = newParams;
         }
         await updateHelper_1.update(updateOptions);

package/lib/commands/functions-config-export.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const clc = require("cli-color");
+const requireInteractive_1 = require("../requireInteractive");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const iam_1 = require("../gcp/iam");
+const logger_1 = require("../logger");
+const prompt_1 = require("../prompt");
+const requirePermissions_1 = require("../requirePermissions");
+const utils_1 = require("../utils");
+const functional_1 = require("../functional");
+const configExport = require("../functions/runtimeConfigExport");
+const requireConfig = require("../requireConfig");
+const REQUIRED_PERMISSIONS = [
+    "runtimeconfig.configs.list",
+    "runtimeconfig.configs.get",
+    "runtimeconfig.variables.list",
+    "runtimeconfig.variables.get",
+];
+const RESERVED_PROJECT_ALIAS = ["local"];
+const MAX_ATTEMPTS = 3;
+function checkReservedAliases(pInfos) {
+    for (const pInfo of pInfos) {
+        if (pInfo.alias && RESERVED_PROJECT_ALIAS.includes(pInfo.alias)) {
+            utils_1.logWarning(`Project alias (${clc.bold(pInfo.alias)}) is reserved for internal use. ` +
+                `Saving exported config in .env.${pInfo.projectId} instead.`);
+            delete pInfo.alias;
+        }
+    }
+}
+async function checkRequiredPermission(pInfos) {
+    pInfos = pInfos.filter((pInfo) => !pInfo.config);
+    const testPermissions = pInfos.map((pInfo) => iam_1.testIamPermissions(pInfo.projectId, REQUIRED_PERMISSIONS));
+    const results = await Promise.all(testPermissions);
+    for (const [pInfo, result] of functional_1.zip(pInfos, results)) {
+        if (result.passed) {
+            throw new error_1.FirebaseError(`Unexpectedly failed to fetch runtime config for project ${pInfo.projectId}`);
+        }
+        utils_1.logWarning("You are missing the following permissions to read functions config on project " +
+            `${clc.bold(pInfo.projectId)}:\n\t${result.missing.join("\n\t")}`);
+        const confirm = await prompt_1.promptOnce({
+            type: "confirm",
+            name: "skip",
+            default: true,
+            message: `Continue without importing configs from project ${pInfo.projectId}?`,
+        });
+        if (!confirm) {
+            throw new error_1.FirebaseError("Command aborted!");
+        }
+    }
+}
+async function promptForPrefix(errMsg) {
+    utils_1.logWarning("The following configs keys could not be exported as environment variables:\n");
+    utils_1.logWarning(errMsg);
+    return await prompt_1.promptOnce({
+        type: "input",
+        name: "prefix",
+        default: "CONFIG_",
+        message: "Enter a PREFIX to rename invalid environment variable keys:",
+    }, {});
+}
+function fromEntries(itr) {
+    const obj = {};
+    for (const [k, v] of itr) {
+        obj[k] = v;
+    }
+    return obj;
+}
+exports.default = new command_1.Command("functions:config:export")
+    .description("Export environment config as environment variables in dotenv format")
+    .before(requirePermissions_1.requirePermissions, [
+    "runtimeconfig.configs.list",
+    "runtimeconfig.configs.get",
+    "runtimeconfig.variables.list",
+    "runtimeconfig.variables.get",
+])
+    .before(requireConfig)
+    .before(requireInteractive_1.default)
+    .action(async (options) => {
+    let pInfos = configExport.getProjectInfos(options);
+    checkReservedAliases(pInfos);
+    utils_1.logBullet("Importing functions configs from projects [" +
+        pInfos.map(({ projectId }) => `${clc.bold(projectId)}`).join(", ") +
+        "]");
+    await configExport.hydrateConfigs(pInfos);
+    await checkRequiredPermission(pInfos);
+    pInfos = pInfos.filter((pInfo) => pInfo.config);
+    logger_1.logger.debug(`Loaded function configs: ${JSON.stringify(pInfos)}`);
+    utils_1.logBullet(`Importing configs from projects: [${pInfos.map((p) => p.projectId).join(", ")}]`);
+    let attempts = 0;
+    let prefix = "";
+    while (true) {
+        if (attempts >= MAX_ATTEMPTS) {
+            throw new error_1.FirebaseError("Exceeded max attempts to fix invalid config keys.");
+        }
+        const errMsg = configExport.hydrateEnvs(pInfos, prefix);
+        if (errMsg.length == 0) {
+            break;
+        }
+        prefix = await promptForPrefix(errMsg);
+        attempts += 1;
+    }
+    const header = `# Exported firebase functions:config:export command on ${new Date().toLocaleDateString()}`;
+    const dotEnvs = pInfos.map((pInfo) => configExport.toDotenvFormat(pInfo.envs, header));
+    const filenames = pInfos.map(configExport.generateDotenvFilename);
+    const filesToWrite = fromEntries(functional_1.zip(filenames, dotEnvs));
+    filesToWrite[".env.local"] = `${header}\n# .env.local file contains environment variables for the Functions Emulator.\n`;
+    filesToWrite[".env"] = `${header}# .env file contains environment variables that applies to all projects.\n`;
+    const functionsDir = options.config.get("functions.source", ".");
+    for (const [filename, content] of Object.entries(filesToWrite)) {
+        await options.config.askWriteProjectFile(path.join(functionsDir, filename), content);
+    }
+});

package/lib/commands/functions-delete.js

@@ -1,15 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("../command");
 const clc = require("cli-color");
 const functionsConfig = require("../functionsConfig");
-const functionsDelete_1 = require("../functionsDelete");
+const command_1 = require("../command");
+const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
 const prompt_1 = require("../prompt");
-const helper = require("../deploy/functions/functionsDeployHelper");
+const functional_1 = require("../functional");
 const requirePermissions_1 = require("../requirePermissions");
+const helper = require("../deploy/functions/functionsDeployHelper");
 const utils = require("../utils");
 const backend = require("../deploy/functions/backend");
+const planner = require("../deploy/functions/release/planner");
+const fabricator = require("../deploy/functions/release/fabricator");
+const executor = require("../deploy/functions/release/executor");
+const reporter = require("../deploy/functions/release/reporter");
 exports.default = new command_1.Command("functions:delete [filters...]")
     .description("delete one or more Cloud Functions by name or group name.")
     .option("--region <region>", "Specify region of the function to be deleted. " +
@@ -22,35 +27,29 @@ exports.default = new command_1.Command("functions:delete [filters...]")
     }
     const context = {
         projectId: projectUtils_1.needProjectId(options),
+        filters: filters.map((f) => f.split(".")),
     };
-    const filterChunks = filters.map((filter) => {
-        return filter.split(".");
-    });
     const [config, existingBackend] = await Promise.all([
         functionsConfig.getFirebaseConfig(options),
         backend.existingBackend(context),
     ]);
     await backend.checkAvailability(context, backend.empty());
     const appEngineLocation = functionsConfig.getAppEngineLocation(config);
-    const functionsToDelete = existingBackend.cloudFunctions.filter((fn) => {
-        const regionMatches = options.region ? fn.region === options.region : true;
-        const nameMatches = helper.functionMatchesAnyGroup(fn, filterChunks);
-        return regionMatches && nameMatches;
-    });
-    if (functionsToDelete.length === 0) {
-        return utils.reject(`The specified filters do not match any existing functions in project ${clc.bold(context.projectId)}.`, { exit: 1 });
+    if (options.region) {
+        existingBackend.endpoints = { [options.region]: existingBackend.endpoints[options.region] };
     }
-    const schedulesToDelete = existingBackend.schedules.filter((schedule) => {
-        functionsToDelete.some(backend.sameFunctionName(schedule.targetService));
+    const plan = planner.createDeploymentPlan(backend.empty(), existingBackend, {
+        filters: context.filters,
+        deleteAll: true,
     });
-    const topicsToDelete = existingBackend.topics.filter((topic) => {
-        functionsToDelete.some(backend.sameFunctionName(topic.targetService));
-    });
-    const deleteList = functionsToDelete
-        .map((func) => {
-        return "\t" + helper.getFunctionLabel(func);
-    })
-        .join("\n");
+    const allEpToDelete = Object.values(plan)
+        .map((changes) => changes.endpointsToDelete)
+        .reduce(functional_1.reduceFlat, [])
+        .sort(backend.compareFunctions);
+    if (allEpToDelete.length === 0) {
+        throw new error_1.FirebaseError(`The specified filters do not match any existing functions in project ${clc.bold(context.projectId)}.`);
+    }
+    const deleteList = allEpToDelete.map((func) => `\t${helper.getFunctionLabel(func)}`).join("\n");
     const confirmDeletion = await prompt_1.promptOnce({
         type: "confirm",
         name: "force",
@@ -60,7 +59,28 @@ exports.default = new command_1.Command("functions:delete [filters...]")
             "\n  Are you sure?",
     }, options);
     if (!confirmDeletion) {
-        return utils.reject("Command aborted.", { exit: 1 });
+        throw new error_1.FirebaseError("Command aborted.");
+    }
+    const functionExecutor = new executor.QueueExecutor({
+        retries: 30,
+        backoff: 20000,
+        concurrency: 40,
+        maxBackoff: 40000,
+    });
+    try {
+        const fab = new fabricator.Fabricator({
+            functionExecutor,
+            executor: new executor.QueueExecutor({}),
+            appEngineLocation,
+        });
+        const summary = await fab.applyPlan(plan);
+        await reporter.logAndTrackDeployStats(summary);
+        reporter.printErrors(summary);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Failed to delete functions", {
+            original: err,
+            exit: 1,
+        });
     }
-    return await functionsDelete_1.deleteFunctions(functionsToDelete, schedulesToDelete, topicsToDelete, appEngineLocation);
 });

package/lib/commands/functions-list.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("../command");
+const error_1 = require("../error");
+const projectUtils_1 = require("../projectUtils");
+const requirePermissions_1 = require("../requirePermissions");
+const backend = require("../deploy/functions/backend");
+const previews_1 = require("../previews");
+const logger_1 = require("../logger");
+const Table = require("cli-table");
+exports.default = new command_1.Command("functions:list")
+    .description("list all deployed functions in your Firebase project")
+    .before(requirePermissions_1.requirePermissions, ["cloudfunctions.functions.list"])
+    .action(async (options) => {
+    try {
+        const context = {
+            projectId: projectUtils_1.needProjectId(options),
+        };
+        const existing = await backend.existingBackend(context);
+        const endpointsList = backend.allEndpoints(existing).sort(backend.compareFunctions);
+        const table = previews_1.previews.functionsv2
+            ? new Table({
+                head: ["Function", "Version", "Trigger", "Location", "Memory", "Runtime"],
+                style: { head: ["yellow"] },
+            })
+            : new Table({
+                head: ["Function", "Trigger", "Location", "Memory", "Runtime"],
+                style: { head: ["yellow"] },
+            });
+        for (const endpoint of endpointsList) {
+            const trigger = backend.endpointTriggerType(endpoint);
+            const availableMemoryMb = endpoint.availableMemoryMb || "---";
+            const entry = previews_1.previews.functionsv2
+                ? [
+                    endpoint.id,
+                    endpoint.platform === "gcfv2" ? "v2" : "v1",
+                    trigger,
+                    endpoint.region,
+                    availableMemoryMb,
+                    endpoint.runtime,
+                ]
+                : [endpoint.id, trigger, endpoint.region, availableMemoryMb, endpoint.runtime];
+            table.push(entry);
+        }
+        logger_1.logger.info(table.toString());
+        return endpointsList;
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Failed to list functions", {
+            exit: 1,
+            original: err,
+        });
+    }
+});

package/lib/commands/functions-log.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
 const opn = require("open");
 const qs = require("querystring");
 const command_1 = require("../command");
 const error_1 = require("../error");
-const gcp = require("../gcp");
+const cloudlogging = require("../gcp/cloudlogging");
+const functionsLog = require("../functions/functionslog");
 const projectUtils_1 = require("../projectUtils");
-const logger_1 = require("../logger");
 const requirePermissions_1 = require("../requirePermissions");
 module.exports = new command_1.Command("functions:log")
     .description("read logs from deployed functions")
@@ -18,30 +17,14 @@ module.exports = new command_1.Command("functions:log")
     .action(async (options) => {
     try {
         const projectId = projectUtils_1.needProjectId(options);
-        let apiFilter = `resource.type="cloud_function"`;
-        if (options.only) {
-            const funcNames = options.only.split(",");
-            const apiFuncFilters = _.map(funcNames, (funcName) => {
-                return `resource.labels.function_name="${funcName}"`;
-            });
-            apiFilter += `\n(${apiFuncFilters.join(" OR ")})`;
-        }
+        const apiFilter = functionsLog.getApiFilter(options.only);
         if (options.open) {
             const url = `https://console.developers.google.com/logs/viewer?advancedFilter=${qs.escape(apiFilter)}&project=${projectId}`;
             opn(url);
             return;
         }
-        const entries = await gcp.cloudlogging.listEntries(projectId, apiFilter, options.lines || 35, "desc");
-        for (let i = _.size(entries) - 1; i >= 0; i--) {
-            const entry = entries[i];
-            logger_1.logger.info(entry.timestamp, _.get(entry, "severity", "?").substring(0, 1), _.get(entry, "resource.labels.function_name") + ":", entry.textPayload ||
-                JSON.stringify(entry.jsonPayload) ||
-                JSON.stringify(entry.protoPayload) ||
-                "");
-        }
-        if (_.isEmpty(entries)) {
-            logger_1.logger.info("No log entries found.");
-        }
+        const entries = await cloudlogging.listEntries(projectId, apiFilter, options.lines || 35, "desc");
+        functionsLog.logEntries(entries);
         return entries;
     }
     catch (err) {

package/lib/commands/hosting-channel-deploy.js

@@ -29,9 +29,6 @@ exports.default = new command_1.Command("hosting:channel:deploy [channelId]")
     if (options.open) {
         throw new error_1.FirebaseError("open is not yet implemented");
     }
-    if (options["no-authorized-domains"]) {
-        throw new error_1.FirebaseError("no-authorized-domains is not yet implemented");
-    }
     let expireTTL = expireUtils_1.DEFAULT_DURATION;
     if (options.expires) {
         expireTTL = expireUtils_1.calculateChannelExpireTTL(options.expires);
@@ -95,8 +92,13 @@ exports.default = new command_1.Command("hosting:channel:deploy [channelId]")
             versionNames.push(version);
         });
     }
+    if (options.authorizedDomains) {
+        await syncAuthState(projectId, sites);
+    }
+    else {
+        logger_1.logger.debug(`skipping syncAuthState since authorizedDomains is ${options.authorizedDomains}`);
+    }
     logger_1.logger.info();
-    await syncAuthState(projectId, sites);
     const deploys = {};
     sites.forEach((d) => {
         deploys[d.target || d.site] = d;

package/lib/commands/index.js

@@ -11,6 +11,9 @@ module.exports = function (client) {
     };
     client.appdistribution = {};
     client.appdistribution.distribute = loadCommand("appdistribution-distribute");
+    client.appdistribution.testers = {};
+    client.appdistribution.testers.add = loadCommand("appdistribution-testers-add");
+    client.appdistribution.testers.delete = loadCommand("appdistribution-testers-remove");
     client.apps = {};
     client.apps.create = loadCommand("apps-create");
     client.apps.list = loadCommand("apps-list");
@@ -23,6 +26,11 @@ module.exports = function (client) {
     client.auth = {};
     client.auth.export = loadCommand("auth-export");
     client.auth.upload = loadCommand("auth-import");
+    if (previews.crashlyticsSymbolsUpload) {
+        client.crashlytics = {};
+        client.crashlytics.symbols = {};
+        client.crashlytics.symbols.upload = loadCommand("crashlytics-symbols-upload");
+    }
     client.database = {};
     client.database.get = loadCommand("database-get");
     client.database.instances = {};
@@ -81,12 +89,16 @@ module.exports = function (client) {
     client.functions = {};
     client.functions.config = {};
     client.functions.config.clone = loadCommand("functions-config-clone");
+    if (previews.dotenv) {
+        client.functions.config.export = loadCommand("functions-config-export");
+    }
     client.functions.config.get = loadCommand("functions-config-get");
     client.functions.config.set = loadCommand("functions-config-set");
     client.functions.config.unset = loadCommand("functions-config-unset");
     client.functions.delete = loadCommand("functions-delete");
     client.functions.log = loadCommand("functions-log");
     client.functions.shell = loadCommand("functions-shell");
+    client.functions.list = loadCommand("functions-list");
     if (previews.deletegcfartifacts) {
         client.functions.deletegcfartifacts = loadCommand("functions-deletegcfartifacts");
     }