firebase-tools 10.5.0 → 10.7.1

package/lib/deploy/functions/ensure.js

@@ -9,7 +9,7 @@ const secretManager_1 = require("../../gcp/secretManager");
 const previews_1 = require("../../previews");
 const projects_1 = require("../../management/projects");
 const functional_1 = require("../../functional");
-const track = require("../../track");
+const track_1 = require("../../track");
 const backend = require("./backend");
 const ensureApiEnabled = require("../../ensureApiEnabled");
 const FAQ_URL = "https://firebase.google.com/support/faq#functions-runtime";
@@ -26,9 +26,9 @@ async function defaultServiceAccount(e) {
 }
 exports.defaultServiceAccount = defaultServiceAccount;
 function nodeBillingError(projectId) {
-    void track("functions_runtime_notices", "nodejs10_billing_error");
+    void (0, track_1.track)("functions_runtime_notices", "nodejs10_billing_error");
     return new error_1.FirebaseError(`Cloud Functions deployment requires the pay-as-you-go (Blaze) billing plan. To upgrade your project, visit the following URL:
-      
+
 https://console.firebase.google.com/project/${projectId}/usage/details
 
 For additional information about this requirement, see Firebase FAQs:
@@ -36,7 +36,7 @@ For additional information about this requirement, see Firebase FAQs:
 ${FAQ_URL}`, { exit: 1 });
 }
 function nodePermissionError(projectId) {
-    void track("functions_runtime_notices", "nodejs10_permission_error");
+    void (0, track_1.track)("functions_runtime_notices", "nodejs10_permission_error");
     return new error_1.FirebaseError(`Cloud Functions deployment requires the Cloud Build API to be enabled. The current credentials do not have permission to enable APIs for project ${clc.bold(projectId)}.
 
 Please ask a project owner to visit the following URL to enable Cloud Build:

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,41 +1,116 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionLabel = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
-function functionMatchesAnyGroup(func, filterGroups) {
-    if (!filterGroups.length) {
+exports.groupEndpointsByCodebase = exports.targetCodebases = exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
+const backend = require("./backend");
+const projectConfig_1 = require("../../functions/projectConfig");
+function endpointMatchesAnyFilter(endpoint, filters) {
+    if (!filters) {
         return true;
     }
-    return filterGroups.some((groupChunk) => functionMatchesGroup(func, groupChunk));
+    return filters.some((filter) => endpointMatchesFilter(endpoint, filter));
 }
-exports.functionMatchesAnyGroup = functionMatchesAnyGroup;
-function functionMatchesGroup(func, groupChunks) {
-    const functionNameChunks = func.id.split("-").slice(0, groupChunks.length);
-    if (functionNameChunks.length !== groupChunks.length) {
+exports.endpointMatchesAnyFilter = endpointMatchesAnyFilter;
+function endpointMatchesFilter(endpoint, filter) {
+    if (endpoint.codebase && filter.codebase) {
+        if (endpoint.codebase !== filter.codebase) {
+            return false;
+        }
+    }
+    if (!filter.idChunks) {
+        return true;
+    }
+    const idChunks = endpoint.id.split("-");
+    if (idChunks.length < filter.idChunks.length) {
         return false;
     }
-    for (let i = 0; i < groupChunks.length; i += 1) {
-        if (groupChunks[i] !== functionNameChunks[i]) {
+    for (let i = 0; i < filter.idChunks.length; i += 1) {
+        if (idChunks[i] !== filter.idChunks[i]) {
             return false;
         }
     }
     return true;
 }
-exports.functionMatchesGroup = functionMatchesGroup;
-function getFilterGroups(options) {
+exports.endpointMatchesFilter = endpointMatchesFilter;
+function parseFunctionSelector(selector) {
+    const fragments = selector.split(":");
+    if (fragments.length < 2) {
+        return [
+            { codebase: fragments[0] },
+            { codebase: projectConfig_1.DEFAULT_CODEBASE, idChunks: fragments[0].split(/[-.]/) },
+        ];
+    }
+    return [
+        {
+            codebase: fragments[0],
+            idChunks: fragments[1].split(/[-.]/),
+        },
+    ];
+}
+exports.parseFunctionSelector = parseFunctionSelector;
+function getEndpointFilters(options) {
     if (!options.only) {
-        return [];
-    }
-    const only = options.only.split(",");
-    const onlyFunctions = only.filter((filter) => {
-        const opts = filter.split(":");
-        return opts[0] === "functions" && opts[1];
-    });
-    return onlyFunctions.map((filter) => {
-        return filter.split(":")[1].split(/[.-]/);
-    });
+        return undefined;
+    }
+    const selectors = options.only.split(",");
+    const filters = [];
+    for (let selector of selectors) {
+        if (selector.startsWith("functions:")) {
+            selector = selector.replace("functions:", "");
+            if (selector.length > 0) {
+                filters.push(...parseFunctionSelector(selector));
+            }
+        }
+    }
+    if (filters.length === 0) {
+        return undefined;
+    }
+    return filters;
 }
-exports.getFilterGroups = getFilterGroups;
+exports.getEndpointFilters = getEndpointFilters;
 function getFunctionLabel(fn) {
-    return `${fn.id}(${fn.region})`;
+    let id = `${fn.id}(${fn.region})`;
+    if (fn.codebase && fn.codebase !== projectConfig_1.DEFAULT_CODEBASE) {
+        id = `[${fn.codebase}]${id}`;
+    }
+    return id;
 }
 exports.getFunctionLabel = getFunctionLabel;
+function targetCodebases(config, filters) {
+    const codebasesFromConfig = [...new Set(Object.values(config).map((c) => c.codebase))];
+    if (!filters) {
+        return [...codebasesFromConfig];
+    }
+    const codebasesFromFilters = [
+        ...new Set(filters.map((f) => f.codebase).filter((c) => c !== undefined)),
+    ];
+    if (codebasesFromFilters.length === 0) {
+        return [...codebasesFromConfig];
+    }
+    const intersections = [];
+    for (const codebase of codebasesFromConfig) {
+        if (codebasesFromFilters.includes(codebase)) {
+            intersections.push(codebase);
+        }
+    }
+    return intersections;
+}
+exports.targetCodebases = targetCodebases;
+function groupEndpointsByCodebase(wantBackends, haveEndpoints) {
+    const grouped = {};
+    let endpointsToAssign = haveEndpoints;
+    for (const codebase of Object.keys(wantBackends)) {
+        const names = backend.allEndpoints(wantBackends[codebase]).map((e) => backend.functionName(e));
+        grouped[codebase] = backend.of(...endpointsToAssign.filter((e) => names.includes(backend.functionName(e))));
+        endpointsToAssign = endpointsToAssign.filter((e) => !names.includes(backend.functionName(e)));
+    }
+    for (const codebase of Object.keys(wantBackends)) {
+        const matchedEndpoints = endpointsToAssign.filter((e) => e.codebase === codebase);
+        grouped[codebase] = backend.merge(grouped[codebase], backend.of(...matchedEndpoints));
+        const matchedNames = matchedEndpoints.map((e) => backend.functionName(e));
+        endpointsToAssign = endpointsToAssign.filter((e) => {
+            return !matchedNames.includes(backend.functionName(e));
+        });
+    }
+    return grouped;
+}
+exports.groupEndpointsByCodebase = groupEndpointsByCodebase;

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferDetailsFromExisting = exports.prepare = void 0;
+exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const backend = require("./backend");
 const ensureApiEnabled = require("../../ensureApiEnabled");
@@ -20,63 +20,127 @@ const triggerRegionHelper_1 = require("./triggerRegionHelper");
 const checkIam_1 = require("./checkIam");
 const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
+const previews_1 = require("../../previews");
+const v1_1 = require("../../functions/events/v1");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
-function hasDotenv(opts) {
-    return functionsEnv.hasUserEnvs(opts);
-}
 async function prepare(context, options, payload) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
-    context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions)[0];
-    const sourceDirName = context.config.source;
-    if (!sourceDirName) {
-        throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+    context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
+    context.filters = (0, functionsDeployHelper_1.getEndpointFilters)(options);
+    const codebases = (0, functionsDeployHelper_1.targetCodebases)(context.config, context.filters);
+    if (codebases.length === 0) {
+        throw new error_1.FirebaseError("No function matches given --only filters. Aborting deployment.");
     }
-    const sourceDir = options.config.path(sourceDirName);
-    const delegateContext = {
-        projectId,
-        sourceDir,
-        projectDir: options.config.projectDir,
-        runtime: context.config.runtime || "",
-    };
-    const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
-    logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
-    await runtimeDelegate.validate();
-    logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
-    await runtimeDelegate.build();
     const checkAPIsEnabled = await Promise.all([
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
         ensure.cloudBuildEnabled(projectId),
         ensure.maybeEnableAR(projectId),
     ]);
-    context.runtimeConfigEnabled = checkAPIsEnabled[1];
     context.artifactRegistryEnabled = checkAPIsEnabled[3];
     const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
     context.firebaseConfig = firebaseConfig;
-    const runtimeConfig = await (0, prepareFunctionsUpload_1.getFunctionsConfig)(context);
-    const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
-    const userEnvOpt = {
-        functionsSource: sourceDir,
-        projectId: projectId,
-        projectAlias: options.projectAlias,
-    };
-    const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
-    const usedDotenv = hasDotenv(userEnvOpt);
+    let runtimeConfig = { firebase: firebaseConfig };
+    if (checkAPIsEnabled[1]) {
+        runtimeConfig = Object.assign(Object.assign({}, runtimeConfig), (await (0, prepareFunctionsUpload_1.getFunctionsConfig)(projectId)));
+    }
+    context.sources = {};
+    const codebaseUsesEnvs = [];
+    const wantBackends = {};
+    for (const codebase of codebases) {
+        (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(codebase)} for deployment`);
+        const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
+        const sourceDirName = config.source;
+        if (!sourceDirName) {
+            throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+        }
+        const sourceDir = options.config.path(sourceDirName);
+        const delegateContext = {
+            projectId,
+            sourceDir,
+            projectDir: options.config.projectDir,
+            runtime: config.runtime || "",
+        };
+        const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
+        logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
+        await runtimeDelegate.validate();
+        logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
+        await runtimeDelegate.build();
+        const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
+        const userEnvOpt = {
+            functionsSource: sourceDir,
+            projectId: projectId,
+            projectAlias: options.projectAlias,
+        };
+        const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
+        logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
+        const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
+        wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
+        for (const endpoint of backend.allEndpoints(wantBackend)) {
+            endpoint.environmentVariables = wantBackend.environmentVariables;
+            endpoint.codebase = codebase;
+        }
+        wantBackends[codebase] = wantBackend;
+        if (functionsEnv.hasUserEnvs(userEnvOpt)) {
+            codebaseUsesEnvs.push(codebase);
+        }
+    }
+    validate.endpointsAreUnique(wantBackends);
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
+        const sourceDirName = config.source;
+        const sourceDir = options.config.path(sourceDirName);
+        const source = {};
+        if (backend.someEndpoint(wantBackend, () => true)) {
+            (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
+        }
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+            if (!previews_1.previews.functionsv2) {
+                throw new error_1.FirebaseError("This version of firebase-tools does not support Google Cloud " +
+                    "Functions gen 2\n" +
+                    "If Cloud Functions for Firebase gen 2 is still in alpha, sign up " +
+                    "for the alpha program at " +
+                    "https://services.google.com/fb/forms/firebasealphaprogram/\n" +
+                    "If Cloud Functions for Firebase gen 2 is in beta, get the latest " +
+                    "version of Firebse Tools with `npm i -g firebase-tools@latest`");
+            }
+            source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config);
+        }
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
+            source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config, runtimeConfig);
+        }
+        context.sources[codebase] = source;
+    }
+    payload.functions = {};
+    const haveBackends = (0, functionsDeployHelper_1.groupEndpointsByCodebase)(wantBackends, backend.allEndpoints(await backend.existingBackend(context)));
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        const haveBackend = haveBackends[codebase] || Object.assign({}, backend.empty());
+        payload.functions[codebase] = { wantBackend, haveBackend };
+    }
+    for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
+        inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
+        await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
+        validate.endpointsAreValid(wantBackend);
+        inferBlockingDetails(wantBackend);
+    }
     const tag = hasUserConfig(runtimeConfig)
