firebase-tools 15.22.3 → 15.22.4

package/lib/accountExporter.js

@@ -24,6 +24,7 @@ const EXPORTED_JSON_KEYS = [
     "phoneNumber",
     "disabled",
     "customAttributes",
+    "mfaInfo",
 ];
 const EXPORTED_JSON_KEYS_RENAMING = {
     lastLoginAt: "lastSignedInAt",

package/lib/accountImporter.js

@@ -27,6 +27,7 @@ const ALLOWED_JSON_KEYS = [
     "phoneNumber",
     "disabled",
     "customAttributes",
+    "mfaInfo",
 ];
 const ALLOWED_JSON_KEYS_RENAMING = {
     lastSignedInAt: "lastLoginAt",

package/lib/apphosting/localbuilds.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runUniversalMaker = runUniversalMaker;
 exports.localBuild = localBuild;
+exports.validateLocalBuildNodeVersion = validateLocalBuildNodeVersion;
 const childProcess = require("child_process");
 const fs = require("fs-extra");
 const path = require("path");
+const semver = require("semver");
 const index_1 = require("./secrets/index");
 const prompt_1 = require("../prompt");
 const error_1 = require("../error");
@@ -138,3 +140,51 @@ async function toProcessEnv(projectId, env) {
     }));
     return Object.fromEntries(resolvedEntries);
 }
+function validateLocalBuildNodeVersion(backend, projectRoot) {
+    const runtimeValue = backend.runtime?.value ?? "";
+    const isLegacyRuntime = runtimeValue === "" || runtimeValue === "nodejs";
+    const abiuEnabled = !isLegacyRuntime && !backend.automaticBaseImageUpdatesDisabled;
+    if (!abiuEnabled) {
+        throw new error_1.FirebaseError(`Local builds are only supported for backends with ABIU (Automatic Base Image Updates) enabled. ` +
+            `Your backend is currently configured with a non-ABIU runtime ("${runtimeValue || "unspecified"}"). ` +
+            `Please update your backend to a versioned runtime (e.g., nodejs22) to enable local builds.`, { exit: 1 });
+    }
+    const targetMajorMatch = runtimeValue.match(/^nodejs(\d+)$/);
+    if (!targetMajorMatch) {
+        (0, utils_1.logLabeledWarning)("apphosting", `Unable to extract Node.js major version from the backend runtime ("${runtimeValue}"). ` +
+            `Skipping local Node.js version compatibility checks.`);
+        return;
+    }
+    const targetMajor = parseInt(targetMajorMatch[1], 10);
+    let localNodeVersion;
+    try {
+        localNodeVersion = childProcess.execSync("node -v", { encoding: "utf8" }).trim();
+    }
+    catch {
+        (0, utils_1.logLabeledWarning)("apphosting", `Unable to detect your local Node.js version (is 'node' installed and in your PATH?). ` +
+            `Skipping local Node.js version compatibility checks.`);
+        return;
+    }
+    const packageJsonPath = path.join(projectRoot, "package.json");
+    const packageJson = fs.readJsonSync(packageJsonPath, { throws: false });
+    const enginesNode = packageJson?.engines?.node;
+    if (enginesNode) {
+        (0, utils_1.logLabeledWarning)("apphosting", `Your package.json specifies Node.js engine "${enginesNode}". ` +
+            `Please note that local builds do NOT use the "engines" field to resolve or download Node.js. ` +
+            `Instead, your local build uses your host machine's active Node.js version (${localNodeVersion}) to compile the app, ` +
+            `and your deployed app will run on the backend's configured ABIU runtime (${runtimeValue}).`);
+        const targetRange = `^${targetMajor}.0.0`;
+        if (semver.validRange(enginesNode) && !semver.intersects(targetRange, enginesNode)) {
+            (0, utils_1.logLabeledWarning)("apphosting", `The Node.js version range specified in your package.json engines ("${enginesNode}") ` +
+                `does not satisfy your backend's target ABIU runtime version (Node.js ${targetMajor}). ` +
+                `Please update your package.json engines to align with your backend configuration.`);
+        }
+    }
+    const localMajorMatch = localNodeVersion.match(/^v?(\d+)/);
+    const localMajor = localMajorMatch ? parseInt(localMajorMatch[1], 10) : null;
+    if (localMajor !== null && localMajor !== targetMajor) {
+        (0, utils_1.logLabeledWarning)("apphosting", `Local Node.js version (${localNodeVersion}) does not match your backend's target Node.js version (Node.js ${targetMajor}). ` +
+            `This mismatch may cause runtime issues. ` +
+            `Please switch your local environment to Node.js ${targetMajor} to ensure build-to-run parity.`);
+    }
+}

