firebase-tools 14.3.1 → 14.4.0

package/lib/dataconnect/cloudAICompanionClient.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callCloudAICompanion = exports.cloudAICompationClient = void 0;
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+const CLOUD_AI_COMPANION_VERSION = "v1";
+const CLIENT_CONTEXT_NAME_IDENTIFIER = "firebase_vscode";
+const FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME = "type.googleapis.com/google.cloud.cloudaicompanion.v1main.FirebaseChatRequestContext";
+const FDC_SCHEMA_EXPERIENCE_CONTEXT = "/appeco/firebase/fdc-schema-generator";
+const FDC_OPERATION_EXPERIENCE_CONTEXT = "/appeco/firebase/fdc-query-generator";
+const USER_AUTHOR = "USER";
+function cloudAICompationClient() {
+    return new apiv2_1.Client({
+        urlPrefix: (0, api_1.cloudAiCompanionOrigin)(),
+        apiVersion: CLOUD_AI_COMPANION_VERSION,
+        auth: true,
+    });
+}
+exports.cloudAICompationClient = cloudAICompationClient;
+async function callCloudAICompanion(client, vscodeRequest, type) {
+    const request = buildRequest(vscodeRequest, type);
+    const { projectId } = getServiceParts(vscodeRequest.servicePath);
+    const instance = toChatResourceName(projectId);
+    const res = await client.post(`${instance}:completeTask`, request);
+    return res;
+}
+exports.callCloudAICompanion = callCloudAICompanion;
+function buildRequest({ servicePath, naturalLanguageQuery, chatHistory }, type) {
+    const { serviceId } = getServiceParts(servicePath);
+    const input = {
+        messages: [
+            ...chatHistory,
+            {
+                author: USER_AUTHOR,
+                content: naturalLanguageQuery,
+            },
+        ],
+    };
+    const clientContext = {
+        name: CLIENT_CONTEXT_NAME_IDENTIFIER,
+        additionalContext: {
+            "@type": FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME,
+            fdcInfo: {
+                serviceId,
+                fdcServiceName: servicePath,
+                requiresQuery: true,
+            },
+        },
+    };
+    return {
+        input,
+        clientContext,
+        experienceContext: {
+            experience: type === "schema" ? FDC_SCHEMA_EXPERIENCE_CONTEXT : FDC_OPERATION_EXPERIENCE_CONTEXT,
+        },
+    };
+}
+function toChatResourceName(projectId) {
+    return `projects/${projectId}/locations/global/instances/default`;
+}
+function getServiceParts(name) {
+    const match = name.match(/projects\/([^/]*)\/locations\/([^/]*)\/services\/([^/]*)/);
+    if (!match) {
+        throw new Error(`Invalid service name: ${name}`);
+    }
+    return { projectId: match[1], locationId: match[2], serviceId: match[3] };
+}