-        ? usedDotenv
+        ? codebaseUsesEnvs.length > 0
             ? "mixed"
             : "runtime_config"
-        : usedDotenv
+        : codebaseUsesEnvs.length > 0
             ? "dotenv"
             : "none";
     void (0, track_1.track)("functions_codebase_deploy_env_method", tag);
-    logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-    const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
-    wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
-    payload.functions = { backend: wantBackend };
+    const codebaseCnt = Object.keys(payload.functions).length;
+    void (0, track_1.track)("functions_codebase_deploy_count", codebaseCnt >= 5 ? "5+" : codebaseCnt.toString());
+    const wantBackend = backend.merge(...Object.values(wantBackends));
+    const haveBackend = backend.merge(...Object.values(haveBackends));
+    await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
+        return ensureApiEnabled.ensure(projectId, api, "functions", false);
+    }));
     if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
         const V2_APIS = [
             "artifactregistry.googleapis.com",
@@ -90,36 +154,13 @@ async function prepare(context, options, payload) {
         });
         await Promise.all(enablements);
     }
-    if (backend.someEndpoint(wantBackend, () => true)) {
-        (0, utils_1.logBullet)(clc.cyan.bold("functions:") +
-            " preparing " +
-            clc.bold(sourceDirName) +
-            " directory for uploading...");
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
-        context.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
-    }
-    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
-        context.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
-    }
-    for (const endpoint of backend.allEndpoints(wantBackend)) {
-        endpoint.environmentVariables = wantBackend.environmentVariables;
-    }
-    await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
-        return ensureApiEnabled.ensure(projectId, api, "functions", false);
-    }));
-    validate.endpointsAreValid(wantBackend);
-    context.filters = (0, functionsDeployHelper_1.getFilterGroups)(options);
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, context.filters);
+        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, context.filters);
     });