package/lib/deploy/apphosting/prepare.js

@@ -4,6 +4,7 @@ exports.default = default_1;
 exports.injectEnvVarsFromApphostingConfig = injectEnvVarsFromApphostingConfig;
 exports.injectAutoInitEnvVars = injectAutoInitEnvVars;
 exports.getBackendConfigs = getBackendConfigs;
+exports.injectAngularEnvVars = injectAngularEnvVars;
 const crypto = require("crypto");
 const fs = require("fs");
 const os = require("os");
@@ -134,10 +135,29 @@ async function default_1(context, options) {
             continue;
         }
         experiments.assertEnabled("apphostinglocalbuilds", "locally build App Hosting backends");
+        let backend = backends.find((b) => (0, apphosting_1.parseBackendName)(b.name).id === cfg.backendId);
+        if (!backend) {
+            const location = context.backendLocations[cfg.backendId];
+            if (location) {
+                const apphosting = await Promise.resolve().then(() => require("../../gcp/apphosting"));
+                try {
+                    backend = await apphosting.getBackend(projectId, location, cfg.backendId);
+                }
+                catch {
+                }
+            }
+        }
+        if (!backend) {
+            throw new error_1.FirebaseError(`Backend ${cfg.backendId} not found.`);
+        }
+        const rootDir = path.resolve(options.projectRoot || process.cwd());
+        const appDir = path.join(rootDir, cfg.rootDir || "");
+        (0, localbuilds_1.validateLocalBuildNodeVersion)(backend, appDir);
         (0, utils_1.logLabeledBullet)("apphosting", `Starting local build for backend ${cfg.backendId}`);
         await injectEnvVarsFromApphostingConfig(configs.filter((c) => c.backendId === cfg.backendId), options, buildEnv, runtimeEnv);
         await injectAutoInitEnvVars(cfg, backends, buildEnv, runtimeEnv);
-        const rootDir = path.resolve(options.projectRoot || process.cwd());
+        const location = context.backendLocations[cfg.backendId];
+        await injectAngularEnvVars(cfg, rootDir, projectId, location, buildEnv, runtimeEnv);
         const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
         const localBuildScratchDir = path.join(os.tmpdir(), `apphosting-local-build-${cfg.backendId}-${pathHash}`);
         try {
@@ -266,3 +286,82 @@ async function prepareLocalBuildScratchDirectory(rootDir, localBuildScratchDir,
         fs.copyFileSync(file.name, destPath);
     }
 }