package/lib/deploy/apphosting/args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/deploy/apphosting/deploy.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const error_1 = require("../../error");
+const gcs = require("../../gcp/storage");
+const getProjectNumber_1 = require("../../getProjectNumber");
+const projectUtils_1 = require("../../projectUtils");
+const utils_1 = require("../../utils");
+const util_1 = require("./util");
+async function default_1(context, options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    options.projectNumber = await (0, getProjectNumber_1.getProjectNumber)(options);
+    if (!context.backendConfigs) {
+        return;
+    }
+    for (const loc of context.backendLocations.values()) {
+        const bucketName = `firebaseapphosting-sources-${options.projectNumber}-${loc.toLowerCase()}`;
+        try {
+            await gcs.getBucket(bucketName);
+        }
+        catch (err) {
+            const errStatus = (0, error_1.getErrStatus)(err.original);
+            if (errStatus === 403 || errStatus === 404) {
+                (0, utils_1.logLabeledBullet)("apphosting", `Creating Cloud Storage bucket in ${loc} to store App Hosting source code uploads at ${bucketName}...`);
+                try {
+                    await gcs.createBucket(projectId, {
+                        name: bucketName,
+                        location: loc,
+                        lifecycle: {
+                            rule: [
+                                {
+                                    action: {
+                                        type: "Delete",
+                                    },
+                                    condition: {
+                                        age: 30,
+                                    },
+                                },
+                            ],
+                        },
+                    });
+                }
+                catch (err) {
+                    if ((0, error_1.getErrStatus)(err.original) === 403) {
+                        (0, utils_1.logLabeledWarning)("apphosting", "Failed to create Cloud Storage bucket because user does not have sufficient permissions. " +
+                            "See https://cloud.google.com/storage/docs/access-control/iam-roles for more details on " +
+                            "IAM roles that are able to create a Cloud Storage bucket, and ask your project administrator " +
+                            "to grant you one of those roles.");
+                        throw err.original;
+                    }
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    for (const cfg of context.backendConfigs.values()) {
+        const { projectSourcePath, zippedSourcePath } = await (0, util_1.createArchive)(cfg, options.projectRoot);
+        const backendLocation = context.backendLocations.get(cfg.backendId);
+        if (!backendLocation) {
+            throw new error_1.FirebaseError(`Failed to find location for backend ${cfg.backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);
+        }
+        (0, utils_1.logLabeledBullet)("apphosting", `Uploading source code at ${projectSourcePath} for backend ${cfg.backendId}...`);
+        const { bucket, object } = await gcs.uploadObject({
+            file: zippedSourcePath,
+            stream: fs.createReadStream(zippedSourcePath),
+        }, `firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}`);
+        (0, utils_1.logLabeledBullet)("apphosting", `Source code uploaded at gs://${bucket}/${object}`);
+        context.backendStorageUris.set(cfg.backendId, `gs://firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}/${path.basename(zippedSourcePath)}`);
+    }
+}
+exports.default = default_1;

package/lib/deploy/apphosting/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.deploy = exports.prepare = void 0;
+const prepare_1 = require("./prepare");
+exports.prepare = prepare_1.default;
+const deploy_1 = require("./deploy");
+exports.deploy = deploy_1.default;
+const release_1 = require("./release");
+exports.release = release_1.default;

package/lib/deploy/apphosting/prepare.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackendConfigs = void 0;
+const path = require("path");
+const backend_1 = require("../../apphosting/backend");
+const apphosting_1 = require("../../gcp/apphosting");
+const devConnect_1 = require("../../gcp/devConnect");
+const projectUtils_1 = require("../../projectUtils");
+const prompt_1 = require("../../prompt");
+const utils_1 = require("../../utils");
+async function default_1(context, options) {
+    var _a;
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, apphosting_1.ensureApiEnabled)(options);
+    await (0, backend_1.ensureRequiredApisEnabled)(projectId);
+    try {
+        await (0, backend_1.ensureAppHostingComputeServiceAccount)(projectId, "", true);
+    }
+    catch (err) {
+        if (err.status === 400) {
+            (0, utils_1.logLabeledWarning)("apphosting", "Your App Hosting compute service account is still being provisioned. Please try again in a few moments.");
+        }
+        throw err;
+    }
+    context.backendConfigs = new Map();
+    context.backendLocations = new Map();
+    context.backendStorageUris = new Map();
+    const configs = getBackendConfigs(options);
+    const { backends } = await (0, apphosting_1.listBackends)(projectId, "-");
+    const foundBackends = [];
+    const notFoundBackends = [];
+    const ambiguousBackends = [];
+    for (const cfg of configs) {
+        const filteredBackends = backends.filter((backend) => (0, apphosting_1.parseBackendName)(backend.name).id === cfg.backendId);
+        if (filteredBackends.length === 0) {
+            notFoundBackends.push(cfg);
+        }
+        else if (filteredBackends.length === 1) {
+            foundBackends.push(cfg);
+        }
+        else {
+            ambiguousBackends.push(cfg);
+        }
+    }
+    for (const cfg of ambiguousBackends) {
+        const filteredBackends = backends.filter((backend) => (0, apphosting_1.parseBackendName)(backend.name).id === cfg.backendId);
+        const locations = filteredBackends.map((b) => (0, apphosting_1.parseBackendName)(b.name).location);
+        (0, utils_1.logLabeledWarning)("apphosting", `You have multiple backends with the same ${cfg.backendId} ID in regions: ${locations.join(", ")}. This is not allowed until we can support more locations. ` +
+            "Please delete and recreate any backends that share an ID with another backend.");
+    }
+    if (foundBackends.length > 0) {
+        (0, utils_1.logLabeledBullet)("apphosting", `Found backend(s) ${foundBackends.map((cfg) => cfg.backendId).join(", ")}`);
+    }
+    for (const cfg of foundBackends) {
+        const filteredBackends = backends.filter((backend) => (0, apphosting_1.parseBackendName)(backend.name).id === cfg.backendId);
+        if (cfg.alwaysDeployFromSource === false) {
+            continue;
+        }
+        const backend = filteredBackends[0];
+        const { location } = (0, apphosting_1.parseBackendName)(backend.name);
+        if (cfg.alwaysDeployFromSource === undefined && ((_a = backend.codebase) === null || _a === void 0 ? void 0 : _a.repository)) {
+            const { connectionName, id } = (0, devConnect_1.parseGitRepositoryLinkName)(backend.codebase.repository);
+            const gitRepositoryLink = await (0, devConnect_1.getGitRepositoryLink)(projectId, location, connectionName, id);
+            if (!options.force) {
+                const confirmDeploy = await (0, prompt_1.confirm)({
+                    default: true,
+                    message: `${cfg.backendId} is linked to the remote repository at ${gitRepositoryLink.cloneUri}. Are you sure you want to deploy your local source?`,
+                });
+                cfg.alwaysDeployFromSource = confirmDeploy;
+                const configPath = path.join(options.projectRoot || "", "firebase.json");
+                options.config.writeProjectFile(configPath, options.config.src);
+                (0, utils_1.logLabeledBullet)("apphosting", `Your deployment preferences have been saved to firebase.json. On future invocations of "firebase deploy", your local source will be deployed to ${cfg.backendId}. You can edit this setting in your firebase.json at any time.`);
+                if (!confirmDeploy) {
+                    (0, utils_1.logLabeledWarning)("apphosting", `Skipping deployment of backend ${cfg.backendId}`);
+                    continue;
+                }
+            }
+        }
+        context.backendConfigs.set(cfg.backendId, cfg);
+        context.backendLocations.set(cfg.backendId, location);
+    }
+    if (notFoundBackends.length === 0) {
+        return;
+    }
+    if (options.force) {
+        (0, utils_1.logLabeledWarning)("apphosting", `Skipping deployments of backend(s) ${notFoundBackends.map((cfg) => cfg.backendId).join(", ")}; ` +
+            "the backend(s) do not exist yet and we cannot create them for you because you must choose primary regions for each one. " +
+            "Please run 'firebase deploy' without the --force flag, or 'firebase apphosting:backends:create' to create the backend, " +
+            "then retry deployment.");
+        return;
+    }
+    const confirmCreate = await (0, prompt_1.confirm)({
+        default: true,
+        message: `Did not find backend(s) ${notFoundBackends.map((cfg) => cfg.backendId).join(", ")}. Do you want to create them (you'll have the option to select which to create in the next step)?`,
+    });
+    if (!confirmCreate) {
+        return;
+    }
+    const selected = await (0, prompt_1.checkbox)({
+        message: "Which backends do you want to create and deploy to?",
+        choices: notFoundBackends.map((cfg) => cfg.backendId),
+    });
+    const selectedBackends = selected.map((id) => notFoundBackends.find((backend) => backend.backendId === id));
+    for (const cfg of selectedBackends) {
+        (0, utils_1.logLabeledBullet)("apphosting", `Creating a new backend ${cfg.backendId}...`);
+        const { location } = await (0, backend_1.doSetupSourceDeploy)(projectId, cfg.backendId);
+        context.backendConfigs.set(cfg.backendId, cfg);
+        context.backendLocations.set(cfg.backendId, location);
+    }
+    return;
+}
+exports.default = default_1;
+function getBackendConfigs(options) {
+    if (!options.config.src.apphosting) {
+        return [];
+    }
+    const backendConfigs = Array.isArray(options.config.src.apphosting)
+        ? options.config.src.apphosting
+        : [options.config.src.apphosting];
+    if (!options.only) {
+        return backendConfigs;
+    }
+    const selectors = options.only.split(",");
+    const backendIds = [];
+    for (const selector of selectors) {
+        if (selector === "apphosting") {
+            return backendConfigs;
+        }
+        if (selector.startsWith("apphosting:")) {
+            const backendId = selector.replace("apphosting:", "");
+            if (backendId.length > 0) {
+                backendIds.push(backendId);
+            }
+        }
+    }
+    if (backendIds.length === 0) {
+        return [];
+    }
+    return backendConfigs.filter((cfg) => backendIds.includes(cfg.backendId));
+}
+exports.getBackendConfigs = getBackendConfigs;

package/lib/deploy/apphosting/release.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ora = require("ora");
+const api_1 = require("../../api");
+const backend_1 = require("../../apphosting/backend");
+const rollout_1 = require("../../apphosting/rollout");
+const projectUtils_1 = require("../../projectUtils");
+const utils_1 = require("../../utils");
+async function default_1(context, options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const rollouts = [];
+    const backendIds = [];
+    for (const backendId of context.backendConfigs.keys()) {
+        const config = context.backendConfigs.get(backendId);
+        const location = context.backendLocations.get(backendId);
+        const storageUri = context.backendStorageUris.get(backendId);
+        if (!config || !location || !storageUri) {
+            (0, utils_1.logLabeledWarning)("apphosting", `Failed to find metadata for backend ${backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);
+            continue;
+        }
+        backendIds.push(backendId);
+        rollouts.push((0, rollout_1.orchestrateRollout)({
+            projectId,
+            location,
+            backendId,
+            buildInput: {
+                source: {
+                    archive: {
+                        userStorageUri: storageUri,
+                        rootDirectory: config.rootDir,
+                    },
+                },
+            },
+        }));
+    }
+    (0, utils_1.logLabeledBullet)("apphosting", `You may also track the rollout(s) at:\n\t${(0, api_1.consoleOrigin)()}/project/${projectId}/apphosting`);
+    const rolloutsSpinner = ora(`Starting rollout(s) for backend(s) ${Array.from(context.backendConfigs.keys()).join(", ")}; this may take a few minutes. It's safe to exit now.\n`).start();
+    const results = await Promise.allSettled(rollouts);
+    for (let i = 0; i < results.length; i++) {
+        const res = results[i];
+        if (res.status === "fulfilled") {
+            const backend = await (0, backend_1.getBackend)(projectId, backendIds[i]);
+            (0, utils_1.logLabeledSuccess)("apphosting", `Rollout for backend ${backendIds[i]} complete!`);
+            (0, utils_1.logLabeledSuccess)("apphosting", `Your backend is now deployed at:\n\thttps://${backend.uri}`);
+        }
+        else {
+            (0, utils_1.logLabeledWarning)("apphosting", `Rollout for backend ${backendIds[i]} failed.`);
+            (0, utils_1.logLabeledError)("apphosting", res.reason);
+        }
+    }
+    rolloutsSpinner.stop();
+}
+exports.default = default_1;

package/lib/deploy/apphosting/util.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArchive = void 0;
+const archiver = require("archiver");
+const fs = require("fs");
+const path = require("path");
+const tmp = require("tmp");
+const error_1 = require("../../error");
+const fsAsync = require("../../fsAsync");
+async function createArchive(config, projectRoot) {
+    const tmpFile = tmp.fileSync({ prefix: `${config.backendId}-`, postfix: ".zip" }).name;
+    const fileStream = fs.createWriteStream(tmpFile, {
+        flags: "w",
+        encoding: "binary",
+    });
+    const archive = archiver("zip");
+    if (!projectRoot) {
+        projectRoot = process.cwd();
+    }
+    const ignore = config.ignore || ["node_modules", ".git"];
+    ignore.push("firebase-debug.log", "firebase-debug.*.log");
+    const gitIgnorePatterns = parseGitIgnorePatterns(projectRoot);
+    ignore.push(...gitIgnorePatterns);
+    try {
+        const files = await fsAsync.readdirRecursive({
+            path: projectRoot,
+            ignore: ignore,
+            isGitIgnore: true,
+        });
+        for (const file of files) {
+            const name = path.relative(projectRoot, file.name);
+            archive.file(file.name, {
+                name,
+                mode: file.mode,
+            });
+        }
+        await pipeAsync(archive, fileStream);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Could not read source directory. Remove links and shortcuts and try again.", { original: err, exit: 1 });
+    }
+    return { projectSourcePath: projectRoot, zippedSourcePath: tmpFile };
+}
+exports.createArchive = createArchive;
+function parseGitIgnorePatterns(projectRoot, gitIgnorePath = ".gitignore") {
+    const absoluteFilePath = path.resolve(projectRoot, gitIgnorePath);
+    if (!fs.existsSync(absoluteFilePath)) {
+        return [];
+    }
+    const lines = fs
+        .readFileSync(absoluteFilePath)
+        .toString()
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => !line.startsWith("#") && !(line === ""));
+    return lines;
+}
+async function pipeAsync(from, to) {
+    from.pipe(to);
+    await from.finalize();
+    return new Promise((resolve, reject) => {
+        to.on("finish", resolve);
+        to.on("error", reject);
+    });
+}

package/lib/deploy/extensions/v2FunctionHelper.js

@@ -9,6 +9,7 @@ const ensureApiEnabled_1 = require("../../ensureApiEnabled");
 const planner = require("./planner");
 const projectUtils_1 = require("../../projectUtils");
 const api_1 = require("../../api");
+const computeEngine_1 = require("../../gcp/computeEngine");
 const SERVICE_AGENT_ROLE = "roles/eventarc.eventReceiver";
 async function checkSpecForV2Functions(i) {
     const extensionSpec = await planner.getExtensionSpec(i);
@@ -23,7 +24,7 @@ async function ensureNecessaryV2ApisAndRoles(options) {
 exports.ensureNecessaryV2ApisAndRoles = ensureNecessaryV2ApisAndRoles;
 async function ensureComputeP4SARole(projectId) {
     const projectNumber = await (0, getProjectNumber_1.getProjectNumber)({ projectId });
-    const saEmail = `${projectNumber}-compute@developer.gserviceaccount.com`;
+    const saEmail = await (0, computeEngine_1.getDefaultServiceAccount)(projectNumber);
     let policy;
     try {
         policy = await resourceManager.getIamPolicy(projectId);

package/lib/deploy/functions/checkIam.js

@@ -89,8 +89,8 @@ function obtainPubSubServiceAgentBindings(projectNumber) {
     return [serviceAccountTokenCreatorBinding];
 }
 exports.obtainPubSubServiceAgentBindings = obtainPubSubServiceAgentBindings;
-function obtainDefaultComputeServiceAgentBindings(projectNumber) {
-    const defaultComputeServiceAgent = `serviceAccount:${gce.getDefaultServiceAccount(projectNumber)}`;
+async function obtainDefaultComputeServiceAgentBindings(projectNumber) {
+    const defaultComputeServiceAgent = `serviceAccount:${await gce.getDefaultServiceAccount(projectNumber)}`;
     const runInvokerBinding = {
         role: exports.RUN_INVOKER_ROLE,
         members: [defaultComputeServiceAgent],
@@ -117,7 +117,7 @@ async function ensureServiceAgentRoles(projectId, projectNumber, want, have, dry
     const requiredBindings = [...(0, functional_1.flattenArray)(nestedRequiredBindings)];
     if (haveServices.length === 0) {
         requiredBindings.push(...obtainPubSubServiceAgentBindings(projectNumber));
-        requiredBindings.push(...obtainDefaultComputeServiceAgentBindings(projectNumber));
+        requiredBindings.push(...(await obtainDefaultComputeServiceAgentBindings(projectNumber)));
     }
     if (requiredBindings.length === 0) {
         return;

package/lib/deploy/functions/ensure.js

@@ -10,6 +10,7 @@ const projects_1 = require("../../management/projects");
 const functional_1 = require("../../functional");
 const api_1 = require("../../api");
 const backend = require("./backend");
+const computeEngine_1 = require("../../gcp/computeEngine");
 const FAQ_URL = "https://firebase.google.com/support/faq#functions-runtime";
 const metadataCallCache = new Map();
 async function defaultServiceAccount(e) {
@@ -23,7 +24,7 @@ async function defaultServiceAccount(e) {
         return `${metadata.projectId}@appspot.gserviceaccount.com`;
     }
     else if (e.platform === "gcfv2") {
-        return `${metadata.projectNumber}-compute@developer.gserviceaccount.com`;
+        return await (0, computeEngine_1.getDefaultServiceAccount)(metadata.projectNumber);
     }
     (0, functional_1.assertExhaustive)(e.platform);
 }

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnIfNewGenkitFunctionIsMissingSecrets = exports.loadCodebases = exports.resolveCpuAndConcurrency = exports.inferBlockingDetails = exports.updateEndpointTargetedStatus = exports.inferDetailsFromExisting = exports.prepare = exports.EVENTARC_SOURCE_ENV = void 0;
+exports.ensureAllRequiredAPIsEnabled = exports.warnIfNewGenkitFunctionIsMissingSecrets = exports.loadCodebases = exports.resolveCpuAndConcurrency = exports.inferBlockingDetails = exports.updateEndpointTargetedStatus = exports.inferDetailsFromExisting = exports.prepare = exports.EVENTARC_SOURCE_ENV = void 0;
 const clc = require("colorette");
 const backend = require("./backend");
 const build = require("./build");
@@ -171,22 +171,8 @@ async function prepare(context, options, payload) {
     }
     const wantBackend = backend.merge(...Object.values(wantBackends));
     const haveBackend = backend.merge(...Object.values(haveBackends));
+    await ensureAllRequiredAPIsEnabled(projectNumber, wantBackend);
     await warnIfNewGenkitFunctionIsMissingSecrets(wantBackend, haveBackend, options);
-    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 = [(0, api_1.cloudRunApiOrigin)(), (0, api_1.eventarcOrigin)(), (0, api_1.pubsubOrigin)(), (0, api_1.storageOrigin)()];
-        const enablements = V2_APIS.map((api) => {
-            return ensureApiEnabled.ensure(context.projectId, api, "functions");
-        });
-        await Promise.all(enablements);
-        const services = ["pubsub.googleapis.com", "eventarc.googleapis.com"];
-        const generateServiceAccounts = services.map((service) => {
-            return (0, serviceusage_1.generateServiceIdentity)(projectNumber, service, "functions");
-        });
-        await Promise.all(generateServiceAccounts);
-    }
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
         return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, context.filters);
     });
@@ -350,3 +336,24 @@ async function warnIfNewGenkitFunctionIsMissingSecrets(have, want, options) {
     }
 }
 exports.warnIfNewGenkitFunctionIsMissingSecrets = warnIfNewGenkitFunctionIsMissingSecrets;
+async function ensureAllRequiredAPIsEnabled(projectNumber, wantBackend) {
+    await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
+        return ensureApiEnabled.ensure(projectNumber, api, "functions", false);
+    }));
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+        const V2_APIS = [(0, api_1.cloudRunApiOrigin)(), (0, api_1.eventarcOrigin)(), (0, api_1.pubsubOrigin)(), (0, api_1.storageOrigin)()];
+        const enablements = V2_APIS.map((api) => {
+            return ensureApiEnabled.ensure(projectNumber, api, "functions");
+        });
+        await Promise.all(enablements);
+        const services = ["pubsub.googleapis.com", "eventarc.googleapis.com"];
+        const generateServiceAccounts = services.map((service) => {
+            return (0, serviceusage_1.generateServiceIdentity)(projectNumber, service, "functions");
+        });
+        await Promise.all(generateServiceAccounts);
+    }
+    if (backend.someEndpoint(wantBackend, (e) => !!(e.secretEnvironmentVariables && e.secretEnvironmentVariables.length > 0))) {
+        await ensureApiEnabled.ensure(projectNumber, (0, api_1.secretManagerOrigin)(), "functions", false);
+    }
+}
+exports.ensureAllRequiredAPIsEnabled = ensureAllRequiredAPIsEnabled;

package/lib/deploy/functions/release/fabricator.js

@@ -335,7 +335,7 @@ class Fabricator {
         else if (backend.isScheduleTriggered(endpoint)) {
             const invoker = endpoint.serviceAccount
                 ? [endpoint.serviceAccount]
-                : [gce.getDefaultServiceAccount(this.projectNumber)];
+                : [await gce.getDefaultServiceAccount(this.projectNumber)];
             await this.executor
                 .run(() => run.setInvokerCreate(endpoint.project, serviceName, invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
@@ -420,7 +420,7 @@ class Fabricator {
         else if (backend.isScheduleTriggered(endpoint)) {
             invoker = endpoint.serviceAccount
                 ? [endpoint.serviceAccount]
-                : [gce.getDefaultServiceAccount(this.projectNumber)];
+                : [await gce.getDefaultServiceAccount(this.projectNumber)];
         }
         if (invoker) {
             await this.executor
@@ -509,13 +509,13 @@ class Fabricator {
         }
     }
     async upsertScheduleV1(endpoint) {
-        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation, this.projectNumber);
+        const job = await scheduler.jobFromEndpoint(endpoint, this.appEngineLocation, this.projectNumber);
         await this.executor
             .run(() => scheduler.createOrReplaceJob(job))
             .catch(rethrowAs(endpoint, "upsert schedule"));
     }
     async upsertScheduleV2(endpoint) {
-        const job = scheduler.jobFromEndpoint(endpoint, endpoint.region, this.projectNumber);
+        const job = await scheduler.jobFromEndpoint(endpoint, endpoint.region, this.projectNumber);
         await this.executor
             .run(() => scheduler.createOrReplaceJob(job))
             .catch(rethrowAs(endpoint, "upsert schedule"));

package/lib/deploy/functions/release/index.js

@@ -122,7 +122,7 @@ async function setupArtifactCleanupPolicies(options, projectId, locations) {
         utils.logLabeledWarning("functions", `Failed to set up cleanup policy for repositories in ${locationsWithErrors.length > 1 ? "regions" : "region"} ` +
             `${locationsWithErrors.join(", ")}.` +
             "This could result in a small monthly bill as container images accumulate over time.");
-        throw new error_1.FirebaseError(`Functions successfully deployed but could not set up cleanup policy in ` +
+        utils.logLabeledWarning("functions", `Functions successfully deployed but could not set up cleanup policy in ` +
             `${locationsWithErrors.length > 1 ? "regions" : "region"} ${locationsWithErrors.join(", ")}. ` +
             `Pass the --force option to automatically set up a cleanup policy or ` +
             "run 'firebase functions:artifacts:setpolicy' to set up a cleanup policy to automatically delete old images.");

package/lib/deploy/functions/runtimes/python/index.js

@@ -42,6 +42,9 @@ function getPythonBinary(runtime) {
     else if (runtime === "python312") {
         return "python3.12";
     }
+    else if (runtime === "python313") {
+        return "python3.13";
+    }
     (0, functional_1.assertExhaustive)(runtime, `Unhandled python runtime ${runtime}`);
 }
 exports.getPythonBinary = getPythonBinary;