firebase-tools 10.7.1 → 10.9.0

package/lib/emulator/extensionsEmulator.js

@@ -65,7 +65,7 @@ class ExtensionsEmulator {
             if (!this.hasValidSource({ path: instance.localPath, extTarget: instance.localPath })) {
                 throw new error_1.FirebaseError(`Tried to emulate local extension at ${instance.localPath}, but it was missing required files.`);
             }
-            return instance.localPath;
+            return path.resolve(instance.localPath);
         }
         else if (instance.ref) {
             const ref = (0, refs_1.toExtensionVersionRef)(instance.ref);
@@ -152,6 +152,7 @@ class ExtensionsEmulator {
         return emulatableBackend;
     }
     autoPopulatedParams(instance) {
+        var _a;
         const projectId = this.args.projectId;
         return {
             PROJECT_ID: projectId !== null && projectId !== void 0 ? projectId : "",
@@ -159,6 +160,8 @@ class ExtensionsEmulator {
             DATABASE_INSTANCE: projectId !== null && projectId !== void 0 ? projectId : "",
             DATABASE_URL: `https://${projectId}.firebaseio.com`,
             STORAGE_BUCKET: `${projectId}.appspot.com`,
+            ALLOWED_EVENT_TYPES: instance.allowedEventTypes ? instance.allowedEventTypes.join(",") : "",
+            EVENTARC_CHANNEL: (_a = instance.eventarcChannel) !== null && _a !== void 0 ? _a : "",
         };
     }
     async checkAndWarnAPIs(instances) {

package/lib/emulator/functionsEmulator.js

@@ -223,7 +223,6 @@ class FunctionsEmulator {
         return Promise.resolve();
     }
     async connect() {
-        const loadTriggerPromises = [];
         for (const backend of this.args.emulatableBackends) {
             this.logger.logLabeled("BULLET", "functions", `Watching "${backend.functionsDir}" for Cloud Functions...`);
             const watcher = chokidar.watch(backend.functionsDir, {
@@ -239,9 +238,8 @@ class FunctionsEmulator {
                 this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
                 return debouncedLoadTriggers();
             });
-            loadTriggerPromises.push(this.loadTriggers(backend, true));
+            await this.loadTriggers(backend, true);
         }
-        await Promise.all(loadTriggerPromises);
         await this.performPostLoadOperations();
         return;
     }
@@ -669,7 +667,10 @@ class FunctionsEmulator {
         envs.FUNCTIONS_EMULATOR = "true";
         envs.TZ = "UTC";
         envs.FIREBASE_DEBUG_MODE = "true";
-        envs.FIREBASE_DEBUG_FEATURES = JSON.stringify({ skipTokenVerification: true });
+        envs.FIREBASE_DEBUG_FEATURES = JSON.stringify({
+            skipTokenVerification: true,
+            enableCors: true,
+        });
         const firestoreEmulator = this.getEmulatorInfo(types_1.Emulators.FIRESTORE);
         if (firestoreEmulator != null) {
             envs[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = (0, functionsEmulatorShared_1.formatHost)(firestoreEmulator);
@@ -853,11 +854,9 @@ class FunctionsEmulator {
     }
     async reloadTriggers() {
         this.triggerGeneration++;
-        const loadTriggerPromises = [];
         for (const backend of this.args.emulatableBackends) {
-            loadTriggerPromises.push(this.loadTriggers(backend));
+            await this.loadTriggers(backend);
         }
-        await Promise.all(loadTriggerPromises);
         await this.performPostLoadOperations();
         return;
     }

package/lib/emulator/functionsEmulatorRuntime.js

@@ -213,7 +213,7 @@ function initializeNetworkFiltering(frb) {
             })
                 .filter((v) => v);
             const href = (hrefs.length && hrefs[0]) || "";
-            if (href && !history[href] && !href.startsWith("http://localhost")) {
+            if (href && !history[href] && !(0, functionsEmulatorUtils_1.isLocalHost)(href)) {
                 history[href] = true;
                 if (href.indexOf("googleapis.com") !== -1) {
                     new types_1.EmulatorLog("SYSTEM", "googleapis-network-access", "", {

package/lib/emulator/functionsEmulatorShared.js

@@ -106,6 +106,9 @@ function emulatedFunctionsFromEndpoints(endpoints) {
                 options: endpoint.blockingTrigger.options || {},
             };
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            def.httpsTrigger = {};
+        }
         else {
         }
         regionDefinitions.push(def);

package/lib/emulator/functionsEmulatorUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareVersionStrings = exports.parseVersionString = exports.parseRuntimeVersion = exports.removePathSegments = exports.trimSlashes = exports.isValidWildcardMatch = exports.extractParamsFromPath = void 0;
+exports.isLocalHost = exports.compareVersionStrings = exports.parseVersionString = exports.parseRuntimeVersion = exports.removePathSegments = exports.trimSlashes = exports.isValidWildcardMatch = exports.extractParamsFromPath = void 0;
 const wildcardRegex = new RegExp("{[^/{}]*}");
 const wildcardKeyRegex = new RegExp("^{(.+)}$");
 function extractParamsFromPath(wildcardPath, snapshotPath) {
@@ -85,3 +85,7 @@ function compareVersionStrings(a, b) {
     return 0;
 }
 exports.compareVersionStrings = compareVersionStrings;
+function isLocalHost(href) {
+    return !!href.match(/^(http(s)?:\/\/)?(localhost|127.0.0.1|\[::1])/);
+}
+exports.isLocalHost = isLocalHost;

package/lib/emulator/storage/apis/firebase.js

@@ -118,7 +118,7 @@ function createFirebaseEndpoints(emulator) {
         return res.json(new metadata_1.OutgoingFirebaseMetadata(metadata));
     });
     firebaseStorageAPI.get("/b/:bucketId/o", async (req, res) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         const maxResults = (_a = req.query.maxResults) === null || _a === void 0 ? void 0 : _a.toString();
         let listResponse;
         try {
@@ -144,10 +144,12 @@ function createFirebaseEndpoints(emulator) {
         }
         return res.status(200).json({
             nextPageToken: listResponse.nextPageToken,
-            prefixes: (_c = listResponse.prefixes) !== null && _c !== void 0 ? _c : [],
-            items: (_e = (_d = listResponse.items) === null || _d === void 0 ? void 0 : _d.map((item) => {
+            prefixes: ((_c = listResponse.prefixes) !== null && _c !== void 0 ? _c : []).filter(isValidPrefix),
+            items: ((_d = listResponse.items) !== null && _d !== void 0 ? _d : [])
+                .filter((item) => isValidNonEncodedPathString(item.name))
+                .map((item) => {
                 return { name: item.name, bucket: item.bucket };
-            })) !== null && _e !== void 0 ? _e : [],
+            }),
         });
     });
     const handleUpload = async (req, res) => {
@@ -467,3 +469,23 @@ function setObjectHeaders(res, metadata, headerOverride = { "Content-Encoding":
         res.setHeader("Content-Language", metadata.contentLanguage);
     }
 }
+function isValidPrefix(prefix) {
+    return isValidNonEncodedPathString(removeAtMostOneTrailingSlash(prefix));
+}
+function isValidNonEncodedPathString(path) {
+    if (path.startsWith("/")) {
+        path = path.substring(1);
+    }
+    if (!path) {
+        return false;
+    }
+    for (const pathSegment of path.split("/")) {
+        if (!pathSegment) {
+            return false;
+        }
+    }
+    return true;
+}
+function removeAtMostOneTrailingSlash(path) {
+    return path.replace(/\/$/, "");
+}

package/lib/extensions/askUserForEventsConfig.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askForEventArcLocation = exports.askShouldCollectEventsConfig = exports.askForAllowedEventTypes = exports.askForEventsConfig = exports.checkAllowedEventTypesResponse = void 0;
+const prompt_1 = require("../prompt");
+const extensionsApi = require("../extensions/extensionsApi");
+const utils = require("../utils");
+const clc = require("cli-color");
+const logger_1 = require("../logger");
+const { marked } = require("marked");
+function checkAllowedEventTypesResponse(response, validEvents) {
+    const validEventTypes = validEvents.map((e) => e.type);
+    if (response.length === 0) {
+        return false;
+    }
+    for (const e of response) {
+        if (!validEventTypes.includes(e)) {
+            utils.logWarning(`Unexpected event type '${e}' was configured to be emitted. This event type is not part of the extension spec.`);
+            return false;
+        }
+    }
+    return true;
+}
+exports.checkAllowedEventTypesResponse = checkAllowedEventTypesResponse;
+async function askForEventsConfig(events, projectId, instanceId) {
+    var _a, _b;
+    logger_1.logger.info(`\n${clc.bold("Enable Events")}: ${marked("If you enable events, you can write custom event handlers ([https://firebase.google.com/docs/extensions/install-extensions#eventarc](https://firebase.google.com/docs/extensions/install-extensions#eventarc)) that respond to these events.\n\nYou can always enable or disable events later. Events will be emitted via Eventarc. Fees apply ([https://cloud.google.com/eventarc/pricing](https://cloud.google.com/eventarc/pricing)).")}`);
+    if (!(await askShouldCollectEventsConfig())) {
+        return undefined;
+    }
+    let existingInstance;
+    try {
+        existingInstance = instanceId
+            ? await extensionsApi.getInstance(projectId, instanceId)
+            : undefined;
+    }
+    catch (_c) {
+    }
+    const preselectedTypes = (_a = existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.config.allowedEventTypes) !== null && _a !== void 0 ? _a : [];
+    const oldLocation = (_b = existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.config.eventarcChannel) === null || _b === void 0 ? void 0 : _b.split("/")[3];
+    const location = await askForEventArcLocation(oldLocation);
+    const channel = `projects/${projectId}/locations/${location}/channels/firebase`;
+    const allowedEventTypes = await askForAllowedEventTypes(events, preselectedTypes);
+    return { channel, allowedEventTypes };
+}
+exports.askForEventsConfig = askForEventsConfig;
+async function askForAllowedEventTypes(eventDescriptors, preselectedTypes) {
+    let valid = false;
+    let response = [];
+    const eventTypes = eventDescriptors.map((e, index) => ({
+        checked: false,
+        name: `${index + 1}. ${e.type}\n   ${e.description}`,
+        value: e.type,
+    }));
+    while (!valid) {
+        response = await (0, prompt_1.promptOnce)({
+            name: "selectedEventTypesInput",
+            type: "checkbox",
+            default: preselectedTypes !== null && preselectedTypes !== void 0 ? preselectedTypes : [],
+            message: `Please select the events [${eventTypes.length} types total] that this extension is permitted to emit. ` +
+                "You can implement your own handlers that trigger when these events are emitted to customize the extension's behavior. ",
+            choices: eventTypes,
+            pageSize: 20,
+        });
+        valid = checkAllowedEventTypesResponse(response, eventDescriptors);
+    }
+    return response.filter((e) => e !== "");
+}
+exports.askForAllowedEventTypes = askForAllowedEventTypes;
+async function askShouldCollectEventsConfig() {
+    return (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "shouldCollectEvents",
+        message: `Would you like to enable events?`,
+        default: false,
+    });
+}
+exports.askShouldCollectEventsConfig = askShouldCollectEventsConfig;
+async function askForEventArcLocation(preselectedLocation) {
+    let valid = false;
+    const allowedRegions = ["us-central1", "us-west1", "europe-west4", "asia-northeast1"];
+    let location = "";
+    while (!valid) {
+        location = await (0, prompt_1.promptOnce)({
+            name: "input",
+            type: "list",
+            default: preselectedLocation !== null && preselectedLocation !== void 0 ? preselectedLocation : "us-central1",
+            message: "Which location would you like the Eventarc channel to live in? We recommend using the default option. A channel location that differs from the extension's Cloud Functions location can incur egress cost.",
+            choices: allowedRegions.map((e) => ({ checked: false, value: e })),
+        });
+        valid = allowedRegions.includes(location);
+        if (!valid) {
+            utils.logWarning(`Unexpected EventArc region '${location}' was specified. Allowed regions: ${allowedRegions.join(", ")}`);
+        }
+    }
+    return location;
+}
+exports.askForEventArcLocation = askForEventArcLocation;

package/lib/extensions/export.js

@@ -45,6 +45,7 @@ function displayExportInfo(withRef, withoutRef) {
 }
 exports.displayExportInfo = displayExportInfo;
 function displaySpecs(specs) {
+    var _a;
     for (let i = 0; i < specs.length; i++) {
         const spec = specs[i];
         logger_1.logger.info(`${i + 1}. ${(0, deploymentSummary_1.humanReadable)(spec)}`);
@@ -52,6 +53,12 @@ function displaySpecs(specs) {
         for (const p of Object.entries(spec.params)) {
             logger_1.logger.info(`\t${p[0]}=${p[1]}`);
         }
+        if ((_a = spec.allowedEventTypes) === null || _a === void 0 ? void 0 : _a.length) {
+            logger_1.logger.info(`\tALLOWED_EVENTS=${spec.allowedEventTypes}`);
+        }
+        if (spec.eventarcChannel) {
+            logger_1.logger.info(`\tEVENTARC_CHANNEL=${spec.eventarcChannel}`);
+        }
         logger_1.logger.info("");
     }
 }

package/lib/extensions/extensionsApi.js

@@ -58,6 +58,8 @@ async function createInstance(args) {
     var _a, _b;
     const config = {
         params: args.params,
+        allowedEventTypes: args.allowedEventTypes,
+        eventarcChannel: args.eventarcChannel,
     };
     if (args.extensionSource && args.extensionVersionRef) {
         throw new error_1.FirebaseError("ExtensionSource and ExtensionVersion both provided, but only one should be.");
@@ -73,6 +75,12 @@ async function createInstance(args) {
     else {
         throw new error_1.FirebaseError("No ExtensionVersion or ExtensionSource provided but one is required.");
     }
+    if (args.allowedEventTypes) {
+        config.allowedEventTypes = args.allowedEventTypes;
+    }
+    if (args.eventarcChannel) {
+        config.eventarcChannel = args.eventarcChannel;
+    }
     return createInstanceHelper(args.projectId, args.instanceId, config, args.validateOnly);
 }
 exports.createInstance = createInstance;
@@ -88,8 +96,16 @@ async function deleteInstance(projectId, instanceId) {
 }
 exports.deleteInstance = deleteInstance;
 async function getInstance(projectId, instanceId) {
-    const res = await apiClient.get(`/projects/${projectId}/instances/${instanceId}`);
-    return res.body;
+    try {
+        const res = await apiClient.get(`/projects/${projectId}/instances/${instanceId}`);
+        return res.body;
+    }
+    catch (err) {
+        if (err.status === 404) {
+            throw new error_1.FirebaseError(`Extension instance '${clc.bold(instanceId)}' not found in project '${clc.bold(projectId)}'.`, { status: 404 });
+        }
+        throw err;
+    }
 }
 exports.getInstance = getInstance;
 async function listInstances(projectId) {
@@ -114,7 +130,7 @@ async function listInstances(projectId) {
 exports.listInstances = listInstances;
 async function configureInstance(args) {
     var _a;
-    const res = await patchInstance({
+    const reqBody = {
         projectId: args.projectId,
         instanceId: args.instanceId,
         updateMask: "config.params",
@@ -124,8 +140,16 @@ async function configureInstance(args) {
                 params: args.params,
             },
         },
-    });
-    return res;
+    };
+    if (args.canEmitEvents) {
+        if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
+            throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
+        }
+        reqBody.data.config.allowedEventTypes = args.allowedEventTypes;
+        reqBody.data.config.eventarcChannel = args.eventarcChannel;
+    }
+    reqBody.updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    return patchInstance(reqBody);
 }
 exports.configureInstance = configureInstance;
 async function updateInstance(args) {
@@ -140,7 +164,15 @@ async function updateInstance(args) {
         body.config.params = args.params;
         updateMask += ",config.params";
     }
-    return await patchInstance({
+    if (args.canEmitEvents) {
+        if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
+            throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
+        }
+        body.config.allowedEventTypes = args.allowedEventTypes;
+        body.config.eventarcChannel = args.eventarcChannel;
+    }
+    updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    return patchInstance({
         projectId: args.projectId,
         instanceId: args.instanceId,
         updateMask,
@@ -163,7 +195,15 @@ async function updateInstanceFromRegistry(args) {
         body.config.params = args.params;
         updateMask += ",config.params";
     }
-    return await patchInstance({
+    if (args.canEmitEvents) {
+        if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
+            throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
+        }
+        body.config.allowedEventTypes = args.allowedEventTypes;
+        body.config.eventarcChannel = args.eventarcChannel;
+    }
+    updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    return patchInstance({
         projectId: args.projectId,
         instanceId: args.instanceId,
         updateMask,

package/lib/extensions/manifest.js

@@ -48,7 +48,7 @@ async function writeLocalSecrets(specs, config, force) {
             continue;
         }
         const writeBuffer = {};
-        const locallyOverridenSecretParams = extensionSpec.params.filter((p) => p.type === extensionsApi_1.ParamType.SECRET && spec.params[p.param].local);
+        const locallyOverridenSecretParams = extensionSpec.params.filter((p) => { var _a; return p.type === extensionsApi_1.ParamType.SECRET && ((_a = spec.params[p.param]) === null || _a === void 0 ? void 0 : _a.local); });
         for (const paramSpec of locallyOverridenSecretParams) {
             const key = paramSpec.param;
             const localValue = spec.params[key].local;

package/lib/extensions/paramHelper.js

@@ -11,6 +11,7 @@ const askUserForParam = require("./askUserForParam");
 const track_1 = require("../track");
 const env = require("../functions/env");
 const utils_1 = require("../utils");
+const warnings_1 = require("./warnings");
 function getBaseParamBindings(params) {
     let ret = {};
     for (const [k, v] of Object.entries(params)) {
@@ -57,6 +58,7 @@ async function getParams(args) {
             paramsMessage);
     }
     else if (args.paramsEnvPath) {
+        (0, warnings_1.paramsFlagDeprecationWarning)();
         params = getParamsFromFile({
             paramSpecs: args.paramSpecs,
             paramsEnvPath: args.paramsEnvPath,

package/lib/extensions/updateHelper.js

@@ -59,13 +59,16 @@ async function displayChanges(args) {
 }
 exports.displayChanges = displayChanges;
 async function update(updateOptions) {
-    const { projectId, instanceId, source, extRef, params } = updateOptions;
+    const { projectId, instanceId, source, extRef, params, canEmitEvents, allowedEventTypes, eventarcChannel, } = updateOptions;
     if (extRef) {
         return await extensionsApi.updateInstanceFromRegistry({
             projectId,
             instanceId,
             extRef,
             params,
+            canEmitEvents,
+            allowedEventTypes,
+            eventarcChannel,
         });
     }
     else if (source) {
@@ -74,6 +77,9 @@ async function update(updateOptions) {
             instanceId,
             extensionSource: source,
             params,
+            canEmitEvents,
+            allowedEventTypes,
+            eventarcChannel,
         });
     }
     throw new error_1.FirebaseError(`Neither a source nor a version of the extension was supplied for ${instanceId}. Please make sure this is a valid extension and try again.`);

package/lib/extensions/warnings.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
+exports.paramsFlagDeprecationWarning = exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
 const { marked } = require("marked");
 const clc = require("cli-color");
 const extensionsApi_1 = require("./extensionsApi");
@@ -11,6 +11,7 @@ const deploymentSummary_1 = require("../deploy/extensions/deploymentSummary");
 const planner_1 = require("../deploy/extensions/planner");
 const functional_1 = require("../functional");
 const utils = require("../utils");
+const logger_1 = require("../logger");
 function displayEAPWarning({ publisherId, sourceDownloadUri, githubLink, }) {
     const publisherNameLink = githubLink ? `[${publisherId}](${githubLink})` : publisherId;
     const warningMsg = `This extension is in preview and is built by a developer in the [Extensions Publisher Early Access Program](http://bit.ly/firex-provider). Its functionality might change in backward-incompatible ways. Since this extension isn't built by Firebase, reach out to ${publisherNameLink} with questions about this extension.`;
@@ -57,14 +58,20 @@ async function displayWarningsForDeploy(instancesToCreate) {
     const experimental = nonEapExtensions.filter((i) => i.extension.registryLaunchStage === extensionsApi_1.RegistryLaunchStage.EXPERIMENTAL);
     if (experimental.length) {
         const humanReadableList = experimental.map((i) => `\t${(0, deploymentSummary_1.humanReadable)(i)}`).join("\n");
-        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`The following are instances of ${clc.bold("experimental")} extensions.They may not be production-ready. Their functionality may change in backward-incompatible ways before their official release, or they may be discontinued.\n${humanReadableList}\n`));
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`The following are instances of ${clc.bold("experimental")} extensions.They may not be production-ready. Their functionality may change in backward-incompatible ways before their official release, or they may be discontinued.\n${humanReadableList}\n`, { gfm: false }));
     }
     if (eapExtensions.length) {
         const humanReadableList = eapExtensions.map(toListEntry).join("\n");
-        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`These extensions are in preview and are built by a developer in the Extensions Publisher Early Access Program (http://bit.ly/firex-provider. Their functionality might change in backwards-incompatible ways. Since these extensions aren't built by Firebase, reach out to their publisher with questions about them.` +
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`These extensions are in preview and are built by a developer in the Extensions Publisher Early Access Program (http://bit.ly/firex-provider). Their functionality might change in backwards-incompatible ways. Since these extensions aren't built by Firebase, reach out to their publisher with questions about them.` +
             ` They are provided “AS IS”, without any warranty, express or implied, from Google.` +
-            ` Google disclaims all liability for any damages, direct or indirect, resulting from the use of these extensions\n${humanReadableList}`));
+            ` Google disclaims all liability for any damages, direct or indirect, resulting from the use of these extensions\n${humanReadableList}`, { gfm: false }));
     }
     return experimental.length > 0 || eapExtensions.length > 0;
 }
 exports.displayWarningsForDeploy = displayWarningsForDeploy;
+function paramsFlagDeprecationWarning() {
+    logger_1.logger.warn("The --params flag is deprecated and will be removed in firebase-tools@11. " +
+        "Instead, use an extensions manifest and `firebase deploy --only extensions` to deploy extensions noninteractively. " +
+        "See https://firebase.google.com/docs/extensions/manifest for more details");
+}
+exports.paramsFlagDeprecationWarning = paramsFlagDeprecationWarning;

package/lib/frameworks/index.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareFrameworks = exports.shortSiteName = void 0;
+const path_1 = require("path");
+const process_1 = require("process");
+const projectUtils_1 = require("../projectUtils");
+const normalizedHostingConfigs_1 = require("../hosting/normalizedHostingConfigs");
+const api_1 = require("../hosting/api");
+const apps_1 = require("../management/apps");
+const fs_1 = require("fs");
+const prompt_1 = require("../prompt");
+const { writeFile } = fs_1.promises;
+const shortSiteName = (site) => (site === null || site === void 0 ? void 0 : site.name) && site.name.split("/").pop();
+exports.shortSiteName = shortSiteName;
+const prepareFrameworks = async (targetNames, context, options) => {
+    const project = (0, projectUtils_1.needProjectId)(context);
+    const configs = (0, normalizedHostingConfigs_1.normalizedHostingConfigs)(Object.assign({ site: project }, options), { resolveTargets: true });
+    options.normalizedHostingConfigs = configs;
+    if (configs.length === 0)
+        return;
+    for (const config of configs) {
+        const { source, site, public: publicDir } = config;
+        if (!source)
+            continue;
+        const dist = (0, path_1.join)(".firebase", site);
+        const hostingDist = (0, path_1.join)(dist, "hosting");
+        const functionsDist = (0, path_1.join)(dist, "functions");
+        if (publicDir)
+            throw new Error(`hosting.public and hosting.source cannot both be set in firebase.json`);
+        const getProjectPath = (...args) => (0, path_1.join)(process.cwd(), source, ...args);
+        const functionName = `ssr${site.replace(/-/g, "")}`;
+        const { build } = require("firebase-frameworks/tools");
+        const { usingCloudFunctions, rewrites, redirects, headers, usesFirebaseConfig } = await build({
+            dist,
+            project,
+            site,
+            function: {
+                name: functionName,
+                region: "us-central1",
+            },
+        }, getProjectPath);
+        config.public = hostingDist;
+        if (usingCloudFunctions) {
+            if (context.hostingChannel) {
+                const message = "Cannot preview changes to the backend, you will only see changes to the static content on this channel.";
+                if (!options.nonInteractive) {
+                    const continueDeploy = await (0, prompt_1.promptOnce)({
+                        type: "confirm",
+                        default: true,
+                        message: `${message} Would you like to continue with the deploy?`,
+                    });
+                    if (!continueDeploy)
+                        (0, process_1.exit)(1);
+                }
+                else {
+                    console.error(message);
+                }
+            }
+            else {
+                const functionConfig = {
+                    source: functionsDist,
+                    codebase: `firebase-frameworks-${site}`,
+                };
+                if (targetNames.includes("functions")) {
+                    const combinedFunctionsConfig = [functionConfig].concat(options.config.get("functions") || []);
+                    options.config.set("functions", combinedFunctionsConfig);
+                }
+                else {
+                    targetNames.unshift("functions");
+                    options.config.set("functions", functionConfig);
+                }
+            }
+            config.rewrites = [
+                ...(config.rewrites || []),
+                ...rewrites,
+                {
+                    source: "**",
+                    function: functionName,
+                },
+            ];
+            let firebaseProjectConfig = null;
+            if (usesFirebaseConfig) {
+                const sites = await (0, api_1.listSites)(project);
+                const selectedSite = sites.find((it) => (0, exports.shortSiteName)(it) === site);
+                if (selectedSite) {
+                    const { appId } = selectedSite;
+                    if (appId) {
+                        firebaseProjectConfig = await (0, apps_1.getAppConfig)(appId, apps_1.AppPlatform.WEB);
+                    }
+                    else {
+                        console.warn(`No Firebase app associated with site ${site}, unable to provide authenticated server context`);
+                    }
+                }
+            }
+            writeFile((0, path_1.join)(functionsDist, ".env"), `FRAMEWORKS_FIREBASE_PROJECT_CONFIG="${JSON.stringify(firebaseProjectConfig).replace(/"/g, '\\"')}"`);
+        }
+        else {
+            config.rewrites = [
+                ...(config.rewrites || []),
+                ...rewrites,
+                {
+                    source: "**",
+                    destination: "/index.html",
+                },
+            ];
+        }
+        config.redirects = [...(config.redirects || []), ...redirects];
+        config.headers = [...(config.headers || []), ...headers];
+    }
+};
+exports.prepareFrameworks = prepareFrameworks;

package/lib/functions/functionslog.js

@@ -2,18 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logEntries = exports.getApiFilter = void 0;
 const logger_1 = require("../logger");
-const previews_1 = require("../previews");
 function getApiFilter(functionList) {
-    const baseFilter = previews_1.previews.functionsv2
-        ? 'resource.type="cloud_function" OR ' +
-            '(resource.type="cloud_run_revision" AND ' +
-            'labels."goog-managed-by"="cloudfunctions")'
-        : 'resource.type="cloud_function"';
+    const baseFilter = 'resource.type="cloud_function" OR ' +
+        '(resource.type="cloud_run_revision" AND ' +
+        'labels."goog-managed-by"="cloudfunctions")';
     if (functionList) {
         const apiFuncFilters = functionList.split(",").map((fn) => {
-            return previews_1.previews.functionsv2
-                ? `resource.labels.function_name="${fn}" ` + `OR resource.labels.service_name="${fn}"`
-                : `resource.labels.function_name="${fn}"`;
+            return `resource.labels.function_name="${fn}" ` + `OR resource.labels.service_name="${fn}"`;
         });
         return baseFilter + `\n(${apiFuncFilters.join(" OR ")})`;
     }

package/lib/gcp/cloudfunctions.js

@@ -145,7 +145,7 @@ async function setInvokerUpdate(projectId, fnName, invoker) {
 exports.setInvokerUpdate = setInvokerUpdate;
 async function updateFunction(cloudFunction) {
     const endpoint = `/${cloudFunction.name}`;
-    const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables");
+    const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables", "secretEnvironmentVariables");
     try {
         const headers = {};
         if (previews_1.previews.artifactregistry) {