+function isAngularApplication(appDir) {
+    const packageJsonPath = path.join(appDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+            if (parsed && typeof parsed === "object") {
+                const pkg = parsed;
+                const angularDeps = ["@angular/core", "@angular/ssr", "@angular/platform-server"];
+                if (angularDeps.some((d) => pkg.dependencies?.[d] || pkg.devDependencies?.[d])) {
+                    return true;
+                }
+            }
+        }
+        catch (e) {
+            (0, utils_1.logLabeledError)("apphosting", `error when checking if application is angular: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    const angularJsonPath = path.join(appDir, "angular.json");
+    if (fs.existsSync(angularJsonPath)) {
+        return true;
+    }
+    return false;
+}
+async function injectAngularEnvVars(cfg, projectRoot, projectId, location, buildEnv, runtimeEnv) {
+    const appDir = path.join(projectRoot, cfg.rootDir || "");
+    if (!isAngularApplication(appDir)) {
+        return;
+    }
+    if (!location) {
+        throw new error_1.FirebaseError(`Failed to find location for backend ${cfg.backendId}.`);
+    }
+    const backendId = cfg.backendId;
+    runtimeEnv[backendId] ?? (runtimeEnv[backendId] = {});
+    buildEnv[backendId] ?? (buildEnv[backendId] = {});
+    const allowedProxyHeaders = [
+        "x-forwarded-host",
+        "x-forwarded-port",
+        "x-forwarded-proto",
+        "x-forwarded-for",
+    ];
+    const allowedProxyHeadersValue = allowedProxyHeaders.join(",");
+    let shouldInjectProxyHeaders = true;
+    if (runtimeEnv[backendId]["NG_TRUST_PROXY_HEADERS"]) {
+        const userProxyHeadersStr = runtimeEnv[backendId]["NG_TRUST_PROXY_HEADERS"].value;
+        const userProxyHeaders = userProxyHeadersStr
+            ? userProxyHeadersStr
+                .split(",")
+                .map((h) => h.trim().toLowerCase())
+                .filter(Boolean)
+            : [];
+        const isSubset = userProxyHeaders.length > 0 && userProxyHeaders.every((h) => allowedProxyHeaders.includes(h));
+        if (isSubset) {
+            shouldInjectProxyHeaders = false;
+        }
+        else {
+            throw new error_1.FirebaseError(`User-defined RUNTIME environment variable NG_TRUST_PROXY_HEADERS contains invalid headers. Allowed values: ${allowedProxyHeadersValue}`);
+        }
+    }
+    if (shouldInjectProxyHeaders) {
+        runtimeEnv[backendId]["NG_TRUST_PROXY_HEADERS"] = {
+            value: allowedProxyHeadersValue,
+            availability: ["RUNTIME"],
+        };
+    }
+    if (!runtimeEnv[backendId]["NG_ALLOWED_HOSTS"]) {
+        const projectNumber = await (0, getProjectNumber_1.getProjectNumber)({ project: projectId });
+        const sharedDomain = "hosted.app";
+        const defaultHosts = [
+            `${backendId}-${projectNumber}.${location}.run.app`,
+            `${backendId}--${projectId}.${location}.${sharedDomain}`,
+            `${backendId}--${projectId}.web.app`,
+            `${backendId}--${projectId}.firebaseapp.com`,
+        ];
+        runtimeEnv[backendId]["NG_ALLOWED_HOSTS"] = {
+            value: defaultHosts.join(","),
+            availability: ["RUNTIME"],
+        };
+    }
+}

package/lib/deploy/functions/backend.js

@@ -174,6 +174,9 @@ function merge(...backends) {
             apiToReasons[api] = reasons;
         }
         merged.environmentVariables = { ...merged.environmentVariables, ...b.environmentVariables };
+        if (b.lifecycleHooks) {
+            merged.lifecycleHooks = { ...(merged.lifecycleHooks || {}), ...b.lifecycleHooks };
+        }
     }
     for (const [api, reasons] of Object.entries(apiToReasons)) {
         merged.requiredAPIs.push({ api, reason: Array.from(reasons).join(" ") });
@@ -181,7 +184,9 @@ function merge(...backends) {
     return merged;
 }
 function isEmptyBackend(backend) {
-    return (Object.keys(backend.requiredAPIs).length === 0 && Object.keys(backend.endpoints).length === 0);
+    return (Object.keys(backend.requiredAPIs).length === 0 &&
+        Object.keys(backend.endpoints).length === 0 &&
+        Object.keys(backend.lifecycleHooks || {}).length === 0);
 }
 function functionName(cloudFunction) {
     return `projects/${cloudFunction.project}/locations/${cloudFunction.region}/functions/${cloudFunction.id}`;

package/lib/deploy/functions/build.js

@@ -263,6 +263,9 @@ function toBackend(build, paramValues) {
     }
     const bkend = backend.of(...bkEndpoints);
     bkend.requiredAPIs = build.requiredAPIs;
+    if (build.lifecycleHooks) {
+        bkend.lifecycleHooks = build.lifecycleHooks;
+    }
     return bkend;
 }
 function discoverTrigger(endpoint, region, r) {
@@ -375,4 +378,26 @@ function applyPrefix(build, prefix) {
         }
     }
     build.endpoints = newEndpoints;
+    if (build.lifecycleHooks) {
+        for (const hook of Object.values(build.lifecycleHooks)) {
+            if ("task" in hook) {
+                if (hook.task?.function) {
+                    hook.task.function = `${prefix}-${hook.task.function}`;
+                }
+            }
+            else if ("call" in hook) {
+                if (hook.call?.function) {
+                    hook.call.function = `${prefix}-${hook.call.function}`;
+                }
+            }
+            else if ("http" in hook) {
+                if (hook.http?.function) {
+                    hook.http.function = `${prefix}-${hook.http.function}`;
+                }
+            }
+            else {
+                (0, functional_1.assertExhaustive)(hook);
+            }
+        }
+    }
 }

package/lib/deploy/functions/prepare.js

@@ -203,7 +203,7 @@ async function prepare(context, options, payload) {
         await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
         resolveCpuAndConcurrency(wantBackend);
         resolveDefaultTimeout(wantBackend);
-        validate.endpointsAreValid(wantBackend);
+        validate.endpointsAreValid(wantBackend, existingBackend);
         inferBlockingDetails(wantBackend);
     }
     const wantBackend = backend.merge(...Object.values(wantBackends));

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

@@ -18,6 +18,7 @@ const error_1 = require("../../../error");
 const getProjectNumber_1 = require("../../../getProjectNumber");
 const extensions_1 = require("../../extensions");
 const artifacts = require("../../../functions/artifacts");
+const lifecycle_1 = require("./lifecycle");
 async function release(context, options, payload) {
     if (context.extensions && payload.extensions) {
         await (0, extensions_1.release)(context.extensions, options, payload.extensions);
@@ -88,6 +89,9 @@ async function release(context, options, payload) {
     reporter.printErrors(summary);
     const wantBackend = backend.merge(...Object.values(payload.functions).map((p) => p.wantBackend));
     printTriggerUrls(wantBackend, projectNumber);
+    for (const [codebase, { wantBackend: w, haveBackend: h }] of Object.entries(payload.functions)) {
+        await (0, lifecycle_1.executeLifecycleHooks)(w, h, plan, codebase);
+    }
     await setupArtifactCleanupPolicies(options, options.projectId, Object.keys(wantBackend.endpoints));
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineDeploymentDelta = determineDeploymentDelta;
+exports.executeLifecycleHooks = executeLifecycleHooks;
+const backend = require("../backend");
+const error_1 = require("../../../error");
+const logger_1 = require("../../../logger");
+const utils_1 = require("../../../utils");
+const cloudtasks = require("../../../gcp/cloudtasks");
+const computeEngine = require("../../../gcp/computeEngine");
+const projects_1 = require("../../../management/projects");
+const functional_1 = require("../../../functional");
+function determineDeploymentDelta(haveBackend) {
+    const hasExistingEndpoints = backend.someEndpoint(haveBackend, () => true);
+    if (!hasExistingEndpoints) {
+        return "afterInstall";
+    }
+    return "afterUpdate";
+}
+async function executeLifecycleHooks(wantBackend, haveBackend, plan, codebase) {
+    const delta = determineDeploymentDelta(haveBackend);
+    const hooks = wantBackend.lifecycleHooks || {};
+    const hook = hooks[delta];
+    if (!hook) {
+        logger_1.logger.debug(`No lifecycle hook configured for event: ${delta}`);
+        return false;
+    }
+    if (delta === "afterUpdate" && plan) {
+        const relevantChangesets = Object.entries(plan)
+            .filter(([key]) => {
+            if (!codebase)
+                return true;
+            if (key.startsWith(`${codebase}-`))
+                return true;
+            if (codebase === "default" && key.startsWith("-"))
+                return true;
+            return false;
+        })
+            .map(([, c]) => c);
+        const hasResourceModifications = relevantChangesets.some((changeset) => changeset.endpointsToCreate.length > 0 ||
+            changeset.endpointsToUpdate.length > 0 ||
+            changeset.endpointsToDelete.length > 0);
+        if (!hasResourceModifications) {
+            (0, utils_1.logLabeledBullet)("functions", "No resources modified in codebase. Skipping afterUpdate lifecycle hook.");
+            return false;
+        }
+    }
+    if ("task" in hook) {
+        (0, utils_1.logLabeledBullet)("functions", `Executing ${delta} lifecycle hook targeting: ${hook.task.function}...`);
+        await executeTaskQueueHook(hook.task, wantBackend);
+        return true;
+    }
+    else if ("call" in hook) {
+        throw new error_1.FirebaseError(`Lifecycle hook action type "call" is not supported.`);
+    }
+    else if ("http" in hook) {
+        throw new error_1.FirebaseError(`Lifecycle hook action type "http" is not supported.`);
+    }
+    else {
+        (0, functional_1.assertExhaustive)(hook);
+    }
+}
+async function executeTaskQueueHook(taskHook, wantBackend) {
+    const targetEndpoint = findTargetEndpoint(wantBackend, taskHook.function);
+    if (!targetEndpoint) {
+        throw new error_1.FirebaseError(`Target endpoint "${taskHook.function}" not found in backend for lifecycle hook.`);
+    }
+    if (!backend.isTaskQueueTriggered(targetEndpoint)) {
+        throw new error_1.FirebaseError(`Target endpoint "${taskHook.function}" is not a task queue function.`);
+    }
+    const queueName = cloudtasks.queueNameForEndpoint(targetEndpoint);
+    const bodyStr = taskHook.body ? JSON.stringify(taskHook.body) : "";
+    const body = bodyStr ? Buffer.from(bodyStr).toString("base64") : undefined;
+    const url = targetEndpoint.uri;
+    if (!url) {
+        throw new error_1.FirebaseError(`Target endpoint "${taskHook.function}" does not have a trigger URI.`);
+    }
+    const projectMetadata = await (0, projects_1.getProject)(targetEndpoint.project);
+    const projectNumber = projectMetadata.projectNumber;
+    const sa = targetEndpoint.serviceAccount || (await computeEngine.getDefaultServiceAccount(projectNumber));
+    const task = {
+        httpRequest: {
+            url,
+            httpMethod: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            oidcToken: {
+                serviceAccountEmail: sa,
+                audience: url,
+            },
+        },
+    };
+    if (body) {
+        task.httpRequest.body = body;
+    }
+    try {
+        await cloudtasks.enqueueTask(queueName, task);
+        (0, utils_1.logLabeledSuccess)("functions", `Successfully queued task for lifecycle hook ${taskHook.function} in queue ${queueName}.`);
+        (0, utils_1.logLabeledBullet)("functions", `View logs for ${taskHook.function} at: ${getCloudConsoleLogUrl(targetEndpoint)}`);
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        (0, utils_1.logLabeledWarning)("functions", `Failed to enqueue task for lifecycle hook ${taskHook.function}: ${errorMsg}`);
+    }
+}
+function findTargetEndpoint(backendSpec, targetId) {
+    for (const endpoint of backend.allEndpoints(backendSpec)) {
+        if (endpoint.id === targetId) {
+            return endpoint;
+        }
+    }
+    return undefined;
+}
+function getCloudConsoleLogUrl(endpoint) {
+    const { project, region, id } = endpoint;
+    const serviceName = endpoint.runServiceId || id;
+    const query = `resource.type="cloud_run_revision"\nresource.labels.service_name="${serviceName}"\nresource.labels.location="${region}"`;
+    return `https://console.cloud.google.com/logs/query;query=${encodeURIComponent(query)};project=${project}`;
+}

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -22,6 +22,7 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
         requiredAPIs: "array",
         endpoints: "object",
         extensions: "object",
+        lifecycleHooks: "object",
     });
     const bd = build.empty();
     bd.params = manifest.params || [];