-    const haveBackend = await backend.existingBackend(context);
-    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, wantBackend, haveBackend);
-    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
-    await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
     await (0, prompts_1.promptForFailurePolicies)(options, matchingBackend, haveBackend);
     await (0, prompts_1.promptForMinInstances)(options, matchingBackend, haveBackend);
-    await backend.checkAvailability(context, wantBackend);
+    await backend.checkAvailability(context, matchingBackend);
+    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, matchingBackend, haveBackend);
     await validate.secretsAreValid(projectId, matchingBackend);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend);
 }
@@ -155,3 +196,30 @@ function maybeCopyTriggerRegion(wantE, haveE) {
     }
     wantE.eventTrigger.region = haveE.eventTrigger.region;
 }
+function inferBlockingDetails(want) {
+    var _a, _b, _c;
+    const authBlockingEndpoints = backend
+        .allEndpoints(want)
+        .filter((ep) => backend.isBlockingTriggered(ep) &&
+        v1_1.AUTH_BLOCKING_EVENTS.includes(ep.blockingTrigger.eventType));
+    if (authBlockingEndpoints.length === 0) {
+        return;
+    }
+    let accessToken = false;
+    let idToken = false;
+    let refreshToken = false;
+    for (const blockingEp of authBlockingEndpoints) {
+        accessToken || (accessToken = !!((_a = blockingEp.blockingTrigger.options) === null || _a === void 0 ? void 0 : _a.accessToken));
+        idToken || (idToken = !!((_b = blockingEp.blockingTrigger.options) === null || _b === void 0 ? void 0 : _b.idToken));
+        refreshToken || (refreshToken = !!((_c = blockingEp.blockingTrigger.options) === null || _c === void 0 ? void 0 : _c.refreshToken));
+    }
+    for (const blockingEp of authBlockingEndpoints) {
+        if (!blockingEp.blockingTrigger.options) {
+            blockingEp.blockingTrigger.options = {};
+        }
+        blockingEp.blockingTrigger.options.accessToken = accessToken;
+        blockingEp.blockingTrigger.options.idToken = idToken;
+        blockingEp.blockingTrigger.options.refreshToken = refreshToken;
+    }
+}
+exports.inferBlockingDetails = inferBlockingDetails;

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -14,31 +14,26 @@ const functionsConfig = require("../../functionsConfig");
 const utils = require("../../utils");
 const fsAsync = require("../../fsAsync");
 const CONFIG_DEST_FILE = ".runtimeconfig.json";