@@ -41,6 +42,38 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
             bd.extensions[id] = be;
         }
     }
+    if (manifest.lifecycleHooks) {
+        bd.lifecycleHooks = {};
+        for (const id of Object.keys(manifest.lifecycleHooks)) {
+            if (id !== "afterInstall" && id !== "afterUpdate") {
+                throw new error_1.FirebaseError(`Invalid eventType "${id}" for lifecycle hook.`);
+            }
+            const hook = manifest.lifecycleHooks[id];
+            if (!hook || typeof hook !== "object") {
+                throw new error_1.FirebaseError(`Invalid lifecycle hook configuration for "${id}".`);
+            }
+            if (hook.task) {
+                if (typeof hook.task.function !== "string" || !hook.task.function) {
+                    throw new error_1.FirebaseError(`Invalid target "${hook.task.function || ""}" for lifecycle hook "${id}"`);
+                }
+            }
+            else if (hook.call) {
+                if (typeof hook.call.function !== "string" || !hook.call.function) {
+                    throw new error_1.FirebaseError(`Invalid target "${hook.call.function || ""}" for lifecycle hook "${id}"`);
+                }
+            }
+            else if (hook.http) {
+                const target = hook.http.url || hook.http.function;
+                if (typeof target !== "string" || !target) {
+                    throw new error_1.FirebaseError(`Invalid target "${target || ""}" for lifecycle hook "${id}"`);
+                }
+            }
+            else {
+                throw new error_1.FirebaseError(`No action (task, call, or http) specified for lifecycle hook "${id}"`);
+            }
+            bd.lifecycleHooks[id] = hook;
+        }
+    }
     return bd;
 }
 function parseRequiredAPIs(manifest) {

package/lib/deploy/functions/validate.js

@@ -9,6 +9,7 @@ exports.functionsDirectoryExists = functionsDirectoryExists;
 exports.functionIdsAreValid = functionIdsAreValid;
 exports.secretsAreValid = secretsAreValid;
 exports.checkFiltersIntegrity = checkFiltersIntegrity;
+exports.validateLifecycleHooks = validateLifecycleHooks;
 const path = require("path");
 const clc = require("colorette");
 const error_1 = require("../../error");
@@ -20,6 +21,7 @@ const fsutils = require("../../fsutils");
 const backend = require("./backend");
 const utils = require("../../utils");
 const secrets = require("../../functions/secrets");
+const functional_1 = require("../../functional");
 const MAX_V1_TIMEOUT_SECONDS = 540;
 const MAX_V2_EVENTS_TIMEOUT_SECONDS = 540;
 const MAX_V2_SCHEDULE_TIMEOUT_SECONDS = 1800;
@@ -49,7 +51,8 @@ function validateScheduledTimeout(ep) {
             `The attempt deadline will be capped at ${exports.MAX_V2_SCHEDULE_ATTEMPT_DEADLINE_SECONDS} seconds.`);
     }
 }
-function endpointsAreValid(wantBackend) {
+function endpointsAreValid(wantBackend, existingBackend) {
+    validateLifecycleHooks(wantBackend, existingBackend);
     const endpoints = backend.allEndpoints(wantBackend);
     functionIdsAreValid(endpoints);
     validateTimeoutConfig(endpoints);
@@ -288,3 +291,43 @@ function checkFiltersIntegrity(wantBackends, filters) {
         }
     }
 }
+function validateLifecycleHooks(wantBackend, existingBackend) {
+    if (!wantBackend.lifecycleHooks) {
+        return;
+    }
+    const endpoints = [
+        ...backend.allEndpoints(wantBackend),
+        ...(existingBackend ? backend.allEndpoints(existingBackend) : []),
+    ];
+    for (const [eventType, hook] of Object.entries(wantBackend.lifecycleHooks)) {
+        const keys = Object.keys(hook).filter((k) => ["task", "call", "http"].includes(k));
+        if (keys.length !== 1) {
+            throw new error_1.FirebaseError(`Lifecycle hook "${eventType}" must specify exactly one action (task, call, or http).`);
+        }
+        if ("task" in hook) {
+            const targetEndpoint = findAndValidateTargetEndpoint(endpoints, hook.task.function, eventType);
+            if (!backend.isTaskQueueTriggered(targetEndpoint)) {
+                throw new error_1.FirebaseError(`Lifecycle hook "${eventType}" expects a task queue function.`);
+            }
+        }
+        else if ("call" in hook) {
+            throw new error_1.FirebaseError(`Lifecycle hook action type "call" is not supported in the CLI yet.`);
+        }
+        else if ("http" in hook) {
+            throw new error_1.FirebaseError(`Lifecycle hook action type "http" is not supported in the CLI yet.`);
+        }
+        else {
+            (0, functional_1.assertExhaustive)(hook);
+        }
+    }
+}
+function findAndValidateTargetEndpoint(endpoints, functionName, eventType) {
+    const targetEndpoint = endpoints.find((e) => e.id === functionName);
+    if (!targetEndpoint) {
+        throw new error_1.FirebaseError(`Target endpoint "${functionName}" not found in backend for lifecycle hook "${eventType}".`);
+    }
+    if (targetEndpoint.platform === "gcfv1") {
+        throw new error_1.FirebaseError(`Target endpoint "${functionName}" is a GCF Gen 1 function. Lifecycle hooks are only supported for GCF Gen 2 functions.`);
+    }
+    return targetEndpoint;
+}