-async function getFunctionsConfig(context) {
+async function getFunctionsConfig(projectId) {
     var _a, _b;
-    let config = {};
-    if (context.runtimeConfigEnabled) {
-        try {
-            config = await functionsConfig.materializeAll(context.firebaseConfig.projectId);
+    try {
+        return await functionsConfig.materializeAll(projectId);
+    }
+    catch (err) {
+        logger_1.logger.debug(err);
+        let errorCode = (_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode;
+        if (!errorCode) {
+            logger_1.logger.debug("Got unexpected error from Runtime Config; it has no status code:", err);
+            errorCode = 500;
         }
-        catch (err) {
-            logger_1.logger.debug(err);
-            let errorCode = (_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode;
-            if (!errorCode) {
-                logger_1.logger.debug("Got unexpected error from Runtime Config; it has no status code:", err);
-                errorCode = 500;
-            }
-            if (errorCode === 500 || errorCode === 503) {
-                throw new error_1.FirebaseError("Cloud Runtime Config is currently experiencing issues, " +
-                    "which is preventing your functions from being deployed. " +
-                    "Please wait a few minutes and then try to deploy your functions again." +
-                    "\nRun `firebase deploy --except functions` if you want to continue deploying the rest of your project.");
-            }
-            config = {};
+        if (errorCode === 500 || errorCode === 503) {
+            throw new error_1.FirebaseError("Cloud Runtime Config is currently experiencing issues, " +
+                "which is preventing your functions from being deployed. " +
+                "Please wait a few minutes and then try to deploy your functions again." +
+                "\nRun `firebase deploy --except functions` if you want to continue deploying the rest of your project.");
         }
     }
-    config.firebase = context.firebaseConfig;
-    return config;
+    return {};
 }
 exports.getFunctionsConfig = getFunctionsConfig;
 async function pipeAsync(from, to) {

package/lib/deploy/functions/pricing.js

@@ -93,14 +93,17 @@ exports.V2_FREE_TIER = {
     vCpu: 180000,
     egress: 1,
 };
+const VCPU_TO_GHZ = 2.4;
 const MB_TO_GHZ = {
     128: 0.2,
     256: 0.4,
     512: 0.8,
     1024: 1.4,
-    2048: 2.4,
-    4096: 4.8,
-    8192: 4.8,
+    2048: 1 * VCPU_TO_GHZ,
+    4096: 2 * VCPU_TO_GHZ,
+    8192: 2 * VCPU_TO_GHZ,
+    16384: 4 * VCPU_TO_GHZ,
+    32768: 8 * VCPU_TO_GHZ,
 };
 function canCalculateMinInstanceCost(endpoint) {
     if (!endpoint.minInstances) {

package/lib/deploy/functions/prompts.js

@@ -136,19 +136,13 @@ async function promptForMinInstances(options, want, have) {
         const cost = pricing.monthlyMinInstanceCost(backend.allEndpoints(want)).toFixed(2);
         costLine = `With these options, your minimum bill will be $${cost} in a 30-day month`;
     }
-    let cudAnnotation = "";
-    if (backend.someEndpoint(want, (fn) => fn.platform === "gcfv2" && !!fn.minInstances)) {
-        cudAnnotation =
-            "\nThis bill can be lowered with a one year commitment. See https://cloud.google.com/run/cud for more";
-    }
     const warnMessage = "The following functions have reserved minimum instances. This will " +
         "reduce the frequency of cold starts but increases the minimum cost. " +
         "You will be charged for the memory allocation and a fraction of the " +
         "CPU allocation of instances while they are idle.\n\n" +
         functionLines +
         "\n\n" +
-        costLine +
-        cudAnnotation;
+        costLine;
     utils.logLabeledWarning("functions", warnMessage);
     const proceed = await (0, prompt_1.promptOnce)({
         type: "confirm",