package/lib/emulator/downloadableEmulatorInfo.json

@@ -44,13 +44,13 @@
         }
     },
     "pubsub": {
-        "version": "0.8.33",
-        "expectedSize": 52948835,
-        "expectedChecksum": "7dc33e0c8bb37948228e49a18375d53b",
-        "expectedChecksumSHA256": "93768f8763d85c37f7f6e0f64d10195abaa088f4ff559b7d9fb8a2fc5520848d",
-        "remoteUrl": "https://storage.googleapis.com/firebase-preview-drop/emulator/pubsub-emulator-0.8.33.zip",
-        "downloadPathRelativeToCacheDir": "pubsub-emulator-0.8.33.zip",
-        "binaryPathRelativeToCacheDir": "pubsub-emulator-0.8.33/pubsub-emulator/bin/cloud-pubsub-emulator"
+        "version": "0.8.34",
+        "expectedSize": 53008019,
+        "expectedChecksum": "3eb75c292dfa72d48a36428a49bac314",
+        "expectedChecksumSHA256": "062a71d30cbc0cc29de6e55f22ae9fc7eacb02c60272a2c4692826fdb83f0c25",
+        "remoteUrl": "https://storage.googleapis.com/firebase-preview-drop/emulator/pubsub-emulator-0.8.34.zip",
+        "downloadPathRelativeToCacheDir": "pubsub-emulator-0.8.34.zip",
+        "binaryPathRelativeToCacheDir": "pubsub-emulator-0.8.34/pubsub-emulator/bin/cloud-pubsub-emulator"
     },
     "dataconnect": {
         "darwin": {

package/lib/firestore/api.js

@@ -646,7 +646,9 @@ class FirestoreApi {
                 pageSize: limit,
             },
         });
-        return res.body;
+        return {
+            operations: res.body?.operations || [],
+        };
     }
     async describeOperation(project, databaseId, operationName) {
         const url = `/projects/${project}/databases/${databaseId}/operations/${operationName}`;

package/lib/gcp/cloudtasks.js

@@ -7,6 +7,7 @@ exports.updateQueue = updateQueue;
 exports.upsertQueue = upsertQueue;
 exports.purgeQueue = purgeQueue;
 exports.deleteQueue = deleteQueue;
+exports.enqueueTask = enqueueTask;
 exports.setIamPolicy = setIamPolicy;
 exports.getIamPolicy = getIamPolicy;
 exports.setEnqueuer = setEnqueuer;
@@ -77,6 +78,9 @@ async function purgeQueue(name) {
 async function deleteQueue(name) {
     await client.delete(name);
 }
+async function enqueueTask(queueName, task) {
+    await client.post(`${queueName}/tasks`, { task });
+}
 async function setIamPolicy(name, policy) {
     const res = await client.post(`${name}:setIamPolicy`, {
         policy,